LeetCode148--合并区间(L56)、不同路径(L62)

1、合并区间(L56)

//以数组 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].
//
//
// 示例 2： 
//
//
//输入：intervals = [[1,4],[4,5]]
//输出：[[1,5]]
//解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。 
//
// 
//
// 提示： 
//
// 
// 1 <= intervals.length <= 104 
// intervals[i].length == 2 
// 0 <= starti <= endi <= 104 
// 
// Related Topics 排序 数组

我们先根据这些区间的左端点对这些数组进行排序，从小到大，首先我们把第一个区间先放到结果里面，然后把这个区间指定为当前区间，然后判断下一个区间是不是能和当前区间重合，如果可以那就直接进行合并，如果不行，那就把下一个区间放到结果里，当做下一个区间。至于如何判断能不能重合，是直接通过比较当前区间的右端点和下一个区间的左端点，如果下一个区间的左端点大于当前区间的右端点，那就不能重合，否则重合。重合如何合并，因为当前区间的左端点由于我们排过序，所以肯定是小于下一个区间的左端点的，我们只需要采用当前区间的右端点和下一个区间的右端点，采用最大的那个作为新区间的右端点。

public int[][] merge(int[][] intervals) {
        //查找排序
        for (int i = 0; i < intervals.length - 1; i++) {
            int min = intervals[i][0];
            for (int j = i; j < intervals.length ; j++) {
                if(intervals[j][0] < min){
                    min = intervals[j][0];
                    int[] arr = intervals[j].clone();
                    intervals[j] = intervals[i].clone();
                    intervals[i] = arr.clone();
                }
            }
        }
        List<int[]> merged = new ArrayList<>();
        for (int i = 0; i < intervals.length; i++) {
            int L = intervals[i][0];
            int R = intervals[i][1];
            int length = merged.size();
            if(length == 0 || merged.get(length - 1)[1] < L){
                merged.add(intervals[i]);
            }else{
                merged.get(length - 1)[1] = Math.max(merged.get(length - 1)[1], R);
            }
        }
        return merged.toArray(new int[merged.size()][2]);
    }

2、不同路径(L62)

//一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 
//
// 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 
//
// 问总共有多少条不同的路径？ 
//
// 
//
// 示例 1： 
//
// 
//输入：m = 3, n = 7
//输出：28 
//
// 示例 2： 
//
// 
//输入：m = 3, n = 2
//输出：3
//解释：
//从左上角开始，总共有 3 条路径可以到达右下角。
//1. 向右 -> 向下 -> 向下
//2. 向下 -> 向下 -> 向右
//3. 向下 -> 向右 -> 向下
// 
//
// 示例 3： 
//
// 
//输入：m = 7, n = 3
//输出：28
// 
//
// 示例 4： 
//
// 
//输入：m = 3, n = 3
//输出：6 
//
// 
//
// 提示： 
//
// 
// 1 <= m, n <= 100 
// 题目数据保证答案小于等于 2 * 109 
// 
// Related Topics 数组 动态规划

不同路径的问题实质上是一个排列组合的问题，因为从左端点到右端点中向右或者向下的步数是固定的，所以只需要确定什么时候向下以及什么时候向上，比如一共需要走8步能够到达终点，其中下行4步，右行4步，所以只需要从8个中随机挑出4个就行了。

public int uniquePaths(int m, int n) {
        int k = m + n - 2;
        int min = Math.min(m - 1, n - 1);
        long result_1 = 1;
        long result_2 = 1;
        for (int i = min; i >= 1; i--) {
            result_1 *= k;
            k--;
        }
        while(min >= 1){
            result_2 *= min;
            min--;
        }
        return (int)(result_1/result_2);
    }