代码随想录算法训练营第三十六天| 452. 用最少数量的箭引爆气球 、435. 无重叠区间、763. 划分字母区间

[LeetCode] 452. 用最少数量的箭引爆气球

[LeetCode] 452. 用最少数量的箭引爆气球 文章解释

[LeetCode] 452. 用最少数量的箭引爆气球 视频解释

题目：

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

 

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
解释：每个气球需要射出一支箭，总共需要4支箭。

示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
解释：气球可以用2支箭来爆破:
- 在x = 2处发射箭，击破气球[1,2]和[2,3]。
- 在x = 4处射出箭，击破气球[3,4]和[4,5]。

提示:

• 1 <= points.length <= 10^5
• points[i].length == 2
• -2^31 <= xstart < xend <= 2^31 - 1

[LeetCode] 452. 用最少数量的箭引爆气球

自己看到题目的第一想法

    按起始位置排序，从第一个开始往后遍历，同时不断的收缩右边界。一旦遇到左边界大于右边界的，则说明需要一支新的箭。

    当然我的第一版实现奇奇怪怪的。感恩 LeetCode 让我 AC。

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] a,int[] b){
                if(a[0] == b[0]) {      // 若一维元素相等
                    return a[1] > b[1] ? 1 : -1; // 则按照二维元素升序返回
                }else{
                    return a[0] > b[0] ? 1 : -1;  // 否则，按照一维元素升序返回，故得到最终输出结果！
                }
            }
        });

        int result = 0;
        int left = 0;
        int right = 0;
        for (int i = 0; i < points.length; i++) {
            int jumped = -1;
            result++;
            left = points[i][0];
            right = points[i][1];
            for (int j = i + 1; j < points.length; j++) {
                if (points[j][0] <= right && points[j][0] >= left) {
                    jumped = j;
                    right = Math.min(right, points[j][1]);
                } else {
                    break;
                }
            }
            if (jumped != -1) {
                i = jumped;
            }
        }
        return result;
    }
}

看完代码随想录之后的想法

    想法是一样的， 但是代码实现很重要。

// 效率不高
class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] a,int[] b){
                return a[0] > b[0] ? 1 : -1; // 注意这里别用 a[0] - b[0]
            }
        });
        int result = 1;
        for (int i = 1; i < points.length; i++) {
            if (points[i][0] <= points[i - 1][1]) {
                // 这里很妙
                points[i][1] = Math.min(points[i - 1][1], points[i][1]);
                continue;
            }
            result++;
        }
        return result;
    }
}

自己实现过程中遇到哪些困难

    忘记了

[LeetCode] 435. 无重叠区间
[LeetCode] 435. 无重叠区间 文章解释

[LeetCode] 435. 无重叠区间 视频解释

题目：

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

示例 1:

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

示例 2:

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

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

提示:

• 1 <= intervals.length <= 10^5
• intervals[i].length == 2
• -5 * 10^4 <= starti < endi <= 5 * 10^4

[LeetCode] 435. 无重叠区间

自己看到题目的第一想法

    想不明白。    

看完代码随想录之后的想法

// 左对齐
class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] a,int[] b){
                if (a[0] == b[0]) {// 这里要写， 不然会报协议异常
                    return 0;
                }
                return a[0] > b[0] ? 1 : -1;  // 否则，按照一维元素升序返回，故得到最终输出结果！
            }
        });
        int count = 0;
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] < intervals[i - 1][1]) {
                intervals[i][1] = Math.min(intervals[i][1], intervals[i - 1][1]);
                count++;
            }
        }
        return count;
    }
}

// 右对齐
class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] a,int[] b){
                if (a[1] == b[1]) {
                    return 0;
                }
                return a[1] > b[1] ? 1 : -1;  // 否则，按照一维元素升序返回，故得到最终输出结果！
            }
        });
        int count = 0;
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] < intervals[i - 1][1]) {
                intervals[i][1] = intervals[i - 1][1];
                count++;
            }
        }
        return count;
    }
}

自己实现过程中遇到哪些困难

    忘记了。。。

[LeetCode] 763. 划分字母区间
[LeetCode] 763. 划分字母区间 文章解释

[LeetCode] 763. 划分字母区间 视频解释

题目：

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

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

示例 2：

输入：s = "eccbbbbdec"
输出：[10]

提示：

• 1 <= s.length <= 500
• s 仅由小写英文字母组成

[LeetCode] 763. 划分字母区间

自己看到题目的第一想法

    用 Map 记录每个字母的区间范围，从头到尾遍历每个字符串，如果当前字符串的右边界已经记录的更大且左边界再范围内， 更新右边界。遇到左边界不在范围内的时候即可以统计。

看完代码随想录之后的想法

    1. 想法差不多， 但实现更优雅很多。

    2. 有两种解法。

class Solution {
    private int[] charIndexes = new int[26];
    public List<Integer> partitionLabels(String s) {

        LinkedList<Integer> result = new LinkedList <>();

        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            charIndexes[chars[i] - 'a'] = i;
        }
        int left = -1;
        int right = -1;
        for (int i = 0; i < chars.length; i++) {
            if (charIndexes[chars[i] - 'a'] > right) {
                right = charIndexes[chars[i] - 'a'];
                // 自己实现的时候， 这里写了个迷之 continue。。。
            }
            if (i == right) {
                result.add(right - left);
                left = i;
                right = -1;
            }
        }
        return result;
    }
}

class Solution {
    public List<Integer> partitionLabels(String s) {
        LinkedList<Integer> result = new LinkedList <>();
        Integer[][] charRange = new Integer[26][2];
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int charIndex = chars[i] - 'a';
            if (charRange[charIndex][0] == null) {
                charRange[charIndex][0] = i;
            }

            charRange[charIndex][1] = i;
        }
        Arrays.sort(charRange,new Comparator<Integer[]>() {
            @Override
            public int compare(Integer[] o1, Integer[] o2) {
                if (o1[0] == null) {
                    return -1;
                } else {
                    if (o2[0] == null) {
                        return 1;
                    } else {
                        return o1[0] - o2[0];
                    }
                }
            }
        });
        int left = 0;
        int right = -1;
        for (int i = 0; i < charRange.length; i++) {
            if (charRange[i][0] == null) {
                continue;
            }
            if (right == -1) {
                right = charRange[i][1];
                continue;
            }
            if (charRange[i][0] > right) {
                result.add(right - left + 1);
                left = charRange[i][0];
                right = charRange[i][1];
            } else {
                right = Math.max(charRange[i][1], right);
            }
        }
        result.add(right - left + 1);

        return result;
    }
}

自己实现过程中遇到哪些困难

     无