Leetcode 452 Minimum Number of Arrows to Burst Balloons

题目

There are some spherical balloons spread in two-dimensional space. For each balloon, provided input is the start and end coordinates of the horizontal diameter. Since it’s horizontal, y-coordinates don’t matter, and hence the x-coordinates of start and end of the diameter suffice. The start is always smaller than the end.

An arrow can be shot up exactly vertically from different points along the x-axis. A balloon with xstart and xend bursts by an arrow shot at x if xstart ≤ x ≤ xend. There is no limit to the number of arrows that can be shot. An arrow once shot keeps traveling up infinitely.

Given an array points where points[i] = [xstart, xend], return the minimum number of arrows that must be shot to burst all balloons.

Example 1:
Input: points = [[10,16],[2,8],[1,6],[7,12]]
Output: 2
Explanation: One way is to shoot one arrow for example at x = 6 (bursting the balloons [2,8] and [1,6]) and another arrow at x = 11 (bursting the other two balloons).

Example 2:
Input: points = [[1,2],[3,4],[5,6],[7,8]]
Output: 4

Example 3:
Input: points = [[1,2],[2,3],[3,4],[4,5]]
Output: 2

Example 4:
Input: points = [[1,2]]
Output: 1

Example 5:
Input: points = [[2,3],[2,3]]
Output: 1

Constraints:
0 <= points.length <= 104
points.length == 2
-231 <= xstart < xend <= 231 - 1

思路和代码

最开始想的暴力求解，对于每个区间，用count数组记录有多少个区间cover了这个数，但是超出了memory的限制。

class Solution {
    public int findMinArrowShots(int[][] points) {
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        for (int[] point : points) {
            min = Math.min(min, point[0]);
            max = Math.max(max, point[1]);
        }
        int[] count = new int[max - min + 1];
        for (int[] point : points) {
            for (int temp = point[0]; temp <= point[1]; temp++) {
                count[temp - min]++;
            }
        }
        Arrays.sort(count);
        int pSum = 0;
        for (int i = 1; i <= count.length; i++) {
            pSum += count[count.length - i];
            if (pSum >= points.length) {
                return i;
            }
        }
        return -1;
    }
}

然后考虑排序后融合，最后返回总区间个数减去融合的次数即为答案（融合完后剩下多少组分开的就需要多少箭）。每次比较这一个区间和上一个区间，如果后一个区间的左侧大于前一个的右侧，没有重合不做操作；如有则将当前区间改成融合后区间，继续和下一个做比较。

class Solution {
    public int findMinArrowShots(int[][] points) {
        int merge = 0;
        Arrays.sort(points, (o1, o2) -> Integer.compare(o1[0], o2[0]));
        for (int i = 1; i < points.length; i++) {
            if (!(points[i][0] > points[i - 1][1])) {
                //System.out.println(points[i][0] + " " + points[i][1]);
                merge++;
                points[i] = new int[] {points[i][0], Math.min(points[i][1], points[i - 1][1])};
            }
        }
        return points.length - merge;
    }
}

又因为刚才的做法每次都新建区间points[i]，显然不合理，然后我们又看到新区间只有右边改变了，那考虑只记录右边端点值。

class Solution {
    public int findMinArrowShots(int[][] points) {
        if (points == null || points.length == 0) return 0;
        int merge = 0;
        // Arrays.sort(points, (o1, o2) -> {
        //     if (o1[0] != o2[0]) return Integer.compare(o1[0], o2[0]);
        //     return Integer.compare(o1[1], o2[1]);
        // });
        Arrays.sort(points, (o1, o2) -> Integer.compare(o1[0], o2[0]));
        int right = points[0][1];
        for (int i = 1; i < points.length; i++) {
            if (!(points[i][0] > right)) {
                //System.out.println(points[i][0] + " " + points[i][1]);
                merge++;
                right = Math.min(points[i][1], right);
            } else {
                right = points[i][1];
            }
        }
        return points.length - merge;
    }
}