【每日力扣】738. 单调递增的数字与56. 合并区间

🔥 个人主页: 黑洞晓威
😀你不必等到非常厉害，才敢开始，你需要开始，才会变的非常厉害

738. 单调递增的数字

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

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

解题思路

1. 将给定的数字 n 转换为字符数组，便于逐位处理。
2. 从最高位开始遍历字符数组，找到第一个不满足单调递增条件的位置 idx，即找到第一个满足 nums[idx] > nums[idx + 1] 的下标。
3. 如果找到了不满足条件的位置 idx，则将 nums[idx] 减去 1，并将 idx 及其后面的所有数字都变为 9，以保证最终得到的数字是小于等于 n 的最大的单调递增数字。
4. 如果没有找到不满足条件的位置 idx，说明给定的数字 n 本身就是单调递增的数字，则无需进行额外处理。

代码实现

public class MonotoneIncreasingDigits {
    public int monotoneIncreasingDigits(int n) {
        char[] nums = Integer.toString(n).toCharArray();
        int idx = -1;
        
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] > nums[i + 1]) {
                idx = i;
                break;
            }
        }

        if (idx != -1) {
            while (idx >= 0 && nums[idx] > nums[idx + 1]) {
                nums[idx]--;
                idx--;
            }

            for (int i = idx + 1; i < nums.length; i++) {
                nums[i] = '9';
            }
        }

        return Integer.parseInt(new String(nums));
    }

    public static void main(String[] args) {
        MonotoneIncreasingDigits solution = new MonotoneIncreasingDigits();

        // Test Case 1
        int n1 = 10;
        int result1 = solution.monotoneIncreasingDigits(n1);
        System.out.println("Test Case 1 Result: " + result1);  // Output: 9

        // Test Case 2
        int n2 = 1234;
        int result2 = solution.monotoneIncreasingDigits(n2);
        System.out.println("Test Case 2 Result: " + result2);  // Output: 1234

        // Test Case 3
        int n3 = 332;
        int result3 = solution.monotoneIncreasingDigits(n3);
        System.out.println("Test Case 3 Result: " + result3);  // Output: 299
    }
}

56. 合并区间

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

解题思路

对给定的区间数组 intervals 按照每个区间的起始位置 starti 进行升序排序。

1. 初始化一个结果数组 merged 用于存储合并后的区间。
2. 遍历排序后的区间数组，对于每个区间进行合并判断：
   • 如果当前合并结果数组 merged 为空，或者当前区间的起始位置大于合并结果数组的最后一个区间的结束位置，则直接将当前区间添加到结果数组 merged 中。
   • 否则，将当前区间与合并结果数组的最后一个区间进行比较，如果当前区间的起始位置小于等于合并结果数组的最后一个区间的结束位置，说明两个区间有重叠，需要合并。更新合并结果数组的最后一个区间的结束位置为当前区间的结束位置与合并结果数组最后一个区间的结束位置的较大值。
3. 遍历完成后，返回合并后的结果数组 merged。

代码实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MergeIntervals {
    public int[][] merge(int[][] intervals) {
        // 排序区间数组按照起始位置升序排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        List<int[]> merged = new ArrayList<>();
        for (int[] interval : intervals) {
            if (merged.isEmpty() || interval[0] > merged.get(merged.size() - 1)[1]) {
                merged.add(interval);
            } else {
                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], interval[1]);
            }
        }

        return merged.toArray(new int[merged.size()][]);
    }

    public static void main(String[] args) {
        MergeIntervals solution = new MergeIntervals();

        // Test Case
        int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};
        int[][] mergedIntervals = solution.merge(intervals);

        System.out.println("Merged Intervals:");
        for (int[] interval : mergedIntervals) {
            System.out.println(Arrays.toString(interval));
        }
    }
}