LeetCode题解-贪心算法

我就是我 2022-11-18 02:03 147阅读 0赞

# LeetCode题解-贪心算法 #

### 文章目录 ###

*  LeetCode题解-贪心算法
 *   *  455. 分发饼干（简单）
     *  435.无重叠区间（中等）
     *  452.用最少数量的箭引爆气球（中等）
     *  406. 根据身高重建队列（中等）
     *  121.买卖股票的最佳时机（简单）
     *  122.买卖股票的最佳时机 II（简单）
     *  605. 种花问题（简单）
     *  392. 判断子序列（简单）
     *  665.非递减数列（简单）
     *  53. 最大子序和（简单）
     *  763. 划分字母区间（中等）

--------------------

解决贪心算法的基本步骤

*  将原问题分解为子问题
 *  找出贪心策略
 *  得到每一个子问题的最优解
 *  将所有局部最优解的集合构成称为原问题的一个解

## 455. 分发饼干（简单） ##

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 `i`，都有一个胃口值 `g[i]`，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 `j`，都有一个尺寸 `s[j]` 。如果 `s[j] >= g[i]`，我们可以将这个饼干 `j` 分配给孩子 `i` ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

输入: g = [1,2,3], s = [1,1]
    输出: 1
    解释: 
    你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
    虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
    所以你应该输出1。

输入: g = [1,2], s = [1,2,3]
    输出: 2
    解释: 
    你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
    你拥有的饼干数量和尺寸都足以让所有孩子满足。
    所以你应该输出2.

**解题思路：贪心算法**——为了尽可能满足最多数量的孩子，从贪心的角度考虑，应该按照孩子的胃口从小到大的顺序依次满足每个孩子，且对于每个孩子，应该选择可以满足这个孩子的胃口且尺寸最小的饼干。

首先对数组 g 和 s 从小到大进行排序，然后令两个指针  i i i 和  j j j 分别指向数组的开头，判断  g \[ i \] < = s \[ j \] g\[i\]<=s\[j\] g\[i\]<=s\[j\], 如果满足，说明第一个饼干可以满足第一个孩子，则把它分配给第一个孩子， c o u n t + + count++ count\+\+, 并使  i , j i,j i,j 两个指针均右移；若不能满足，则令 j + + j++ j\+\+，继续判断是否满足条件，直到 i i i或 j j j到达末尾。

class Solution {
        
        public int findContentChildren(int[] g, int[] s) {
        
            Arrays.sort(g);
            Arrays.sort(s);
            int numOfChildren = g.length, numOfCookies = s.length;
            int count = 0;
            for (int i = 0, j = 0; i < numOfChildren && j < numOfCookies; ) {
        
                if(g[i] <= s[j]){
        
                    count++;
                    i++;
                    j++;
                }else{
        
                    j++;
                }
            }
            return count;
        }
    }

--------------------

## 435.无重叠区间（中等） ##

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

**注意:**

1.  可以认为区间的终点总是大于它的起点。
2.  区间 \[1,2\] 和 \[2,3\] 的边界相互“接触”，但没有相互重叠。

输入: [ [1,2], [2,3], [3,4], [1,3] ]
    输出: 1
    解释: 移除 [1,3] 后，剩下的区间没有重叠。

输入: [ [1,2], [1,2], [1,2] ]
    输出: 2
    解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

\*\*解题思路：\*\*贪心算法，先留下右边界最小的区间，再去除重复区间

*  根据区间右边界升序排列，**首个区间就是所有可以选择的区间中右端点最小的那个区间**；
 *  维护end，其代表已留下的不重复区间中最大的右边界；
 *  遍历排序后的区间：
    
     *  如果当前区间的左边界大于end，说明该区间可以留下，count++，并更新end；
     *  如果当前区间的左边界小于end，说明区间存在重复，该区间去除；
     *  最后需要移除的区间数等于区间总数 - count；

class Solution {
        
        public int eraseOverlapIntervals(int[][] intervals) {
        
            if (intervals.length == 0) {
        
                return 0;
            }
            Arrays.sort(intervals, new Comparator<int [] >(){
         //Comparator接口比较器，可参考书籍
                public int compare(int [] a1, int [] a2) {
        
                    return a1[1] - a2[1];   //按照右边界升序排列
                }
            });
            int count = 1;	//最多能组成的不重叠区间个数
            int end = intervals[0][1];
            for (int i = 0; i < intervals.length; i++) {
        
                if (end <= intervals[i][0] ) {
        
                    end = intervals[i][1];
                    count++;
                }           
            }
            return intervals.length - count;
        }
    }

--------------------

## 452.用最少数量的箭引爆气球（中等） ##

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 ```x``start```，```x``end```， 且满足```xstart ≤ x ≤ x``end```，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 `points` ，其中 `points [i] = [xstart,xend]` ，返回引爆所有气球所必须射出的最小弓箭数。

输入：points = [[10,16],[2,8],[1,6],[7,12]]
    输出：2
    解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

输入：points = [[1,2],[3,4],[5,6],[7,8]]
    输出：4

输入：points = [[1,2],[2,3],[3,4],[4,5]]
    输出：2

\*\*解题思路：\*\*本题和上题解法很相似，但又有一点不同，区别在于\[1, 2\] 和 \[2, 3\] 在本题中算是重叠区间：

感觉这类需要用到区间尾部的（利用区间尾部判断是否和后面的某个区间分开）都得按照区间尾排序，因为已经保证后面的区间右侧都是大于当前区间, 所以将发射点设置在右侧边界, 后面的区间只有左边界比它更靠左,则可以被一起处理掉，这里换个example: \[\[10,16\],\[2,5\],\[1,6\],\[7,12\]\] 为例子:

*  先排序, 按区间结束位置排序, 排序后: \[\[2,5\],\[1, 6\],\[7,12\],\[10,16\]\]
 *  遍历计算交叉区间,
    
     *  发射点初始化为pos = 5, 需要的箭数量 arrows = 1;
     *  区间\[1, 6\], 1 是小于5的, 在点5射箭可以干掉这个区间
     *  区间\[7, 12\], 在5的位置射箭无法打掉, 说明需要增加一个新的发射点, 新的待发射点pos = 12
     *  区间\[10,16\], 10 < 12那么在12位置射箭可以干掉它
 *  返回需要射击点的数量

class Solution {
        
        public int findMinArrowShots(int[][] points) {
        
            if(points.length == 0){
        
                return 0;
            }
            Arrays.sort(points, Comparator.comparingInt(o -> o[1]));//与上题的comparator功能一样
            int count = 1;
            int end = points[0][1];
            for(int i = 0; i < points.length; i++){
        
                if(end < points[i][0]){
          //如果该区间的左端点大于end，说明不能用一支箭射击，因而count++，并更新end
                    count++;
                    end = points[i][1];
                }
            }
            return count;
        }
    }

--------------------

## 406. 根据身高重建队列（中等） ##

假设有打乱顺序的一群人站成一个队列，数组 `people` 表示队列中一些人的属性（不一定按顺序）。每个 `people[i] = [hi, ki]` 表示第 `i` 个人的身高为 `hi` ，前面 **正好** 有 `ki` 个身高大于或等于 `hi` 的人。

请你重新构造并返回输入数组 `people` 所表示的队列。返回的队列应该格式化为数组 `queue` ，其中 `queue[j] = [hj, kj]` 是队列中第 `j` 个人的属性（`queue[0]` 是排在队列前面的人）。

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
    输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
    解释：
    编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
    编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
    编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
    编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
    编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
    编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
    因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

**解题思路：**（套路）：一般这种数对，还涉及排序的，根据第一个元素正向排序，根据第二个元素反向排序，或者根据第一个元素反向排序，根据第二个元素正向排序，往往能够简化解题过程。

在本题目中，我首先对数对进行排序，按照数对的元素 1 降序排序，按照数对的元素 2 升序排序。原因是，按照元素 1 进行降序排序，对于每个元素，在其之前的元素的个数，就是大于等于他的元素的数量，这样可以直接按照元素2为索引进行插入；而按照第二个元素正向排序，我们希望 k 大的尽量在后面，减少插入操作的次数。

\[参考链接\]\[“https://leetcode-cn.com/problems/queue-reconstruction-by-height/solution/xian-pai-xu-zai-cha-dui-dong-hua-yan-shi-suan-fa-g/” \]

class Solution {
        
        public int[][] reconstructQueue(int[][] people) {
        
            if(people.length == 0 || people[0].length == 0){
        
                return new int[0][0];
            }
            Arrays.sort(people, new Comparator<int[]>(){
        
                public int compare(int[] p1, int[] p2){
        
                    if(p1[0] != p2[0]){
        
                        return p2[0] - p1[0]; //身高按照降序排列
                    }else{
        
                        return p1[1] - p2[1]; //身高相等时按照个数升序排列
                    }
                }
            });
            List<int[]> queue = new ArrayList<>();
            for(int[] person : people){
        
              //K值定义为 排在h前面且身高大于或等于h的人数 
             //因为从身高降序开始插入，此时所有人身高都大于等于h
             //因此K值即为需要插入的位置
                queue.add(person[1], person); //用于在列表的指定位置插入指定元素，并将当前处于该位置的元素及其后续元素的索引加 1。
            }
    
            return queue.toArray(new int[queue.size()][]);
        }
    }

--------------------

## 121.买卖股票的最佳时机（简单） ##

给定一个数组 `prices` ，它的第 `i` 个元素 `prices[i]` 表示一支给定股票第 `i` 天的价格。

你只能选择 **某一天** 买入这只股票，并选择在 **未来的某一个不同的日子** 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 `0` 。

输入：[7,1,5,3,6,4]
    输出：5
    解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
         注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

输入：prices = [7,6,4,3,1]
    输出：0
    解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

\*\*解题思路：\*\*采用贪心思想，在最低点买入最高点卖出就可以获得最大收益。我们只要用一个变量记录一个历史最低价格 `minprice`，我们就可以假设自己的股票是在那天买的。那么我们在第 `i` 天卖出股票能得到的利润就是 `prices[i] - minprice`。因此，我们只需要遍历价格数组一遍，记录历史最低点，并找到最大利润就可以了。首先设买入点为 p r i c e \[ 0 \] price\[0\] price\[0\]，遍历数组，若有某个值小于 p r i c e \[ 0 \] price\[0\] price\[0\]，则更新买入点，并不断计算`prices[i] - minprice`来更新最大值即可。

class Solution {
        
        public int maxProfit(int[] prices) {
        
            if(prices.length == 0) return 0;
            int min = prices[0];
            int max = 0;
            for(int i = 1; i < prices.length; i++){
        
                if(prices[i] < min) min = prices[i];
                max = Math.max(max, prices[i] - min);
            }
            return max;
        }
    }

--------------------

## 122.买卖股票的最佳时机 II（简单） ##

给定一个数组，它的第 *i* 个元素是一支给定股票第 *i* 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。\*\*注意：\*\*你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

输入: [7,1,5,3,6,4]
    输出: 7
    解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
         随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

输入: [1,2,3,4,5]
    输出: 4
    解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
         注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
         因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

**解题思路**：遍历整个股票交易日价格列表 price，策略是所有上涨交易日都买卖（赚到所有利润），所有下降交易日都不买卖（永不亏钱）。

1.  设 `tmp` 为第 `i-1` 日买入与第 `i` 日卖出赚取的利润，即 `tmp = prices[i] - prices[i - 1]`
2.  当该天利润为正 `tmp > 0`，则将利润加入总利润 `profit`；当利润为 0 或为负，则直接跳过；
3.  遍历完成后，返回总利润 `profit`。

class Solution {
        
        public int maxProfit(int[] prices) {
        
            if(prices.length == 0) return 0;
            int count = 0;
            for(int i = 1; i < prices.length; i++){
        
                if(prices[i] > prices[i -1]){
        
                    count += prices[i] - prices[i - 1];
                }
            }
            return count;
        }
    }

--------------------

## 605. 种花问题（简单） ##

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 `flowerbed` 表示花坛，由若干 `0` 和 `1` 组成，其中 `0` 表示没种植花，`1` 表示种植了花。另有一个数 `n` ，能否在不打破种植规则的情况下种入 `n` 朵花？能则返回 `true` ，不能则返回 `false`。

输入：flowerbed = [1,0,0,0,1], n = 1
    输出：true

输入：flowerbed = [1,0,0,0,1], n = 2
    输出：false

\*\*解题思路：\*\*从左向右遍历花坛，在可以种花的地方就种一朵，能种就种（因为在任一种花时候，不种都不会得到更优解），就是一种贪心的思想  
这里可以种花的条件是：

（自己为空 ） &&（左边为空或自己为最左）&&（右边为空或自己为最右）

最后判断`n`朵花是否有剩余，为了效率起见，可以在种花的过程中做判断，一旦花被种完就返回`true`

\[参考链接\]\[https://leetcode-cn.com/problems/can-place-flowers/solution/1-chong-hua-wen-ti-jian-dan-de-tan-xin-b-h8xb/\]

class Solution {
        
        public boolean canPlaceFlowers(int[] flowerbed, int n) {
        
            for(int i = 0; i < flowerbed.length; i++){
        
                if(flowerbed[i] == 0 && (i == 0 || flowerbed[i-1] == 0) && (i == flowerbed.length-1 || flowerbed[i+1] == 0)){
        
                    n--;
                    flowerbed[i] = 1;
                    if(n == 0){
        
                        return true;
                    }
                }
            }
            return n <= 0;
        }
    }

--------------------

## 392. 判断子序列（简单） ##

给定字符串 **s** 和 **t** ，判断 **s** 是否为 **t** 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，`"ace"`是`"abcde"`的一个子序列，而`"aec"`不是）。

输入：s = "abc", t = "ahbgdc"
    输出：true

输入：s = "axc", t = "ahbgdc"
    输出：false

**解题思路：**双指针：本题询问的是，s 是否是 t 的子序列，因此只要能找到任意一种 s 在 t 中出现的方式，即可认为 s 是 t 的子序列。

而当我们从前往后匹配，可以发现每次贪心地匹配靠前的字符是最优决策。

这样，我们初始化两个指针 i 和 j，分别指向 s 和 t 的初始位置。每次贪心地匹配，匹配成功则 i 和 j 同时右移，匹配 s 的下一个位置，匹配失败则 j 右移，i 不变，尝试用 t 的下一个字符匹配 s。最终如果 i 移动到 s 的末尾，就说明 s 是 t 的子序列。

class Solution {
        
        public boolean isSubsequence(String s, String t) {
        
            int m = s.length();
            int n = t.length();
            int i = 0,j = 0;
            while(i < m && j < n){
        
                if(s.charAt(i) == t.charAt(j)){
        
                    i++;
                }
                j++;
            }
            return i == m;
        }
    }

--------------------

## 665.非递减数列（简单） ##

给你一个长度为 `n` 的整数数组，请你判断在 **最多** 改变 `1` 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的： 对于数组中任意的 `i` `(0 <= i <= n-2)`，总满足 `nums[i] <= nums[i + 1]`。

输入: nums = [4,2,3]
    输出: true
    解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

输入: nums = [3，4,2,3]
    输出: false
    解释: 你不能在只改变一个元素的情况下将其变为非递减数列。

\*\*解题思路：\*\*当 `nums[i]` 破坏了数组的单调递增时，即 `nums[i] < nums[i - 1]` 时，为了让数组有序，我们发现一个规律：

*  如\[4, 2, 5\]的情况，当 `i = 1` ，那么修改 `num[i- 1]` ，不要动 `nums[i]` ，因为`nums[i]`后面的元素是啥我们还不知道呢，少动它为妙。
 *  如\[1, 4, 2, 5\]的情况下，当 `i > 1` 时，我们应该优先考虑把 `nums[i - 1]` 调小到 `>= nums[i - 2] 并且 <=nums[i]。同样尽量不去修改 nums[i] ，理由同上。`
 *  如\[3, 4, 2, 5\]的情况下，当 `i > 1` 且 `nums[i] < nums[i - 2]` 时，我们无法调整 `nums[i - 1]` ，我们只能调整 `nums[i]` 到 `nums[i - 1]` 。

\[参考链接\]\[https://leetcode-cn.com/problems/non-decreasing-array/solution/3-zhang-dong-tu-bang-zhu-ni-li-jie-zhe-d-06gi/\]

class Solution {
        
        public boolean checkPossibility(int[] nums) {
        
            int count = 0;
            for(int i = 1; i < nums.length; i++){
        
                if(nums[i] >= nums[i-1]){
        
                    continue;
                }
                count ++;
                if(i-2>=0 && nums[i-2]>nums[i]){
        
                    nums[i] = nums[i-1];
                }else{
        
                    nums[i-1] = nums[i];
                }
            }
            return count <= 1;//判断调换次数是否小于等于1
        }
    }

--------------------

## 53. 最大子序和（简单） ##

给定一个整数数组 `nums` ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
    输出：6
    解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

输入：nums = [1]
    输出：1

**方法一：动态规划**

**通常我们遍历子串或者子序列有三种遍历方式**

*  以某个节点为开头的所有子序列: 如 `[a]`，`[a, b]`，`[ a, b, c]` … 再从以 `b` 为开头的子序列开始遍历 `[b] [b, c]`
 *  根据子序列的长度为标杆，如先遍历出子序列长度为 1 的子序列，在遍历出长度为 2 的 等等。
 *  以子序列的结束节点为基准，先遍历出以某个节点为结束的所有子序列，因为每个节点都可能会是子序列的结束节点，因此要遍历下整个序列，如: 以 `b` 为结束点的所有子序列: `[a , b]` `[b]` 以 `c` 为结束点的所有子序列: `[a, b, c] [b, c] [ c ]`。

第一种遍历方式通常用于暴力解法, 第二种遍历方式 leetcode (5. 最长回文子串 ) 中的解法就用到了。

第三种遍历方式 因为可以产生递推关系, 采用动态规划时, 经常通过此种遍历方式, 如 背包问题, 最大公共子串 , 这里的动态规划解法也是以 先遍历出 以某个节点为结束节点的所有子序列 的思路

// Kadane算法扫描一次整个数列的所有数值，
    // 在每一个扫描点计算以该点数值为结束点的子数列的最大和（正数和）。
    // 该子数列由两部分组成：以前一个位置为结束点的最大子数列、该位置的数值。
    // 因为该算法用到了“最佳子结构”（以每个位置为终点的最大子数列都是基于其前一位置的最大子数列计算得出, 
    // 该算法可看成动态规划的一个例子。
    // 状态转移方程：sum[i] = max{sum[i-1]+a[i],a[i]}   
    // 其中(sum[i]记录以a[i]为子序列末端的最大序子列连续和)
    class Solution {
        
        public int maxSubArray(int[] nums) {
        
            if(nums == null || nums.length == 0){
        
                return 0;
            }
            int preMax = nums[0];
            int maxAns = nums[0];
            for(int i = 1; i < nums.length; i++){
        
                preMax = Math.max(preMax + nums[i], nums[i]);
                maxAns = Math.max(preMax, maxAns);
            }
            return maxAns;
        }
    }

**方法二：贪心算法**

首先对数组进行遍历，假设当前最大连续子序列和为 sum，最终结果为 ans

*  如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
 *  如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
 *  每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果

class Solution {
        
        public int maxSubArray(int[] nums) {
        
            if(nums == null || nums.length == 0){
        
                return 0;
            }
            int sum = nums[0];
            int ans = nums[0];
            for(int i = 1; i < nums.length; i++){
        
                if(sum <= 0){
        
                    sum = nums[i];
                }else{
        
                    sum += nums[i];
                }
                ans = Math.max(sum, ans);
            }
            return ans;
        }
    }

--------------------

## 763. 划分字母区间（中等） ##

字符串 `S` 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

输入：S = "ababcbacadefegdehijhklij"
    输出：[9,7,8]
    解释：
    划分结果为 "ababcbaca", "defegde", "hijhklij"。
    每个字母最多出现在一个片段中。
    像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

**解题思路：**

1， 首先看第一个字母，找到它在串里最后的一个位置，记作`last`或`一段的最后位置`。

2， 在从`0~last`这个范围里，挨个查其他字母，看他们的最后位置是不是比刚才的`last`或`一段的最后位置`大。

如果没有刚才的last或一段的最后位置大，无视它继续往后找。如果比刚才的大，说明这一段的分隔位置必须往后移动，所以我们把last或一段的最后位置更新为当前的字母的最后位置。

3，肯定到有一个时间，这个`last`就更新不了了，那么这个时候这个位置就是我们的分隔位置。注意题目要分隔后的长度，用`last - startindex + 1`。

4，找到一个分割位，更新一下起始位置，同理搜索就行了。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yj0AL1wN-1618151780408)(C:\\Users\\lp\\AppData\\Roaming\\Typora\\typora-user-images\\image-20210411222349626.png)\]][img-Yj0AL1wN-1618151780408_C_Users_lp_AppData_Roaming_Typora_typora-user-images_image-20210411222349626.png]

class Solution {
        
        public List<Integer> partitionLabels(String S) {
        
            //找到每个字符最后一次出现的索引位置，即最大边界
            //遍历字符串，若当前字符的最大边界大于当前边界，则更新边界，直到索引值等于最大边界，说明这里可以切割
            //然后将切割的字符串的长度存储到列表中，并更新start,继续遍历
            int[] last = new int[26]; //首先要创建一个长度为26的数组，用来存放每个小写字母最后一次出现的位置
            for(int i = 0; i < S.length(); i++){
        
                last[S.charAt(i) - 'a'] = i; 循环遍历字符串，将每个字母最后一次出现的位置添加到last中
            }
            List<Integer> list = new ArrayList<>();
            int start = 0, end = 0; //创建start、end属性来存放起始和结束下标
            for(int i = 0; i < S.length(); i++){
        
                end = Math.max(end, last[S.charAt(i) - 'a']);
                if(end == i){
         //说明所有的重复元素到此截止
                    list.add(end - start + 1);
                    start = end + 1;
                }
            }
            return list;
        }
    }

[img-Yj0AL1wN-1618151780408_C_Users_lp_AppData_Roaming_Typora_typora-user-images_image-20210411222349626.png]: /images/20221022/88dcefd713fa41499a96d1f55226b4f1.png