Nombre le plus court de déplacement d'édition entre deux mots

Je recherche une structure de données et un algorithme pour calculer le nombre minimum de changements requis pour transformer un mot en un autre, étant donné les deux mots en entrée, où les seuls changements autorisés sont

• ajouter une lettre à l'une des extrémités (par exemple, AB -> ABC),
• dupliquer et concaténer le mot entier (par exemple, ABC -> ABCABC),
• couper un mot en deux (le double du mouvement de duplication, ABCABC -> ABC + ABC),
• supprimez l'une des lettres (par exemple, ABC -> AC), et
• répétez l'une des lettres (par exemple, ABC -> ABBC).

Par exemple, une séquence minimale de déplacements d'ABC vers BCBC est ABC -> BC (supprimer A) -> BCBC (duplication).

Je n'ai pas de formation en informatique. C'est peut-être un problème bien connu, mais ma recherche Google ne m'a rien donné.

Connaissez-vous un problème connexe et bien défini?

Edit : Comme suggéré dans la réponse d'Anthony Labarre, j'ai lu quelques articles sur le problème de permutation / arrangement de posets qui est similaire au problème décrit ci-dessus. Quelqu'un en sait-il plus sur ce problème? Est-ce pertinent?

Je ne sais pas si ce problème exact a été étudié, mais Chaudhuri et al. étudié le problème connexe de duplication-perte aléatoire en tandem : on vous donne une permutation, et vous voulez la transformer en permutation d'identité en (1) dupliquant un segment de n'importe quelle longueur et en ajoutant la copie juste après l'original, puis (2) supprimant éléments afin que vous obteniez une nouvelle permutation au lieu d'une chaîne. Notez que l'application de (1) puis (2) représente une opération.

Différentes variantes peuvent être définies en fonction du poids donné à chaque opération, qui dans leur papier dépend de la largeur des segments dupliqués. Ils étudient également un problème similaire avec la duplication du génome entier , qui est exactement le type de duplication que vous autorisez. Je ne me souviens pas avoir lu sur le travail sur ce problème dans le contexte des chaînes, mais j'espère que cela peut au moins vous donner un point de départ pour vos recherches.

Comme cela a été souligné, ce problème est similaire au problème de distance d'édition le plus communément connu (sous-jacent à la distance Levenshtein ). Il a également des points communs avec, par exemple, la distance de distorsion temporelle dynamique (la duplication, ou «bégaiement», dans votre dernière exigence).

Étapes vers une programmation dynamique

$x=x_1\ldots x_n$$y=y_1\ldots y_m$$d(x,y)$

$$\min \begin{cases} d(x,y_1\ldots y_{m-1})+1 & &\text{▻ Add letter at end}\\ d(x,y_2\ldots y_m)+1 & & \text{▻ Add letter at beginning}\\ d(x,y_1\ldots y_{m/2})+1 & \text{if $y=y_1\ldots y_{m/2}y_1\ldots y_{m/2}$} & \text{▻ Doubling}\\ d(x_1\ldots x_{n/2},y)+1 & \text{if $x=x_1\ldots x_{n/2}x_1\ldots x_{n/2}$} & \text{▻ Halving}\\ d(x_1\ldots x_n,y) + 1 && \text{▻ Deletion}\\ d(x_1\ldots x_{n-1},y_1\ldots y_{m-1}) & \text{if $y_n = y_m$} & \text{▻ Ignoring last elt.}\\ \end{cases}$$

Ici, la dernière option dit essentiellement que la conversion de FOOX en BARX est équivalente à la conversion de FOOX en BAR. Cela signifie que vous pouvez utiliser l'option «ajouter une lettre à la fin» pour obtenir l'effet de bégaiement (duplication) et la suppression à un moment donné. Le problème est qu'il vous permet d' ajouter automatiquement un arbitraire caractère au milieu de la chaîne , ainsi , quelque chose que vous ne voulez probablement pas. (Cette «ignorer les derniers éléments identiques» est la manière standard de réaliser la suppression et le bégaiement dans des positions arbitraires. Cela rend l'interdiction des insertions arbitraires, tout en permettant des ajouts à chaque extrémité, un peu délicate, cependant ...)

J'ai inclus cette ventilation même si elle ne fait pas complètement le travail, au cas où quelqu'un d'autre pourrait la "sauver", d'une manière ou d'une autre - et parce que je l'utilise dans ma solution heuristique, ci-dessous.

(Bien sûr, si vous pouviez obtenir une ventilation comme celle-ci qui définissait réellement votre distance, vous n'auriez qu'à ajouter une mémorisation et vous auriez une solution. Cependant, parce que vous ne travaillez pas uniquement avec des préfixes, je ne le fais pas '' Je pense que vous ne pouvez utiliser que des index pour votre mémorisation; vous devrez peut-être stocker les chaînes réelles et modifiées pour chaque appel, ce qui deviendrait énorme si vos chaînes sont de taille importante.)

Étapes vers une solution heuristique

$A^\ast$ $A^*$

$A^*$$A^*$$A^*$courir. (Un compromis temps / espace là-bas.)

Donc…

L'efficacité de ma solution proposée semble dépendre un peu de (1) la longueur de vos chaînes et (2) de la taille de votre alphabet. Si aucun n'est énorme, cela pourrait fonctionner. C'est:

• Implémentez la limite inférieure de votre distance en utilisant ma décomposition récursive et ma programmation dynamique (par exemple, en utilisant une fonction récursive mémorisée).
• $A^*$$A^*$

Je ne peux pas vraiment donner de garantie quant à son efficacité, mais elle devrait être correcte, et ce serait probablement beaucoup mieux qu'une solution à force brute.

Si rien d'autre, j'espère que cela vous donne quelques idées pour de nouvelles investigations.

Un problème connexe et bien défini serait un problème d' alignement de séquence . C'est différent car il n'utilise pas d'opération de duplication. Les opérations définies sont: insertion de caractère, suppression de caractère, transformation de caractère. Needleman-Wunsch est l' algorithme le plus utilisé pour résoudre ce problème .

À l'exception de la duplication, la distance de Levenstein pourrait valoir le coup d'œil: http://en.wikipedia.org/wiki/Levenshtein_distance