Introducción a "el juego"
Hay $2$ jugadores y $2n$ tarjetas, con la etiqueta $1, 1, 2, 2, 3, 3, 4, 4, \dots, n, n$. ($2$ de cada tarjeta de$1$$n$)
En primer lugar, el $2n$ de los jugadores son cada determinado $n$ tarjetas al azar. Más específicamente, un ordenamiento al azar de la $2n$ tarjetas se logra y el primer jugador obtiene el primer lugar en $n$ tarjetas, el segundo jugador obtiene de la otra $n$ tarjetas. Podemos asumir que cada jugador puede ver todas las cartas.
En cada turno, cada jugador va a ordenar su mano de cartas. La etiqueta de los naipes en las manos $a_1, a_2, a_3,\dots, a_n, b_1, b_2, b_3,\dots, b_n$.
Los jugadores encontrar un par de tarjetas de $a_i\neq b_i$. Luego que el intercambio de las tarjetas de $a_i$$b_i$. Después de lo cual, el turno termina.
Claramente si $a_i=b_i$ todos los $i$,$a_i=b_i=i$, y el "juego" termina.
Ejemplo
Deje $n=4$. Llamamos a la $2$ jugadores de $A, B$. En el inicio del juego, que reciben:
$A: 1, 1, 2, 2$
$B: 3, 3, 4, 4$
Turno 1: de Que decidan cambiar la tarjeta por primera vez.
$A: \color{red}{3}, 1, 2, 2$
$B: \color{red}{1}, 3, 4, 4$
Antes de la segunda vuelta comienza, ordenar sus tarjetas.
$A: 1, 2, 2, 3$
$B: 1, 3, 4, 4$
Vuelta 2: Esta vez, deciden cambiar la tarjeta de tercero. No se pueden intercambiar la primera tarjeta con los números de la primera tarjeta son los mismos.
$A: 1, 2, \color{red}{4}, 3$
$B: 1, 3, \color{red}{2}, 4$
Que ordenar sus tarjetas.
$A: 1, 2, 3, 4$
$B: 1, 2, 3, 4$
El juego termina cuando los jugadores de ambos ha $1, 2, 3, 4$. Este juego termina en $2$ turnos.
Preguntas acerca de este "juego"
Va a terminar? (La respuesta es sí, y una idea de un límite basado en el monovariant se añadirá como una auto-respuesta.)
En cuántos se mueve (en la mayoría) tarda un $2n$ juego de cartas para terminar? Lo que los acuerdos que hará que se tome tanto tiempo para terminar?
Suponiendo que el jugador tiene que escoger el lado de la tarjeta para el intercambio de azar (de entre todos los posibles movimientos, elija un movimiento válido, cada movimiento válido, con igual probabilidad), lo que se espera que el número de movimientos para el juego para terminar?
Ideas acerca de la pregunta:
Como sugiere hardmath:
Si hemos de limitar a los jugadores a tomar la carta más baja que las obras o la carta más alta que funciona, el juego será definitivamente final en la mayoría de los $n-1$ turnos. Ambos casos son simétricos, por lo tanto, trabajar en la más alta.
Caso Base: si $n=1$, no se mueve tiene que ser hecho. De lo contrario, $n>1$.
Ahora procedemos en el paso inductivo. Supongamos que la más alta de las tarjetas de los jugadores son diferentes. Si son iguales, se elimina, la reducción de la $n-1$ de los casos, lo que se puede hacer en la mayoría de los $n-2$ se mueve. De lo contrario, un jugador que tiene la carta más alta. Cuando el movimiento se hace, una copia de la carta más alta se da para el otro jugador. Ahora, ambos jugadores tiene la carta más alta, y puede ser eliminada. En total, hay $1+(n-2)=n-1$ se mueve por este.
A partir de esto, podemos obtener que, en promedio, el juego termina en $O(n^2)$ gira, ya que se necesita (en promedio) $O(n)$ vueltas por la carta más alta para ser intercambiados.
Código (para referencia):
Me encontré con una simulación de Monte Carlo de juegos de azar. Una simulación de $1000$ juegos de $1000$ tarjetas dio un promedio de número de intercambios de $1310.703$.
El código de C++ para la referencia:
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int N;
int K;
int maxCounter = 0;
int sumCounter = 0;
int counter;
int arr[999999];
/** Results:
(X cards, 10^6 rounds)
1 -> 0 0
2 -> 1 0.334546 (guess: 1/3)
3 -> 2 0.733746
4 -> 3 1.180559
5 -> 5 1.667006 (guess: 5/3)
6 -> 6 2.179321
7 -> 8 2.721661
8 -> 9 3.283566
9 -> 10 3.867299
10 -> 12 4.471352
Other things I tried: (cards, rounds)
100 1000 -> 143 84.411
200 1000 -> 307 197.332
300 1000 -> 503 319.691
500 1000 -> 960 580.373
1000 1000 -> 1910 1310.703
**/
int main(void) {
srand(23);
printf("Number of cards: ");
scanf("%d", &N);
for (int i=0;i<N;i++) {
arr[i] = arr[i+N] = i;
}
printf("Number of rounds: ");
scanf("%d", &K);
for (int j=0;j<K;j++) {
random_shuffle(arr, arr+2*N);
counter = 0;
while (counter>=0) {
sort(arr, arr+N);
sort(arr+N, arr+2*N);
int pass = 1;
for (int i=0;i<N;i++) {
if (arr[i] != arr[i+N]) {
pass = 0;
break;
}
}
if (pass) break;
counter++;
int theMove = rand()%N;
while (arr[theMove] == arr[theMove+N]) theMove = rand()%N;
int temp = arr[theMove];
arr[theMove] = arr[theMove+N];
arr[theMove+N] = temp;
}
//printf("%d ", counter);
maxCounter = max(maxCounter, counter);
sumCounter += counter;
if (j%(K/100) == 0) printf("Done: %d\n", j);
}
printf("Maximum: %d\nAverage: %lf\n", maxCounter, sumCounter/(double)K);
return 0;
}
Los resultados del código:
El número promedio de movimientos parecen crecer más rápido de lo $O(n)$.