LeetCode 56. 合并区间 (贪心算法)

最新推荐文章于 2024-08-19 16:35:52 发布

QuantumYou

最新推荐文章于 2024-08-19 16:35:52 发布

阅读量212

点赞数 1

分类专栏： # ICPC、洛谷、LeetCode、蓝桥杯文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/QuantumYou/article/details/120048346

版权

ICPC、洛谷、LeetCode、蓝桥杯专栏收录该内容

66 篇文章 5 订阅

订阅专栏

本文介绍了如何使用排序比较法和贪心算法解决合并重叠区间的问题。首先，通过排序区间左边界，然后依次合并相邻的重叠区间，实现整体最优。贪心算法中，按左边界排序后，每次都选取右边界最大的区间进行合并，确保局部最优解。两种方法均能有效合并区间并覆盖所有输入。

摘要由CSDN通过智能技术生成

半岛铁盒

题目

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

示例 1：

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

题解

解法一（排序比较法）

暴力模拟

首先按照区间的左值进行排序（重写排序方法）
加入新区间时，前后进行比较

package leetcodePlan.Base;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class P0056 {

	public static void main(String[] args) {
		int [][] intervals = {{1,3},{2,6},{8,10},{15,18}} ;
	    int [][] res = fun(intervals) ;
	    
	    for(int i =0 ; i < res.length ;i++) {
	    	for(int j =0 ; j <res[0].length ;j++) {
	    		System.out.print(res[i][j] + " ");
	    	}
	    	System.out.println();
	    }
	}
	
	
	public static int [][] fun(int [][] intervals){
		
		// 重写方法，按照区间左边的值进行排序
		Arrays.sort(intervals , new Comparator<int[]>(){
			@Override
			public int compare(int [] o1,int [] o2) {
				return o1[0] - o2[0] ; 
			}
		}) ;
		
		// 初始化 outputs ,用于存储区间合并的动态数组
	    ArrayList<int[]> outputs = new ArrayList<>() ;	
        // 遍历处理每一区间
	    for(int i =0 ; i < intervals.length ;i++) {
	    	int [] currInterval = intervals[i] ;
	    	if(outputs.isEmpty()) {   // 是第一个元素
	    		outputs.add(currInterval) ;
 	    	} else {   // 进行判断是否有重叠
 	    		int [] outputsLastInterval = outputs.get(outputs.size() - 1) ;
 	    		int outputsRight =  outputsLastInterval[1] ;
 	    		int currLeft = currInterval[0] ;
 	    		
 	    		if(outputsRight < currLeft) {  // 没有重叠
 	    			outputs.add(currInterval) ;
 	    		} else {
 	    			int currRight = currInterval[1] ;
 	    			outputsLastInterval[1] = Math.max(outputsRight, currRight) ;
 	    			// 取最大值的原因在于可能存在包含的情况
 	    		}
 	    	}
	    }
	    return outputs.toArray(new int[outputs.size()][]) ;
	    
	}

}

解法二（贪心算法）

关于贪心算法（可以参考这篇文章）跳转链接
按照左边界排序，排序之后局部最优：每次合并都取最大的右边界，这样就可以合并更多的区间了，
整体最优：合并所有重叠的区间。
局部最优可以推出全局最优

	public static int[][] fun2(int[][] intervals){
		List<int []> res = new LinkedList<>() ;
		Arrays.sort(intervals,(o1,o2) -> Integer.compare(o1[0], o2[0]));   // 按照右区间进行排序
		
		int start = intervals[0][0] ;
		for(int i = 1 ; i< intervals.length ;i++) {
			if(intervals[i][0] > intervals[i-1][0]) {   // 没有交集
				res.add(new int[] {start,intervals[i-1][1]});
				start = intervals[i][0] ;
			} else {
				intervals[i][1] = Math.max(intervals[i][1], intervals[i-1][1]) ;
			}
		}
		res.add(new int[] {start,intervals[intervals.length-1][1]}) ;
		return res.toArray(new int[res.size()][]) ;
	}