【leetcode】738单调递增的数字 | 贪心 |累加

最新推荐文章于 2024-09-16 06:54:08 发布

柔水终成雕刀╮(￣▽￣"")╭

最新推荐文章于 2024-09-16 06:54:08 发布

阅读量236

点赞数 1

分类专栏： C++ leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/m0_46201214/article/details/111210804

版权

C++ 同时被 2 个专栏收录

13 篇文章 1 订阅

订阅专栏

leetcode

13 篇文章 0 订阅

订阅专栏

在这里插入图片描述

题目

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

示例 1:

输入: N = 10
输出: 9

示例 2:

输入: N = 1234
输出: 1234

示例 3:

输入: N = 332
输出: 299

说明: N 是在 [0, 10^9] 范围内的一个整数。

题解

刚开始的思路是：从后往前看，如果这一位数比前一位数小，那就把这一位数变为9，前一位数减减，思路简单得仿佛大脑里没有够够的小王这样写，然后开始卡bug

输入：100
输出：90
预期：99

错误原因是只看到了百位上的1和十位上的0，改了之后十位和个位又开始出问题。
小王开始补补丁：改成寻找最后一个比前一位小的数，记住它，然后从它开始后面都是9，他前面那个数减减，结果又错了

输入：332
输出：329
预期：299

后面看到还有输出样例这样的：

输入：999998
输出：999899
预期：899999

错误原因是这数减完以后，可能会比这数的前一个数小，小王有些疯魔，搁您这儿还要我给您搞个递归不是？原本短小的代码现在已经变成这样满是补丁惨不忍睹了。
于是小王一怒之下暴力了，暴力结果如下图注释：

int monotoneIncreasingDigits(int N) {
        vector<int> nums;
        int num = N;
        while(num){
            int cur = num % 10;
            num /= 10;
            nums.push_back(cur);
        }
        int length = nums.size();
        if(length == 1) return N;
        int result,flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }
        /* flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }
        flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }
        flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }
        flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }
        flag = -1;
        for(int i = 0; i != length - 1; i++){
            if(nums[i] < nums[i + 1]){
                flag = i + 1;
            }
        }
        if(flag != -1){
            for(int i = 0; i != flag; i++){
                nums[i] = 9;
            }
            nums[flag]--;
        }*/
        for(int i = length - 1; i != 0; i--){
            result = result*10 + nums[i];
        }
        result = result*10 + nums[0];
        return result;
    }

果然是暴力香啊，暴力出来的结果是：
在这里插入图片描述
小王现在很慌，非常慌

大佬题解

官方题解指出了我之前的问题，给了解答：

但这里存在一个问题：当 strN[i−1] 自身数位减 1 后可能会使得 strN[i−1] 和strN[i−2] 不再满足递增的关系，因此我们需要从 i−1 开始递减比较相邻数位的关系，直到找到第一个位置 j 使得 strN[j] 自身数位减 11 后 strN[j−1] 和 strN[j] 仍然保持递增关系，或者位置 j已经到最左边（即 jj的值为 0），此时我们将 [j+1,n−1] 的数全部变为 9 才能得到最终正确的答案。

int monotoneIncreasingDigits(int N) {
        string strN = to_string(N);//学到了
        int i = 1;
        while (i < strN.length() && strN[i - 1] <= strN[i]) {
            i += 1;
        }
        if (i < strN.length()) {
            while (i > 0 && strN[i - 1] > strN[i]) { //这里是解决方法
                strN[i - 1] -= 1;
                i -= 1;
            }
            for (i += 1; i < strN.length(); ++i) {
                strN[i] = '9';
            }
        }
        return stoi(strN);
    }
/*
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/monotone-increasing-digits/solution/dan-diao-di-zeng-de-shu-zi-by-leetcode-s-5908/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/

试了一下官方题解的结果
在这里插入图片描述
官方好久没这么香过了

还有一个很有趣的想法：最终结果必然是若干个形如 11……11 的数字相加所得，本题中，最大的n为10^9，所以，可以从111111111开始依次累加，如果继续累加将导致结果超过n，则去掉一个1继续循环。总累加次数不超过9次。大佬是用rust写的：

impl Solution {
    pub fn monotone_increasing_digits(n: i32) -> i32 {
        let mut ones = 111111111;
        let mut result = 0;
        for _ in 0..9 {
            while result + ones > n {
                ones /= 10;
            }
            result += ones;
        }
        result
    }
}/*
作者：wincss
链接：https://leetcode-cn.com/problems/monotone-increasing-digits/solution/1111lei-jia-fa-by-wincss-zt83/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/