Algoritmo de retroceso combinado LeetCode-77

Problemas que generalmente pueden resolverse mediante el algoritmo de retroceso:

1. Problemas de combinación: como LeetCode-77-combinación , LeetCode-39-combinación suma , LeetCode-40-combinación suma II , LeetCode-216-combinación suma II , LeetCode-17-letra combinación de número de teléfono
2. Problema de segmentación: como LeetCode-131-cadena palíndromo dividida , LeetCode-93-restore dirección IP
3. Problema de subconjunto: como LeetCode-78-subset , LeetCode-90-subset II , LeetCode-491-subsecuencia creciente
4. Problemas de disposición: como LeetCode-46-Full Arrangement , LeetCode-46-Full Arrangement II
5. Problemas del tablero de ajedrez: como LeetCode-51-N Queen , LeetCode-37-Solution Reading

Trilogía recursiva:
① Determinar los parámetros y el valor de retorno de la función recursiva; generalmente es nula y el nombre suele retroceder
② Determinar la condición de terminación;
③ Determinar la lógica recursiva de una sola capa.

Ideas de resolución de problemas combinadas con LeetCode-77 :

1. La determinación de los parámetros de la función recursiva requiere n, k y un subíndice cambiante startIndex
2. Determine la condición de terminación. Esto es simple: cuando la longitud de la matriz unidimensional es igual a k, significa que es suficiente y simplemente deténgase;
3. Para determinar la lógica recursiva de una sola capa, debe considerar dónde comenzar el juicio. La pregunta comienza desde 1, por lo que el subíndice también comienza desde 1 y comienza a retroceder en el bucle for, peroPara agregar convenientemente el siguiente elemento después de cada seguimiento, es decir, para regresar al nodo principal de la estructura de árbol, necesitamos hacer aparecer un elemento, esto es fácil de ignorar.

Código

class Solution {
    
    
    /**
     * @param n 1~n
     * @param k 要求的个数
     * @return 返回范围 [1, n] 中所有可能的 k 个数的组合
     */
    public List<List<Integer>> combine(int n, int k) {
    
    
        backtracking(n,k,1);
        return res;
    }

    List<List<Integer>> res = new ArrayList<>();//二维数组，要返回的结果
    List<Integer> path = new ArrayList<>();// 树形结构走的路径，即能放进去的数
    public void backtracking(int n, int k, int startIndex){
    
    
        if (path.size() == k){
    
    // 终止条件
            res.add(new ArrayList<>(path));// 满足条件，将一维数组加到结果集中
            return;// 切记需要返回
        }
        for (int i = startIndex; i <= n; i++) {
    
    // 没有剪枝的情况
            path.add(i);
            backtracking(n,k,i+1);// 回溯
            path.remove(path.size()-1);// 还需要弹出一个元素，即表示回到上一步
        }
    }
}