440. 字典序的第K小数字

给定整数 n 和 k，找到 1 到 n 中字典序第 k 小的数字。

注意：1 ≤ k ≤ n ≤ 109。

示例 :

输入:
n: 13 k: 2

输出:
10

解释:
字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。

我的代码 超时

class Solution {
public:
    int result;
    int number,num,max_t;
    void dfs(int t)
    {
        if(t!=0)t*=10;
        if(t>max_t) return;
        for(int i=0;i<=9;i++)
        {
            if(t==0&&i==0) continue;
            int temp=t+i;
            if(temp>max_t) return;
            number++;
            if(number==num)
            {
                result=temp;
                return;
            }
            dfs(temp);
            if(result!=0) return;
        }
    }
    int findKthNumber(int n, int k) {
        max_t=n;
        num=k;
        result=0;
        dfs(0);
        return result;
    }
};

网上的代码 8ms

class Solution {
public:
    int findKthNumber(int n, int k) {
        int cur = 1;
        --k;//初始化为cur = 1，k需要自减1
        while (k > 0)
        {
            long step = 0, first = cur, last = cur + 1;
            //统计这棵子树下所有节点数（step）
            while (first <= n) 
            {
                step += min((long)n + 1, last) - first;//不能超过n的值，并不是所有节点都有十个子节点
                first *= 10;
                last *= 10;
            }
            if (step <= k)
            {//不在子树中
                ++cur;
                k -= step;
            } 
            else 
            {//在子树中，进入子树
                cur *= 10;
                --k; 
            }
        }
        return cur;
    }
};

思路：

其实这是一个"十叉树"，如下图：

1）每个节点的子节点可以有十个，比如节点1的子节点可以是10_{19、节点2的字节的可以是20}29、。。。

但是由于n大小的限制，构成的并不是一个"满十叉树"。

2）分析题目中给的例子可以知道，数字1的子节点有4个(10,11,12,13)，而后面的数字2到9都没有子节点，

那么这道题实际上就变成了一个先序遍历十叉树的问题。

3）那么，难点就变成了 计算出同一层两个相邻的节点的子节点的个数，也就是代码中的steps

3.1）当前节点为 curr （从curr = 1 开始），则同一层的下一个节点为 curr+1;

3.2)计算节点 curr到节点curr+1之间的子节点个数steps

 3.2.1)如果子节点个数 大于 k，说明第k小的树一定在子节点中，

          继续向下一层寻找：curr *=10;

          k -= 1;（原因：向下一层寻找，肯定要减少前面的父节点，即 在上一层中的第k个数，在下一层中是第k-1个数）

 3.2.2)如果子节点个数 小于或者等于 k，说明第k小的树不在子节点中，

          继续向同一层下一个节点寻找：curr +=1;

          k -= steps;（原因：向下一层寻找，肯定要减少前面的所有的字节点）

以此类推，直到k为0推出循环，此时cur即为所求。

原文：https://blog.csdn.net/FJJ543/article/details/81908992