算法Day27|贪心专题四 ​ 435. 无重叠区间，763.划分字母区间，56. 合并区间，738.单调递增的数字

435. 无重叠区间

 1.题目描述

• 给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

2.解题思路 

• 相信很多同学看到这道题目都冥冥之中感觉要排序，但是究竟是按照右边界排序，还是按照左边界排序呢？
• 这其实是一个难点！
  • 按照右边界排序，就要从左向右遍历，因为右边界越小越好，只要右边界越小，留给下一个区间的空间就越大，所以从左向右遍历，优先选右边界小的。
  • 按照左边界排序，就要从右向左遍历，因为左边界数值越大越好（越靠右），这样就给前一个区间的空间就越大，所以可以从右向左遍历。
• 我来按照右边界排序，从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。
• 此时问题就是要求非交叉区间的最大个数。
• 右边界排序之后，局部最优：优先选右边界小的区间，所以从左向右遍历，留给下一个区间的空间大一些，从而尽量避免交叉。全局最优：选取最多的非交叉区间。

• 区间，1，2，3，4，5，6都按照右边界排好序。
• 每次取非交叉区间的时候，都是可右边界最小的来做分割点（这样留给下一个区间的空间就越大），所以第一条分割线就是区间1结束的位置。
• 接下来就是找大于区间1结束位置的区间，是从区间4开始。那有同学问了为什么不从区间5开始？别忘已经是按照右边界排序的了。
• 区间4结束之后，在找到区间6，所以一共记录非交叉区间的个数是三个。
• 总共区间个数为6，减去非交叉区间的个数3。移除区间的最小数量就是3。

3.代码实现

class Solution {
    //435. 无重叠区间--按照区间右边界升序排序
    public int eraseOverlapIntervals(int[][] intervals) {
        // 按照区间右边界升序排序
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[1], b[1]));
        int res = 0;
        int edge = Integer.MIN_VALUE;
        for (int i = 0; i < intervals.length; i++) {
            // 若上一个区间的右边界小于当前区间的左边界，说明无交集
            if (edge <= intervals[i][0]) {
                //更新edge为当前区间的右边界
                edge = intervals[i][1];
            } else {
                res++;
            }
        }
        return res;
    }
}

class Solution {
    //435. 无重叠区间--按照区间左边界升序排序
    public int eraseOverlapIntervals(int[][] intervals) {
        // 按照区间左边界升序排序
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        int res = 0;
        int edge = intervals[0][1];
        for (int i = 1; i < intervals.length; i++) {
            // 若上一个区间的右边界小于当前区间的左边界，说明无交集
            if (edge <= intervals[i][0]) {
                //更新edge为当前区间的右边界
                edge = intervals[i][1];
            } else {
                res++;
                //相交的时候取最小的右边
                edge = Math.min(edge, intervals[i][1]);
            }
        }
        return res;
    }
}

763.划分字母区间

1.题目描述

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

2.解题思路 

• 由于同一个字母只能出现在同一个片段，显然同一个字母的第一次出现的下标位置和最后一次出现的下标位置必须出现在同一个片段。因此需要遍历字符串，得到每个字母最后一次出现的下标位置。
• 在得到每个字母最后一次出现的下标位置之后，可以使用贪心的方法将字符串划分为尽可能多的片段，具体做法如下。

• 在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。
• 可以分为如下两步：
  • 统计每一个字符最后出现的位置
  • 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

3.代码实现

class Solution {
    //763.划分字母区间
    public List<Integer> partitionLabels(String s) {
        List<Integer> res = new ArrayList<>();//结果集
        int[] last = new int[26];//记录每个字符出现的最后位置
        char[] array = s.toCharArray();
        // 1.统计每一个字符最后出现的位置
        for (int i = 0; i < s.length(); i++) {
            last[array[i] - 'a'] = i;
        }
        //2.从左到右遍历字符串，遍历的同时维护当前片段的开始下标start 和结束下标end
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            //3.1对于每个访问到的字母 c，得到当前字母的最后一次出现的下标位置End-c
            //3.2则当前片段的结束下标一定不会小于End-c
            //3.3因此让end为end和End-c的最大值
            end = Math.max(end, last[array[i] - 'a']);
            if (i == end) {
                // 4.1当访问到下标 end 时，当前片段访问结束，当前片段的下标范围是[start,end]，
                // 4.2长度为1end−start+1，将当前片段的长度添加到返回值，
                // 4.3然后令start=end+1，继续寻找下一个片段
                res.add(end - start + 1);
                start = end + 1;
            }
        }
        return res;
    }
}

56. 合并区间

1.题目描述

• 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

 2.解题思路 

• 大家应该都感觉到了，此题一定要排序，那么按照左边界排序，还是右边界排序呢？
• 都可以！
• 那么我按照左边界排序，排序之后局部最优：每次合并都取最大的右边界，这样就可以合并更多的区间了，整体最优：合并所有重叠的区间。

• 按照左边界从小到大排序之后，如果 intervals[i][0] < intervals[i - 1][1] 即intervals[i]左边界 < intervals[i - 1]右边界，则一定有重复，因为intervals[i]的左边界一定是大于等于intervals[i - 1]的左边界。
• 即：intervals[i]的左边界在intervals[i - 1]左边界和右边界的范围内，那么一定有重复！
• 这么说有点抽象，看图：（注意图中区间都是按照左边界排序之后了）

• 知道如何判断重复之后，剩下的就是合并了，如何去模拟合并区间呢？
• 其实就是用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。

  3.代码实现

class Solution {
     //56. 合并区间
    public int[][] merge(int[][] intervals) {
        //按照左边界排序
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        List<int[]> res = new ArrayList<>();
        //initial start 是最小左边界
        int start = intervals[0][0];
        int end = intervals[0][1];
        for (int i = 1; i < intervals.length; i++) {
            //如果左边界大于最大右边界
            if (intervals[i][0] > end) {
                //加入区间 并且更新start，end
                res.add(new int[]{start, end});
                start = intervals[i][0];
                end = intervals[i][1];
            } else {
                //更新最大右边界end
                end = Math.max(end, intervals[i][1]);
            }
        }
        //添加最后一组区间
        res.add(new int[]{start, end});
        return res.toArray(new int[res.size()][]);
    }
}

738.单调递增的数字

1.题目描述

• 当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。
• 给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

 2.解题思路  

• 题目要求小于等于N的最大单调递增的整数，那么拿一个两位的数字来举例。
• 例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]--，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。
• 这一点如果想清楚了，这道题就好办了。
• 局部最优：遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]--，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。
• 全局最优：得到小于等于N的最大单调递增的整数。

• 但这里局部最优推出全局最优，还需要其他条件，即遍历顺序，和标记从哪一位开始统一改成9。
• 此时是从前向后遍历还是从后向前遍历呢？
  • 从前向后遍历的话，遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]减一，但此时如果strNum[i - 1]减一了，可能又小于strNum[i - 2]。
  • 这么说有点抽象，举个例子，数字：332，从前向后遍历的话，那么就把变成了329，此时2又小于了第一位的3了，真正的结果应该是299。
• 所以从前后向遍历会改变已经遍历过的结果！
  • 那么从后向前遍历，就可以重复利用上次比较得出的结果了，从后向前遍历332的数值变化为：332 -> 329 -> 299

3.代码实现

class Solution {
  //738.单调递增的数字
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        char[] array = s.toCharArray();
        int start = s.length();
        for (int i = s.length() - 2; i >= 0; i--) {
            //非单调递增
            if (array[i] > array[i + 1]) {
                //让array[i]减一
                array[i]--;
                //记录下i+1的位置，以后要变成'9'
                start = i + 1;
            }
        }
        for (int i = start; i < s.length(); i++) {
            array[i] = '9';
        }
        return Integer.parseInt(String.valueOf(array));
    }
}