Hola, aquí hay una implementación simple en C ++
#include
# define sync_false std :: ios_base :: sync_with_stdio (falso)
# define tr (c, it) para (typeof (c.begin ()) it = c.begin (); it! = c.end (); it ++)
# define todo (c) c.begin (), c.end ()
- ¿Qué es un algoritmo explicado para que las personas normales puedan entender y también cómo se hacen?
- ¿Cuál es la forma más compleja de reducir 1 + 1?
- Cómo superar y comprender el algoritmo / código de otras personas
- Cómo demostrar que O (f (n) - g (n)) no es necesariamente igual a O (f (n)) - O (g (n))
- ¿Por qué la notación O grande es más común si la notación theta grande nos da más información?
usando el espacio de nombres estándar;
int main () {
sync_false;
cadena s = “abdc”, temp_string; // también puedes leer ‘s’ de stdin. Di “cin >> s;”
ordenar (todos (s)); // requerido en caso de que sus caracteres de cadena no estén ordenados lexicográficamente
hacer{
temp_string = “”;
tr (s, it)
temp_string + = * it;
cout << temp_string << endl;
} while (next_permutation (todas (s)));
devuelve 0;
}
Explicación: “next_permutation” reorganiza los elementos en el rango dado en el siguiente lexicográficamente mayor permutación Entonces, para extraer todas las permutaciones posibles de la cadena dada, debemos comenzar con la disposición que es lexicográficamente más pequeña.
Si tiene curiosidad y desea saber más acerca de cómo “next_permutation” realiza los cálculos. Consulte stackoverflow.com y next_permutation – cppreference.com
EDITAR:
También podemos resolver este problema usando la recursividad. Supongamos que tenemos una lista de 3 números. Digamos [0,1,2], ahora todos los arreglos posibles para este conjunto serían
[0,1,2], [0,2,1], [1,0,2], [1,2,0], [2,0,1], [2,1,0]
El total es [matemáticas] 3! [/ matemáticas] formas. Ahora, si observamos cuidadosamente, descubriremos que estamos fijando el número en la posición [matemática] k [/ matemática] y calculando los arreglos de los números en posiciones mayores que [matemática] k [/ matemática]. Una vez que hayamos terminado de hacer los arreglos de los números en las posiciones mayores que [matemáticas] k [/ matemáticas], fijamos otros números en la posición [matemáticas] k [/ matemáticas] y aplicamos los mismos pasos nuevamente. Aplicando la misma regla para el tamaño de lista reducido. Ahora dicho esto, veamos cómo implementar esta lógica. Lo he implementado en C ++ pero puedes implementarlo en cualquier lenguaje que elijas.
#include
# define tr (container, it) para (typeof (container.begin ()) it = container.begin (); it! = container.end (); it ++)
usando el espacio de nombres estándar;
vacío permut (vector A, int k, int n) // n es el tamaño de la lista, k es el punto de partida.
{
si (k == n) {
rasgo){
cout << * it; // imprime el arreglo actual
}
cout << endl;
}más{
para (int i = k; i <n; i ++) {
intercambio (A [i], A [k]); // arregla uno cambiando a una posición fija
permut (A, k + 1, n); // hacer arreglos para el resto
intercambio (A [i], A [k]); // restaurar a original y luego arreglar otro y así sucesivamente ..
}
}
}
int main ()
{
vector A (3,0);
para (int i = 0; i <3; i ++) {
A [i] = i; // A = [0,1,2]
}
permut (A, 0,3); // permut ([0,1,2], 0, 3)
devuelve 0;
}
Nota: Para imprimir todos los arreglos de una cadena dada, puede considerar calcular los arreglos de todos los índices y finalmente imprimir los caracteres correspondientes en los índices. Supongamos que la cadena dada es “ABC”. Entonces, encontramos los arreglos de [0,1,2]. Digamos, tenemos [1,0,2] por lo que la disposición correspondiente sería “BAC”.
¡Espero que esto ayude!
