Sto cercando una struttura di dati che memorizza un set di stringhe su un set di caratteri $\Sigma$ , in grado di eseguire le seguenti operazioni. Indichiamo $\mathcal{D}(S)$ come struttura dati memorizzare l'insieme di stringhe $S$ .

• Add-Prefix-Setsu $\mathcal{D}(S)$ : dato un insieme $T$ di stringhe (possibilmente vuote), la cui dimensione è delimitata da una costante e le cui lunghezze della stringa sono delimitate da una costante, restituisce $\mathcal{D}( \{ t s\ |\ t \in T, s \in S\} )$ . Entrambe queste costanti delimitazione sono globali: sono uguali per tutti gli ingressi $T$ .
• Get-Prefixessu $\mathcal{D}(S)$ : restituisce . Si noti che non mi dispiace davvero quale struttura viene utilizzata per questo set, purché sia ​​possibile enumerare i suoi contenuti nel tempo .$\{ a \ | \ as \in S, a \in \Sigma \}$$O(|\Sigma|)$
• Remove-Prefixeson : return .$\mathcal{D}(S)$$\mathcal{D}( \{ s \ | \ as \in S, a \in \Sigma \} )$
• Merge: dato e , restituisce .$\mathcal{D}(S)$$\mathcal{D}(T)$$\mathcal{D}(S \cup T)$

Ora, mi piacerebbe davvero fare tutte queste operazioni nel tempo , ma sto bene con una struttura che fa tutte queste operazioni nel tempo , dove è la lunghezza della stringa più lunga nel struttura. Nel caso della fusione, Vorrei una tempo di esecuzione, dove n 1 è per il primo e il per la seconda struttura.$O(1)$$o(n)$$n$$o(n_1+n_2)$$n_1$$n$$n_2$$n$

Un ulteriore requisito è che la struttura sia immutabile, o almeno che le operazioni sopra riportate restituiscano strutture "nuove" in modo tale che i puntatori a quelli vecchi funzionino ancora come prima.

Una nota sull'ammortamento: va bene, ma bisogna fare attenzione alla persistenza. Dato che riutilizzo sempre le vecchie strutture, sarò nei guai se colpirò il caso peggiore con un particolare insieme di operazioni sulla stessa struttura (ignorando così le nuove strutture che crea).

Mi piacerebbe usare una tale struttura in un algoritmo di analisi su cui sto lavorando; la struttura sopra avrebbe il lookahead di cui ho bisogno per l'algoritmo.

Ho già preso in considerazione l'uso di un trie , ma il problema principale è che non so come unire i tentativi in ​​modo efficiente. Se l'insieme di stringhe per è Add-Prefix-Setcostituito solo da stringhe a carattere singolo, è possibile archiviare questi insiemi in una pila, che ti darebbe tempi di esecuzione per le prime tre operazioni. Tuttavia, questo approccio non funziona neanche per la fusione.$O(1)$

Infine, nota che non sono interessato ai fattori: questo è costante per tutto ciò che mi interessa.$|\Sigma|$

Ho pensato per un po 'di tempo, ma non ho trovato il problema con tutte le tue operazioni nel modo più stupido possibile in una struttura DAG simile a un trie:

Add-prefisso-Set

Creare un trie di stringhe da . Collegare ciascun nodo foglia alla radice del vecchio trie.$T$

Complessità: $O(|T|)$

Merge

Unisci le radici di due strutture: crea tutti i nodi figlio del secondo figlio radice del primo nodo. Ora puoi avere più bordi contrassegnati con lo stesso carattere che vanno dallo stesso nodo.

Complessità: $O(1)$

Aggiornamento pigro della radice

1. Per ogni personaggio unisci tutti i figli della radice accessibili dai bordi contrassegnati da questo carattere. ( + O ammortizzato ( 1 ) per ogni bordo mai aggiunto)$O(|\Sigma|)$$O(1)$
2. Elimina tutti i bordi che vanno nella radice dall'alto. (Può succedere dopo Rimuovi prefissi, ammortizzato per ogni bordo mai aggiunto)$O(1)$

Get-prefissi

Lazy aggiorna il root. Ora trova tutti i figli della radice e riporta una serie di lettere sui bordi che vanno verso di loro.

Complessità: $O(|\Sigma|)$

Remove-prefissi

Lazy aggiorna il root. Unisci tutti i figli della radice e imposta il puntatore radice sul risultato di questa unione. Lazy aggiorna la nuova radice.

Complessità: + Aggiornamento pigro$O(|\Sigma|)$

Persistenza

Tutte le informazioni su questa struttura di dati possono essere salvate in array, con informazioni per nodo più informazioni O ( | Σ | ) per ogni figlio del nodo. Ogni operazione può essere svolta come serie di incarichi in questi array. Utilizzare l'albero degli intervalli persistenti o qualsiasi altra struttura di dati che può essere visualizzata come un array persistente. Moltiplicatore aggiuntivo per la memoria e la complessità dello spazio O ( l o g N ) , dove N è il numero totale di caratteri in tutte le query.$O(1)$$O(|\Sigma|)$$O(log N)$$N$