{1, 2 …n}. - Moodle UM
publicité
Ensemble Cnk des parties à k éléments
de l’ensemble En = {1, 2 . . . n}.
partie = sous-ensemble
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { ,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = {
,
,
,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,},
,
,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,1},
,
,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,/1},
,
,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2},
,
,
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4},
,
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2,},
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 1},
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
1},
C42 = { {1,2}, {1, 3}, {1, 4}, {2, //
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3},
,
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
deux éléments d’un ensemble à n éléments est dans
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
deux éléments d’un ensemble à n éléments est dans Θ(n2 )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
trois éléments d’un ensemble à n éléments est dans Θ()
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
trois éléments d’un ensemble à n éléments est dans Θ(n3 )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
k éléments d’un ensemble à n éléments est dans Θ()
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui construit toutes les parties à
k éléments d’un ensemble à n éléments est dans Θ(nk )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
C42
E4 = { 1, 2, 3, 4}
C42 = { {1,2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }
La complexité de l’algorithme naïf qui imprime toutes les parties à
k éléments d’un ensemble à n éléments est dans Θ(nk ×k)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Coût d’impression d’un élément
×
Nombre d’éléments
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Coût d’impression d’un élément Θ(k)
×
Nombre d’éléments
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Coût d’impression d’un élément Θ(k)
×
Nombre d’éléments Cnk
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Coût d’impression d’un élément Θ(k)
×
Nombre d’éléments Cnk
——————————————Θ(k.Cnk )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Peut-on faire mieux ?
Quel est le coût minimum de l’algorithme d’impression ?
Coût d’impression d’un élément Θ(k)
×
Nombre d’éléments Cnk
Θ(k.Cnk )
L’algorithme naïf est en Θ(k × nk ), le coût minimum est en
n!
(k−1)!(n−k)!
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
=
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
=
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=
/1×2/×...×(n−k)
/////
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
i=k−1
nk est beaucoup plus grand que Πi=0
(n − i)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
i=k−1
nk est beaucoup plus grand que Πi=0
(n − i)
Donc le rapport du coût de l’algorithme naïf au coût minimal
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
i=k−1
nk est beaucoup plus grand que Πi=0
(n − i)
Donc le rapport du coût de l’algorithme naïf au coût minimal
k×nk
=
Πi =k−1 (n−i )
i =0
(k−1)!
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
i=k−1
nk est beaucoup plus grand que Πi=0
(n − i)
Donc le rapport du coût de l’algorithme naïf au coût minimal
nk
k×nk
× k! est supèrieur à k!
= i =k−1
Πi =k−1 (n−i )
i =0
(k−1)!
Πi =0
(n−i)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme naïf : Θ(k × nk )
n!
(n−k)!
coût minimum :
n!
(k−1)!(n−k)!
= 1×2×...×(n−k)×(n−k+1)×...×n
= 1×2×...×(n−k)×(n−k+1)×...×n
(n−k)!
1×2×...×(n−k)
=
/1×2/×...×(n−k)
///// ×(n−k+1)×...×n
=Πi=k−1
/1×2/×...×(n−k)
i=0 (n − i)
/////
i=k−1
nk est beaucoup plus grand que Πi=0
(n − i)
Donc le rapport du coût de l’algorithme naïf au coût minimal
nk
k×nk
× k! est supèrieur à k!
= i =k−1
Πi =k−1 (n−i )
i =0
(k−1)!
Πi =0
(n−i)
Ça vaut le coup de tenter quelque chose par exemple quand k ≈
n
2
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {( , , ),
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),( , , )
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2, )
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2,4)
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2,4)(1,2,5),
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2,4)(1,2,5),(1, , )
}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2,4)(1,2,5),(1,3,4)(1,3,5),(2,3,4)(2,3,5)(3,4,5)}
Ensemble Cnk des parties à k éléments de l’ensemble En = {
S35
E5 = {1, 2, 3, 4, 5}
C35 = {(1,2,3),(1,2,4)(1,2,5),(1,3,4)(1,3,5),(2,3,4)(2,3,5)(3,4,5)}
On construit naturellement S35 quand on veut construire C35
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithme Dernier
Données:
deux entiers k ≤ n
T un tableau de k éléments
Résultat: Un booléen qui indique si ce tableau représente la
dernière (au sens de l’ordre lexicographique) des suites
ordonnées de k éléments sur l’ensemble {1, 2, . . . n}
Complexité :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithme Dernier
Données:
deux entiers k ≤ n
T un tableau de k éléments
Résultat: Un booléen qui indique si ce tableau représente la
dernière (au sens de l’ordre lexicographique) des suites
ordonnées de k éléments sur l’ensemble {1, 2, . . . n}
Complexité : Θ( )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithme Dernier
Données:
deux entiers k ≤ n
T un tableau de k éléments
Résultat: Un booléen qui indique si ce tableau représente la
dernière (au sens de l’ordre lexicographique) des suites
ordonnées de k éléments sur l’ensemble {1, 2, . . . n}
Complexité : Θ(k)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
[2 3 4 5 6 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
[2 3 4 5 6 ]
[1 2 3 4 8 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
[2 3 4 5 6 ]
[1 2 3 4 8 ]
[1 2 3 5 6 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
[2 3 4 5 6 ]
[1 2 3 4 8 ]
[1 2 3 5 6 ]
[1 2 3 7 8 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Quelques exemples de Suivant
Quel est (avec n = 8) la suite suivant la suite
[1 2 3 4 5 ]
[1 2 3 4 6 ]
[1 5 6 7 8 ]
[2 3 4 5 6 ]
[1 2 3 4 8 ]
[1 2 3 5 6 ]
[1 2 3 7 8 ]
[1 2 4 5 6 ]
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k
Résultat: Un tableau de taille k
Complexité :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k
Complexité :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ( )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire ce qui est laissé en exercice.
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire ce qui est laissé en exercice.
Premier :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire ce qui est laissé en exercice.
Premier :
Résultat: Un tableau de taille k représentant la première suite ordonnée
Complexité :
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire ce qui est laissé en exercice.
Premier :
Résultat: Un tableau de taille k représentant la première suite ordonnée
Complexité : Θ( )
Ensemble Cnk des parties à k éléments de l’ensemble En = {
Algorithmes Suivant et Premier
Suivant
Données: Un tableau de taille k représentant une suite ordonnée
de k entiers de {1 . . . n}
Résultat: Un tableau de taille k représentant la suite ordonnée suivante
Complexité : Θ(k)
Reste à l’écrire ce qui est laissé en exercice.
Premier :
Résultat: Un tableau de taille k représentant la première suite ordonnée
Complexité : Θ(k)
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Imprimer(T );
fin
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
Θ(k)
Θ(k)
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Imprimer(T );
fin
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
Θ(k)
Θ(k)
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Θ(k)
Imprimer(T );
Θ(k)
fin
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
Θ(k)
Θ(k)
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Θ(k)
Imprimer(T );
Θ(k)
fin
On passe dans la répétitive
fois
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
Θ(k)
Θ(k)
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Θ(k)
Imprimer(T );
Θ(k)
fin
On passe dans la répétitive Cnk fois
Ensemble Cnk des parties à k éléments de l’ensemble En = {
algorithme final
Données: k ≤ n deux entiers
Résultat: Cnk a été imprimé
Θ(k)
Θ(k)
T ← Premier();
Imprimer T ;
tant que non Dernier(T ) faire
T ← Suivant(T );
Θ(k)
Imprimer(T );
Θ(k)
fin
On passe dans la répétitive Cnk fois
La complexité Θ(k × Cnk ) est optimale !
Ensemble Cnk des parties à k éléments de l’ensemble En = {
