代码随想录算法训练营第三十八天| 435. 无重叠区间 、763.划分字母区间、56. 合并区间

435. 无重叠区间

题目链接：435. 无重叠区间

文档讲解：代码随想录/无重叠区间

视频讲解：视频讲解-无重叠区间

状态：已完成（1遍）

解题过程 

看到题目的第一想法

这道题我的想法是首先将集合按照start从小到大排序，如果start一样，局部最优就是把end更大的移除。但是太单薄了，支撑不起题目的要求，想了半天想不到思路，直接看视频讲解吧。

看完代码随想录之后的想法 

找到所有重叠的区间，把重叠的区间去掉就可以了。那么问题难点就在尽可能找到足够重叠的区间。反而跟前一天的射气球是一样的道理。题目换了一种方式，竟然完全想不起来了。。。

看了讲解手搓代码如下：

/**
 * @param {number[][]} intervals
 * @return {number}
 */
var eraseOverlapIntervals = function(intervals) {
    let newArr = intervals.sort((a,b)=>a[0]-b[0]);
    let ans = 0;
    for(let i = 1;i<newArr.length;i++){
        if(newArr[i][0]<newArr[i-1][1]){
            //后一个区间的左端小于前一个区间的右端，即重叠
            ans++;
            newArr[i][1] = Math.min(newArr[i-1][1],newArr[i][1]);
            //将重叠部分的最小右端记录下来，下一个区间的左端只要大于最小右端，就不会发生重叠。
        }
    }
    return ans;
};

总结

同样还可以按照右边界排序：

var eraseOverlapIntervals = function(intervals) {
    intervals.sort((a, b) => {
        return a[1] - b[1]
    })

    let count = 1
    let end = intervals[0][1]

    for(let i = 1; i < intervals.length; i++) {
        let interval = intervals[i]
        if(interval[0] >= end) {
            end = interval[1]
            count += 1
        }
    }
    
    return intervals.length - count
};

---

 763.划分字母区间

题目链接：763.划分字母区间

文档讲解：代码随想录/划分字母区间

视频讲解：视频讲解-划分字母区间

状态：已完成（1遍）

解题过程  

看到题目的第一想法

这题我的想法是首先要获取字符串中每个字母的第一次出现索引和最后一次出现的索引，所以我写了一个for循环用来更新每个字母在数组形式的哈希表中对应的每个小数组中开始和结束的索引。遍历完了之后把得到的哈希数组去除没出现过的字母的小数组，再将他们按照开始索引从小到大进行排序。这样就得到了每个字母出现的区间。

然后就和上一道题一样的流程了，不一样的就是最后一部分切割的字符串长度没办法及时记录，所以需要手动判断一下当前如果是for循环的最后一个元素了，手动添加一下。

手搓代码如下：

/**
 * @param {string} s
 * @return {number[]}
 */
var partitionLabels = function (s) {
    let startEndHash = new Array(26).fill(null).map(() => [-1, -1]);
    for (let i = 0; i < s.length; i++) {
        let index = s[i].charCodeAt() - 97;
        if (startEndHash[index][0] == -1) {
            //记录字符串中每个字母第一次出现的索引,和最后一次出现的索引
            startEndHash[index][0] = i;
            startEndHash[index][1] = i;
        } else {
            //已经出现过的只用改最后一次出现的索引就可以了
            startEndHash[index][1] = i;
        }
    }
    let newHash = startEndHash.filter((arr) => arr[0] !== -1);
    let sortedHash = newHash.sort((a, b) => a[0] - b[0]);
    let ans = [];
    for (let i = 1; i < sortedHash.length; i++) {
        if (sortedHash[i][0] < sortedHash[i - 1][1]) {
            sortedHash[i][1] = Math.max(sortedHash[i][1], sortedHash[i - 1][1]);
            //右端坐标取最大值，要包括所有出现的单个字母
            sortedHash[i][0] = sortedHash[i - 1][0];
            //左端坐标继承下去
            if (i == sortedHash.length - 1) {
                //最后一串记不到
                ans.push(1 + sortedHash[i][1] - sortedHash[i][0]);
            }
        } else {
            ans.push(1 + sortedHash[i - 1][1] - sortedHash[i - 1][0]);
            //记录上一个部分的长度
            if (i == sortedHash.length - 1) {
                //最后一串记不到
                ans.push(1 + sortedHash[i][1] - sortedHash[i][0]);
            }
        }
    }
    return ans;
};

提交成功！

 看完代码随想录之后的想法 

我的解法是代码随想录补充的和前面435思路一样的解法，而这道题有更简便的方法。

只需要记录每个字母的最后一次出现的位置，因为在字符串从前往后的遍历过程中就已经是按照第一次出现顺序来遍历了。然后每遍历一个字母，看看它的最后一次出现位置是什么，如果一直遍历到了最后一次出现的位置，那就说明可以切割了。

讲解代码如下：

/**
 * @param {string} s
 * @return {number[]}
 */
var partitionLabels = function(s) {
    let hash = {}
    for(let i = 0; i < s.length; i++) {
        hash[s[i]] = i
    }
    let result = []
    let left = 0
    let right = 0
    for(let i = 0; i < s.length; i++) {
        right = Math.max(right, hash[s[i]])
        if(right === i) {
            result.push(right - left + 1)
            left = i + 1
        }
    }
    return result
};

总结

和射箭问题以及435的思路一样确实可以解决这道题目，不过过程确实是太过复杂了。

---

56. 合并区间 

题目链接：56. 合并区间

文档讲解：代码随想录/合并区间 

视频讲解：视频讲解-合并区间

状态：已完成（1遍）

解题过程  

看到题目的第一想法

我的想法是首先还是将元素按照起始位置从小到大的顺序排列。然后遍历一个区间，更新当前重叠区间的最右端，如果新区间不和上一个区间重叠，则重新开始计算重叠区间。

手搓代码如下：

/**
 * @param {number[][]} intervals
 * @return {number[][]}
 */
var merge = function (intervals) {
    if(intervals.length == 1)return intervals;
    let sortedArr = intervals.sort((a, b) => a[0] - b[0]);
    let ans = [];
    let left = sortedArr[0][0], right = sortedArr[0][1];
    for (let i = 1; i < sortedArr.length; i++) {
        if (sortedArr[i][0] <= right) {
            //有重叠
            right = Math.max(sortedArr[i][1], right);
            if (i == sortedArr.length - 1) {
                let arr = [left, right];
                ans.push(arr);
            }
        } else {
            let arr = [left, right];
            ans.push(arr);
            left = sortedArr[i][0], right = sortedArr[i][1];
            if (i == sortedArr.length - 1) {
                let arr = [left, right];
                ans.push(arr);
            }
        }
    }
    return ans;
};

提交成功，没有问题。 

 看完代码随想录之后的想法 

大体思路和我差不多，小细节我还需注意，一个是每次添加进ans的数组不用left，right那么费事。还有对最后一个arr的添加不用if来判断，直接在函数最后解决就行。

讲解代码如下：

/**
 * @param {number[][]} intervals
 * @return {number[][]}
 */
var merge = function (intervals) {
    intervals.sort((a, b) => a[0] - b[0]);
    let prev = intervals[0]
    let result = []
    for(let i =0; i<intervals.length; i++){
        let cur = intervals[i]
        if(cur[0] > prev[1]){
            result.push(prev)
            prev = cur
        }else{
            prev[1] = Math.max(cur[1],prev[1])
        }
    }
    result.push(prev)
    return result
};

总结

一些细节确实还需要雕琢。