Quanto è difficile riordinare una stringa?

Una mescolanza di due stringhe si forma intervallando i caratteri in una nuova stringa, mantenendo in ordine i caratteri di ciascuna stringa. Ad esempio, MISSISSIPPIè un riordino di MISIPPe SSISI. Permettetemi di chiamare un quadrato di stringhe se è un riordino di due stringhe identiche. Ad esempio, ABCABDCDè quadrato, perché è un riordino di ABCDe ABCD, ma la stringa ABCDDCBAnon è quadrata.

Esiste un algoritmo veloce per determinare se una stringa è quadrata o è NP-difficile? L'ovvio approccio di programmazione dinamica non sembra funzionare.

Anche i seguenti casi speciali sembrano essere difficili: (1) stringhe in cui ogni carattere appare al massimo quattro sei volte e (2) stringhe con solo due caratteri distinti. Come sottolineato da Austrin di seguito, il caso speciale in cui ogni personaggio si presenta al massimo quattro volte può essere ridotto a 2SAT.

---

Aggiornamento: questo problema ha un'altra formulazione che può rendere più semplice una prova di durezza.

Considera un grafico G i cui vertici sono gli interi da 1 a n; identificare ogni fronte con l'intervallo reale tra i suoi punti finali. Diciamo che due bordi di G sono nidificati se un intervallo contiene correttamente l'altro. Ad esempio, i bordi (1,5) e (2,3) sono nidificati, ma (1,3) e (5,6) non lo sono, e (1,5) e (2,8) non lo sono. Una corrispondenza in G non è nidificata se nessuna coppia di bordi è nidificata. Esiste un algoritmo rapido per determinare se G ha una corrispondenza perfetta non nidificata o è un problema NP-difficile?

• Disordinare una stringa equivale a trovare una corrispondenza perfetta non nidificata in un'unione disgiunta di cricche (con bordi tra caratteri uguali). In particolare, riordinare una stringa binaria equivale a trovare una corrispondenza perfetta non nidificata in un'unione disgiunta di due cricche. Ma non so nemmeno se questo problema è difficile per i grafici generali o facile per qualsiasi classe di grafici interessante.

• Esiste un semplice algoritmo a tempo polinomiale per trovare corrispondenze perfette non incrociate .

---

Aggiornamento (24 giugno 2013): il problema è stato risolto! Ora ci sono due prove indipendenti che identificano le stringhe quadrate è NP-completo.

• Nel novembre 2012, Sam Buss e Michael Soltys hanno annunciato una riduzione da 3 partizioni , il che dimostra che il problema è difficile anche per le stringhe su un alfabeto di 9 caratteri. Vedi "Unshuffling a Square is NP-Hard ", Journal of Computer System Sciences 2014.

• Nel giugno 2013, Romeo Rizzi e Stéphane Vialette hanno pubblicato una riduzione dal più lungo problema di sottosequenza comune . Vedere " Riconoscimento delle parole che sono quadrati per il prodotto casuale ", proc. 8 ° Simposio internazionale di informatica in Russia , Springer LNCS 7913, pagg. 235-245.

C'è anche una prova più semplice che trovare corrispondenze perfette non nidificate è NP-difficile, a causa di Shuai Cheng Li e Ming Li nel 2009. Vedi " Su due problemi aperti di schemi a 2 intervalli ", Theoretical Computer Science 410 (24–25 ): 2410-2423, 2009.

Michael Soltys e io siamo riusciti a dimostrare che il problema di determinare se una stringa può essere scritta come un riordino quadrato è NP completo. Questo vale anche per un alfabeto finito con solo simboli distinti, sebbene la nostra prova sia scritta per un alfabeto con simboli. Questa domanda è ancora aperta per alfabeti più piccoli, diciamo con solo simboli. Non abbiamo esaminato il problema con la restrizione che ogni simbolo appare solo volte (o, più in generale, un numero costante di volte); quindi quella domanda è ancora aperta.9 2 $7$$9$$2$$6$

La dimostrazione utilizza una riduzione da -Partition. È troppo lungo per pubblicare qui, ma una prestampa, "Unshuffling a string is -hard", è disponibile dalle nostre pagine Web all'indirizzo:$3$$\text{NP}$

http://www.math.ucsd.edu/~sbuss/ResearchWeb/Shuffle/

e

http://www.cas.mcmaster.ca/~soltys/#Papers .

L'articolo è stato pubblicato nel Journal of Computer System Sciences:

http://www.sciencedirect.com/science/article/pii/S002200001300189X

Per il caso speciale che menzioni quando ogni personaggio appare al massimo quattro volte, c'è una semplice riduzione a 2-SAT (a meno che non mi manchi qualcosa ...), come segue:

Il punto cruciale è che per ogni personaggio ci sono (al massimo) due modi validi per abbinare le occorrenze del personaggio (la terza possibilità sarà la nidificazione). Utilizzare una variabile booleana per rappresentare quale delle due corrispondenze è stata scelta. Ora un'assegnazione a queste variabili fornisce un riordino valido della stringa iff per ogni coppia di bordi nidificati, non entrambi sono stati scelti. Questa condizione può essere descritta con precisione da una disgiunzione delle variabili (eventualmente negata) corrispondente ai due caratteri coinvolti.

Ecco un algoritmo che potrebbe avere qualche possibilità di essere corretto anche se sembra difficile da dimostrare e non scommetterei la casa su di esso ...

Diciamo che viene eliminato se per ogni bordo e esiste una corrispondenza perfetta (possibilmente nidificata) di G che usa e e non usa alcun bordo contenuto in o contenente e .$G$$e$$G$$e$$e$

È facile verificare se viene rimosso e se non si trovano i bordi che violano. Chiaramente nessuno di questi bordi violanti può essere usato in un perfetto abbinamento senza nidificazione di G , quindi è sicuro rimuoverli dalla considerazione. Ripetendo questo processo, otteniamo un sottografo (unico) purificato di G che ha una corrispondenza perfetta non nidificata se G ha.$G$$G$$G$$G$

Ora arriva il salto di fede, che può o non può essere corretto: la speranza è che in un grafico purificato, se ci sono ancora vertici di grado , possiamo fare la scelta avida e abbinare il primo di questi vertici al primo vicino (o equivalentemente, rimuovi i bordi da tutti gli altri vicini).$> 1$

Dopo la scelta avida eliminiamo di nuovo il grafico, e così via, e il processo termina quando il grafico è (si spera) una corrispondenza perfetta senza nidificazione.

All'inizio ho pensato che sarebbe stato più o meno come avere un piccolo sguardo avanti nell'avido algoritmo e non funzionare davvero, ma ho trovato sorprendentemente difficile trovare un controesempio.

La soluzione che io e Sam Buss abbiamo proposto a novembre 2012 (mostrando che riordinare un quadrato in NP-hard con una riduzione da 3-Partition) è ora un articolo pubblicato sul Journal of Computer System Sciences:

http://www.sciencedirect.com/science/article/pii/S002200001300189X

Romeo Rizzi e Stéphane Vialette dimostrano che il riconoscimento delle stringhe quadrate è NP-completo nel loro documento del 2013 " Riconoscere le parole che sono quadrati per il prodotto Shuffle ", grazie alla riduzione del più lungo problema di sottosequenza binaria. Dichiarano che la complessità di riordinare le stringhe binarie è ancora aperta.

Una prova ancora più semplice che trovare una perfetta corrispondenza non nidificata sia NP-completa è data da Shuai Cheng Li e Ming Li nel loro articolo del 2009 " Su due problemi aperti di schemi a 2 intervalli ". Tuttavia, usano la terminologia ereditata dalla bioinformatica. Invece di "perfetta corrispondenza non nidificata", lo chiamano "problema DIS-2-IP- ". L'equivalenza tra i due problemi è descritta da Blin, Fertin e Vialette :$\{<, \between\}$

Il problema 2-IP-DIS- ha una formulazione immediata in termini di corrispondenze vincolate nei grafici generali: Dato un grafico insieme a un ordinamento lineare dei vertici di , il 2-IP -DIS- problema equivale a trovare una cardinalità massima corrispondente a in con la proprietà che per due spigoli distinti e di né e né$\{<, \between\}$$G$$\pi$$G$$\{<, \between\}$$M$$G$$\{u, v\}$$\{u', v'\}$$M$$min \{ \pi(u), \pi(v) \} \lt min \{ \pi(u'), \pi(v') \}$$max \{ \pi(u'), \pi(v') \lt max \{ \pi(u), \pi(v) \}$$min \{ \pi(u'), \pi(v') \} \lt min \{ \pi(u), \pi(v) \}$ e .$max \{ \pi(u), \pi(v) \} \lt max \{ \pi(u'), \pi(v') \}$

Aggiornamento (25 febbraio 2019): Bulteau e Vialette hanno mostrato che il problema decisionale di riordinare una stringa binaria è NP-completo nel loro documento, Riconoscere i riquadri shuffle binari è NP-difficile .

questo aiuta?

http://users.soe.ucsc.edu/~manfred/pubs/J1.pdf

MAI MENTE, QUESTA RISPOSTA È SBAGLIATA. Non riesce sull'input "AABAAB": abbinare avidamente le prime due A tra loro rende impossibile abbinare i simboli rimanenti. Lo sto lasciando piuttosto che cancellarlo per aiutare gli altri a evitare di fare lo stesso errore.

Mi sembra che sia sempre sicuro abbinare avidamente ogni personaggio successivo del presunto quadrato ad un altro personaggio uguale che si trova il prima possibile. Cioè, penso che dovrebbe funzionare il seguente algoritmo di tempo lineare:

Passa attraverso ogni posizione i nella stringa di input, i = 0, 1, 2, ... n. Per ogni posizione i, controlla se quella posizione è già stata confrontata con una posizione precedente nella stringa. In caso contrario, abbinalo a un carattere uguale che viene dopo l'ultima posizione già abbinata ed è altrimenti il ​​più presto possibile nella stringa. Se non viene trovata una corrispondenza per alcuni personaggi, dichiarare che l'input non è un quadrato; altrimenti, è l'insieme di caratteri nella prima coppia di ogni partita.

Eccolo in Python:

def sqrt (S):
    partite = []
    i, j = 0, 0
    mentre io <len (S):
        se j <len (corrisponde) e corrisponde [j] [1] == i:
            i + = 1
            j + = 1
            Continua
        se corrisponde:
            k = corrisponde a [-1] [1] + 1
        altro:
            k = 1
        mentre k <len (S) e S [k]! = S [i]:
            k + = 1
        se k> = len (S):
            aumenta l'eccezione ("Not a square")
        matches.append ((i, k))
        i + = 1
    restituisce "" .join (S [a] per a, b nelle partite)

print sqrt ("ABCABDCD")

Qui i è la variabile del ciclo principale (la posizione che stiamo cercando di abbinare), j è un puntatore nella matrice di coppie abbinate che accelera il controllo se la posizione i è già abbinata e k è un indice usato per cercare il personaggio che corrisponde a quello in posizione i. È tempo lineare perché i, j e k stanno aumentando monotonicamente attraverso la stringa e ogni iterazione del ciclo interno ne aumenta uno.

Aggiornamento: non ha senso parlare della difficoltà di trovare la corrispondenza perfetta che non è nidificazione e non attraversa, quando le etichette sono da 1 a n, perché ce n'è solo una. (Sì, mi prendo a calci da solo.) Tuttavia, avrebbe senso dare una gamma più ampia sulle etichette ... quindi vedo ancora qualche speranza, ma dopo tutto potrebbe essere del tutto inutile. Dovrei sicuramente dare seguito a questo.

---

Posso pensare al motivo per cui potrebbe essere difficile trovare un abbinamento che non sia nidificante e non attraversante. Vorrei chiamare tale corrispondenza una corrispondenza disgiunta . Non sono sicuro di quanto aiuti, ma lasciatemi comunque presentare il ragionamento. (Devo sottolineare che il mio argomento, così com'è, non è completo, e il dettaglio che lascio fuori è forse cruciale. Tuttavia, immagino che potrebbe essere una sorta di inizio.)

Inizierò con un problema leggermente diverso. Dato un grafico cui bordi sono colorati con colori e i vertici sono etichettati da a , esiste una corrispondenza disgiunta che contiene esattamente un bordo di ciascun colore? Questo problema sembra essere NP-difficile (l'argomento per questo è sia completo che diretto - a meno che non mi manchi qualcosa). La riduzione rivela un grafico che è un'unione disgiunta di cricche.k 1 $G$$k$$1$$n$

La riduzione è dovuta a Disjoint Factors , un problema NP completo introdotto in [1]. Un'istanza di fattori disgiunti è data da una stringa su un alfabeto di dimensione , e la domanda è se ci sono fattori disgiunti, in cui un fattore è una sottostringa che inizia e termina con la stessa lettera; e due fattori sono disgiunti se non si sovrappongono nella stringa (si noti che anche la "nidificazione", in particolare, è vietata).$k$$k$

Vorrei indicare con , gli elementi dell'alfabeto di dimensioni associati all'istanza di Fattori disgiunti.$a_1,\ldots, a_k$$k$

Data un'istanza di fattori disgiunti, vale a dire una stringa di lunghezza , crea un grafico che ha vertici con etichette vertici da a . Aggiungi un bordo tra i vertici e se le posizioni corrispondenti hanno la stessa lettera (diciamo ) e colora anche il bordo con il colore .n 1 n u v a i ( u , v ) $n$$n$$1$$n$$u$$v$$a_i$$(u,v)$$i$

La prova della riduzione deriva essenzialmente dalle definizioni. Dati fattori disgiunti, abbiamo chiaramente una corrispondenza colorata -disjoint, semplicemente selezioniamo i bordi come dato dai fattori disjoint, ed è facile vedere che la corrispondenza risultante è sia colorata che disgiunta. Al contrario, se esiste una corrispondenza colorata -disgiunto, allora abbiamo k fattori disgiunti, uno per ogni lettera, perché la corrispondenza è colorata (e quindi seleziona un fattore per lettera), ed è disgiunta (quindi i fattori corrispondenti non si sovrappongono ).k $k$$k$$k$

Per sbarazzarsi dei colori e rendere perfetto l'abbinamento, anche se su un intervallo forse più ampio , apportare le seguenti modifiche al grafico così creato:

Consenti a indicare il sottoinsieme di vertici che hanno etichette che sono posizioni associate alla lettera . Se ha vertici , quindi aggiungere nuovi vertici e indurre un grafico bipartito completo tra e i vertici appena aggiunti. Ripeti, ovviamente, per ogni lettera. a U a A ( A - 2 ) U $U_a$$a$$U_a$$A$$(A-2)$$U_a$

In , se il grafico deve indurre una corrispondenza perfetta, i vertici appena introdotti devono essere abbinati ai vertici di , e tutti tranne una coppia di vertici, e il bordo tra i vertici rimanenti corrisponderà al fattore disgiunto . Non ho elaborato i numeri che si devono associare ai vertici appena aggiunti ... notare che devono essere in modo che la corrispondenza risultante sia disgiunta. Ho solo la sensazione (leggi: spero) che "si possa fare"!$U_a$

[1] Su problemi senza kernel polinomiali , Hans L. Bodlaender, Rodney G. Downey, Michael R. Fellows e Danny Hermelin, J. Comput. Syst. Sci.

L'approccio non funziona: decomporre un quadrato mischiato eliminando due lettere corrispondenti non si traduce in quadrati mescolati ... Vedi i commenti di Radu di seguito.

---

$\Sigma$

$${\small \begin{aligned} S(XY)&\Rightarrow A(X,Y)&(1)\newline A(aX_1, aX_2Y_1Y_2)&\Rightarrow A(X_1,Y_1)\,A(X_2,Y_2)&(2)\newline A(\varepsilon,\varepsilon)&\Rightarrow\varepsilon&(3) \end{aligned}}$$ $a$$\Sigma$$\varepsilon$

$X_1$$Y_1$$Y_1$$X_2$$Y_2$$Y_1$$Y_2$$X_1$$X_2$

$abcabdcd$

$${\small\begin{aligned} S(abcabdcd) &\Rightarrow A(abc, abdcd) &(\text{by } 1, X=abc, Y=abdcd)\newline &\Rightarrow A(bc,bdcd)\,A(\varepsilon,\varepsilon)&(\text{by } 2, X_1=bc, Y_1=bdcd, X_2=Y_2=\varepsilon)\newline &\Rightarrow A(c,c)\,A(d,d)\,A(\varepsilon,\varepsilon)&(\text{by } 2)\newline &\Rightarrow A(\varepsilon,\varepsilon)\,A(\varepsilon,\varepsilon)\,A(d,d)\,A(\varepsilon,\varepsilon)&(\text{by } 2)\newline &\Rightarrow A(\varepsilon,\varepsilon)\,A(d,d)\,A(\varepsilon,\varepsilon)&(\text{by } 3)\newline &\Rightarrow A(d,d)\,A(\varepsilon,\varepsilon)&(\text{by } 3)\newline &\Rightarrow A(\varepsilon,\varepsilon)\,A(\varepsilon,\varepsilon)\,A(\varepsilon,\varepsilon)&(\text{by } 2)\newline &\Rightarrow^3\varepsilon&\text{i.e. success} \end{aligned}}$$

$0011$

$${\small\begin{aligned} S(0011)&\Rightarrow A(0,011)\newline &\Rightarrow A(\varepsilon,\varepsilon)\,A(1,1)\newline &\Rightarrow A(1,1)\newline &\Rightarrow^\ast \varepsilon \end{aligned}}$$

$X$$Y$

Aggiornamento: Come Tsuyoshi Ito sottolinea nei commenti, questo algoritmo ha un tempo di esecuzione esponenziale.

Post originale:

Ecco come lo programmerei nel mondo reale.

Ci viene data una stringa S = (S [1], ..., S [n]). Per ogni prefisso S_r = (S [1], ..., S [r]), esiste un insieme {(T_i, U_i)} di coppie di stringhe, tale che S_r è un riordino di (T_i, U_i), e T_i è un prefisso di U_i (cioè U_i 'inizia con' T_i). S_r stesso è un quadrato se e solo se questo set contiene una coppia (T_i, U_i) con T_i = U_i.

Ora, non abbiamo bisogno di generare tutte queste coppie; dobbiamo solo generare il suffisso V_i di ogni stringa U_i ottenuta rimuovendo la sua copia di T_i. Ciò eliminerà un numero (possibilmente esponenziale) di duplicati irrilevanti. Ora S_r è un quadrato se e solo se questo insieme di suffissi contiene la stringa vuota. Quindi l'algoritmo diventa:

Initialise: SuffixSet = {<empty string>} ; r = 0
Loop: while (r < n) {
  r = r + 1
  NextSuffixSet = {}
  for each V in SuffixSet {
    if (V[1] == S[r]) Add V[2...] to NextSuffixSet // Remove first character of V
    Add V||S[r] to NextSuffixSet // Append character S[r] to V
    }
  SuffixSet = NextSuffixSet
  }
Now S is a square if and only if SuffixSet contains the empty string.

Ad esempio, se S è AABAAB:

r=0: SuffixSet = {<empty string>}
r=1: S[r] = A; SuffixSet = {A}
r=2: S[r] = A; SuffixSet = {<empty string>, AA}
r=3: S[r] = B; SuffixSet = {B, AAB}
r=4: S[r] = A; SuffixSet = {BA, AB, AABA}
r=5: S[r] = A; SuffixSet = {BAA, B, ABA, AABAA}
r=6: S[r] = B; SuffixSet = {AA, BAAB, <empty string>, BB, ABAB, AABAAB}

Possiamo scartare tutti i suffissi che sono più della metà della stringa di input, quindi questo semplifica:

r=0: SuffixSet = {<empty string>}
r=1: S[r] = A; SuffixSet = {A}
r=2: S[r] = A; SuffixSet = {<empty string>, AA}
r=3: S[r] = B; SuffixSet = {B, AAB}
r=4: S[r] = A; SuffixSet = {BA, AB}
r=5: S[r] = A; SuffixSet = {BAA, B, ABA}
r=6: S[r] = B; SuffixSet = {AA, <empty string>, BB}

L'ho programmato in C ++ e funziona su tutti gli esempi forniti qui. Posso pubblicare il codice, se qualcuno è interessato. La domanda è: la dimensione di SuffixSet può crescere più rapidamente del polinomio?

EDIT: questa è una risposta errata.

---

Sylvain ha suggerito un RCG che purtroppo non era appropriato per questi "riquadri shuffle". Tuttavia, penso che ce ne sia uno (EDIT: non un RCG, vedi i commenti di Kurt qui sotto!) , Che appare come segue:

$\begin{aligned} S(Y) & \rightarrow A(\epsilon,Y) & (1) \newline A(X, ZY) & \rightarrow A(XZ,Y) & (2) \newline A(aX, aY) & \rightarrow A(X,Y) \quad \text{ for every } a \in \Sigma & (3) \newline A(\epsilon,\epsilon) & \rightarrow \epsilon & (4) \end{aligned}$

$a$$a'$$b$$b'$$a \prec b$$a' \prec b'$$\prec$$(1,2)$$(3)$$(2)$

$100110101010$

$\begin{aligned} S(100110101010) & \Rightarrow A(\epsilon,100110101010) & (1) \newline & \Rightarrow A(1001,10101010) & (2) \newline & \Rightarrow^* A(01,101010) & (3) \newline & \Rightarrow A(011,01010) & (2) \newline & \Rightarrow^* A(1,010) & (3) \newline & \Rightarrow A(10,10) & (2) \newline & \Rightarrow^* A(\epsilon, \epsilon) & (3) \newline & \Rightarrow \epsilon & (4) \end{aligned}$

Non ho elaborato una prova formale che questa grammatica catturi davvero esattamente i "riquadri shuffle", ma non dovrebbe essere troppo difficile. Sylvain ha già detto che il problema decisionale per gli RCG è polinomiale.