LeetCode 1823: Encuentra al ganador del juego circular (problema del anillo de Joseph)

1823. Encuentra al ganador del juego circular
      Medio
      Hay n amigos que están jugando un juego. Los amigos están sentados en círculo y están numerados del 1 al n en el sentido de las agujas del reloj. Más formalmente, moverse en el sentido de las agujas del reloj desde el i-ésimo amigo lo lleva al (i+1)-ésimo amigo por 1 <= i < n, y moverse en el sentido de las agujas del reloj desde el n-ésimo amigo lo lleva al 1.er amigo.

Las reglas del juego son las siguientes:

Comience en el primer amigo.
Cuente los próximos k amigos en el sentido de las agujas del reloj, incluido el amigo con el que empezó. El conteo se envuelve alrededor del círculo y puede contar a algunos amigos más de una vez.
El último amigo que contaste abandona el círculo y pierde el juego.
Si todavía hay más de un amigo en el círculo, regrese al paso 2 comenzando desde el amigo inmediatamente en el sentido de las agujas del reloj del amigo que acaba de perder y repita.
De lo contrario, el último amigo en el círculo gana el juego.
Dado el número de amigos, n, y un número entero k, devuelva el ganador del juego.

Ejemplo 1:

Entrada: n = 5, k = 2
Salida: 3
Explicación: Estos son los pasos del juego:

1. Comienza en el amigo 1.
2. Cuente 2 amigos en el sentido de las agujas del reloj, que son los amigos 1 y 2.
3. El amigo 2 abandona el círculo. El próximo comienzo es el amigo 3.
4. Cuente 2 amigos en el sentido de las agujas del reloj, que son los amigos 3 y 4.
5. El amigo 4 abandona el círculo. El próximo comienzo es el amigo 5.
6. Cuente 2 amigos en el sentido de las agujas del reloj, que son los amigos 5 y 1.
7. El amigo 1 abandona el círculo. El próximo comienzo es el amigo 3.
8. Cuente 2 amigos en el sentido de las agujas del reloj, que son los amigos 3 y 5.
9. El amigo 5 abandona el círculo. Solo queda el amigo 3, por lo que es el ganador.
   Ejemplo 2:

Entrada: n = 6, k = 5
Salida: 1
Explicación: Los amigos salen en este orden: 5, 4, 6, 2, 3. El ganador es el amigo 1.

Restricciones:

1 <= k <= n <= 500

Hacer un seguimiento:

¿Podrías resolver este problema en tiempo lineal con espacio constante?

Solución 1: lista doble enlazada. Pero no hay lugar.

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    
    
    struct Node *prev, *next;
    int val;
} Node;

int findTheWinner(int n, int k) {
    
    
    printf("sizeof(Node *) = %ld\n", sizeof(Node *));
    Node *head = (Node *)malloc(sizeof(Node *));
    head->val = 1; 
    head->prev = NULL; 
    head->next = NULL;
    Node *origHead = head;
    Node *node;
    for (int i = 2; i <= n; i++) {
    
    
        node = (Node *)malloc(sizeof(Node *));
        node->val = i;
        head->next = node;
        node->prev = head;
        head = node;
    }
    head->next = origHead;
    origHead->prev = head;
    node = origHead;
    while (n > 0) {
    
    
        for (int i = 0; i < k - 1; i++) {
    
    
            node = node->next;
        }
        node->prev->next = node->next;
        node->next->prev = node->prev;
        node = node->next;
        n--;
    }
    return node->val;
}