386. Clasificación lexicográfica: "Recursión" e "Iteración"

¡Acostúmbrate a escribir juntos! Este es el día 18 de mi participación en el "Nuevo plan diario de Nuggets · Desafío de actualización de abril", haga clic para ver los detalles del evento .

Tema Descripción

Este es 386. número lexicográfico en LeetCode , dificultad media .

Etiqueta: "DFS", "recursión", "iteración"

te da un número entero n, devuelve el rango lexicográficamente $[1, norte]$ todos los números enteros.

Tienes que diseñar una complejidad de tiempo de $Sobre)$ y uso $O(1)$ espacio extra.

Ejemplo 1:

输入：n = 13

输出：[1,10,11,12,13,2,3,4,5,6,7,8,9]
复制代码

Ejemplo 2:

输入：n = 2

输出：[1,2]
复制代码

insinuación:

$1 <= norte <= 5 * 10^4$

recursión

En primer lugar, es fácil pensar en usar "recursividad" para lograr esto DFS.

Será $[1, norte]$ se agregan a la respuesta lexicográficamente, esencialmente para un nodo con un número de $norte$ , se atraviesa un árbol de orden múltiple con una forma similar a un árbol de diccionario, y el nodo raíz es $0$ ，需要被跳过，因此我们可以从树的第二层开始搜索。

树中每个节点的值为其搜索路径所代表的数字，且每个节点有 $[0, 9]$ 共 $10$ 个子节点。

代码：

class Solution {
    List<Integer> ans = new ArrayList<>();
    public List<Integer> lexicalOrder(int n) {
        for (int i = 1; i <= 9; i++) dfs(i, n);
        return ans;
    }
    void dfs(int cur, int limit) {
        if (cur > limit) return ;
        ans.add(cur);
        for (int i = 0; i <= 9; i++) dfs(cur * 10 + i, limit);
    }
}
复制代码

时间复杂度：本质上在搜索一棵节点数量为 $n$ 的多阶树（形态类似于字典树），复杂度为 $O(n)$
空间复杂度：忽略递归带来的额外空间开销，复杂度为 $O(1)$

迭代

递归具有额外的空间开销，为了实现严格的 $O(1)$ 空间，我们需要使用「迭代」来实现 DFS。

共有 $n$ 个数需要被处理，假设当前处理到的数为 $j$ ，根据字典序规则，在满足条件的前提下，我们优先在 $j$ 的后面添加 $0$ （即 $j * 10 < n$ satisfecho), de lo contrario, consideramos retroceder el bit anterior y agregar uno.

Código:

class Solution {
    public List<Integer> lexicalOrder(int n) {
        List<Integer> ans = new ArrayList<>();
        for (int i = 0, j = 1; i < n; i++) {
            ans.add(j);
            if (j * 10 <= n) {
                j *= 10;
            } else {
                while (j % 10 == 9 || j + 1 > n) j /= 10;
                j++;
            }
        }
        return ans;
    }
}
复制代码

complejidad del tiempo: $Sobre)$
Complejidad del espacio: $O(1)$

Al final

Este es el primer No.386artículo serie comienza el 01/01/2021. A partir de la fecha de inicio, hay 1916 preguntas en LeetCode, algunas de las cuales están bloqueadas. Primero pondremos todas las preguntas sin cerraduras Tema terminado.

En esta serie de artículos, además de explicar las ideas de resolución de problemas, se dará el código más conciso posible. Si se trata de soluciones generales, también se proporcionarán las plantillas de código correspondientes.

Para facilitar a los estudiantes la depuración y el envío de código en la computadora, he establecido un repositorio relacionado: github.com/SharingSour… .

En la dirección del almacén, puede ver el enlace a la solución de la serie de artículos, el código correspondiente de la serie de artículos, el enlace a la pregunta original de LeetCode y otras soluciones preferidas.