Para describir una permutación de n elementos, ves que para la posición en la que termina el primer elemento, tienes n posibilidades, por lo que puedes describir esto con un número entre 0 y n-1. Para la posición en la que termina el siguiente elemento, tiene n-1 posibilidades restantes, por lo que puede describir esto con un número entre 0 y n-2.
Etcétera hasta que tenga n números.
Como ejemplo para n = 5, considere la permutación que trae abcdea caebd.
a, el primer elemento, termina en la segunda posición, por lo que le asignamos el índice 1 .btermina en la cuarta posición, que sería el índice 3, pero es la tercera que queda, así que le asignamos 2 .ctermina en la primera posición restante, que siempre es 0 .dtermina en la última posición restante, que (de solo dos posiciones restantes) es 1 .etermina en la única posición restante, indexada en 0 .
Entonces tenemos la secuencia de índice {1, 2, 0, 1, 0} .
Ahora sabe que, por ejemplo, en un número binario, 'xyz' significa z + 2y + 4x. Para un número decimal,
es z + 10y + 100x. Cada dígito se multiplica por algún peso y se suman los resultados. El patrón obvio en el peso es, por supuesto, que el peso es w = b ^ k, con b la base del número yk el índice del dígito. (Siempre contaré los dígitos desde la derecha y comenzando en el índice 0 para el dígito más a la derecha. Del mismo modo, cuando hablo del 'primer' dígito, me refiero al más a la derecha).
La razón por la que los pesos de los dígitos siguen este patrón es que el número más alto que se puede representar con los dígitos del 0 al k debe ser exactamente 1 más bajo que el número más bajo que se puede representar usando solo el dígito k + 1. En binario, 0111 debe ser uno menor que 1000. En decimal, 099999 debe ser uno menor que 100000.
Codificación a base variable
La regla importante es que el espaciado entre números subsiguientes sea exactamente 1. Al darnos cuenta de esto, podemos representar nuestra secuencia de índice mediante un número de base variable . La base de cada dígito es la cantidad de posibilidades diferentes para ese dígito. Para decimal, cada dígito tiene 10 posibilidades, para nuestro sistema el dígito más a la derecha tendría 1 posibilidad y el más a la izquierda tendrá n posibilidades. Pero como el dígito más a la derecha (el último número de nuestra secuencia) es siempre 0, lo dejamos fuera. Eso significa que nos quedamos con las bases 2 an. En general, el dígito k 'tendrá la base b [k] = k + 2. El valor más alto permitido para el dígito k es h [k] = b [k] - 1 = k + 1.
Nuestra regla sobre los pesos w [k] de dígitos requiere que la suma de h [i] * w [i], donde i va de i = 0 a i = k, sea igual a 1 * w [k + 1]. Dicho de forma recurrente, w [k + 1] = w [k] + h [k] * w [k] = w [k] * (h [k] + 1). El primer peso w [0] siempre debe ser 1. A partir de ahí, tenemos los siguientes valores:
k h[k] w[k]
0 1 1
1 2 2
2 3 6
3 4 24
... ... ...
n-1 n n!
(La relación general w [k-1] = k! Se demuestra fácilmente por inducción).
El número que obtenemos al convertir nuestra secuencia será la suma de s [k] * w [k], con k corriendo de 0 a n-1. Aquí s [k] es el k'th (más a la derecha, comenzando en 0) elemento de la secuencia. Como ejemplo, tomemos nuestro {1, 2, 0, 1, 0}, con el elemento más a la derecha eliminado como se mencionó anteriormente: {1, 2, 0, 1} . Nuestra suma es 1 * 1 + 0 * 2 + 2 * 6 + 1 * 24 = 37 .
Tenga en cuenta que si tomamos la posición máxima para cada índice, tendríamos {4, 3, 2, 1, 0}, y eso se convierte en 119. Dado que los pesos en nuestra codificación numérica se eligieron para no omitir cualquier número, todos los números del 0 al 119 son válidos. Hay precisamente 120 de estos, que es n! para n = 5 en nuestro ejemplo, precisamente el número de permutaciones diferentes. Para que pueda ver que nuestros números codificados especifican completamente todas las permutaciones posibles.
La decodificación desde la decodificación de base variable
es similar a la conversión a binario o decimal. El algoritmo común es este:
int number = 42;
int base = 2;
int[] bits = new int[n];
for (int k = 0; k < bits.Length; k++)
{
bits[k] = number % base;
number = number / base;
}
Para nuestro número de base variable:
int n = 5;
int number = 37;
int[] sequence = new int[n - 1];
int base = 2;
for (int k = 0; k < sequence.Length; k++)
{
sequence[k] = number % base;
number = number / base;
base++; // b[k+1] = b[k] + 1
}
Esto decodifica correctamente nuestro 37 de nuevo a {1, 2, 0, 1} ( sequenceestaría {1, 0, 2, 1}en este ejemplo de código, pero lo que sea ... siempre que indexe adecuadamente). Solo necesitamos agregar 0 en el extremo derecho (recuerde que el último elemento siempre tiene solo una posibilidad para su nueva posición) para recuperar nuestra secuencia original {1, 2, 0, 1, 0}.
Permutación de una lista usando una secuencia de índice
Puede usar el siguiente algoritmo para permutar una lista de acuerdo con una secuencia de índice específica. Es un algoritmo O (n²), desafortunadamente.
int n = 5;
int[] sequence = new int[] { 1, 2, 0, 1, 0 };
char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' };
char[] permuted = new char[n];
bool[] set = new bool[n];
for (int i = 0; i < n; i++)
{
int s = sequence[i];
int remainingPosition = 0;
int index;
// Find the s'th position in the permuted list that has not been set yet.
for (index = 0; index < n; index++)
{
if (!set[index])
{
if (remainingPosition == s)
break;
remainingPosition++;
}
}
permuted[index] = list[i];
set[index] = true;
}
Representación común de permutaciones
Normalmente, no representaría una permutación tan poco intuitiva como lo hemos hecho, sino simplemente por la posición absoluta de cada elemento después de que se aplica la permutación. Nuestro ejemplo {1, 2, 0, 1, 0} para abcdea caebdnormalmente está representado por {1, 3, 0, 4, 2}. Cada índice de 0 a 4 (o en general, de 0 a n-1) ocurre exactamente una vez en esta representación.
Aplicar una permutación en esta forma es fácil:
int[] permutation = new int[] { 1, 3, 0, 4, 2 };
char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' };
char[] permuted = new char[n];
for (int i = 0; i < n; i++)
{
permuted[permutation[i]] = list[i];
}
Invertirlo es muy similar:
for (int i = 0; i < n; i++)
{
list[i] = permuted[permutation[i]];
}
Conversión de nuestra representación a la representación común
Tenga en cuenta que si tomamos nuestro algoritmo para permutar una lista usando nuestra secuencia de índice y lo aplicamos a la permutación de identidad {0, 1, 2, ..., n-1}, obtenemos el permutación inversa , representada en la forma común. ( {2, 0, 4, 1, 3} en nuestro ejemplo).
Para obtener la premutación no invertida, aplicamos el algoritmo de permutación que acabo de mostrar:
int[] identity = new int[] { 0, 1, 2, 3, 4 };
int[] inverted = { 2, 0, 4, 1, 3 };
int[] normal = new int[n];
for (int i = 0; i < n; i++)
{
normal[identity[i]] = list[i];
}
O simplemente puede aplicar la permutación directamente, utilizando el algoritmo de permutación inversa:
char[] list = new char[] { 'a', 'b', 'c', 'd', 'e' };
char[] permuted = new char[n];
int[] inverted = { 2, 0, 4, 1, 3 };
for (int i = 0; i < n; i++)
{
permuted[i] = list[inverted[i]];
}
Tenga en cuenta que todos los algoritmos para tratar las permutaciones en la forma común son O (n), mientras que aplicar una permutación en nuestra forma es O (n²). Si necesita aplicar una permutación varias veces, primero conviértala a la representación común.