单调递增的数

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

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

示例 1:

输入: N = 10
输出: 9
示例 2:

输入: N = 1234
输出: 1234

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/monotone-increasing-digits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 暴力遍历 - 超时

class Solution {
   public int monotoneIncreasingDigits(int N) {
        int curr = N + 1;
        while (--curr >= 0) {
            if(isZeng(curr)) {
                return curr;
            }
        }
        return 0;
    }

    private boolean isZeng(int n) {
        while (true) {
            if (n < 10) {
                return true;
            }
            int a = n % 10;
            int b = (n / 10) % 10;
            if (a < b) {
                return false;
            }
            n = n / 10;
        }
    }
}

2. 仔细想想 结果是可以由当前的数直接推出来的
   因为要最大 所以优先从数的右边开始计算（这样减去的数值是最小的）
   如果当前位数需要减1 则把其右边的数值都置9

class Solution {
   public int monotoneIncreasingDigits(int N) {
          if (N < 10) {
            return N;
        }
        List<Integer> ints = new ArrayList<>();
        int num = N;
        while (num > 0) {
            ints.add(num % 10);
            num /= 10;
        }
        Collections.reverse(ints);

        for (int i = ints.size() - 1; i >= 0; i--) {
            boolean adjust = false;

            for (int j = i + 1; j < ints.size(); j++) {
                if (adjust) {
                    ints.set(j, 9);
                }
                if (ints.get(j) < ints.get(i)) {
                    ints.set(i, ints.get(i) - 1);
                    ints.set(j, 9);
                    adjust = true;
                }
            }
        }

        Collections.reverse(ints);
        int result = 0;
        int radix = 1;
        for (int i = 0; i < ints.size(); i++) {
            result += ints.get(i) * radix;
            radix *= 10;
        }
        return result;
    }

   
}