Quão difícil é embaralhar uma string?

Um embaralhamento de duas strings é formado pela intercalação dos caracteres em uma nova string, mantendo os caracteres de cada string em ordem. Por exemplo, MISSISSIPPIé um embaralhamento de MISIPPe SSISI. Deixe-me chamar um quadrado de cadeia de caracteres, se for uma mistura de duas cadeias idênticas. Por exemplo, ABCABDCDé quadrado, porque é um embaralhamento de ABCDe ABCD, mas a sequência ABCDDCBAnão é quadrada.

Existe um algoritmo rápido para determinar se uma string é quadrada ou é NP-difícil? A abordagem óbvia de programação dinâmica parece não funcionar.

Até os seguintes casos especiais parecem difíceis: (1) cadeias nas quais cada caractere aparece no máximo quatro seis vezes e (2) cadeias com apenas dois caracteres distintos. Como aponta Por Austrin abaixo, o caso especial em que cada personagem ocorre no máximo quatro vezes pode ser reduzido para 2SAT.

---

Atualização: Esse problema possui outra formulação que pode facilitar a prova de dureza.

Considere um gráfico G cujos vértices são os inteiros de 1 a n; identifique cada aresta com o intervalo real entre seus pontos finais. Dizemos que duas arestas de G estão aninhadas se um intervalo contém adequadamente o outro. Por exemplo, as arestas (1,5) e (2,3) estão aninhadas, mas (1,3) e (5,6) não, e (1,5) e (2,8) não. Uma correspondência em G não é aninhada se nenhum par de arestas estiver aninhado. Existe um algoritmo rápido para determinar se G tem uma correspondência perfeita não aninhada ou esse problema é difícil de NP?

• Desembaralhar uma sequência é equivalente a encontrar uma correspondência perfeita não aninhada em uma união separada de cliques (com arestas entre caracteres iguais). Em particular, desordenar uma sequência binária é equivalente a encontrar uma correspondência perfeita não aninhada em uma união disjunta de duas panelinhas. Mas nem sei se esse problema é difícil para gráficos gerais ou fácil para qualquer classe interessante de gráficos.

• Existe um algoritmo de tempo polinomial fácil para encontrar combinações sem cruzamento perfeitas .

---

Atualização (24/06/2013): O problema está resolvido! Agora existem duas provas independentes de que a identificação de cadeias quadradas é NP-completa.

• Em novembro de 2012, Sam Buss e Michael Soltys anunciaram uma redução de 3 partições , o que mostra que o problema é difícil, mesmo para cadeias de caracteres com um alfabeto de 9 caracteres. Veja "Desembaralhar um quadrado é NP-Hard ", Journal of Computer System Sciences 2014.

• Em junho de 2013, Romeo Rizzi e Stéphane Vialette publicaram uma redução do maior problema de subsequência comum . Consulte " Reconhecendo palavras que são quadrados para o produto aleatório ", Proc. 8º Simpósio Internacional de Ciência da Computação na Rússia , Springer LNCS 7913, pp. 235-245.

Há também uma prova mais simples de que encontrar combinações perfeitas não aninhadas é difícil para o NP, devido a Shuai Cheng Li e Ming Li em 2009. Consulte " Sobre dois problemas em aberto de padrões de 2 intervalos ", Theoretical Computer Science 410 (24–25 ): 2410-2323, 2009.

Michael Soltys e eu conseguimos provar que o problema de determinar se uma string pode ser escrita como um shuffle quadrado é NP completo. Isso se aplica mesmo a um alfabeto finito com apenas símbolos distintos, embora nossa prova seja escrita para um alfabeto com 9 símbolos. Esta pergunta ainda está aberta para alfabetos menores, digamos com apenas 2 símbolos. Não analisamos o problema sob a restrição de que cada símbolo aparece apenas 6 vezes (ou, geralmente, um número constante de vezes); então essa pergunta ainda está aberta.$7$$9$$2$$6$

A prova usa uma redução de Partition. É muito longo para postar aqui, mas uma pré-impressão, "Descompactar uma string é NP -hard", está disponível em nossas páginas da web em:$3$$\text{NP}$

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

e

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

O artigo foi publicado no Journal of Computer System Sciences:

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

Para o caso especial que você menciona quando cada personagem aparece no máximo quatro vezes, há uma redução simples para 2-SAT (a menos que esteja faltando alguma coisa ...), da seguinte maneira:

O ponto crucial é que, para cada personagem, existem (no máximo) duas maneiras válidas de combinar as ocorrências do personagem (a terceira possibilidade será aninhada). Use uma variável booleana para representar qual das duas correspondências é escolhida. Agora, uma atribuição a essas variáveis ​​fornece um desarranjo válido da sequência iff para cada par de arestas aninhadas, nem as duas foram escolhidas. Essa condição pode ser descrita com precisão por uma disjunção das variáveis ​​(possivelmente negadas) correspondentes aos dois caracteres envolvidos.

Aqui está um algoritmo que pode ter alguma chance de estar correto, embora pareça complicado de provar e eu não apostaria a casa nele ...

Digamos que seja eliminado se, para cada borda e , existir uma correspondência perfeita (possivelmente aninhada) de G que use e e não use nenhuma borda contida em ou contendo e .$G$$e$$G$$e$$e$

É fácil testar se é purgado e se não encontra as arestas violadoras. Claramente, nenhuma dessas arestas violadoras pode ser usada em uma combinação perfeita sem aninhamento de G ; portanto, é seguro removê-las da consideração. Repetindo esse processo, obtemos um subgrafo limpo (exclusivo) de G que possui uma correspondência perfeita não aninhada se $G$$G$$G$$G$ tiver.

Agora vem o salto de fé, que pode ou não estar correto: a esperança é que, em um gráfico eliminado, se ainda houver vértices de grau , possamos fazer a escolha gananciosa e combinar o primeiro vértice com o primeiro vizinho. (ou equivalente, remova as bordas de todos os outros vizinhos).$> 1$

Após a escolha gananciosa, limpamos o gráfico novamente, e assim por diante, e o processo termina quando o gráfico é (com sorte) uma correspondência perfeita sem aninhamento.

No começo, pensei que isso seria mais ou menos como ter uma pequena visão do algoritmo ganancioso e não realmente funcionar, mas achei surpreendentemente difícil criar um contra-exemplo.

A solução que Sam Buss e eu propusemos em novembro de 2012 (mostrando que a separação de um quadrado em NP-hard por uma redução de 3-Partition) agora é um artigo publicado no Journal of Computer System Sciences:

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

Romeo Rizzi e Stéphane Vialette provam que o reconhecimento de cadeias de caracteres quadradas é NP-completo em seu artigo de 2013 " Sobre o reconhecimento de palavras que são quadrados para o produto aleatório ", reduzindo o maior problema de subsequência binária. Eles afirmam que a complexidade de descodificar as seqüências binárias ainda está aberta.

Uma prova ainda mais simples de que encontrar a combinação perfeita não aninhada é NP-complete é dada por Shuai Cheng Li e Ming Li em seu artigo de 2009 " Sobre dois problemas abertos de padrões de 2 intervalos ". No entanto, eles usam terminologia herdada da bioinformática. Em vez de "correspondência perfeita não aninhada", eles chamam de "problema DIS-2-IP- $\{<, \between\}$ ". A equivalência entre os dois problemas é descrita por Blin, Fertin e Vialette :

O problema 2-IP-DIS- $\{<, \between\}$ tem uma formulação imediata em termos de correspondências restritas nos gráficos gerais: dado um gráfico $G$ juntamente com uma ordem linear $\pi$ dos vértices de $G$ , o 2-IP-DIS- $\{<, \between\}$ é equivalente a encontrar uma cardinalidade máxima correspondente a $M$ em $G$ com a propriedade que, para quaisquer duas arestas distintas $\{u, v\}$ e $\{u', v'\}$ de $M$ nem$min \{ \pi(u), \pi(v) \} \lt min \{ \pi(u'), \pi(v') \}$ e$max \{ \pi(u'), \pi(v') \lt max \{ \pi(u), \pi(v) \}$nem $min \{ \pi(u'), \pi(v') \} \lt min \{ \pi(u), \pi(v) \}$ e $max \{ \pi(u), \pi(v) \} \lt max \{ \pi(u'), \pi(v') \}$ ocorrem.

Atualização (25 de fevereiro de 2019): Bulteau e Vialette mostraram que o problema de decisão de ordenar uma sequência binária é NP-completo em seu artigo, Reconhecer quadrados de reprodução aleatória binária é NP-difícil .

Isso ajuda?

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

NUNCA MENTE, ESTA RESPOSTA ESTÁ ERRADA. Ele falha na entrada "AABAAB": combinar avidamente os dois primeiros As torna impossível combinar os símbolos restantes. Estou deixando para lá, em vez de excluí-lo, para ajudar outras pessoas a evitar o mesmo erro.

Parece-me que é sempre seguro associar cada caractere sucessivo do suposto quadrado avidamente a outro caractere igual que esteja na posição o mais cedo possível. Ou seja, acho que o seguinte algoritmo de tempo linear deve funcionar:

Faça um loop em cada posição i na sequência de entrada, i = 0, 1, 2, ... n. Para cada posição i, verifique se essa posição já foi correspondida com alguma posição anterior na sequência. Caso contrário, combine-o com um caractere igual que vem após a última posição já correspondida e, caso contrário, o mais cedo possível na sequência. Se uma correspondência não for encontrada para algum caractere, declare que a entrada não é um quadrado; caso contrário, é o conjunto de caracteres no primeiro par de cada partida.

Aqui está em Python:

def sqrt (S):
    corresponde = []
    i, j = 0, 0
    enquanto eu <len (S):
        se j <len (corresponde) e corresponde a [j] [1] == i:
            i + = 1
            j + = 1
            continuar
        se corresponde:
            k = corresponde a [-1] [1] + 1
        outro:
            k = 1
        enquanto k <len (S) e S [k]! = S [i]:
            k + = 1
        se k> = len (S):
            aumentar exceção ("Não é um quadrado")
        match.append ((i, k))
        i + = 1
    retornar "" .join (S [a] para a, b em correspondências)

imprimir sqrt ("ABCABDCD")

Aqui i é a variável principal do loop (a posição que estamos tentando corresponder), j é um ponteiro para a matriz de pares correspondentes que acelera a verificação da posição em que a correspondência já está correspondida ek é um índice usado para procurar o personagem que corresponde ao da posição i. É um tempo linear, porque i, j e k estão aumentando monotonicamente através da string e cada iteração do loop interno aumenta um deles.

Atualização: não faz sentido falar sobre a dificuldade de encontrar uma correspondência perfeita que não seja aninhada e não cruzada, quando os rótulos são de 1 a n, porque existe apenas um. (Sim, estou me chutando.) No entanto, faria sentido se houvesse uma faixa maior nos rótulos ... então ainda vejo alguma esperança, mas pode ser inútil, afinal. Eu certamente teria que acompanhar isso um pouco mais.

---

Posso pensar por que pode ser difícil encontrar uma correspondência que não seja aninhada e não seja cruzada. Deixe-me chamar essa correspondência de uma correspondência não- conjunta . Não sei até que ponto isso ajuda, mas deixe-me apresentar o raciocínio de qualquer maneira. (Devo salientar que meu argumento, como está aqui, não está completo, e os detalhes que deixo de fora são possivelmente cruciais. No entanto, imagino que possa ser um começo.)

Vou começar com um problema um pouco diferente. Dado um gráfico cujas arestas são coloridas com k cores e os vértices são rotulados de 1 a n , existe uma correspondência disjunta que contém exatamente uma aresta de cada cor? Esse problema parece ser NP-difícil (o argumento para isso é completo e direto - a menos que esteja faltando alguma coisa). A redução expele um gráfico que é uma união desmembrada de panelinhas.$G$$k$$1$$n$

A redução é de fatores disjuntos , um problema completo de NP introduzido em [1]. Uma instância de fatores disjuntos é dada por uma string sobre um alfabeto de tamanho , e a questão é se existem k fatores disjuntos, em que um fator é uma subcadeia que começa e termina com a mesma letra; e dois fatores são disjuntos se não se sobrepõem à string (observe que 'aninhamento', em particular, também não é permitido).$k$$k$

Deixe-me por denotar , os elementos do k alfabeto -sized associado ao Disjoint Fatores instância.$a_1,\ldots, a_k$$k$

Dada uma instância de fatores disjuntos, ou seja, digamos uma sequência de comprimento , crie um gráfico que tenha n vértices com rótulos de vértices de 1 a n . Adicione uma aresta entre os vértices u e v se as posições correspondentes tiverem a mesma letra (digamos a i ) e também pinte a aresta ( u , v ) com a cor i .$n$$n$$1$$n$$u$$v$$a_i$$(u,v)$$i$

A prova da redução segue essencialmente as definições. Dado fatores disjuntos, temos claramente uma correspondência colorida desdobrável k , apenas selecionamos as arestas conforme determinado pelos fatores disjuntos, e é fácil ver que a correspondência resultante é colorida e disjunta. Por outro lado, se houver uma correspondência colorida k-não- conjunta, temos k fatores disjuntos, um para cada letra, porque a correspondência é colorida (e, portanto, escolhe um fator por letra) e é desunida (portanto, os fatores correspondentes não se sobrepõem )$k$$k$$k$

Para se livrar das cores e fazer a correspondência perfeita, embora em uma faixa possivelmente maior , faça as seguintes modificações no gráfico assim criado:

$U_a$$a$$U_a$$A$$(A-2)$$U_a$

$U_a$

[1] Sobre problemas sem núcleos polinomiais , Hans L. Bodlaender, Rodney G. Downey, Michael R. Fellows e Danny Hermelin, J. Comput. Syst. Sci.

A abordagem não funciona: decompor um quadrado embaralhado retirando duas letras correspondentes não resulta em quadrados embaralhados ... Veja os comentários de Radu abaixo.

---

$\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$

Atualização: Como Tsuyoshi Ito aponta nos comentários, esse algoritmo tem tempo de execução exponencial.

Post original:

Aqui está como eu programaria isso no mundo real.

Nos é dada uma string S = (S [1], ..., S [n]). Para cada prefixo S_r = (S [1], ..., S [r]), existe um conjunto {(T_i, U_i)} de pares de cadeias, de forma que S_r seja um shuffle de (T_i, U_i), e T_i é um prefixo de U_i (ou seja, U_i 'começa com' T_i). O próprio S_r é um quadrado se e somente se este conjunto contiver um par (T_i, U_i) com T_i = U_i.

Agora, não precisamos gerar todos esses pares; só precisamos gerar o sufixo V_i de cada string U_i obtida removendo sua cópia de T_i. Isso eliminará um número (possivelmente exponencial) de duplicatas irrelevantes. Agora S_r é um quadrado se e somente se esse conjunto de sufixos contiver a sequência vazia. Então o algoritmo se torna:

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.

Por exemplo, 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}

Podemos descartar todos os sufixos com mais da metade do comprimento da string de entrada, portanto, isso simplifica para:

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}

Programei isso em C ++ e funciona em todos os exemplos dados aqui. Posso postar o código, se alguém estiver interessado. A questão é: o tamanho do SuffixSet pode crescer mais rápido do que o polinômio?

EDIT: Esta é uma resposta incorreta.

---

Sylvain sugeriu um RCG que infelizmente não era apropriado para esses "quadrados aleatórios". No entanto, acho que existe um (EDIT: não um RCG, veja os comentários de Kurt abaixo!) , Que se parece com o seguinte:

$\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}$

Não elaborei uma prova formal de que essa gramática de fato captura exatamente os "quadrados aleatórios", mas não deve ser muito difícil. Sylvain já mencionou que o problema de decisão dos RCGs é polinomial.