Cómo buscar todas las combinaciones posibles en una lista

Dado que potencialmente hay muchos subconjuntos para buscar, no hay forma de hacerlo más rápido que el tiempo exponencial.

El método más fácil es enumerar todos los subconjuntos en orden. Esto se puede hacer contando y seleccionando los elementos en las posiciones correspondientes a 1 bit en el contador. Eche un vistazo al código que utilicé en esta respuesta para seleccionar los signos de coeficientes para un ejemplo: la respuesta de David Rutter a ¿Cuáles son, asintóticamente, las raíces racionales más comunes de polinomios de coeficiente entero?

Puede acelerar este algoritmo asegurándose de que está seleccionando de un conjunto, no solo de una lista. En otras palabras, todos los valores involucrados deben ser únicos.

También puede contar en un orden diferente: observe los subconjuntos de tamaño 1, luego 2, luego 3, etc. Esto es más difícil de implementar pero permite un ahorro de tiempo significativo, ya que puede ordenar los elementos y asegurarse de comenzar por incluido el elemento más pequeño que debe incluirse para garantizar que la suma sea lo suficientemente grande como para que varios elementos alcancen la suma requerida. No obstante, el algoritmo aún requiere un tiempo exponencial en el peor de los casos.

A2A

Esto se puede resolver usando en retroceso. En general, el problema requiere que encontremos todas las combinaciones posibles [matemáticas] k [/ matemáticas] de un conjunto de elementos [matemáticas] n [/ matemáticas].

Considere todas las combinaciones de longitud [math] k [/ math] que comienzan en [math] i [/ math], podemos construir esto iterativamente usando una matriz temporal hasta que el tamaño de la matriz sea hasta [math] k [/ math ]

A continuación se muestra un código de muestra.

Solución de clase pública {
public List > combine (int n, int k) {

List > A = new ArrayList <> ();
si (n List tmp = new ArrayList <> ();
int [] v = nuevo int [n + 1];
resolver (A, tmp, v, k, 1);
devolver A;
}
vacío resolver (List > A, List tmp, int [] v, int k, int index) {

int n = v.length-1;

if (tmp.size () == k) {
List cop = new ArrayList <> ();
para (Entero y: tmp) cop.add (y);
A.add (policía);
regreso;
}

for (int i = index; i <= n; i ++) {

if (v [i] == 0) {
tmp.add (i);
v [i] = 1;
resolver (A, tmp, v, k, i + 1);
tmp.remove (tmp.size () – 1);
v [i] = 0;
}
}
}
}

La forma más rápida que conozco para obtener un conjunto de potencia es el conteo binario: cuente de 0 a elementos de número en el conjunto-1 con ceros a la izquierda para que cada número binario tenga el número de bins que para cada número binario si su bit k es 1, incluya el k elemento en el subconjunto que construye y este desafortunado es una complejidad exponencial.

Sin embargo, podemos acortar nuestra cantidad de trabajo, si la lista es bastante larga, dará sus frutos:

Primero verifique si la suma de la lista es de hecho mayor que su valor t, si no, entonces no tiene resultados si es así, clasifique [1] la lista, pero recuerde las posiciones originales de los elementos (la lista ordenada es una lista de pares con este aspecto ([value = value1, position = position_of_value1_in_original_list], [value = value2, position = position_of_value2_in_original_list], [value = value3, position = position_of_value3_in_original_list], …)) que con una búsqueda binaria [2] encuentre el elemento más pequeño e en la lista ordenada de manera tal que [math] e _ {\ text {value}} \ ge t [/ math], que compruebe si [math] \ sum \ limits_ {k = 0} ^ {\ text {posición de e en la lista ordenada -1}} \ text {led_list_values} [k] \ ge t [/ math] si no ha terminado, tome el conjunto de potencia de todos los elementos de la lista ordenada ue tal que [math] ue _ {\ text {value}} \ lt e _ {\ text {value}} [/ math] y combínelos con el conjunto de poder de los elementos de la lista ordenada ae tal que [math] ae _ {\ text {value}} \ ge e _ {\ text {value}} [/matemáticas]

en caso afirmativo, elimine el último elemento de ue (es el más grande) hasta que la suma de ue sea menor que t que tomar todas las combinaciones de ue eqaul t más grande y agregarlas a ae.

Notas al pie

[1] Algoritmo de clasificación – Wikipedia

[2] Algoritmo de búsqueda binaria – Wikipedia