leetcode396

从今天开始，每天至少一道题

题目链接

leetcode386

标准的递归回溯

public List<Integer> lexicalOrder(int n) {
        List<Integer> ans = new ArrayList<>();
        for (int i = 1; i < 10; i++) {
            dfs(ans, String.valueOf(i), n);
        }
        return ans;
    }

    public void dfs(List<Integer> ans, String cur, int n) {
        int data = Integer.parseInt(cur);
        if (data > n) {
            return;
        }
        ans.add(data);
        for (int i = 0; i < 10; i++) {
            dfs(ans, cur + i, n);
        }
    }

直接使用Int类型

public List<Integer> lexicalOrder(int n) {
        List<Integer> ans = new ArrayList<>();
        for (int i = 1; i < 10; i++) {
            dfs(ans, i, n);
        }
        return ans;
    }

    public void dfs(List<Integer> ans, int cur, int n) {
        if (cur > n) {
            return;
        }
        ans.add(cur);
        for (int i = 0; i < 10; i++) {
            dfs(ans, cur * 10 + i, n);
        }
    }

实现严格o(1)，只能使用迭代

/*
如果number mod 10=9 或number+1>n，那么说明末尾的数位已经搜索完成，退回上一位
*/
class Solution {
    public List<Integer> lexicalOrder(int n) {
        List<Integer> ret = new ArrayList<Integer>();
        int number = 1;
        for (int i = 0; i < n; i++) {
            ret.add(number);
            if (number * 10 <= n) {
                number *= 10;
            } else {
                while (number % 10 == 9 || number + 1 > n) {
                    number /= 10;
                }
                number++;
            }
        }
        return ret;
    }
}