LeetCode之团灭字典序相关题目

数据与后端架构提升之路

已于 2022-12-08 19:26:00 修改

阅读量217

点赞数

分类专栏： # 算法文章标签：深度优先算法

于 2022-11-01 18:48:40 首次发布

本文链接：https://blog.csdn.net/lzhcoder/article/details/127639021

版权

算法专栏收录该内容

125 篇文章 3 订阅

订阅专栏

386之字典序排数(相关话题:n叉树的深度遍历)

题目描述

解题思路

代码实现

440. 字典序的第K小数字(相关话题:n叉树的深度条件遍历)

题目描述

解题思路

386之字典序排数(相关话题:n叉树的深度遍历)

题目描述

给你一个整数 n ，按字典序返回范围 [1, n] 内所有整数。

你必须设计一个时间复杂度为 O(n) 且使用 O(1) 额外空间的算法。

示例 1：

输入：n = 13
输出：[1,10,11,12,13,2,3,4,5,6,7,8,9]

示例 2：

输入：n = 2
输出：[1,2]

解题思路

对于输入 20，得到的答案是：

[1,10,11,12,13,14,15,16,17,18,19,2,20,3,4,5,6,7,8,9]

其实就是上面那棵树的先序遍历 DFS，只是把大于 20 的数字（还有 0）去掉了。

代码实现

class Solution {
    List<Integer> list = new ArrayList<>();
    int n;

    public List<Integer> lexicalOrder(int n) {
        this.n = n;
        // 因为没有 0 ，相当于从 十叉树 的第 2 层开始遍历，也就是起始是 1 ~ 9
        for (int i = 1; i <= 9; i++) dfs(i);
        return list;
    }
    
    // 树的先序遍历 DFS
    void dfs(int k) {
        // 大于 n 就直接结束
        if (k > n) return;
        list.add(k);
        // 假如传来是 1, 继续遍历 10 ~ 19 加入 list
        for (int i = 0; i <= 9; i++) dfs(k * 10 + i);
    }
}

440. 字典序的第K小数字(相关话题:n叉树的深度条件遍历)

题目描述

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

示例 1:

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

示例 2:

输入: n = 1, k = 1
输出: 1

提示:

1 <= k <= n <= 109

解题思路

但是很显然将整棵树构建起来是不现实的，当n = 10^9的时候就是上亿个节点了

我们就可以通过计算得到某个节点下的子树节点的总数而跳过遍历的时间

例如下图中求1的子树节点数量：

1下的第一层：最左端为10，即1*10；最右端为19，即(1+1) * 10 - 1，合计20-10 = 10

把1换成i：最左端为i*10；最右端为(i + 1) * 10 - 1

1下的第二层：最左端为100，最右端为112(即n)，而不是200了，合计112-100+1 = 13

这一层到不了200那么多，只能到n

合计10+13 = 26

如果求出以i为根的子树节点有nodes个

如果nodes比k少，那么这个部分都可以全部跳过，第k小的数肯定不在这些节点里，i右移
如果nodes比k多，那么第k小的数一定在这个里面，并是以i开头的数，i下移

因此我们可以移动 i 指向的节点，直到跳过的节点数达到k

代码实现

class Solution {
    public int findKthNumber(int n, int k) {
        long cur = 1;
        k--;
        while(k > 0) {
            // 以cur为根的子树节点有nodes个
            int nodes = getNodes(n, cur);
            // 如果个数比k少，那么这个部分都可以直接跳过
            if(k >= nodes) {
                // 跳过全部
                k = k -nodes;
                // 往右移一位
                cur++;
            }
            // 如果数量比k多，那么我们要找的结果就一定是以cur下的子节点
            else {
                // 跳过当前结点
                k = k - 1;
                // 往下走一层
                cur = cur * 10;
            }
        }
        return (int)cur;
    }

    // 获得以cur为根结点的子树节点数量
    private int getNodes(int n, long cur) {
        long next = cur + 1;
        long totalNodes = 0;
        while(cur <= n) {
            // 一次性求出下一层的节点个数和，要是没满就用n来减，要是满了就用next减（这里的next可以理解为上图中的2，20,200）
            totalNodes += Math.min(n - cur + 1, next - cur);
            // 进入下一层
            next = next * 10;
            cur = cur * 10;
        }
        return (int)totalNodes;
    }
}