Hmm, je peux penser à deux algorithmes possibles: un balayage linéaire à travers la séquence A , ou la construction d'un dictionnaire avec une recherche en temps constant des indices.
Si vous testez de nombreuses sous-séquences B potentielles contre une seule séquence A plus grande , je vous suggère d'utiliser la variante avec le dictionnaire.
Balayage linéaire
La description
Nous maintenons un curseur pour la séquence A . Ensuite , nous parcourons tous les articles dans la sous- séquence B . Pour chaque élément, nous déplaçons le curseur vers l'avant dans A jusqu'à ce que nous ayons trouvé un élément correspondant. Si aucun élément correspondant n'a été trouvé, alors B n'est pas une sous-séquence.
Cela s'exécute toujours en O (taille suivante) .
Pseudocode
Style impératif:
def subsequence? seq, subseq:
i = 0
for item in subseq:
i++ while i < seq.size and item != seq[i]
return false if i == seq.size
return true
Style fonctionnel:
let rec subsequence? = function
| _ [] -> true
| [] _ -> false
| cursor::seq item::subseq ->
if cursor = item
then subsequence? seq subseq
else subsequence? seq item::subseq
Exemple d'implémentation (Perl):
use strict; use warnings; use signatures; use Test::More;
sub is_subsequence_i ($seq, $subseq) {
my $i = 0;
for my $item (@$subseq) {
$i++ while $i < @$seq and $item != $seq->[$i];
return 0 if $i == @$seq;
}
return 1;
}
sub is_subsequence_f ($seq, $subseq) {
return 1 if @$subseq == 0;
return 0 if @$seq == 0;
my ($cursor, @seq) = @$seq;
my ($item, @subseq) = @$subseq;
return is_subsequence_f(\@seq, $cursor == $item ? \@subseq : $subseq);
}
my $A = [1, 2, 3, 4];
my $B = [1, 3];
my $C = [1, 3, 4];
my $D = [3, 1];
my $E = [1, 2, 5];
for my $is_subsequence (\&is_subsequence_i, \&is_subsequence_f) {
ok $is_subsequence->($A, $B), 'B in A';
ok $is_subsequence->($A, $C), 'C in A';
ok ! $is_subsequence->($A, $D), 'D not in A';
ok ! $is_subsequence->($A, $E), 'E not in A';
ok $is_subsequence->([1, 2, 3, 4, 3, 5, 6], [2, 3, 6]), 'multiple nums';
}
done_testing;
Recherche dans le dictionnaire
La description
Nous mappons les éléments de la séquence A à leurs indices. Ensuite, nous recherchons des indices appropriés pour chaque élément de B , ignorons les indices trop petits et choisissons le plus petit indice possible comme limite inférieure. Quand aucun indice n'est trouvé, alors B n'est pas une sous-séquence.
Fonctionne dans quelque chose comme O (subseq.size · k) , où k décrit le nombre de numéros en double qu'il y a seq. De plus un O (seq.size) les frais généraux
L'avantage de cette solution est qu'une décision négative peut être prise beaucoup plus rapidement (jusqu'à un temps constant), une fois que vous avez payé les frais généraux de construction de la table de recherche.
Pseudocode:
Style impératif:
# preparing the lookup table
dict = {}
for i, x in seq:
if exists dict[x]:
dict[x].append(i)
else:
dict[x] = [i]
def subsequence? subseq:
min_index = -1
for x in subseq:
if indices = dict[x]:
suitable_indices = indices.filter(_ > min_index)
return false if suitable_indices.empty?
min_index = suitable_indices[0]
else:
return false
return true
Style fonctionnel:
let subsequence? subseq =
let rec subseq-loop = function
| [] _ -> true
| x::subseq min-index ->
match (map (filter (_ > min-index)) data[x])
| None -> false
| Some([]) -> false
| Some(new-min::_) -> subseq-loop subseq new-min
in
subseq-loop subseq -1
Exemple d'implémentation (Perl):
use strict; use warnings; use signatures; use Test::More;
sub build_dict ($seq) {
my %dict;
while (my ($i, $x) = each @$seq) {
push @{ $dict{$x} }, $i;
}
return \%dict;
}
sub is_subsequence_i ($seq, $subseq) {
my $min_index = -1;
my $dict = build_dict($seq);
for my $x (@$subseq) {
my $indices = $dict->{$x} or return 0;
($min_index) = grep { $_ > $min_index } @$indices or return 0;
}
return 1;
}
sub is_subsequence_f ($seq, $subseq) {
my $dict = build_dict($seq);
use feature 'current_sub';
return sub ($subseq, $min_index) {
return 1 if @$subseq == 0;
my ($x, @subseq) = @$subseq;
my ($new_min) = grep { $_ > $min_index } @{ $dict->{$x} // [] } or return 0;
__SUB__->(\@subseq, $new_min);
}->($subseq, -1);
}
my $A = [1, 2, 3, 4];
my $B = [1, 3];
my $C = [1, 3, 4];
my $D = [3, 1];
my $E = [1, 2, 5];
for my $is_subsequence (\&is_subsequence_i, \&is_subsequence_f) {
ok $is_subsequence->($A, $B), 'B in A';
ok $is_subsequence->($A, $C), 'C in A';
ok ! $is_subsequence->($A, $D), 'D not in A';
ok ! $is_subsequence->($A, $E), 'E not in A';
ok $is_subsequence->([1, 2, 3, 4, 3, 5, 6], [2, 3, 6]), 'multiple nums';
}
done_testing;
Variante de recherche de dictionnaire: codage en tant que machine à états finis
La description
Nous pouvons réduire davantage la complexité algorithmique jusqu'à O (subseq.size) si nous échangeons plus de mémoire. Au lieu de mapper des éléments à leurs indices, nous créons un graphique où chaque nœud représente un élément à son index. Les bords montrent des transitions possibles, par exemple la séquence a, b, aaurait les bords a@1 → b@2, a@1 → a@3, b@2 → a@3. Ce graphique est équivalent à une machine à états finis.
Pendant la recherche, nous maintenons un curseur qui est initialement le premier nœud de l'arbre. Nous marchons ensuite le bord pour chaque élément dans la sous - liste B . Si aucun bord de ce type n'existe, alors B n'est pas une sous-liste. Si après tous les éléments le curseur contient un nœud valide, alors B est une sous-liste.
Pseudocode
Style impératif:
# preparing the graph
graph = {}
for x in seq.reverse:
next_graph = graph.clone
next_graph[x] = graph
graph = next_graph
def subseq? subseq:
cursor = graph
for x in subseq:
cursor = graph[x]
return false if graph == null
return true
Style fonctionnel:
let subseq? subseq =
let rec subseq-loop = function
| [] _ -> true
| x::subseq graph -> match (graph[x])
| None -> false
| Some(next-graph) -> subseq-loop subseq next-graph
in
subseq-loop subseq graph
Exemple d'implémentation (Perl):
use strict; use warnings; use signatures; use Test::More;
sub build_graph ($seq) {
my $graph = {};
for (reverse @$seq) {
$graph = { %$graph, $_ => $graph };
}
return $graph;
}
sub is_subsequence_i ($seq, $subseq) {
my $cursor = build_graph($seq);
for my $x (@$subseq) {
$cursor = $cursor->{$x} or return 0;
}
return 1;
}
sub is_subsequence_f ($seq, $subseq) {
my $graph = build_graph($seq);
use feature 'current_sub';
return sub ($subseq, $graph) {
return 1 if @$subseq == 0;
my ($x, @subseq) = @$subseq;
my $next_graph = $graph->{$x} or return 0;
__SUB__->(\@subseq, $next_graph);
}->($subseq, $graph);
}
my $A = [1, 2, 3, 4];
my $B = [1, 3];
my $C = [1, 3, 4];
my $D = [3, 1];
my $E = [1, 2, 5];
for my $is_subsequence (\&is_subsequence_i, \&is_subsequence_f) {
ok $is_subsequence->($A, $B), 'B in A';
ok $is_subsequence->($A, $C), 'C in A';
ok ! $is_subsequence->($A, $D), 'D not in A';
ok ! $is_subsequence->($A, $E), 'E not in A';
ok $is_subsequence->([1, 2, 3, 4, 3, 5, 6], [2, 3, 6]), 'multiple nums';
}
done_testing;