代码随想录算法训练营第三十一天|56. 合并区间 738.单调递增的数字

56. 合并区间

题目：

以数组 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

思路：

要解决合并重叠区间的问题，可以使用贪心算法。

1. 排序区间：首先，将所有区间按照起始位置 starti 进行排序。这样可以确保在遍历区间时，每个区间的起始位置总是比前一个区间的起始位置大或相等。

2. 合并区间：创建一个空的结果数组 merged 用于存放合并后的区间。然后，依次遍历排序后的区间：

   • 如果 merged 为空或者 merged 中最后一个区间的结束位置小于当前区间的起始位置，说明当前区间与前面的区间没有重叠，可以直接将当前区间加入到 merged 中。
   • 如果 merged 中最后一个区间的结束位置大于或等于当前区间的起始位置，说明当前区间与前面的区间有重叠，此时需要将它们合并。合并的方法是更新 merged 中最后一个区间的结束位置为二者的最大结束位置。

3. 返回结果：最终，merged 中存储的就是合并后的不重叠区间。

上代码：

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.empty()) return {};
        
        // 按照每个区间的起始位置排序
        sort(intervals.begin(), intervals.end());

        // 存储合并后的区间
        vector<vector<int>> merged;
        
        for (const auto& interval : intervals) {
            // 如果 merged 为空或当前区间与 merged 中最后一个区间不重叠，则将当前区间加入到 merged 中
            if (merged.empty() || merged.back()[1] < interval[0]) {
                merged.push_back(interval);
            } else {
                // 否则，合并当前区间与 merged 中最后一个区间
                merged.back()[1] = max(merged.back()[1], interval[1]);
            }
        }
        
        return merged;
    }
};

738.单调递增的数字

题目：

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

提示:

• 0 <= n <= 109

思路：

要解决这个问题，可以使用贪心算法来确保生成的数字尽可能大且满足单调递增的条件。

贪心思路

1. 从左到右遍历数字：将给定的数字转换为字符数组，从左到右遍历这个字符数组，寻找第一个不满足单调递增的地方。

2. 调整数字：

   • 一旦发现某个位置 i 上的数字比它后面的数字大（即 digits[i] > digits[i+1]），我们就需要从 i 开始调整数字以确保单调递增。
   • 为了使数字尽可能大，我们将 digits[i] 减 1，并将 digits[i] 之后的所有数字变为 9，这样可以尽可能接近给定的数字，同时满足单调递增的条件。

3. 处理连续相等的情况：

   • 如果在 digits[i] 减 1 之后，发现前面的数字（即 digits[i-1]）与 digits[i] 相等，则继续向前检查并进行相同的操作，直到确保调整后的数字也是单调递增的。

4. 返回结果：最后，将调整后的字符数组转换回整数并返回。

上代码：

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string digits = to_string(n);
        int len = digits.size();
        int mark = len; // 记录需要改为9的位置

        // 从左到右找到第一个不满足单调递增的地方
        for (int i = len - 1; i > 0; --i) {
            if (digits[i] < digits[i - 1]) {
                mark = i; // 从这里开始后面的都改为9
                digits[i - 1]--;
            }
        }

        // 将标记后的所有数字变为9
        for (int i = mark; i < len; ++i) {
            digits[i] = '9';
        }

        // 转换回整数并返回
        return stoi(digits);
    }
};