39. El sentido de combinación de combinación y preguntas de entrevista

 Hoy, el problema es bastante serio. Creo que la reunión es realmente ambigua, incluido el algoritmo de retroceso. Lo más importante del algoritmo de retroceso es la suspensión del estado, el resumen del estado y el signo del comienzo. La suma es el objetivo, y la condición permitida es que puede leer los elementos de la matriz un número ilimitado de veces, pero el conjunto de soluciones no puede repetirse, por lo que es posible que desee configurar una etiqueta para él, que es filtrar cada ronda. El código es el siguiente

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.List;

public class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        int len = candidates.length;

        // 排序是为了提前终止搜索
        Arrays.sort(candidates);

        dfs(candidates, len, target, 0, new ArrayDeque<>(), res);
        return res;
    }

    /**
     * @param candidates 数组输入
     * @param len        输入数组的长度，冗余变量
     * @param residue    剩余数值
     * @param begin      本轮搜索的起点下标
     * @param path       从根结点到任意结点的路径
     * @param res        结果集变量
     */
    private void dfs(int[] candidates,
                     int len,
                     int residue,
                     int begin,
                     Deque<Integer> path,
                     List<List<Integer>> res) {
        if (residue == 0) {
            // 由于 path 全局只使用一份，到叶子结点的时候需要做一个拷贝
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = begin; i < len; i++) {

            // 在数组有序的前提下，剪枝
            if (residue - candidates[i] < 0) {
                break;
            }

            path.addLast(candidates[i]);
            dfs(candidates, len, residue - candidates[i], i, path, res);
            path.removeLast();

        }
    }
}

Cada ronda es I. Es decir, cada ronda comienza desde el mismo lugar. Si no puede encontrarla, vaya a i + 1, que es la siguiente ronda.

 

 

Y la segunda pregunta! La limitación es principalmente la longitud: la cadena debe leerse, lo que equivale a decir que la longitud de la cadena generada es la misma que la cadena original, pero cada elemento solo se puede leer una vez, luego debemos leer el elemento. Restringido, solo podemos leer uno a la vez, utilizamos la matriz visitada para marcar los elementos, marcarlos cuando se leen y realizar una lectura anidada. La condición del bucle es que para el recorrido de la matriz visitada, no hay La matriz visitada marcada está bien, pero algunas personas preguntarán, cada vez que comience desde 0, cómo formar todas las cadenas paso a paso, la respuesta es la siguiente, porque aunque cada vez comienza desde 0, nuestro estándar es para Restricciones en la longitud de la cadena de caracteres: cuando la longitud es 0, comienza desde 0. Cuando la longitud es 1, comienza desde 0. Cuando la longitud es 1, selecciona un carácter de la capa superior para la detección de 1 longitud. El código es el siguiente:

    public String[] permutation(String s) {
        if(s.equals("")) return new String[0];
        char[] schars=s.toCharArray();
        boolean[] visited=new boolean[schars.length];
        Set<String>set=new HashSet<>();
            dfs_per(set,"",visited,schars);

        String[] res=  new String[set.size()];
               return set.toArray(res);
 
    }
    public void dfs_per(Set<String>res,String str,boolean[] visited,char[] sc){
        if(str.length()==sc.length){
            res.add(new String(str));
            System.out.println(str);
            return;
        }
        
        for(int i=0;i<sc.length;i++){
            if(visited[i]==true) continue;
            visited[i]=true;
            dfs_per(res,str+sc[i],visited,sc);
            visited[i]=false;
        }
    }

    Significa que al final de cada ciclo, cuando encuentro el ciclo de la capa anterior, debo levantar la marca transversal de esta capa, y luego el elemento predeterminado de la capa anterior cambia de 0 a 1, y luego marca 1 y luego busca. , ¡Completa la tarea de atravesar todos los elementos! ! ! ! ! ~