Comment vérifier si deux chaînes sont des permutations l'une de l'autre en utilisant l'espace supplémentaire O (1)?

Étant donné deux chaînes, comment pouvez-vous vérifier si elles sont une permutation l'une de l'autre en utilisant l'espace O (1)? La modification des chaînes n'est en aucun cas autorisée.
Remarque: espace O (1) par rapport à la longueur de la chaîne ET à la taille de l'alphabet.

L'approche naïve consisterait à créer des histogrammes des deux chaînes et à vérifier si elles sont identiques. Comme nous ne sommes pas autorisés à stocker une telle structure de données (dont la taille serait linéaire à la taille de l'alphabet) qui pourrait être calculée en une seule passe, nous devons compter les occurrences de chaque symbole possible après l'autre:

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

Cela suppose bien sûr que les nombres et les indices d'itérateur sont des entiers de taille constante, au lieu de dépendre de la longueur des chaînes.

Notons les tableaux par et supposons qu'ils sont de longueur n .$A,B$$n$

Supposons d'abord que les valeurs de chaque tableau soient distinctes. Voici un algorithme qui utilise l' espace :$O(1)$

1. Calculez les valeurs minimales des deux tableaux et vérifiez qu'elles sont identiques.

2. Calculez les deuxièmes valeurs minimales des deux tableaux et vérifiez qu'elles sont identiques.

3. Etc.

Le calcul de la valeur minimale d'un tableau utilise clairement l' espace . Étant donné le k ème plus petit élément, nous pouvons trouver le ( k + 1 ) st le plus petit élément en trouvant la valeur minimale plus grande que le $O(1)$$k$$(k+1)$$k$ ème plus petit élément (ici, nous utilisons le fait que tous les éléments sont distincts).

Lorsque les éléments sont autorisés à se répéter, nous modifions l'algorithme comme suit:

1. Calculez les valeurs minimales des deux tableaux, comptez combien de fois chacun apparaît et vérifiez les m A , 1 = m B , $m_{A,1},m_{B,1}$$m_{A,1} = m_{B,1}$ et que les comptes sont identiques.

2. Calculez les valeurs minimales supérieures à m A , 1 , m B , 1 dans les deux tableaux (respectivement) et comptez combien de fois chacune apparaît. Vérifiez que m A , 2 = m B , 2 et que les nombres sont identiques.$m_{A,2},m_{B,2}$$m_{A,1},m_{B,1}$$m_{A,2} = m_{B,2}$

3. Etc.

Définissez une fonction f (c) qui mappe un caractère c à un nombre premier unique (a = 2, b = 3, c = 5, etc.).

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

Le simple fait de déclarer que vous pouvez utiliser une fonction de mappage de nombres premiers est un peu vague, et très probablement où un problème surviendrait en gardant l' espace .$\textit{O}\textbf{(1)}$

Vous pouvez le faire est O(nlogn). Triez les deux chaînes et comparez-les index par index. S'ils diffèrent quelque part, ce ne sont pas des permutations les uns des autres.

Pour une O(n)solution, le hachage pourrait être utilisé. Cette fonction de hachage fonctionnerait, et epour toute lettre serait sa valeur ascii. Si les deux hachages des chaînes diffèrent, ce ne sont pas des permutations l'une de l'autre.

La fonction de hachage dans le lien:

Un candidat potentiel pourrait être celui-ci. Fixez un entier impair R. Pour chaque élément e que vous souhaitez hacher, calculez le facteur (R + 2 * e). Calculez ensuite le produit de tous ces facteurs. Enfin, divisez le produit par 2 pour obtenir le hachage.

Le facteur 2 dans (R + 2e) garantit que tous les facteurs sont impairs, évitant ainsi que le produit ne devienne jamais 0. La division par 2 à la fin est parce que le produit sera toujours impair, donc la division supprime simplement un bit constant .

Par exemple, je choisis R = 1779033703. C'est un choix arbitraire, faire quelques expériences devrait montrer si un R donné est bon ou mauvais. Supposons que vos valeurs soient [1, 10, 3, 18]. Le produit (calculé à l'aide d'ints 32 bits) est

(R + 2) * (R + 20) * (R + 6) * (R + 36) = 3376724311 Par conséquent, le hachage serait

3376724311/2 = 1688362155.

L'utilisation du double hachage (ou pour une surpuissance encore plus) en modifiant la valeur de R les identifierait avec succès comme des permutations avec une très forte probabilité.

Disons que vous avez deux chaînes appelées s et t.

Vous pouvez utiliser des heuristiques pour vous assurer qu'elles ne sont pas inégales.

1. s.length == t.length
2. somme des caractères de s == somme des caractères en t
3. [comme en 2. mais avec xor au lieu de sum]

Après cela, vous pouvez facilement exécuter un algorithme pour prouver que la chaîne est égale.

1. trier une chaîne pour qu'elle soit égale à l'autre et comparer (O (n ^ 2))
2. trier les deux et comparer (O (2n log (n))
3. vérifier pour chaque caractère en s s'il y a les mêmes quantités dans les deux chaînes (O (n ^ 2))

Bien sûr, vous ne pouvez pas trier aussi rapidement si vous n'êtes pas autorisé à utiliser de l'espace supplémentaire. Donc, peu importe l'algorithme que vous choisissez - chaque algorithme devra fonctionner en temps O (n ^ 2) lorsqu'il n'y a que de l'espace O (1) et si l'heuristique n'a pas pu prouver qu'ils ne peuvent pas être égaux.

En code de style C pour toute la 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; 

Ou en pseudo code très verbeux (en utilisant une indexation basée sur 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

où la fonction checkLetters (A, B, i) vérifie que s'il y a M copies de A [i] dans A [1] .. A [i], alors il y a au moins M copies de A [i] dans 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

et la fonction findNextValue recherche dans B une valeur à partir d'un index et retourne l'index où il a été trouvé (ou n + 1 s'il n'est pas trouvé).

$n^2$

Je pense que c'est l'algorithme le plus simple (avec $O(n^3$) temps, $n$ longueur des cordes)

Parcourez string1et string2, pour chaque personnage, vérifiez la fréquence à laquelle il peut être trouvé dans string1et string2. Si un personnage est plus souvent dans une chaîne que dans l'autre, ce n'est pas une permutation. Si les fréquences de tous les caractères sont égales, les chaînes sont des permutations les unes des autres.

Voici un morceau de python pour rendre cela précis

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)

Le programme a besoin de quelques pointeurs vers des chaînes ( string, string1, string2, char, char1, char2) et les variables de taille$O(\log n)$pour compter ( count1, count2). Il doit vérifier si les caractères sont égaux ou non, mais il n'a besoin d'aucun ordre sur ces caractères. Peut-être qu'il a besoin de certaines variables pour les petits entiers (par exemple pour contenir des valeurs booléennes ou pour représenter la position de stringin [string1, string2].

Bien sûr, vous n'avez même pas besoin des variables de comptage, mais vous pouvez utiliser des pointeurs.

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)

Ce deuxième programme a besoin de variables similaires à la première, sauf qu'il n'a pas besoin du $O(\log(n))$-taille variables pour conserver les valeurs de comptage.

Donc, cela ne dépend pas $n$ ou la taille de l'alphabet.