Wie überprüfe ich, ob zwei Zeichenfolgen Permutationen voneinander sind, indem ich O (1) zusätzlichen Raum verwende?

Wie können Sie bei zwei gegebenen Zeichenfolgen überprüfen, ob sie eine Permutation voneinander sind, indem Sie den O (1) -Raum verwenden? Das Ändern der Zeichenfolgen ist in keiner Weise zulässig.
Anmerkung: O (1) Abstand in Bezug sowohl auf die Zeichenkettenlänge als auch auf die Größe des Alphabets.

Der naive Ansatz würde darin bestehen, Histogramme beider Zeichenfolgen zu erstellen und zu überprüfen, ob sie gleich sind. Da wir keine Datenstruktur speichern dürfen (deren Größe linear zur Größe des Alphabets wäre), die in einem Durchgang berechnet werden könnte, müssen wir die Vorkommen der einzelnen möglichen Symbole nacheinander zählen:

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

Dies setzt natürlich voraus, dass die Zählwerte und Iteratorindizes ganze Zahlen konstanter Größe sind, anstatt von der Länge der Zeichenfolgen abhängig zu sein.

Bezeichnen Sie die Arrays mit und nehmen Sie an, dass sie die Länge n haben .$A,B$$n$

Nehmen wir zunächst an, dass die Werte in jedem Array unterschiedlich sind. Hier ist ein Algorithmus, der den -Raum verwendet:$O(1)$

1. Berechnen Sie die Mindestwerte beider Arrays und überprüfen Sie, ob sie identisch sind.

2. Berechnen Sie die zweiten Mindestwerte beider Arrays und überprüfen Sie, ob sie identisch sind.

3. Und so weiter.

Bei der Berechnung des Mindestwerts eines Arrays wird eindeutig der Abstand verwendet. Ausgehend von dem k- ten kleinsten Element können wir ( k + $O(1)$$k$indemden Minimalwert finden, der größer als das k- te kleinste Element ist (hier verwenden wir die Tatsache, dass alle Elemente verschieden sind).$(k+1)$$k$

Wenn sich Elemente wiederholen dürfen, ändern wir den Algorithmus wie folgt:

1. Berechnen Sie die Mindestwerte beider Arrays, zählen Sie, wie oft sie jeweils auftreten, und überprüfen Sie, ob m A , 1 = m $m_{A,1},m_{B,1}$ und dass die Zählungen identisch sind.$m_{A,1} = m_{B,1}$

2. Berechnen Sie die Mindestwerte größer als m A , 1 , m B , 1 in den beiden Arrays sind, und zählen Sie, wie oft sie jeweils auftreten. Stellen Sie sicher, dass m A , 2 = m B , 2 ist und dass die Zählungen identisch sind.$m_{A,2},m_{B,2}$$m_{A,1},m_{B,1}$$m_{A,2} = m_{B,2}$

3. Und so weiter.

Definieren Sie eine Funktion f (c), die ein Zeichen c einer eindeutigen Primzahl zuordnet (a = 2, b = 3, c = 5 usw.).

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

Nur zu erklären, dass Sie eine Primzahlzuordnungsfunktion verwenden können, ist ein bisschen handwavey, und am wahrscheinlichsten, wenn ein Problem auftreten würde, Raum zu halten.$\textit{O}\textbf{(1)}$

Sie können dies tun O(nlogn). Sortieren Sie die beiden Zeichenfolgen und vergleichen Sie sie indexweise. Wenn sie sich irgendwo unterscheiden, sind sie keine Permutationen voneinander.

Für eine O(n)Lösung könnte Hashing verwendet werden. Diese Hash-Funktion würde funktionieren, und efür jeden Buchstaben wäre dies der ASCII-Wert. Wenn sich die beiden Hashes der Zeichenfolgen unterscheiden, sind sie keine Permutationen voneinander.

Die Hash-Funktion im Link:

Ein möglicher Kandidat könnte dies sein. Legen Sie eine ungerade Ganzzahl R fest. Berechnen Sie für jedes Element e, das Sie hashen möchten, den Faktor (R + 2 * e). Berechnen Sie dann das Produkt all dieser Faktoren. Teilen Sie das Produkt zum Schluss durch 2, um den Hash zu erhalten.

Der Faktor 2 in (R + 2e) garantiert, dass alle Faktoren ungerade sind, wodurch vermieden wird, dass das Produkt jemals zu 0 wird. Die Division durch 2 am Ende liegt daran, dass das Produkt immer ungerade ist, sodass die Division nur ein konstantes Bit entfernt .

ZB wähle ich R = 1779033703. Dies ist eine willkürliche Wahl. Einige Experimente sollten zeigen, ob ein gegebenes R gut oder schlecht ist. Angenommen, Ihre Werte sind [1, 10, 3, 18]. Das Produkt (berechnet mit 32-Bit-Ints) ist

(R + 2) * (R + 20) * (R + 6) * (R + 36) = 3376724311 Daher wäre der Hash

3376724311/2 = 1688362155.

Durch die Verwendung von Double-Hashing (oder für noch mehr Overkill) durch Ändern des Werts von R würden sie erfolgreich als Permutationen mit sehr hoher Wahrscheinlichkeit identifiziert .

Angenommen, Sie haben zwei Zeichenfolgen mit den Namen s und t.

Sie können Heuristiken verwenden, um sicherzustellen, dass sie nicht ungleich sind.

1. Länge == Länge
2. Summe der Zeichen von s == Summe der Zeichen in t
3. [das selbe wie in 2. aber mit xor statt sum]

Danach können Sie leicht einen Algorithmus ausführen, um zu beweisen, dass die Zeichenfolge gleich ist.

1. sortiere einen String so, dass er gleich dem anderen ist und vergleiche (O (n ^ 2))
2. sortiere beide und vergleiche (O (2n log (n))
3. überprüfe für jedes Zeichen in s, ob es in beiden Zeichenketten die gleichen Beträge gibt (O (n ^ 2))

Natürlich können Sie nicht so schnell sortieren, wenn Sie keinen zusätzlichen Speicherplatz verwenden dürfen. Es spielt also keine Rolle, welchen Algorithmus Sie wählen - jeder benötigte Algorithmus wird in O (n ^ 2) ausgeführt, wenn nur O (1) Platz vorhanden ist und die Heuristik nicht beweisen konnte, dass sie nicht gleich sein können.

Im C-Code für die gesamte Routine:

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; 

Oder in sehr ausführlichem Pseudocode (mit 1-basierter Indizierung)

// 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

Dabei prüft die Funktion checkLetters (A, B, i), ob in A [1] .. A [i] M Kopien von A [i] vorhanden sind. In B sind dann mindestens M Kopien von A [i] vorhanden:

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

Die Funktion findNextValue sucht in B nach einem Wert, der von einem Index ausgeht, und gibt den Index an der Stelle zurück, an der er gefunden wurde (oder n + 1, wenn er nicht gefunden wurde).

Die Idee hier ist, dass wir bereits bestätigt haben, dass wir eine Permutation der Zeichen vor i in der äußeren Schleife haben. In der j-Schleife durchlaufen wir alle Zeichen, die mit A [i] übereinstimmen, und müssen in der Lage sein, eindeutige Indizes in B zu finden, die mit ihnen übereinstimmen (einschließlich der i-ten Position). Daher müssen wir für jeden von ihnen unseren Scan um B vorwärts bewegen. Die Zeit ist O ($n^2$).

Ich denke das ist der einfachste Algorithmus (mit $O(n^3$) Zeit, $n$ Länge der Saiten)

Durchlaufe string1und string2, überprüfe für jeden Charakter, wie oft er in string1und zu finden iststring2 . Wenn ein Zeichen in einer Zeichenfolge häufiger vorkommt als in der anderen, handelt es sich nicht um eine Permutation. Wenn die Frequenzen aller Zeichen gleich sind, sind die Zeichenfolgen Permutationen voneinander.

Hier ist ein Stück Python, um dies zu präzisieren

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)

Das Programm benötigt einige Hinweise auf Strings ( string, string1, string2, char, char1, char2) und Variablen der Größe$O(\log n)$zum Zählen ( count1, count2). Es muss überprüft werden, ob die Zeichen gleich sind oder nicht, aber es muss keine Reihenfolge für diese Zeichen festgelegt werden. Vielleicht braucht es einige Variablen für kleine ganze Zahlen (zB um boolesche Werte zu speichern oder die Position von stringin darzustellen[string1, string2] .

Natürlich brauchen Sie nicht einmal die Zählvariablen, sondern können Zeiger verwenden.

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)

Dieses zweite Programm benötigt ähnliche Variablen wie das erste, außer dass es das nicht benötigt $O(\log(n))$-size Variablen zum Speichern der Zählwerte.

Also kommt es eigentlich nicht darauf an $n$ oder die Größe des Alphabets.