Algorithme Combinatoire Cours 1 : Coloriage d`un graphe But

Algorithme Combinatoire
Cours 1 : Coloriage d’un graphe
But : Formalisation + Rappels
𝐺 = (𝑉, 𝐸)
graphe
sommet(vertices)
arrêtes/arc(edges)
Créer des graphes par algorithme supermaster
Utilisation : G[u]
ajd(u) -> ensemble des voisins du sommet u
𝑎𝑑𝑗(2) = 1 3 4
𝑝𝑎𝑡ℎ(𝑢, 𝑣)𝐺 → chemin de u à v dans G
𝑑(2) → degré d’un sommet
𝑑(2) = 3 (nombre de voisin d’un graphe)
𝑑+ (2) / 𝑑 − (2) -> pour graphe orienté
degré entrant / degré sortant
Exo : Equipe un carrefour de feu tricolore :
Interet : reguler la circulation en evitant les
accidents
Relation de compatibilité entre les sommets
Le but est de transformer cet exo en graphe
Idée principale : ne pas faire d’algorithme compliqué,
 ne pas les crée,
 adapter les schémas à des algorithmes déjà connu
 minimiser à des algorithmes supermaster
Lien et direction
Complexité algorithme pour écrire graph :
𝒪(𝑉 + 𝐸) = linéaire
Problème NP - complet
Ce sont les liens compatibles entre eux : donc pas de collision
E = direction incomptable
V = toutes les directions définies par le problème
Colorier graphe : colorier les sommets de même couleur qui lien compatible de façon
minimale
𝜋𝑐𝑅𝑇 → problème complet = feu tricolore
𝜋𝑎 → problème abstrait = coloration d’un graphe : à formaliser !
On traduit un problème complet à un problème abstrait pour le réutiliser ensuite sur
d’autre algorithme
Pour formaliser on doit comprendre le problème et répondre à ces questions :
- Quelles sont les données ?
- Quels sont les résultats ?
- Quels sont les liens entre ces données et ces résultats ?
Pour écrire une équation on doit avoir ces 4 qualité :
I -> objet informatique -> graph : 𝐺 = (𝑉, 𝐸)
S -> solution : {𝑃𝐴(𝑉)/ ∀ 𝑝 ∈ 𝑃𝐴(𝑉), ∀ 𝑥, 𝑦 ∈ 𝑝((𝑥, 𝑦) ∉ 𝐸)}
F -> |𝑃𝐴(𝑉)| = Logarithme des blocs
Opt -> min -> ce que l’on cherche comme solution
Ici on cherche donc le plus petit paquet de direction compatible
FORMALISATION : ses 4 étapes
I : les données : {listes, ensembles, graphes, automates, arbres, grammaires}
S : ensemble des solutions : {ObjetCombinatoire(I), propriétés}
F : la meilleure solution : mesurer S
Opt : min / max : ce que l’on cherche à obtenir comme nombre de solution dans
l’ensemble S
Exercice :
I : {1,2,3,4,5}
Partition possible :
{1,5} , {2} , {3,4}
{1,3,4} , {2,5}
la meilleur des solutions car moins de couleur utilisé (2)
Les partitions se crées par compatibilités des sommets entre eux, c’est à dire quand il n’y
a pas d’arrête entre eux
Ex : {1,2,3,5} , {4} -> non compatible
Formalisation : traduire un problème complet en problème abstrait
On utilise 3 technique pour cela :
- choisir et traiter (la favorite)
- diviser pour régner
- programmation dynamique
Choisir et traiter :
On choisit un sommet, et on se traite pour connaître ses adjacents : u -> adj[u]
Moins on utilise de couleur plus on se rapproche de la solution !
On choisit le sommet 2 et on lui attribut la
première couleur.
On traite ses adjacents et leur donne la deuxième
couleur.
On applique à 5 sa couleur, puisque {2,5} est
compatible
-> On regarde pour chaque sommet ses adjacents
et leur couleur, et on ne prend pas celle là !
2 1 2 2 1
1 2 3 4 5
Exemple d’algorithme juste mais non optimal :
Liste des partitions :
{1,5} , {2} , {3, 4}
On obtient 3 couleurs, ce n’est pas
optimal, le but est de trouver le
moins de couleur possible
Remarque : on a autant le droit de mettre 1 de la même couleur que 5 que 2, puisque
tout les 2 n’ont pas de lien jusqu’à 5, la seule différence est l’optimisation
Création de l’algorithme :
𝐶𝑂𝐿(𝑧. 𝑄, 𝐶) = 𝛼(𝑎𝑑𝑗[𝑧], 1, 𝐶, 𝑧. 𝑄)
sommet
ensemble de couleur
liste où z appartient
voisin de z
couleur 1
fonction
Formalisation du problème :
𝐶𝑂𝐿(𝑧. 𝑄, 𝐶) = 𝛼(𝑎𝑑𝑗[𝑧], 1, 𝐶, 𝑧. 𝑄)
𝐶𝑂𝐿 ( ) = 𝐶
𝐶[𝑥] ≠ 𝑖 → 𝛼(𝑥. 𝑙, 𝑖, 𝐶, 𝑧. 𝑄) = 𝛼(𝑙, 𝑖, 𝑐𝐶 𝑧. 𝑄)
𝐶[𝑥] = 𝑖 → 𝛼(𝑥. 𝑙, 𝑖, 𝐶, 𝑧. 𝑄) = 𝛼(𝑎𝑑𝑗[𝑧], 𝑖 + 1, 𝐶, 𝑧. 𝑄)
= 𝛼([ ], 𝑖, 𝑧, 𝑧. 𝑄) = 𝐶𝑂𝐿(𝑄, 𝐶[𝑧] = 𝑖)
𝐶𝑂𝐿(𝑧. 𝑄, 𝐶) = 𝛼(𝑎𝑑𝑗[𝑧], [], 𝐶, 𝑧. 𝑄)
𝐶𝑂𝐿 ([ ], 𝐶) = 𝐶
si on a pas de couleur :
𝐶[𝑥] = 0 → 𝛼(𝑥. 𝑙, 𝑅 𝐶 𝑧. 𝑄) = 𝛼(𝑙, 𝑅, 𝐶, 𝑧. 𝑄)
si il y en a, on l’ajoute à la liste R (liste des couleurs):
𝐶[𝑥] ≠ 0 → 𝛼(𝑥. 𝑙, 𝑅, 𝐶, 𝑧. 𝑄) = 𝛼(𝑙, 𝑅 + 𝐶[𝑥], 𝐶, 𝑧. 𝑄)
= 𝛼([ ], 𝑅 𝑧, 𝑧. 𝑄) = 𝐶𝑂𝐿(𝑄, 𝐶[𝑧] = 𝑚𝑖𝑛𝑡𝑟𝑜𝑢(𝑅))
 On demande le plus petit nombre qui n’est pas dans la liste de couleur
Code de l’algorithme
𝐶 = 𝑧𝑒𝑟𝑜𝑠(𝑛) → tableau de zero
𝑄 = [ ] → tableau de sommet
𝑄. 𝑎𝑝𝑝𝑒𝑛𝑑(𝑢) → ajout du premier sommet
𝑤ℎ𝑖𝑙𝑒 𝑄 ∶
→ (𝑄 ≠ 0)
𝑍 = 𝑄. 𝑝𝑜𝑝()
→ on prends le premier sommet de Q
𝑅=[ ]
→ on stock les couleurs adjacentes dans la liste R
𝑓𝑜𝑟 𝑥 𝑖𝑛 𝑎𝑑𝑗[𝑧] :
𝑖𝑓 𝐶[𝑥] ! = 𝑂 ∶
𝑅. 𝑎𝑝𝑝𝑒𝑛𝑑( 𝐶[𝑥])
𝑒𝑙𝑠𝑒 𝑄. 𝑎𝑝𝑝𝑒𝑛𝑑(𝑥)
𝐶[𝑧] = 𝑚𝑖𝑛𝑡𝑟𝑜𝑢(𝑅)
𝒪(𝑉 + 𝐸)
Algorithme
SSSM
(super x3
master)
Application du cours : partie TD
Organisation d’une session d’examen :
Créneaux : 8-10 / 10-12 / 13-15 / 15-17 / 17-19
Données : Etudiant / Professeur / Salle / Module
Sortie : Planning et liste
Nobre fini de module : C, Python, Ana2 ect …
Les modules sont représentés par une lettre
{𝐴 𝐹 𝐶 𝐻 } {𝐵 𝐸 𝐺 } {𝐷}
On a donc 3 créneaux suffisants
𝑛𝑜𝑚𝑏𝑟𝑒 𝑑 ′ é𝑞𝑢𝑖𝑣𝑎𝑙𝑒𝑛𝑐𝑒
= 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑗𝑜𝑢𝑟 𝑛𝑒𝑐𝑒𝑠𝑠𝑎𝑖𝑟𝑒 𝑝𝑜𝑢𝑟 𝑐𝑎𝑠𝑒𝑟 𝑡𝑜𝑢𝑡 𝑙𝑒𝑠 𝑐𝑟𝑒𝑛𝑒𝑎𝑢𝑥
5
Problème : on cherche l’immédiatement supérieur : celui qui est juste au dessus du
nombre en gardant les mêmes chiffres, par permutation
Ex : 4235 < 4253 > 4325 ect …
Données : Un tableau L sur (𝐴, ≼)
Sortie : Immédiatement supérieur de L
𝑖←𝑛
𝑤ℎ𝑖𝑙𝑒 (𝑖 > 1 𝑒𝑡 𝐿[𝑖 − 1] ≥ 𝐿 [𝑖]) :
𝑖−−
𝑖𝑓 (𝑖 = 1)
𝑟𝑒𝑡𝑢𝑟𝑛 ⊥
j← 𝑖 − 1; 𝑘 ← 𝑚
𝑤ℎ𝑖𝑙𝑒 (𝐿[𝐾] ≤ 𝐿[𝑗]) :
𝑘−−
𝐿[𝑘 ↔ 𝑗]
l← 𝑖; 𝑚 ← 𝑛
𝑤ℎ𝑖𝑙𝑒 (𝑙 < 𝑚) :
𝐿[𝑙 ↔ 𝑚]
𝑙++
𝑚−−
𝑟𝑒𝑡𝑢𝑟𝑛 𝐿