转换字符串有多困难？

通过将字符散布到新的字符串中，从而使每个字符串的字符保持顺序，从而形成两个字符串的混洗。例如，MISSISSIPPI是一个洗牌MISIPP和SSISI。如果我将两个相同的字符串混洗，请说一个字符串平方。例如，ABCABDCDis square是因为它是ABCDand 的混洗ABCD，但是字符串ABCDDCBA不是正方形。

是否有一种快速的算法来确定字符串是方形的还是NP硬的？显而易见的动态编程方法似乎不起作用。

甚至以下特殊情况也似乎很困难：（1）每个字符最多出现四次 六次的字符串，以及（2）只有两个不同字符的字符串。 正如Per Austrin指出的那样，每个字符最多出现四次的特殊情况可以简化为2SAT。

---

更新： 此问题有另一种说法可以使硬度证明更容易。

考虑图G的顶点为1到n的整数。用端点之间的真实间隔来标识每个边缘。我们说，如果一个间隔适当地包含另一个，则嵌套两个G边。例如，边（1,5）和（2,3）是嵌套的，但（1,3）和（5,6）不是，而（1,5）和（2,8）不是。如果没有嵌套任何一对边，则G中的匹配是非嵌套的。 是否有一种快速的算法来确定G是否具有非嵌套的完美匹配，或者该问题是否难解决？

• 对字符串进行改组等效于在不相交的团体（边缘之间的字符相等）中找到一个非嵌套的完美匹配。特别地，对二进制字符串进行混排等效于在两个集团的不相交联合中找到非嵌套的完美匹配。但是我什至不知道这个问题对于一般的图形来说是困难的，还是对于任何有趣的图形类来说都不容易。

• 有一个简单的多项式时间算法可以找到完美的非交叉匹配。

---

更新（2013年6月24日）：问题已解决！ 现在有两个独立的证明，证明方串是NP完全的。

• 2012年11月，Sam Buss和Michael Soltys宣布减少3分区，这表明即使是9个字母以上的字符串，问题也很难解决。请参阅《 2014年计算机系统科学学报》中的“将正方形解混是NP-Hard ” 。

• 2013年6月，Romeo Rizzi和StéphaneVialette发布了最长的子序列问题的简化版本。请参见“ 关于识别随机混排乘积的平方的单词 ”，Proc。第八届俄罗斯国际计算机科学研讨会，Springer LNCS 7913，第235-245页。

还有一个更简单的证据表明，由于Shuai Cheng Li和Ming Li在2009 年，发现非嵌套完美匹配是NP困难的。请参见“ 论2区间模式的两个开放问题 ”，理论计算机科学 410（24–25） ）：2410–2423，2009年。

Michael Soltys和我已经成功证明确定字符串是否可以写为方形混洗的问题是NP完整的。即使我们的证明是针对具有9个符号的字母编写的，这甚至适用于只有不同符号的有限字母。这个问题仍然适用于较小的字母，例如只有2个符号。我们没有在每个符号仅出现6次（或更常见的是固定次数）的限制下没有考虑这个问题。所以这个问题仍然悬而未决。$7$$9$$2$$6$

证明使用的是 Partition 的减少量。在此处发布的时间太长了，但是可以从我们的网页上获得预印本“将字符串解混为NP -hard”：$3$$\text{NP}$

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

和

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

该论文已发表在《计算机系统科学杂志》上：

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

对于您提到的特殊情况，当每个字符最多出现四次时，可以简单地简化为2-SAT（除非我遗漏了某些东西...），如下所示：

关键点是，对于每个字符，最多（有）两种匹配字符出现的有效方法（第三个可能性是嵌套）。使用布尔值变量表示选择了两个匹配项中的哪一个。现在，对这些变量的赋值会为嵌套的每对边对（而不是同时选择这对边）对字符串iff进行有效的随机排列。通过与所涉及的两个字符相对应的变量（可能取反）的分离，可以精确地描述这种情况。

这是一个算法，可能有一定的正确性，尽管要证明它似乎很棘手，但我不会在上面打赌。

让我们说，如果对于每个边e，存在一个使用e且不使用e中包含或包含e的边的G（可能嵌套）完美匹配，则被清除。$G$$e$$G$$e$$e$

可以很容易地测试是否清除了，以及是否没有发现弯曲的边缘。显然，这些违规边缘都不能用于G的非嵌套完美匹配，因此可以安全地将它们从考虑中删除。重复此过程，我们获得G的（唯一）清除子图，该子图具有iff G具有的非嵌套完美匹配 。$G$$G$$G$$G$

现在是信仰的飞跃，这可能是正确的，也可能是不正确的：希望是在清除的图中，如果仍然存在度数顶点 ，我们可以进行贪婪的选择并将第一个这样的顶点与其第一个邻居匹配（或等效地，删除所有其他邻居的边）。$> 1$

经过贪婪的选择之后，我们再次清除图形，依此类推，当图形（希望是）非嵌套的完美匹配时，过程结束。

起初，我认为这有点像贪婪算法中的一个小小的先行步骤，但实际上没有用，但是我发现想出一个反例非常困难。

我和Sam Buss在2012年11月提出的解决方案（表明通过减少3分区来减少NP-hard的正方形）现在在《计算机系统科学杂志》上发表了一篇文章：

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

Romeo Rizzi和StéphaneVialette 通过减少最长的二进制子序列问题，证明了他们在2013年的论文《关于识别随机混排的平方的单词》中对方串的识别是NP完全的。他们指出，解组二进制字符串的复杂性仍然存在。

Shuai Cheng Li和Ming Li在2009年的论文“ 关于2区间模式的两个开放问题 ”中给出了一个更简单的证明，即找到非嵌套的完美匹配是NP完全。但是，他们使用从生物信息学继承的术语。他们称其为“ DIS-2-IP- $\{<, \between\}$问题” ，而不是“完美的非嵌套匹配”。Blin，Fertin和Vialette描述了两个问题之间的对等关系：

2-IP-解散$\{<, \between\}$问题已在一般图约束匹配数方面立即制剂：给定一个图$G$具有线性排序一起$\pi$的顶点的$G$，2-IP-解散$\{<, \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) \}$和$max \{ \pi(u), \pi(v) \} \lt max \{ \pi(u'), \pi(v') \}$。

更新（2019年2月25日）： Bulteau和Vialette表明在他们的论文中对二进制字符串进行混洗的决策问题是NP完全的，识别二进制混洗平方是NP-hard的。

这有帮助吗？

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

永远不要介意，这个答案很糟糕。在输入“ AABAAB”时失败：贪婪地将前两个A相互匹配使得无法匹配其余符号。我将其保留而不是删除它以帮助其他人避免犯同样的错误。

在我看来，将假定正方形的每个连续字符贪婪地匹配到另一个处于较早位置的相等字符始终是安全的。也就是说，我认为以下线性时间算法应该有效：

循环遍历输入字符串中的每个位置i，i = 0、1、2，... n。对于每个位置i，检查该位置是否已经与字符串中的某个较早位置匹配。如果不是，则将其与等号匹配，该等号位于最后一个已匹配位置之后，否则应尽早出现在字符串中。如果找不到某个字符的匹配项，则声明输入不是正方形；否则，它是每个匹配项的第一对字符集。

在Python中：

def sqrt（S）：
    匹配= []
    i，j = 0，0
    而我<len（S）：
        如果j <len（matches）并匹配[j] [1] == i：
            我+ = 1
            j + = 1
            继续
        如果匹配：
            k =符合[-1] [1] + 1
        其他：
            k = 1
        而k <len（S）且S [k]！= S [i]：
            k + = 1
        如果k> = len（S）：
            引发Exception（“非正方形”）
        matchs.append（（i，k））
        我+ = 1
    返回“” .join（S [a]中匹配的a，b）

打印sqrt（“ ABCABDCD”）

在这里，i是主循环变量（我们尝试匹配的位置），j是指向匹配对数组的指针，可加快对位置i是否已匹配的检查，k是用于搜索的索引与位置i上的字符匹配的字符。这是线性时间，因为i，j和k在字符串中单调增加，并且每个内部循环迭代都会增加其中之一。

更新：当标签从1到n时，谈论找到非嵌套且非交叉的完美匹配的困难是没有意义的，因为只有这样一个。（是的，正在踢自己。）但是，考虑到标签的范围更大，这是有道理的……所以我仍然看到了一些希望，但毕竟可能毫无意义。我当然必须再跟进一些。

---

我可以想到为什么为什么很难找到一个非嵌套且非交叉的匹配。让我称这种匹配为不相交的匹配。不知道这在多大程度上有帮助，但是无论如何，让我介绍一下推理过程。（我应该指出，我的论点目前还不完整，我遗漏的细节可能至关重要。但是，我认为这可能只是个开始。）

$G$$k$$1$$n$

$k$$k$

$a_1,\ldots, a_k$$k$

$n$$n$$1$$n$$u$$v$$a_i$$(u,v)$$i$

$k$$k$$k$

为了消除颜色并使匹配完美，尽管可能范围更大，但对这样创建的图形进行以下修改：

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

$U_a$

[1] 关于没有多项式内核的问题，Hans Bodlaender，Rodney G. Downey，Michael R. Fellows和Danny Hermelin，J。Comput 。Syst。科学

该方法不起作用：通过取出两个匹配的字母来分解混洗的正方形不会导致混洗的正方形...请参阅下面的Radu的评论。

---

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

现在，Boullier在先前链接的论文中显示了一种针对RCG的动态编程多项式时间算法，该算法可以回答上述语法是否正确的问题。这个想法是，尽管我在上面介绍了变量的实例化$X$$Y$

更新： 正如伊藤刚（Tsuyoshi Ito）在评论中指出的那样，该算法具有指数运行时间。

原始帖子：

这是我在真实世界中如何编程的方法。

给定一个字符串S =（S [1]，...，S [n]）。对于每个前缀S_r =（S [1]，...，S [r]），都有一组{{T_i，U_i）}对字符串，这样S_r是（T_i，U_i）的混洗， T_i是U_i的前缀（即U_i'以'T_i开头）。当且仅当该集合包含T_i = U_i的一对（T_i，U_i）时，S_r本身才是正方形。

现在，我们不需要生成所有这些对。我们只需要生成每个字符串U_i的后缀V_i，即可通过删除其副本T_i获得。这将消除（可能呈指数形式）数量不相关的重复项。现在，并且仅当这组后缀包含空字符串时，S_r是一个正方形。因此该算法变为：

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.

例如，如果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}

我们可以舍弃所有长度超过输入字符串一半的后缀，因此可以简化为：

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}

我已经用C ++编写了此程序，它适用于此处给出的所有示例。如果有人感兴趣，我可以发布代码。问题是：SuffixSet的大小可以比多项式增长得更快吗？

编辑：这是一个不正确的答案。

---

Sylvain建议使用RCG，不幸的是，RCG不适合这些“混洗方块”。但是，我认为有一个（编辑：不是RCG，请参见下面的Kurt注释！），其外观如下：

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

我还没有得出正式的证明，证明这种语法确实可以准确地捕捉到“混搭方块”，但是应该不会太难。Sylvain已经提到RCG的决策问题是多项式。