Leetcode每日一题440

题意

        给定整数 n 和 k，返回  [1, n] 中字典序第 k 小的数字。

思考

        本题当n = 13, k = 2 时，输出: 10。 字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。从这个排列规律我们可以看出，在字典序里，+1相当于自然序*10， *10相当于自然序+1。简而言之，字典序就是根据数字的前缀进行排序，比如 10 < 9，因为 10 的前缀是 1，比 9 小。再比如 112 < 12，因为 112 的前缀 11 小于 12。这样排序下来，会跟平常的升序排序会有非常大的不同。

        所以这道题理论上来说，可以直接套用昨天每日一题386的求解字典序排列数组的代码，return变为result[k-1]就行。但....这题它超内存了....博主一整个托马斯回旋大吐血。在内存上vector还是太不禁打了。

class Solution {
public:
    vector<int> lexicalOrder(int n) 
    {
        vector<int> result(n);
        int number = 1;
        for(int i = 0; i < n; i++)
        {
            result[i] = number;
            if(number * 10 <= n)
            {
                number *= 10;
            }
            else
            {
                while(number % 10 == 9 ||number + 1 > n)
                {
                    number /= 10;
                }
                number++;
            }
        }
        return result;
    }
};

题解——灵茶山艾府

        本题可以看成一棵十叉树如下图（太好了是树我没救了）

        那么根据字典序排列的规则，对应到树上应当为中左右——前序遍历。前序遍历访问到的第 k 个节点就是答案。

Leetcode 440解题代码——灵茶山艾府

class Solution {
public:
    int findKthNumber(int n, int k) 
    {
        // 逐层统计 node 子树大小
        auto count_subtree_size = [&](int node) -> int 
        {
            // 子树大小不会超过 n，所以 size 用 int 类型
            // 但计算过程中的 left 和 right 会超过 int，所以用 long long 类型
            int size = 0;
            long long left = node, right = node + 1;
            while (left <= n) 
            {
                // 这一层的最小值是 left，最大值是 min(right, n + 1) - 1
                size += min(right, n + 1LL) - left;
                left *= 10; // 继续，计算下一层
                right *= 10;
            }
            return size;
        };

        int node = 1;
        k--; // 访问节点 node
        while (k > 0) 
        {
            int size = count_subtree_size(node);
            if (size <= k) // 向右，跳过 node 子树
            { 
                node++; // 访问 node 右侧兄弟节点
                k -= size; // 访问子树中的每个节点，以及新的 node 节点
            } 
            else // 向下，深入 node 子树
            { 
                node *= 10; // 访问 node 的第一个儿子
                k--; // 访问新的 node 节点
            }
        }
        return node;
    }
};