Langages formels et analyse syntaxique
CM7 : Automate LR - Analyse tabulaire/CYK
Timothée Bernard 06 novembre 2020
Université de Paris
Construction de l’automate LR
À lire
• Fin de la section 8.2.2,Analyseur LR(0), du polycopié d’Yvon et Demaille (2016).
1
À lire
• Fin de la section 8.2.2,Analyseur LR(0), du polycopié d’Yvon et Demaille (2016).
1
Petite transformation de la grammaire
• Nouveau symbole non-terminalZ(axiome), nouveau symbole terminal#.
• Nouvelle règleZ→S#(Sest l’axiome original).
• On ajoute#à la fin de tout mot avant de l’analyser.
• L’analyse est réussie ssi la pile ne contient queZ.
2
Petite transformation de la grammaire
• Nouveau symbole non-terminalZ(axiome), nouveau symbole terminal#.
• Nouvelle règleZ→S#(Sest l’axiome original).
• On ajoute#à la fin de tout mot avant de l’analyser.
• L’analyse est réussie ssi la pile ne contient queZ.
2
Petite transformation de la grammaire
• Nouveau symbole non-terminalZ(axiome), nouveau symbole terminal#.
• Nouvelle règleZ→S#(Sest l’axiome original).
• On ajoute#à la fin de tout mot avant de l’analyser.
• L’analyse est réussie ssi la pile ne contient queZ.
2
Petite transformation de la grammaire
• Nouveau symbole non-terminalZ(axiome), nouveau symbole terminal#.
• Nouvelle règleZ→S#(Sest l’axiome original).
• On ajoute#à la fin de tout mot avant de l’analyser.
• L’analyse est réussie ssi la pile ne contient queZ.
2
Petite transformation de la grammaire
• Nouveau symbole non-terminalZ(axiome), nouveau symbole terminal#.
• Nouvelle règleZ→S#(Sest l’axiome original).
• On ajoute#à la fin de tout mot avant de l’analyser.
• L’analyse est réussie ssi la pile ne contient queZ.
2
Construction de l’automate LR
1. Construction d’un automate non-déterministe. 2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Construction de l’automate LR
1. Construction d’un automate non-déterministe.
2. Déterminisation.
Règle pointée
• A→a B C • d E
• B→ •a B C d
• C→a B C d E F•
3
Automate LR non-déterministe
• États :{A→α• β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
Automate LR non-déterministe
• États :{A→α • β |A→α β∈P}(toutes les règles pointées obtenues à partir de toutes les règles de la grammaires).
• État initial :Z→ •S#.
• États finals :{A→α• |A→α∈P}.
• Transitions :
• δ(A→α •Xβ,X) =A→αX•β;
• δ(A→α •Xβ, ϵ) =X→ •γ.
4
• S→A B
• A→a A|b
• B→b B|a
• Z→S#
Z→ •S#
start
Z→S•# Z→S#•
S→ •A B S→A•B S→A B•
A→ •a A
A→a•A A→a A•
A→ •b A→b•
B→ •b B
B→b•B B→b B•
B→ •a B→a•
S
# A
a A b B b
B
a
ϵ ϵ
ϵ
ϵ ϵ
ϵ ϵ
ϵ ϵ
5
• S→A B
• A→a A|b
• B→b B|a
• Z→S#
Z→ •S#
start
Z→S•# Z→S#•
S→ •A B S→A•B S→A B•
A→ •a A
A→a•A A→a A•
A→ •b A→b•
B→ •b B
B→b•B B→b B•
B→ •a B→a•
S
# A
a A b B b
B
a
ϵ ϵ
ϵ
ϵ ϵ
ϵ ϵ
ϵ ϵ
5
• S→A B
• A→a A|b
• B→b B|a
• Z→S#
Z→ •S#
start
Z→S•# Z→S#•
S→ •A B S→A•B S→A B•
A→ •a A
A→a•A A→a A•
A→ •b A→b•
B→ •b B
B→b•B B→b B•
B→ •a B→a•
S
# A
a A b B b
B
a
ϵ ϵ
ϵ
ϵ ϵ
ϵ ϵ
ϵ ϵ
5
• S→A B
• A→a A|b
• B→b B|a
• Z→S#
Z→ •S#
start
Z→S•# Z→S#•
S→ •A B S→A•B S→A B•
A→ •a A
A→a•A A→a A•
A→ •b A→b•
B→ •b B
B→b•B B→b B•
B→ •a B→a•
S
# A
a A b B b
B
a
ϵ ϵ
ϵ
ϵ ϵ
ϵ ϵ
ϵ ϵ
5
a b A B S # (1){Z→ •S# (2){A→a•A (3){A→b•} (4){S→A•B ∅ (5){Z→S•#} ∅
S→ •A B A→ •a A B→ •b B
A→ •a A A→ •b} B→ •a}
A→ •b}
(2) (2) (3) (6){A→a A•} ∅ ∅ ∅
(3) ∅ ∅ ∅ ∅ ∅ ∅
(4) (7){B→a•} (8){B→b•B ∅ (9){S→A B•} ∅ ∅
B→ •b B B→ •a}
(5) ∅ ∅ ∅ ∅ ∅ (10){Z→S#•}
(6) ∅ ∅ ∅ ∅ ∅ ∅
(7) ∅ ∅ ∅ ∅ ∅ ∅
(8) (7) (8) ∅ (11){B→b B•} ∅ ∅
(9) ∅ ∅ ∅ ∅ ∅ ∅
(10) ∅ ∅ ∅ ∅ ∅ ∅
(11) ∅ ∅ ∅ ∅ ∅ ∅
6
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1
s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s
2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2
3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3
4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4
5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
1 start
2 6 A→a A
3 A→b
4 5
8
9 S→A B
10
7 B→a
11 B→b B
a b
A S
A b
b a B
#
B a a
b
État Shift Goto
Action a b # A B S
1 s 2 3 4 5
2 s 2 3 6
3 r(A→b)
4 s 7 8 9
5 s 10
6 r(A→a A) 7 r(B→a)
8 s 7 8 11
9 r(S→A B) 10 accept 11 r(B→b B)
7
Analyse tabulaire
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
• Pour la plupart des grammaires, et notamment les grammaires ambiguës, les algorithmes de type LL/LR sont loin d’être optimaux.
• Vocabulaire : le span(i,j)d’une séquenceu1· · ·unest la sous-séquenceui· · ·uj.
• En analyse tabulaire, on va remplir un tableau bidimensionnel où la cellule(i,j)contient des informations relatives à l’analyse du span(i,j−1).
• Ce tableau va permettre d’éviter les calculs redondants, d’encoder de manière compacte l’ensemble des analyses possibles et éventuellement même guider l’analyse.
• Remarque : le nombre d’analyses d’un mot donné est potentiellement exponentiel en la longueur du mot.
• Deux (familles d’)algorithmes classiques de complexitéO(n3):
• CYK ;
• Earley.
8
Algorithme CYK
À lire
• Chapitre 14 du polycopié d’Yvon et Demaille (2016), jusqu’à la fin de la section 14.1,Analyser des langages ambigus avec CYK.
9
À lire
• Chapitre 14 du polycopié d’Yvon et Demaille (2016), jusqu’à la fin de la section 14.1,Analyser des langages ambigus avec CYK.
9
• Le nom de l’algorithme CYK est dérivé des noms de (certains de) ses découvreurs (Cocke, Younger, Kasami).
• Nécessite une grammaire en CNF (règlesA→B CouA→a).
• Dans la cellule(i,j), on enregistre l’ensemble des non-terminaux qui peuvent se réécrire enui· · ·uj−1(pouri<j).
• Exemple :
4 {P} ∅ {V, SV}
3 {SN} {N} 2 {DET}
1 2 3
ma sœur mange
1 DET→ma 2 N→sœur 3
V→mange, SV→mange4 SN→DET N
P→SN SV
10
• Le nom de l’algorithme CYK est dérivé des noms de (certains de) ses découvreurs (Cocke, Younger, Kasami).
• Nécessite une grammaire en CNF (règlesA→B CouA→a).
• Dans la cellule(i,j), on enregistre l’ensemble des non-terminaux qui peuvent se réécrire enui· · ·uj−1(pouri<j).
• Exemple :
4 {P} ∅ {V, SV}
3 {SN} {N} 2 {DET}
1 2 3
ma sœur mange
1 DET→ma 2 N→sœur 3
V→mange, SV→mange4 SN→DET N
P→SN SV
10
• Le nom de l’algorithme CYK est dérivé des noms de (certains de) ses découvreurs (Cocke, Younger, Kasami).
• Nécessite une grammaire en CNF (règlesA→B CouA→a).
• Dans la cellule(i,j), on enregistre l’ensemble des non-terminaux qui peuvent se réécrire enui· · ·uj−1(pouri<j).
• Exemple :
4 {P} ∅ {V, SV}
3 {SN} {N} 2 {DET}
1 2 3
ma sœur mange
1 DET→ma 2 N→sœur 3
V→mange, SV→mange4 SN→DET N
P→SN SV
10
• Le nom de l’algorithme CYK est dérivé des noms de (certains de) ses découvreurs (Cocke, Younger, Kasami).
• Nécessite une grammaire en CNF (règlesA→B CouA→a).
• Dans la cellule(i,j), on enregistre l’ensemble des non-terminaux qui peuvent se réécrire enui· · ·uj−1(pouri<j).
• Exemple :
4 {P} ∅ {V, SV}
3 {SN} {N}
2 {DET}
1 2 3
ma sœur mange
1 DET→ma 2 N→sœur 3
V→mange, SV→mange4 SN→DET N
P→SN SV
10
• Le nom de l’algorithme CYK est dérivé des noms de (certains de) ses découvreurs (Cocke, Younger, Kasami).
• Nécessite une grammaire en CNF (règlesA→B CouA→a).
• Dans la cellule(i,j), on enregistre l’ensemble des non-terminaux qui peuvent se réécrire enui· · ·uj−1(pouri<j).
• Exemple :
4 {P} ∅ {V, SV}
3 {SN} {N}
2 {DET}
1 2 3
ma sœur mange
1 DET→ma 2 N→sœur 3
V→mange, SV→mange4 SN→DET N
P→SN SV
10
Remplir la table
• Les cellules(i,i+1)se remplissent en utilisant les règles lexicales (A→a).
• Sinon, on aA∈T[i,j]ssi∃(A→B C)∈G,∃k∈Ji+1,j−1K, B∈T[i,k],C∈T[k,j].
i · · · k · · · j
A→B C
B→... C→...
11
Remplir la table
• Les cellules(i,i+1)se remplissent en utilisant les règles lexicales (A→a).
• Sinon, on aA∈T[i,j]ssi∃(A→B C)∈G,∃k∈Ji+1,j−1K, B∈T[i,k],C∈T[k,j].
i · · · k · · · j
A→B C
B→... C→...
11
Remplir la table
• Les cellules(i,i+1)se remplissent en utilisant les règles lexicales (A→a).
• Sinon, on aA∈T[i,j]ssi∃(A→B C)∈G,∃k∈Ji+1,j−1K, B∈T[i,k],C∈T[k,j].
i · · · k · · · j
A→B C
B→... C→...
11
Remplir la table
• Les cellules(i,i+1)se remplissent en utilisant les règles lexicales (A→a).
• Sinon, on aA∈T[i,j]ssi∃(A→B C)∈G,∃k∈Ji+1,j−1K, B∈T[i,k],C∈T[k,j].
i · · · k · · · j
A→B C
B→... C→...
11
Remplir la table
i i+1 · · · k · · · j−1 j
A→B C
B→...
C→...
12
Remplir la table
i i+1 · · · k · · · j−1 j
A→B C
B→...
C→...
12
Remplir la table
i i+1 · · · k · · · j−1 j
A→B C
B→... C→...
12
Remplir la table
i i+1 · · · k · · · j−1 j
A→B C B→...
C→...
12
Remplir la table
i i+1 · · · k · · · j−1 j
A→B C B→...
C→...
12
Remplir la table
j A C
C C C C
j-1
B
...
B
k
B
...
B
i+1 B
i i+1 ... k ... j-1
13
Remplir la table
j A
C
C
C C C
j-1
B
...
B
k
B
... B i+1
B
i i+1 ... k ... j-1
13
Remplir la table
j A
C C
C
C C
j-1
B
...
B
k B
...
B
i+1
B
i i+1 ... k ... j-1
13
Remplir la table
j A
C C C
C
C
j-1
B
... B k
B
...
B
i+1
B
i i+1 ... k ... j-1
13
Remplir la table
j A
C C C C
C j-1 B
...
B
k
B
...
B
i+1
B
i i+1 ... k ... j-1
13
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.
Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
Remplir la table
• On peut remplir une cellule(i,j)ssi on a déjà rempli le dessous de sa colonne (jusque(i,i+1)) et la droite de sa ligne (jusque (j−1,j)).
• Plusieurs ordres possibles :
• en diagonale (de la plus grande vers la plus petite) ;
• par ligne (de droite à gauche, des lignes du bas vers le haut) ;
• par colonne (de bas en haut, des colonnes de la droite vers la gauche).
• Dans le polycopié : en diagonale.Bon exercice : modifier l’algorithme pour effectuer un remplissage par ligne, ou par colonne.
• Réussite :S∈T[1,n+1].
• Complexité :O(n3).
14
