Come verificare se due stringhe sono permutazioni l'una dell'altra utilizzando O (1) spazio aggiuntivo?

Date due stringhe come puoi verificare se sono una permutazione l'una dell'altra usando lo spazio O (1)? La modifica delle stringhe non è consentita in alcun modo.
Nota: O (1) spazio in relazione sia alla lunghezza della stringa che alla dimensione dell'alfabeto.

L'approccio ingenuo sarebbe costruire istogrammi di entrambe le stringhe e verificare se sono uguali. Poiché non ci è consentito memorizzare una tale struttura di dati (la cui dimensione sarebbe lineare rispetto alla dimensione dell'alfabeto) che potrebbe essere calcolata in un passaggio, dobbiamo contare le occorrenze di ogni possibile simbolo dopo l'altro:

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

Ciò presuppone ovviamente che i conteggi e gli indici iteratori siano numeri interi di dimensione costante, anziché dipendere dalla lunghezza delle stringhe.

Indica le matrici con e supponi che siano di lunghezza n .$A,B$$n$

Supponiamo innanzitutto che i valori in ciascun array siano distinti. Ecco un algoritmo che utilizza lo spazio :$O(1)$

1. Calcola i valori minimi di entrambi gli array e verifica che siano identici.

2. Calcola i secondi valori minimi di entrambi gli array e verifica che siano identici.

3. E così via.

Il calcolo del valore minimo di un array utilizza chiaramente lo spazio . Dato il k ° elemento più piccolo, possiamo trovare l'elemento ( k + 1 ) più piccolo trovando il valore minimo più grande dell'elemento k k più piccolo (qui usiamo il fatto che tutti gli elementi sono distinti).$O(1)$$k$$(k+1)$$k$

Quando gli elementi possono ripetere, modifichiamo l'algoritmo come segue:

1. Calcola i valori minimi di entrambi gli array, conta quante volte appaiono ciascuna e verifica m A , 1 = m B , 1 e che i conteggi siano identici.$m_{A,1},m_{B,1}$$m_{A,1} = m_{B,1}$

2. Calcola i valori minimi maggiori di m A , 1 , m B , 1 nei due array (rispettivamente) e conta quante volte appaiono ciascuna. Verificare che m A , 2 = m B , 2 e che i conteggi siano identici.$m_{A,2},m_{B,2}$$m_{A,1},m_{B,1}$$m_{A,2} = m_{B,2}$

3. E così via.

Definire alcune funzioni f (c) che mappano alcuni caratteri c su un numero primo univoco (a = 2, b = 3, c = 5, ecc.).

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

Dichiarare che è possibile utilizzare una funzione di mappatura dei numeri primi è un po 'complicato, e molto probabilmente dove sorgerebbe un problema mantenendo lo spazio .$\textit{O}\textbf{(1)}$

Puoi farlo O(nlogn). Ordina le due stringhe e confrontale per indice. Se differiscono ovunque, non sono permutazioni l'una dell'altra.

Per una O(n)soluzione, è possibile utilizzare l'hash. Questa funzione di hashing avrebbe funzionato, e eper ogni lettera sarebbe il suo valore ASCII. Se i due hash delle stringhe differiscono, non sono permutazioni l'una dell'altra.

La funzione di hashing nel link:

Un potenziale candidato potrebbe essere questo. Correggi un numero intero dispari R. Per ogni elemento e vuoi calcolare l'hash del fattore (R + 2 * e). Quindi calcola il prodotto di tutti questi fattori. Dividi infine il prodotto per 2 per ottenere l'hash.

Il fattore 2 in (R + 2e) garantisce che tutti i fattori siano dispari, evitando così che il prodotto diventerà mai 0. La divisione per 2 alla fine è perché il prodotto sarà sempre dispari, quindi la divisione rimuove solo un bit costante .

Ad esempio, scelgo R = 1779033703. Questa è una scelta arbitraria, fare alcuni esperimenti dovrebbe mostrare se una data R è buona o cattiva. Supponi che i tuoi valori siano [1, 10, 3, 18]. Il prodotto (calcolato utilizzando ints a 32 bit) è

(R + 2) * (R + 20) * (R + 6) * (R + 36) = 3376724311 Quindi l'hash sarebbe

3376724311/2 = 1688362155.

L'uso del doppio hashing (o ancora per eccesso) modificando il valore di R li identificherebbe con successo come permutazioni con probabilità molto alta .

Supponiamo che tu abbia due stringhe chiamate s e t.

È possibile utilizzare l'euristica per assicurarsi che non siano disuguali.

1. s.length == t.length
2. somma dei caratteri di s == somma dei caratteri in t
3. [lo stesso di 2. ma con xor invece di somma]

Dopodiché puoi facilmente eseguire un algoritmo per dimostrare che la stringa è uguale.

1. ordina una stringa in modo che sia uguale all'altra e confronta (O (n ^ 2))
2. ordina entrambi e confronta (O (2n log (n))
3. controlla per ogni carattere in s se ci sono gli stessi importi in entrambe le stringhe (O (n ^ 2))

Ovviamente non puoi ordinare così velocemente se non ti è permesso usare spazio aggiuntivo. Quindi non importa quale algoritmo si scelga: ogni algoritmo di cui avrà bisogno verrà eseguito nel tempo O (n ^ 2) quando c'è solo O (1) spazio e se l'euristica non è stata in grado di dimostrare che non possono essere uguali.

Nel codice in stile C per l'intera 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; 

O in pseudo codice molto dettagliato (usando l'indicizzazione basata su 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

dove la funzione checkLetters (A, B, i) controlla che se ci sono M copie di A [i] in A [1] .. A [i], allora ci sono almeno M copie di A [i] in B:

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

e la funzione findNextValue cerca in B un valore a partire da un indice e restituisce l'indice in cui è stato trovato (o n + 1 se non trovato).

$n^2$

$O(n^3$$n$

Passa attraverso string1e string2, per ogni personaggio, controlla quanto spesso può essere trovato in string1e string2. Io un personaggio è più spesso in una stringa che nell'altra, non è una permutazione. Se le frequenze di tutti i caratteri sono uguali, le stringhe sono permutazioni l'una dell'altra.

Ecco un pezzo di pitone per renderlo preciso

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)

stringstring1string2charchar1char2$O(\log n)$count1count2string[string1, string2]

Ovviamente non hai nemmeno bisogno delle variabili di conteggio ma puoi usare i puntatori.

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

Quindi in realtà non dipende $n$ o la dimensione dell'alfabeto.