力扣74题——贪心算法：合并区间的高效策略

约翰_麦卡岩
38 阅读6分钟

在算法设计中，贪心算法是一种非常直观且高效的方法。它通过在每一步选择中都采取最优解，试图通过一系列局部最优解来达到全局最优。今天，我们将通过一个经典的算法问题——合并区间（LeetCode 第 56 题），来深入探讨贪心算法的应用和实现。

一、问题描述

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

示例 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] 重叠，合并后为 [1,5]。

二、为什么选择贪心算法

贪心算法在每一步选择中都采取最优解，希望通过一系列局部最优解来达到全局最优。对于合并区间问题，贪心算法的核心思想是按区间的起点排序，然后依次尝试合并当前区间与已合并的最后一个区间。如果当前区间的起点小于或等于已合并区间的终点，说明它们重叠，可以合并；否则，将当前区间加入到结果中。

1. 排序是贪心的基础

排序是贪心算法的基础。通过将区间按起点排序，我们可以确保前面的区间起点不会晚于后面的区间起点。这为我们的贪心选择提供了便利。具体来说，排序后，我们可以依次遍历每个区间，尝试将其与已合并的最后一个区间进行合并。

2. 局部最优选择

在合并区间的过程中，我们每次选择当前区间的起点与已合并的最后一个区间的终点进行比较。如果当前区间的起点小于或等于已合并区间的终点，说明它们重叠，可以合并。这种局部最优选择最终能够得到最少数量的不重叠区间，符合贪心思想。

三、算法实现

1. 排序

首先，我们需要对输入的区间按起点进行排序。在JavaScript中，可以使用sort()方法实现：

intervals.sort((a, b) => a[0] - b[0]);

2. 合并区间

排序后，我们遍历每个区间，尝试将其与已合并的最后一个区间进行合并。具体实现如下：

function merge(intervals) {
    if (intervals.length <= 1) {
        return intervals;
    }
    
    // 按区间的起点排序
    intervals.sort((a, b) => a[0] - b[0]);
    
    const merged = [intervals[0]]; // 初始化结果列表，加入第一个区间
    
    for (let i = 1; i < intervals.length; i++) {
        const currentInterval = intervals[i];
        const lastMergedInterval = merged[merged.length - 1];
        
        if (currentInterval[0] <= lastMergedInterval[1]) {
            // 如果当前区间与最后一个已合并区间重叠，合并它们
            lastMergedInterval[1] = Math.max(lastMergedInterval[1], currentInterval[1]);
        } else {
            // 否则，将当前区间加入结果列表
            merged.push(currentInterval);
        }
    }
    
    return merged;
}

3. 示例

让我们通过一个示例来理解算法的执行过程：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]

  1. 排序后：[[1,3],[2,6],[8,10],[15,18]]
  2. 初始化结果列表：merged = [[1,3]]
  3. 遍历每个区间：
    • 当前区间 [2,6]，与 merged[-1] = [1,3] 重叠，合并后 merged = [[1,6]]
    • 当前区间 [8,10]，不与 merged[-1] = [1,6] 重叠，加入结果列表 merged = [[1,6],[8,10]]
    • 当前区间 [15,18]，不与 merged[-1] = [8,10] 重叠，加入结果列表 merged = [[1,6],[8,10],[15,18]]

最终输出：[[1,6],[8,10],[15,18]]

四、贪心算法的优势

贪心算法在合并区间问题中具有明显的优势：

  1. 时间复杂度低：排序的时间复杂度为O(n log n)，遍历的时间复杂度为O(n)，总的时间复杂度为O(n log n)。
  2. 空间复杂度低：只需要一个额外的列表来存储结果，空间复杂度为O(n)。
  3. 实现简单：代码简洁，逻辑清晰，易于理解和实现。

五、其他解法

1. 分治法

分治法将问题分解为多个子问题，递归解决每个子问题，然后将子问题的解合并。对于合并区间问题，可以将区间分为两部分，分别合并，最后将结果合并。这种方法的时间复杂度较高，通常不推荐。

2. 动态规划

动态规划通常用于解决具有重叠子问题和最优子结构的问题。对于合并区间问题，动态规划的实现较为复杂，且时间复杂度较高。因此，贪心算法是更优的选择。

六、实际应用

合并区间问题在实际应用中非常常见。例如，在日程安排中，我们需要合并重叠的时间段；在资源分配中，我们需要合并重叠的资源使用区间。通过贪心算法，我们可以高效地解决这些问题，提高系统的性能和用户体验。

七、总结

合并区间问题是一个经典的贪心算法问题。通过按区间的起点排序，我们可以确保前面的区间起点不会晚于后面的区间起点。然后，通过依次尝试合并当前区间与已合并的最后一个区间，我们可以实现最少数量的不重叠区间。贪心算法不仅实现简单，而且时间复杂度低，是解决这类问题的最佳选择。

希望这篇文章能帮助你更好地理解贪心算法在合并区间问题中的应用。如果你对这个问题或贪心算法有其他疑问，欢迎在评论区留言，我们一起探讨！

八、代码实现

为了方便大家理解和使用，以下是完整的JavaScript代码实现：

function merge(intervals) {
    if (intervals.length <= 1) {
        return intervals;
    }
    
    // 按区间的起点排序
    intervals.sort((a, b) => a[0] - b[0]);
    
    const merged = [intervals[0]]; // 初始化结果列表，加入第一个区间
    
    for (let i = 1; i < intervals.length; i++) {
        const currentInterval = intervals[i];
        const lastMergedInterval = merged[merged.length - 1];
        
        if (currentInterval[0] <= lastMergedInterval[1]) {
            // 如果当前区间与最后一个已合并区间重叠，合并它们
            lastMergedInterval[1] = Math.max(lastMergedInterval[1], currentInterval[1]);
        } else {
            // 否则，将当前区间加入结果列表
            merged.push(currentInterval);
        }
    }
    
    return merged;
}

// 示例
const intervals = [[1,3],[2,6],[8,10],[15,18]];
console.log(merge(intervals)); // 输出：[[1,6],[8,10],[15,18]]

通过这段代码，你可以轻松地合并任何给定的区间集合。希望这篇文章对你有所帮助！

avatar
文章
阅读
粉丝