Come implementare uno shuffle ponderato

Di recente ho scritto del codice che ho ritenuto molto inefficiente, ma poiché includeva solo pochi valori, l'ho accettato. Tuttavia, sono ancora interessato a un algoritmo migliore per quanto segue:

1. Un elenco di oggetti X, a ciascuno di essi viene assegnato un "peso"
2. Riassumi i pesi
3. Genera un numero casuale da 0 alla somma
4. Scorrere gli oggetti, sottraendo il loro peso dalla somma fino a quando la somma non è positiva
5. Rimuovere l'oggetto dall'elenco e quindi aggiungerlo alla fine del nuovo elenco

Gli articoli 2,4 e 5 richiedono tutti del ntempo, quindi è un O(n^2)algoritmo.

Questo può essere migliorato?

Come esempio di shuffle ponderato, un elemento ha maggiori possibilità di trovarsi davanti con un peso maggiore.

Esempio (genererò numeri casuali per renderlo reale):

6 oggetti con pesi 6,5,4,3,2,1; La somma è 21

Ho scelto 19 19-6-5-4-3-2 = -1:, quindi 2 va in prima posizione, i pesi ora sono 6,5,4,3,1; La somma è 19

Ho scelto 16 16-6-5-4-3 = -2:, quindi 3 va in seconda posizione, i pesi ora sono 6,5,4,1; La somma è 16

Ho scelto 3 3-6 = -3:, quindi 6 va in terza posizione, i pesi ora sono 5,4,1; La somma è 10

Ho scelto 8:, 8-5-4 = -1quindi 4 va in quarta posizione, i pesi ora sono 5,1; La somma è 6

Ho scelto 5:, 5-5=0quindi 5 va in quinta posizione, i pesi ora sono 1; La somma è 1

Ho scelto 1:, 1-1=0quindi 1 va nell'ultima posizione, non ho più pesi, finisco

Questo può essere implementato O(n log(n))usando un albero.

Innanzitutto, creare l'albero, mantenendo in ciascun nodo la somma cumulativa di tutti i nodi discendenti a destra e a sinistra di ciascun nodo.

Per campionare un elemento, campiona ricorsivamente dal nodo radice, usando le somme cumulative per decidere se restituire il nodo corrente, un nodo da sinistra o un nodo da destra. Ogni volta che si campiona un nodo, impostarne il peso su zero e anche aggiornare i nodi padre.

Questa è la mia implementazione in Python:

import random

def weigthed_shuffle(items, weights):
    if len(items) != len(weights):
        raise ValueError("Unequal lengths")

    n = len(items)
    nodes = [None for _ in range(n)]

    def left_index(i):
        return 2 * i + 1

    def right_index(i):
        return 2 * i + 2

    def total_weight(i=0):
        if i >= n:
            return 0
        this_weigth = weights[i]
        if this_weigth <= 0:
            raise ValueError("Weigth can't be zero or negative")
        left_weigth = total_weight(left_index(i))
        right_weigth = total_weight(right_index(i))
        nodes[i] = [this_weigth, left_weigth, right_weigth]
        return this_weigth + left_weigth + right_weigth

    def sample(i=0):
        this_w, left_w, right_w = nodes[i]
        total = this_w + left_w + right_w
        r = total * random.random()
        if r < this_w:
            nodes[i][0] = 0
            return i
        elif r < this_w + left_w:
            chosen = sample(left_index(i))
            nodes[i][1] -= weights[chosen]
            return chosen
        else:
            chosen = sample(right_index(i))
            nodes[i][2] -= weights[chosen]
            return chosen

    total_weight() # build nodes tree

    return (items[sample()] for _ in range(n - 1))

Uso:

In [2]: items = list(range(10))
   ...: weights = list(range(10, 0, -1))
   ...:

In [3]: for _ in range(10):
   ...:     print(list(weigthed_shuffle(items, weights)))
   ...:
[5, 0, 8, 6, 7, 2, 3, 1, 4]
[1, 2, 5, 7, 3, 6, 9, 0, 4]
[1, 0, 2, 6, 8, 3, 7, 5, 4]
[4, 6, 8, 1, 2, 0, 3, 9, 7]
[3, 5, 1, 0, 4, 7, 2, 6, 8]
[3, 7, 1, 2, 0, 5, 6, 4, 8]
[1, 4, 8, 2, 6, 3, 0, 9, 5]
[3, 5, 0, 4, 2, 6, 1, 8, 9]
[6, 3, 5, 0, 1, 2, 4, 8, 7]
[4, 1, 2, 0, 3, 8, 6, 5, 7]

weigthed_shuffleè un generatore, quindi puoi campionare gli kelementi migliori in modo efficiente. Se si desidera lo shuffle dell'intero array, basta scorrere il generatore fino all'esaurimento (usando la listfunzione).

AGGIORNARE:

Il campionamento casuale ponderato (2005; Efraimidis, Spirakis) fornisce un algoritmo molto elegante per questo. L'implementazione è super semplice e funziona anche in O(n log(n)):

def weigthed_shuffle(items, weights):
    order = sorted(range(len(items)), key=lambda i: -random.random() ** (1.0 / weights[i]))
    return [items[i] for i in order]

EDIT: questa risposta non interpreta i pesi nel modo previsto. Vale a dire un articolo con peso 2 non è il doppio delle probabilità di essere il primo di uno con peso 1.

Un modo per mescolare un elenco è quello di assegnare numeri casuali a ciascun elemento nell'elenco e ordinarli in base a tali numeri. Possiamo estendere quell'idea, dobbiamo solo selezionare numeri casuali ponderati. Ad esempio, potresti usare random() * weight. Scelte diverse produrranno distribuzioni diverse.

In qualcosa come Python, questo dovrebbe essere semplice come:

items.sort(key = lambda item: random.random() * item.weight)

Fai attenzione a non valutare le chiavi più di una volta, poiché finiranno con valori diversi.

Innanzitutto, consente di lavorare in base al quale il peso di un determinato elemento nell'elenco da ordinare è costante. Non cambierà tra le iterazioni. Se lo fa, allora ... beh, questo è un problema più grande.

Per esempio, usiamo un mazzo di carte in cui vogliamo pesare le carte frontali. weight(card) = card.rank. Riassumendo questi, se non sappiamo che la distribuzione dei pesi è effettivamente O (n) una volta.

Questi elementi sono memorizzati in una struttura ordinata come una modifica in un elenco di salto indicizzabile in modo tale che tutti gli indici dei livelli siano accessibili da un determinato nodo:

   1 10
 o ---> o -------------------------------------------- -------------> o Livello superiore
   1 3 2 5
 o ---> o ---------------> o ---------> o ---------------- -----------> o Livello 3
   1 2 1 2 5
 o ---> o ---------> o ---> o ---------> o ----------------- ----------> o Livello 2
   1 1 1 1 1 1 1 1 1 1 1 
 o ---> o ---> o ---> o ---> o ---> o ---> o ---> o ---> o ---> o ---> o ---> o Livello inferiore

Testa 1 ° 2 ° 3 ° 4 ° 5 ° 6 ° 7 ° 8 ° 9 ° 10 ° NIL
      Nodo Nodo Nodo Nodo Nodo Nodo Nodo Nodo Nodo Nodo

Tuttavia, in questo caso, ogni nodo "occupa" tanto spazio quanto il suo peso.

Ora, quando si cerca una carta in questo elenco, è possibile accedere alla sua posizione nell'elenco in O (log n) time e rimuoverlo dagli elenchi associati in O (1) time. Ok, potrebbe non essere O (1), potrebbe essere O (log log n) volta (dovrei pensarci molto di più). La rimozione del sesto nodo nell'esempio sopra implicherebbe l'aggiornamento di tutti e quattro i livelli - e quei quattro livelli sono indipendenti dal numero di elementi presenti nell'elenco (a seconda della modalità di implementazione dei livelli).

Poiché il peso di un elemento è costante, si può semplicemente fare a sum -= weight(removed)meno di dover attraversare di nuovo la struttura.

E quindi, hai un costo una tantum di O (n) e un valore di ricerca di O (log n) e un costo di rimozione dalla lista di O (1). Questo diventa O (n) + n * O (log n) + n * O (1) che ti dà una performance complessiva di O (n log n).

Vediamo questo con le carte, perché è quello che ho usato sopra.

      10
top 3 -----------------------> 4d
                                .
       3 7.
    2 ---------> 2d ---------> 4d
                  . .
       1 2. 3 4.
bot 1 -> Annuncio -> 2d -> 3d -> 4d

Questo è un mazzo davvero piccolo con solo 4 carte. Dovrebbe essere facile vedere come può essere esteso. Con 52 carte una struttura ideale avrebbe 6 livelli (log ₂ (52) ~ = 6), anche se se si scava negli skip list anche quello potrebbe essere ridotto a un numero più piccolo.

La somma di tutti i pesi è 10. Quindi ottieni un numero casuale da [1 .. 10) e il suo 4 Cammina l'elenco salta per trovare l'oggetto che si trova al soffitto (4). Poiché 4 è inferiore a 10, si passa dal livello superiore al secondo livello. Quattro è maggiore di 3, quindi ora siamo al 2 di diamanti. 4 è inferiore a 3 + 7, quindi passiamo al livello inferiore e 4 è inferiore a 3 + 3, quindi abbiamo 3 diamanti.

Dopo aver rimosso il 3 di diamanti dalla struttura, la struttura ora appare come:

       7
top 3 ----------------> 4d
                         .
       3 4.
    2 ---------> 2d -> 4d
                  . .
       1 2. 4
bot 1 -> Annuncio -> 2d -> 4d

Noterai che i nodi occupano una quantità di "spazio" proporzionale al loro peso nella struttura. Ciò consente la selezione ponderata.

Poiché questo si avvicina a un albero binario bilanciato, la ricerca in questo non ha bisogno di camminare sul livello inferiore (che sarebbe O (n)) e invece andare dall'alto ti consente di saltare rapidamente la struttura per trovare ciò che stai cercando per.

Gran parte di questo potrebbe invece essere fatto con una sorta di albero equilibrato. Il problema è che il riequilibrio della struttura quando un nodo viene rimosso diventa confuso poiché questa non è una struttura ad albero classica e le pulizie per ricordare che il 4 di diamanti viene ora spostato da posizioni [6 7 8 9] a [3 4 5 6] può costare di più rispetto ai vantaggi della struttura ad albero.

Tuttavia, mentre l'elenco skip si avvicina ad un albero binario nella sua capacità di saltare l'elenco in tempo O (log n), ha invece la semplicità di lavorare con un elenco collegato.

Questo non vuol dire che è facile fare tutto questo (è comunque necessario tenere sotto controllo tutti i collegamenti che è necessario modificare quando si rimuove un elemento), ma significa aggiornare solo i livelli che si hanno e i loro collegamenti piuttosto di tutto a destra sulla corretta struttura ad albero.