435.无重叠区间 763.划分字母区间 56. 合并区间

最新推荐文章于 2024-09-13 16:27:15 发布

Cedar~~

最新推荐文章于 2024-09-13 16:27:15 发布

阅读量163

点赞数 4

文章标签：算法排序算法数据结构 leetcode

本文链接：https://blog.csdn.net/qq_43361824/article/details/134515086

版权

435.无重叠区间

力扣题目链接(opens new window)

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

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

示例 1:

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

示例 2:

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

示例 3:

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

思路

首先区间存在两个边界，那么左边界和右边界相当于两个维度
先对其中一个维度排序，然后在进行下一步的思考
这里先对左边界升序排序
接下来想不到贪心的局部最优解，看下题解
恍然大悟啊
跟弓箭射爆气球的题目非常类似，弓箭的数量相当于非交叉区间的数量
用总区间数量减去弓箭的数量，就是要移除的区间数量
这里注意下边界条件的处理： intervals[i - 1][1] > intervals[i][0] intervals[i - 1][1] <= intervals[i][0]
[[1,2],[2,3],[3,4],[4,5]]区间在气球那道题中，应该需要两个箭
但此题目中，要处理边界条件，使得上述区间有四支箭。这样4-4 = 0 也就是需要移除的区间数量

局部最优解：尽可能找到多个重叠的区间（弓箭尽可能射爆多个气球）
整体最优解：无重叠区间

代码如下

public static void main(String args[]){
    int[][] intervals = new int[][]{{1,2},{2,3},{3,4},{1,3}};
    eraseOverlapIntervals(intervals);
}


public static int eraseOverlapIntervals(int[][] intervals) {

    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0] , b[0])); // 按照数组起始位置排序


    int num = 1;
    int minRightIndex = intervals[0][1];
    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i - 1][1] > intervals[i][0]) {

            if (intervals[i][0] >= minRightIndex) {// 大于最小右侧
                num++;
                minRightIndex = intervals[i][1];

            } else {
                if (intervals[i][1] < minRightIndex)
                    minRightIndex = intervals[i][1];
            }


        } else {
            num++;
            minRightIndex = intervals[i][1];
        }
    }

    return intervals.length - num;

}

问题

对二维数组排序出现错误：java.lang.IllegalArgumentException: Comparison method violates its general contract
错误原因：你的比较函数违反了Java的比较器（Comparator）的一般约定。在你的代码中，当a[0]等于b[0]时，你的比较函数返回1，这意味着a[0]大于b[0]。然而，这违反了比较器的一般约定，即如果a[0]等于b[0]，比较函数应该返回0。
错误代码

Arrays.sort(intervals, (a, b) -> {// 左边界升序排序
           if (a[0] < b[0])
               return -1;
           return 1;
       });

正确代码

 Arrays.sort(intervals, (a, b) -> {// 左边界升序排序
    if (a[0] < b[0])
        return -1;
    else if (a[0] > b[0])
        return 1;
    else
        return 0;
});

或者

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0] , b[0])); // 左边界升序排序

763.划分字母区间

力扣题目链接(opens new window)

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

示例：

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

提示：

S的长度在[1, 500]之间。
S只包含小写字母 ‘a’ 到 ‘z’ 。

思路:贪心

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。
首先先确认一个区间，可以是字符串第一个字母，和该字母最后一次出现的位置。
对该区间元素遍历，找到区间元素最后一个出现的位置，
若大于右侧区间边界，则更新区间
以此类推
当右侧边界为字符串最后一个元素时，划分结束
贪心局部最优解：遍历当前区间所有元素，找到最后一个元素出现的位置
贪心整体最优解：字符串划分为尽可能多的片段
时间复杂度O(N2)
空间复杂度O(1)

代码如下

public static void main(String args[]) {
    String str = "eccbbbbdec";
    partitionLabels(str);
}


public static List<Integer> partitionLabels(String s) {
    List<Integer> result = new ArrayList<>();
    if (s == null || s.length() == 0) {
        return result;
    }

    // 子区间左边界
    int leftIndex = 0;
    // 子区间右边界
    int rightIndex = 0;

    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        for (int j = s.length() - 1; j >= i; j--) {
            if (s.charAt(j) == c) {// 找到当前元素最后出现的位置
                rightIndex = Math.max(j, rightIndex);
            }
        }

        // 当前遍历元素超过边界
        if (i == rightIndex) {
            int num = rightIndex - leftIndex + 1;// 当前区间数量
            result.add(num);
            leftIndex = rightIndex = i + 1;// 更新当前区间左右边界
        }
    }

    return result;

}

思路：贪心优化

上述代码时间复杂度比较高的原因是嵌套了两个for循环
是否可以去除一个For循环呢？
找到当前区间右侧边界这个步骤，可以放到For循环外,用另一个for循环遍历字符串，事先存储每个字符最后出现的位置
这样两个嵌套的for循环，就拆分为两个单独的For循环，时间复杂度可降低为O(N)

代码如下

public static List<Integer> partitionLabels(String s) {
    List<Integer> result = new ArrayList<>();
    if (s == null || s.length() == 0) {
        return result;
    }

    int[] charLastIndex = new int[26];
    for (int i = s.length() - 1; i >= 0; i--) {// 遍历字符串，找出字符串所有元素最后出现的位置，并存储在数组中
        char c = s.charAt(i);
        if (charLastIndex[c - 'a'] == 0) {
            charLastIndex[c - 'a'] = i;
        }
    }

    int leftIndex = 0;// 子区间左边界
    int rightIndex = 0;// 子区间右边界
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        rightIndex = Math.max(charLastIndex[c-'a'], rightIndex);

        // 当前遍历元素超过边界
        if (i == rightIndex) {
            int num = rightIndex - leftIndex + 1;// 当前区间数量
            result.add(num);
            leftIndex = rightIndex = i + 1;// 更新当前区间左右边界
        }
    }
    return result;

}

56.合并区间

力扣题目链接(opens new window)

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
注意：输入类型已于2019年4月15日更改。请重置默认代码定义以获取新方法签名。

思路:贪心

区间左边界和右边界为两个维度，先对其中一个维度排序，然后在合并重叠区间
这里先对左区间升序排序
定义数组第一个区间表示重叠区间，遍历二维数组的区间，如果出现重叠，那么更新重叠区间即可
如果没有出现重叠，保存重叠区间，并更新重叠区间为当前区间
贪心算法局部最优解：合并重叠的区间
贪心算法整体最优解：合并所有的重叠区间
时间复杂度 : O(NlogN) 排序需要 O(NlogN) 的复杂度
空间复杂度 : O(logN) java所使用的内置函数用的是快速排序需要 logN 的空间

代码如下

public static void main(String args[]) {
    int[][] intervals = new int[][]{{1,4},{4,5}};
    merge(intervals);
}


public static int[][] merge(int[][] intervals) {
    LinkedList<int[]> result = new LinkedList<>();
    if (intervals == null || intervals.length == 0)
        return result.toArray(new int[0][]);

    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));// 对左区间升序排序
    int leftIndex = intervals[0][0];// 重叠区间左边界
    int rightIndex = intervals[0][1];// 重叠区间右边界

    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] > rightIndex) {// 当前区间左边界>重叠区间右侧边界
            result.add(new int[]{leftIndex, rightIndex});
            leftIndex = intervals[i][0];
            rightIndex = intervals[i][1];
        } else {// 当前区间左边界<=重叠区间右侧边界
            if (intervals[i][1] > rightIndex) { // 当前区间右侧边界 > 重叠区间右侧边界
                rightIndex = intervals[i][1];
            }
        }
    }
    result.add(new int[]{leftIndex, rightIndex});

    return result.toArray(new int[0][]);

}