Metodo della parentesi del torneo per mettere la distanza tra i compagni di squadra

Ordina i giocatori per squadra e numerali a partire da 0, quindi ad es.

0(000)  T1a (team 1 player a)
1(001)  T1b
2(010)  T1c
3(011)  T2a
4(100)  T2b
5(101)  T3a
6(110)  T3b
7(111)  T3c

Quindi invertire i bit in ciascun numero per compilare il riquadro della parentesi

0(000)  T1a\______
1(001)  T2b/      \_______
2(010)  T1c\______/       \
3(011)  T3b/               \________
4(100)  T1b\______         /
5(101)  T3a/      \_______/
6(110)  T2a\______/
7(111)  T3c/

Supponiamo che i nodi foglia del tuo albero siano numerati 0..n-1 dove n è il numero totale di giocatori. Questi numeri verrebbero assegnati tramite la ricerca in profondità. Ciò risulterebbe nei nodi 0 e 1 che hanno un genitore comune e 2 e 3 che hanno un genitore comune. I genitori di questi genitori avranno un genitore comune e così via.

Ora, supponiamo anche che tu abbia m squadre, ognuna con n / m giocatori, potresti assegnare i numeri dei giocatori in modalità round-robin in modo tale che i giocatori della squadra i siano numerati i, n / m + i, n / m * 2 + i, n / m * 3 + i, ...

Una volta che ciò accade, li distribuisci attraverso i nodi foglia del tuo albero e ciò dovrebbe massimizzare la distanza tra loro.

Example:
If no. of players = 16, no. of teams = 4.
Team 0 players = 0, 4,  8, 12
Team 1 players = 1, 5,  9, 13
Team 2 players = 2, 6, 10, 14
Team 3 players = 3, 7, 11, 15

Tutti i giocatori sono equamente distribuiti con la maggior distanza possibile senza sacrificare le distanze degli altri giocatori.

Se il numero di giocatori non è lo stesso su ogni squadra, per favore fallo sapere, prenderò un altro tentativo.

Spero che questo abbia una dimostrazione integrata in se stesso.

L'idea principale è di ritardare il più possibile l'incontro di 2 compagni di squadra. Quindi un algoritmo avido funzionerebbe.

Il massimo che possiamo ritardare è nel finale, poi in semi-final1, in semi-final2, quarter-final1, ecc ... Salva questo elenco ordinato di match-up nella lista L1.

Ordina l'elenco dei giocatori con la stessa squadra tutti insieme all'inizio della lista. Questa è la lista L2

Scoppia un match-up da L1, schiocca 2 giocatori nella stessa squadra da L2, riempi i giocatori in qualsiasi parte dei rami vuoti della partita appena arrivati da L1. [correzione: dopo la prima iterazione del loop, a ogni match-up sarà assegnato un solo branch unfilled (con i giocatori della stessa squadra), quindi dobbiamo fare un altro match-up per riempire il secondo giocatore]. Questo garantirà la massima distanza tra 2 compagni di squadra.

Continua con nuovo match-up fino a quando il match-up è il primo round. Ora non possiamo più ritardare, quindi riempire tutti i giocatori in modo arbitrario. Questo è abbastanza astratto, ma sono sicuro che ha abbastanza dettagli da implementare

1. Inizia dal nodo radice (la partita finale) e dall'intero elenco di giocatori.
2. Partiziona la lista in due elenchi di dimensioni uguali in modo che le persone della stessa squadra finiscano in elenchi diversi. Puoi farlo collegando i gruppi e metti metà dei giocatori da quella squadra in ciascuna delle due partizioni.
3. Recupera la sottostruttura di sinistra con la prima lista e la sottostruttura di destra con la seconda lista e fai di nuovo la stessa cosa in ogni sottostruttura.

Questo garantirà che i giocatori della stessa squadra siano distribuiti uniformemente. Se ci sono solo due giocatori di una squadra, ti viene persino garantito che non possono incontrarsi fino alla finale perché sono stati immediatamente divisi in sottotitoli diversi.

È possibile rendere generica la funzione di partizione utilizzata nel passaggio 2. Invialo come puntatore a funzione e puoi estenderlo facilmente per tenere conto di cose come il rank.