Compressione efficiente di alberi senza etichetta

Prendi in considerazione alberi binari senza etichetta e con radici. Possiamo comprimere tali alberi: quando sono puntatori ai sottoalberi e T ' con T = T ' (interpretazione = la parità strutturali), abbiamo memorizzare (WLOG) T e sostituire tutti i puntatori alle T ' con puntatori a T . Vedi la risposta di uli per un esempio.$T$$T'$$T = T'$$=$$T$$T'$$T$

Fornire un algoritmo che accetta come input un albero nel senso sopra indicato e calcola il numero (minimo) di nodi che rimangono dopo la compressione. L'algoritmo dovrebbe essere eseguito nel tempo (nel modello di costo uniforme) con n il numero di nodi nell'input.$\cal{O}(n\log n)$$n$

Questa è stata una domanda d'esame e non sono stato in grado di trovare una buona soluzione, né ne ho vista una.

Sì, è possibile eseguire questa compressione nel tempo , ma non è facile :) Facciamo prima alcune osservazioni e poi presentiamo l'algoritmo. Supponiamo che l'albero inizialmente non sia compresso - questo non è davvero necessario ma semplifica l'analisi.$O(n \log n)$

Innanzitutto, definiamo induttivamente la "parità strutturale". Sia e T ′ due (sotto) alberi. Se T e T ' sono entrambi gli alberi nulli (senza vertici), sono strutturalmente equivalenti. Se T e T 'non sono entrambi alberi nulli, allora sono strutturalmente equivalenti se i loro figli sinistri sono strutturalmente equivalenti e i loro figli giusti sono strutturalmente equivalenti. L '"equivalenza strutturale" è il punto fisso minimo su queste definizioni.$T$$T'$$T$$T'$$T$$T'$

Ad esempio, due nodi foglia qualsiasi sono strutturalmente equivalenti, poiché entrambi hanno gli alberi null come entrambi i loro figli, che sono strutturalmente equivalenti.

Dato che è piuttosto fastidioso dire "i loro figli sinistri sono strutturalmente equivalenti e così sono i loro figli giusti", spesso diremo "i loro figli sono strutturalmente equivalenti" e intendono lo stesso. Nota anche che a volte diciamo "questo vertice" quando intendiamo "la sottostruttura radicata in questo vertice".

La definizione sopra ci dà immediatamente un indizio su come eseguire la compressione: se conosciamo l'equivalenza strutturale di tutti i sottotitoli con profondità al massimo , allora possiamo facilmente calcolare l'equivalenza strutturale dei sottotitoli con profondità d + 1 . Dobbiamo fare questo calcolo in modo intelligente per evitare un tempo di esecuzione O ( n 2 ) .$d$$d+1$$O(n^2)$

L'algoritmo assegnerà identificatori a ogni vertice durante la sua esecuzione. Un identificatore è un numero nell'insieme . Gli identificatori sono unici e non cambiano mai: assumiamo quindi di impostare una variabile (globale) su 1 all'inizio dell'algoritmo e ogni volta che assegniamo un identificatore a un vertice, assegniamo il valore corrente di quella variabile al vertice e all'incremento il valore di quella variabile.$\{ 1, 2, 3, \dots, n \}$

Trasformiamo innanzitutto l'albero di input in (al massimo ) elenchi contenenti vertici di uguale profondità, insieme a un puntatore al loro genitore. Questo è facilmente eseguibile in O ( n ) tempo.$n$$O(n)$

Per prima cosa comprimiamo tutte le foglie (possiamo trovare queste foglie nell'elenco con vertici di profondità 0) in un singolo vertice. Assegniamo a questo vertice un identificatore. La compressione di due vertici viene effettuata reindirizzando il genitore di uno dei vertici in modo che punti invece all'altro vertice.

Facciamo due osservazioni: in primo luogo, ogni vertice ha figli di profondità strettamente inferiore e, in secondo luogo, se abbiamo eseguito la compressione su tutti i vertici di profondità inferiori a (e abbiamo dato loro degli identificatori), allora due vertici di profondità d sono strutturalmente equivalenti e può essere compresso se gli identificatori dei loro figli coincidono. Quest'ultima osservazione deriva dal seguente argomento: due vertici sono strutturalmente equivalenti se i loro figli sono strutturalmente equivalenti, e dopo la compressione questo significa che i loro puntatori indicano gli stessi figli, il che a sua volta significa che gli identificatori dei loro figli sono uguali.$d$$d$

Esaminiamo tutte le liste con nodi di uguale profondità da piccola profondità a grande profondità. Per ogni livello creiamo un elenco di coppie di numeri interi, in cui ogni coppia corrisponde agli identificatori dei figli di alcuni vertici su quel livello. Abbiamo che due vertici in quel livello sono strutturalmente equivalenti se le loro coppie intere corrispondenti sono uguali. Usando l'ordinamento lessicografico, possiamo ordinarli e ottenere gli insiemi di coppie di numeri interi uguali. Comprimiamo questi set in vertici singoli come sopra e forniamo loro identificatori.

Le osservazioni di cui sopra dimostrano che questo approccio funziona e risulta nell'albero compresso. Il tempo di esecuzione totale è più il tempo necessario per ordinare gli elenchi che creiamo. Poiché il numero totale di coppie di numeri interi che creiamo è n , questo ci dà che il tempo di esecuzione totale è O ( n log n ) , come richiesto. Contare il numero di nodi rimasti al termine della procedura è banale (basta guardare quanti identificatori abbiamo distribuito).$O(n)$$n$$O(n \log n)$

La compressione di una struttura di dati non mutabile in modo tale da non duplicare alcun sotterma strutturalmente uguale è nota come hash consing . Questa è una tecnica importante nella gestione della memoria nella programmazione funzionale. L'hash consing è una sorta di memorizzazione sistematica per le strutture dati.

Andremo a hash-contro dell'albero e contiamo i nodi dopo il consumo di hash. L'hash che consenta una struttura di dati di dimensione può sempre essere eseguito in O ( $n$ operazioni; il conteggio del numero di nodi alla fine è lineare nel numero di nodi.$O(n\:\mathrm{lg}(n))$

Considero gli alberi con la seguente struttura (scritta qui nella sintassi di Haskell):

data Tree = Leaf
          | Node Tree Tree

Per ogni costruttore, dobbiamo mantenere una mappatura dai suoi possibili argomenti al risultato dell'applicazione del costruttore a questi argomenti. Le foglie sono banali. Per i nodi, manteniamo una mappa parziale finita dove T è l'insieme degli identificatori dell'albero e N è l'insieme degli identificatori dei nodi; T = N ⊎ { ℓ } dove ℓ è l'unico identificatore foglia. (In termini concreti, un identificatore è un puntatore a un blocco di memoria.)$\mathtt{nodes} : T \times T \to N$$T$$N$$T = N \uplus \{\ell\}$$\ell$

Possiamo usare una struttura di dati tempo logaritmico per nodes, come un albero di ricerca binario bilanciato. Di seguito chiamerò lookup nodesl'operazione che cerca una chiave nella nodesstruttura dei dati e insert nodesl'operazione che aggiunge un valore sotto una nuova chiave e restituisce quella chiave.

Ora attraversiamo l'albero e aggiungiamo i nodi mentre procediamo. Sebbene scrivo in uno pseudocodice simile a Haskell, tratterò nodescome una variabile mutabile globale; lo aggiungeremo sempre e solo, ma gli inserimenti devono essere sottoposti a thread. La addfunzione ricorre su un albero, aggiungendo i suoi sottoalberi alla nodesmappa e restituisce l'identificatore della radice.

insert (p1,p2) =
add Leaf = $\ell$
add (Node t1 t2) =
    let p1 = add t1
    let p2 = add t2
    case lookup nodes (p1,p2) of
      Nothing -> insert nodes (p1,p2)
      Just p -> p

Il numero di insertchiamate, che è anche la dimensione finale della nodesstruttura dei dati, è il numero di nodi dopo la massima compressione. (Se necessario, aggiungine uno per l'albero vuoto).

Ecco un'altra idea che mira a (iniettivamente) codificare la struttura degli alberi in numeri, piuttosto che etichettarli arbitrariamente. Per questo, usiamo che la fattorizzazione primaria di qualsiasi numero è unica.

Ai nostri scopi, sia denoti una posizione vuota nell'albero, e N ( l , r ) un nodo con sottostruttura sinistra l e sottostruttura destra r . N ( E , E ) sarebbe una foglia. Adesso molla$E$$N(l,r)$$l$$r$$N(E,E)$

$\qquad \displaystyle \begin{align*} f(E) &= 0 \\ f(N(l,r)) &= 2^{f(l)}\cdot 3^{f(r)} \end{align*}$

Usando , possiamo calcolare l'insieme di tutti i sottotitoli contenuti in un albero dal basso verso l'alto; in ogni nodo, uniamo i set di codifiche ottenute dai bambini e aggiungiamo un nuovo numero (che può essere calcolato in tempo costante dalle codifiche dei bambini).$f$

Quest'ultima ipotesi è un allungamento su macchine reali; in questo caso, si preferirebbe usare qualcosa di simile alla funzione di accoppiamento di Cantor anziché esponenziazione.

$\cal{O}(n \log n)$$\cal{O}(n \log n)$

Poiché le foto non sono consentite nei commenti:

in alto a sinistra: un albero di input

in alto a destra: anche i sottotitoli radicati nei nodi 5 e 7 sono isomorfi.

in basso a sinistra e a destra: gli alberi compressi non sono definiti in modo univoco.

$7+5|T|$$6+|T|$

Modifica: ho letto la domanda poiché T e T ′ erano figli dello stesso genitore. Ho preso anche la definizione di compressione come ricorsiva, nel senso che potresti comprimere due sottotitoli precedentemente compressi. Se questa non è la vera domanda, la mia risposta potrebbe non funzionare.

$O(n \log n)$$T(n) = 2T(n/2) + cn$

def Comp(T):
   if T == null:
     return 0
   leftCount = Comp(T.left)
   rightCount = Comp(T.right)
   if leftCount == rightCount:
     if hasSameStructure(T.left, T.right):
       T.right = T.left
       return leftCount + 1
     else
       return leftCount + rightCount + 1    

Dov'è hasSameStructure()una funzione che confronta due sottostrutture già compresse in tempo lineare per vedere se hanno la stessa struttura esatta. Scrivere una funzione ricorsiva temporale lineare che attraversa ciascuna e controlla se una sottostruttura ha un figlio sinistro ogni volta che l'altra lo fa ecc. Non dovrebbe essere difficile.

$n_\ell$$n_r$