Как проверить, являются ли две строки перестановками друг друга, используя O (1) дополнительное пространство?

Учитывая две строки, как вы можете проверить, являются ли они перестановкой друг друга, используя пространство O (1)? Модификация строк никоим образом не допускается.
Примечание: O (1) пробел по отношению как к длине строки, так и к размеру алфавита.

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

function count(letter, string)
    var count := 0
    foreach element in string
        if letter = element
            count++
    return count

function samePermutation(stringA, stringB)
    foreach s in alphabet
        if count(s, stringA) != count(s, stringB)
            return false
    return true

Это, конечно, предполагает, что счетчики и индексы итераторов являются целыми числами постоянного размера, а не зависят от длины строк.

Обозначим массивы через и предположим, что они имеют длину n .$A,B$$n$

Предположим сначала, что значения в каждом массиве различны. Вот алгоритм, который использует пространство :$O(1)$

1. Вычислите минимальные значения обоих массивов и убедитесь, что они идентичны.

2. Вычислите вторые минимальные значения обоих массивов и убедитесь, что они идентичны.

3. И так далее.

Для вычисления минимального значения массива явно используется пространство . Учитывая k- й наименьший элемент, мы можем найти ( k + 1 ) -й наименьший элемент, найдя минимальное значение, превышающее k- й наименьший элемент (здесь мы используем тот факт, что все элементы различны).$O(1)$$k$$(k+1)$$k$

Когда элементам разрешено повторяться, мы модифицируем алгоритм следующим образом:

1. Вычислите минимальные значения для обоих массивов, посчитайте, сколько раз каждый из них появляется, и проверьте, что m A , 1 = m B , 1 и что значения идентичны.$m_{A,1},m_{B,1}$$m_{A,1} = m_{B,1}$

2. Вычислите минимальные значения превышающие m A , 1 , m B , 1 в двух массивах (соответственно), и подсчитайте, сколько раз каждый из них появляется. Убедитесь, что m A , 2 = m B , 2 и что количество идентичных.$m_{A,2},m_{B,2}$$m_{A,1},m_{B,1}$$m_{A,2} = m_{B,2}$

3. И так далее.

Определите некоторую функцию f (c), которая отображает некоторый символ c на уникальное простое число (a = 2, b = 3, c = 5 и т. Д.).

set checksum = 1
set count = 0 <-- this is probably not even necessary, but it's another level of check
for character c in string 1
    checksum = checksum * f(c)
    count = count + 1
for character c in string 2
    checksum = checksum / f(c)
    count = count = 1

permutation = count == 0 and checksum == 1

$\textit{O}\textbf{(1)}$

Вы можете сделать это O(nlogn). Сортируйте две строки и сравнивайте их индекс по индексу. Если они где-то отличаются, они не являются перестановками друг друга.

Для O(n)решения проблемы можно использовать хеширование. Эта функция хеширования будет работать, и eдля любой буквы будет ее значение ascii. Если два хэша строк различаются, они не являются перестановками друг друга.

Функция хеширования в ссылке:

Одним из потенциальных кандидатов может быть это. Зафиксируйте нечетное целое число R. Для каждого элемента e, который вы хотите хэшировать, вычислите коэффициент (R + 2 * e). Затем вычислите произведение всех этих факторов. Наконец, разделите произведение на 2, чтобы получить хеш.

Коэффициент 2 в (R + 2e) гарантирует, что все факторы являются нечетными, следовательно, избегая того, чтобы продукт когда-либо становился равным 0. Деление на 2 в конце состоит в том, что продукт всегда будет нечетным, следовательно, деление просто удаляет постоянный бит ,

Например, я выбираю R = 1779033703. Это произвольный выбор, поэтому некоторые эксперименты должны показать, является ли данный R хорошим или плохим. Предположим, ваши значения [1, 10, 3, 18]. Продукт (рассчитанный с использованием 32-битных целых)

(R + 2) * (R + 20) * (R + 6) * (R + 36) = 3376724311 Следовательно, хеш будет

3376724311/2 = 1688362155.

Использование двойного хеширования (или даже для избыточного убийства) путем изменения значения R успешно идентифицирует их как перестановки с очень высокой вероятностью.

Допустим, у вас есть две строки с именами s и t.

Вы можете использовать эвристику, чтобы убедиться, что они не являются неравными.

1. s.length == t.length
2. сумма символов s == сумма символов в t
3. [так же, как в 2. но с xor вместо sum]

После этого вы можете легко запустить алгоритм, чтобы доказать, что строки равны.

1. отсортировать одну строку, чтобы она была равна другой, и сравнить (O (n ^ 2))
2. отсортировать оба и сравнить (O (2n log (n))
3. проверьте для каждого символа в s, есть ли одинаковые суммы в обеих строках (O (n ^ 2))

Конечно, вы не можете сортировать так быстро, если вам не разрешено использовать дополнительное пространство. Таким образом, не имеет значения, какой алгоритм вы выберете - каждый алгоритм будет нуждаться в O (n ^ 2) времени, когда есть только O (1) пространство и если эвристика не смогла доказать, что они не могут быть равны.

В коде в стиле C для всей процедуры:

for (int i = 0; i < n; i++) {
   int k = -1;
   next: for (int j = 0; j <= i; j++)
       if (A[j] == A[i]) {
          while (++k < n)
              if (B[k] == A[i])
                  continue next;
          return false; // note at this point j == i
       }
}
return true; 

Или в очень подробном псевдокоде (с использованием индексации на основе 1)

// our loop invariant is that B contains a permutation of the letters
// in A[1]..A[i-1]
for i=1..n
   if !checkLetters(A, B, i)
      return false
return true

где функция checkLetters (A, B, i) проверяет, что если в A [1] .. A [i] имеется M копий A [i], то в B имеется как минимум M копий A [i]:

checkLetters(A,B,i)
    k = 0 // scan index into B
    for j=1..i
      if A[j] = A[i]
         k = findNextValue(B, k+1, A[i])
         if k > n
            return false
    return true

и функция findNextValue ищет в B значение, начинающееся с индекса, и возвращает индекс, где оно было найдено (или n + 1, если не найдено).

Идея в том, что мы уже проверили, что у нас есть перестановка символов перед i во внешнем цикле. В цикле j мы проходим все символы, которые соответствуют A [i], и мы должны быть в состоянии найти уникальные индексы в B, которые соответствуют им (включая i-ую позицию). Таким образом, для каждого из них нам нужно продвинуть наше сканирование вперед через B. Время равно O ($n^2$).

Я думаю, что это самый простой алгоритм (с $O(n^3$) время, $n$ длина струн)

Цикл string1и string2, для каждого символа, проверьте, как часто он может быть найден в string1и string2. Если символ находится в одной строке чаще, чем в другой, это не перестановка. Если частоты всех символов равны, то строки являются перестановками друг друга.

Вот кусок питона, чтобы сделать это точным

s1="abcaba"
s2="aadbba"

def check_if_permutations(string1, string2):
  for string in [string1, string2]:
    # string references string1 
    #  string2, it is not a copy
    for char in string:
      count1=0
      for char1 in string1:
        if  char==char1:
          count1+=1
      count2=0
      for char2 in string2:
        if  char==char2:
          count2+=1
      if count1!=count2:
        print('unbalanced character',char)
        return()
  print ("permutations")
  return()

check_if_permutations(s1,s2)

Программа нуждается в некоторых указателях на строки ( string, string1, string2, char, char1, char2) и переменного размера$O(\log n)$для подсчета ( count1, count2). Нужно проверить, равны ли символы или нет, но не нужно упорядочивать эти символы. Возможно, для небольших целых чисел нужны переменные (например, для хранения логических значений или для представления позиции stringв [string1, string2].

Конечно, вам даже не нужны переменные count, но вы можете использовать указатели.

s1="abcaba"
s2="aadbba"

def check_if_permutations(string1, string2):
  for string in [string1, string2]:
    # string references one of string1 
    # or string2, it is not a copy
    for char in string:
      # p1 and p2 should be views as pointers
      p1=0
      p2=0
      while (p1<len(string1)) and (p2<len(string2)):
        # p1>=len(string1): p1 points to beyond end of string
        while (p1<len(string1)) and (string1[p1]!=char) :
          p1+=1
        while(p2<len(string2)) and (string2[p2]!=char):
          p2+=1
        if (p1<len(string1)) != (p2<len(string2)):
          print('unbalanced character',char)
          return()
        p1+=1
        p2+=1
  print ("permutations")
  return()

check_if_permutations(s1,s2)

Эта вторая программа нуждается в переменных, аналогичных первой, за исключением того, что она не нуждается в $O(\log(n))$переменные для хранения значений счетчика.

Так что на самом деле это не зависит от $n$ или размер алфавита.