Как тяжело расставлять строки?

Перестановка двух строк формируется путем встраивания символов в новую строку, сохраняя символы каждой строки в порядке. Например, MISSISSIPPIэто перетасовка MISIPPи SSISI. Позвольте мне назвать строковый квадрат, если это тасование двух одинаковых строк. Например, ABCABDCDквадратный, потому что это перетасовка ABCDи ABCD, но строка ABCDDCBAне квадрат.

Существует ли быстрый алгоритм для определения того, является ли строка квадратной или NP-трудной? Очевидный подход динамического программирования, похоже, не работает.

Даже следующие особые случаи кажутся сложными: (1) строки, в которых каждый символ встречается не более четырех- шести раз, и (2) строки только с двумя разными символами. Как указывает Пер Острин ниже, частный случай, когда каждый персонаж встречается не более четырех раз, может быть уменьшен до 2SAT.

---

Обновление: у этой проблемы есть другая формулировка, которая может упростить проверку твердости.

Рассмотрим граф G, вершинами которого являются целые числа от 1 до n; идентифицировать каждое ребро с реальным интервалом между его конечными точками. Мы говорим, что два ребра G вложены, если один интервал правильно содержит другой. Например, ребра (1,5) и (2,3) являются вложенными, а (1,3) и (5,6) - нет, а (1,5) и (2,8) - нет. Совпадение в G не является вложенным, если нет пары ребер. Существует ли быстрый алгоритм для определения того, имеет ли G не вложенное идеальное соответствие, или эта проблема NP-трудная?

• Отмена перестановки строки эквивалентна нахождению не вложенного идеального совпадения в непересекающемся объединении кликов (с ребрами между равными символами). В частности, отмена перестановки двоичной строки эквивалентна нахождению не вложенного идеального совпадения в непересекающемся объединении двух клик. Но я даже не знаю, сложна ли эта проблема для общих графов или для каких-либо интересных классов графов.

• Существует простой алгоритм полиномиальное время , чтобы найти идеальный Непро- пересечения паросочетания.

---

Обновление (24 июня 2013 г.): проблема решена! Теперь есть два независимых доказательства того, что идентификация квадратных строк является NP-полной.

• В ноябре 2012 года Сэм Бусс и Майкл Солтис объявили о сокращении с 3 разделов , что показывает, что проблема трудна даже для строк с алфавитом из 9 символов. См. «Разыгрывание квадрата - NP-Hard », Журнал Computer System Sciences 2014.

• В июне 2013 года Ромео Рицци и Стефан Виалетт опубликовали сокращение от самой длинной общей проблемы подпоследовательности . См. « О распознавании слов, являющихся квадратами для случайного произведения », Proc. 8-й Международный симпозиум по информатике в России , Springer LNCS 7913, с. 235–245.

Существует также более простое доказательство того, что поиск не вложенных совершенных соответствий является NP-трудным, благодаря Шуай Ченг Ли и Мин Ли в 2009 году. См. « О двух открытых задачах 2-интервальных паттернов », Теоретическая информатика 410 (24–25). ): 2410–2423, 2009.

Майкл Солтис и я сумели доказать, что проблема определения возможности записи строки в виде квадратного тасования является NP-решением. Это применимо даже к конечному алфавиту с только различными символами, хотя наше доказательство написано для алфавита с 9 символами. Этот вопрос все еще открыт для небольших алфавитов, скажем, только с 2 символами. Мы не рассматривали проблему под ограничением, что каждый символ появляется только 6 раз (или, в более общем случае, постоянное число раз); так что этот вопрос все еще открыт.$7$$9$$2$$6$

В доказательстве используется сокращение от части. Публикация здесь слишком длинна, но препринт «Отмена перемешивания строки - 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 для каждой пары ребер, которые вложены, но не оба были выбраны. Это условие может быть точно описано дизъюнкцией переменных (возможно, с отрицанием), соответствующих двум задействованным символам.

Вот алгоритм, который может иметь некоторые шансы быть правильным, хотя это сложно доказать, и я бы не стал ставить на это дом ...

Будем говорить , что будет очищен , если для каждого ребра е , существует (возможно , вложенная) совершенное соответствие G , который использует е и не использует край , содержащийся в или содержащие е .$G$$e$$G$$e$$e$

Легко проверить , очищен ли и не найдены ли нарушающие края. Ясно, что ни одно из этих нарушающих ребер не может быть использовано в идеальном сопоставлении без вложенности G , поэтому его можно исключить из рассмотрения. Повторяя этот процесс, мы получаем (единственный) очищенный подграф G, который имеет не вложенное совершенное совпадение, если G имеет.$G$$G$$G$$G$

Теперь наступает скачок веры, который может быть или не быть правильным: надежда состоит в том, что в очищенном графе, если все еще есть вершины степени , мы можем сделать жадный выбор и сопоставить первую такую ​​вершину с ее первым соседом. (или, что то же самое, удалите ребра для всех остальных соседей).$> 1$

После жадного выбора мы снова очищаем график и т. Д., И процесс заканчивается, когда граф (надеюсь) не является идеальным соответствием без вложенности.

Сначала я подумал, что это будет похоже на небольшой взгляд в жадный алгоритм и не очень хорошо работает, но я обнаружил, что на удивление трудно найти контрпример.

Решение, которое мы с Сэмом Буссом предложили в ноябре 2012 года (показывающее, что отмена квадрата в NP-hard путем сокращения с 3-х разделов) теперь является опубликованной статьей в журнале Computer System Sciences:

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

Ромео Рицци и Стефан Виалетт доказывают, что распознавание квадратных строк является NP-завершенным в их статье 2013 года « О распознавании слов, являющихся квадратами для случайного произведения », путем сокращения из самой длинной проблемы двоичной подпоследовательности. Они утверждают, что сложность откатывания двоичных строк все еще открыта.

Еще более простое доказательство того, что нахождение не вложенного идеального соответствия является NP-полным, даны Шуай Ченг Ли и Мин Ли в их статье 2009 года « О двух открытых задачах 2-интервальных паттернов ». Однако они используют терминологию, унаследованную от биоинформатики. Вместо «идеального не вложенного соответствия» они называют это « проблемой DIS-2-IP- $\{<, \between\}$ ». Эквивалентность между этими двумя проблемами описана Блиным, Фертином и Виалеттой :

Задача 2-IP-DIS- $\{<, \between\}$ имеет непосредственную формулировку в терминах ограниченных сопоставлений в общих графах: для данного графа $G$ вместе с линейным порядком $\pi$ вершин группы $G$ 2-IP-DIS- $\{<, \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') \}$ происходят.

Обновление (25 февраля 2019 г.): Булто и Виалетт показали, что проблема решения проблемы перетасовки двоичной строки в их статье является NP-полной. Распознавание двоичных квадратов тасования является NP-сложной задачей .

Это помогает?

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 (соответствует) и соответствует [j] [1] == i:
            я + = 1
            j + = 1
            Продолжить
        если совпадает:
            k = соответствует [-1] [1] + 1
        еще:
            к = 1
        в то время как k <len (S) и S [k]! = S [i]:
            k + = 1
        если k> = len (S):
            поднять Исключение («Не квадрат»)
        matches.append ((I, K))
        я + = 1
    return "" .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] О задачах без полиномиальных ядер , Ханс Л. Бодлендер, Родни Г. Дауни, Майкл Р. Феллоуз и Дэнни Хермелин, Дж. Компут. Сист. Sci.

Подход не работает: декомпозиция перетасованного квадрата путем извлечения двух совпадающих букв не приводит к перетасовыванию квадратов ... См. Комментарии Раду ниже.

---

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

Обновить: Как отмечает Цуёси Ито в комментариях, этот алгоритм имеет экспоненциальное время выполнения.

Исходное сообщение:

Вот как я бы запрограммировал это в реальном мире.

Нам дана строка 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). Сам S_r является квадратом тогда и только тогда, когда этот набор содержит пару (T_i, U_i) с T_i = U_i.

Теперь нам не нужно генерировать все эти пары; нам просто нужно сгенерировать суффикс V_i каждой строки U_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 расти быстрее, чем полиномиально?

РЕДАКТИРОВАТЬ: Это неправильный ответ.

---

Сильвен предложил RCG, который, к сожалению, не подходит для этих «случайных квадратов». Тем не менее, я думаю, что есть один (РЕДАКТИРОВАТЬ: не RCG, см. Комментарии Курта ниже!) , Который выглядит следующим образом:

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

Я не разработал формального доказательства того, что эта грамматика действительно отражает именно «случайные квадраты», но это не должно быть слишком сложно. Сильвен уже упоминал, что проблема решения для RCGs является полиномиальной.