Implémentation d`algorithmes exacts pour le probl`eme du stable

ANR AGAPE -
Impl´ementation d’algorithmes
exacts pour le probl`eme du
stable maximum
Vincent Levorato
LIFO, Universit´e d’Orl´eans
Rapport noRR-2011-15
1

Table des mati`eres
1 Contexte et travail effectu´e 2
2 Algorithmes exacts pour le probl`eme du Stable Maximum 2
2.1 Algorithme bas´e sur le travail de Moon and Moser (1965) . . . . 2
2.2 Algorithme Degr´e Maximum . . . . . . . . . . . . . . . . . . . . 3
2.3 Algorithme Fomin, Grandoni and Kratsch (2009) . . . . . . . . . 3
2.3.1 Recherche de composantes connexes . . . . . . . . . . . . 5
2.3.2 Recherche de noeuds domin´es . . . . . . . . . . . . . . . . 5
2.3.3 Pliage de noeuds (folding) . . . . . . . . . . . . . . . . . . 5
2.3.4 Noeuds mirroirs (mirroring) . . . . . . . . . . . . . . . . . 6
2.3.5 Algorithme FGK09 renvoyant l’ensemble stable . . . . . . 8
3 R´esultats 8
3.1 Algorithmes.............................. 9
3.2 Impl´ementations ........................... 10
3.3 Etude des appels r´ecursifs pour FGK09 . . . . . . . . . . . . . . 14
3.4 Interpr´etation des r´esultats . . . . . . . . . . . . . . . . . . . . . 14
4 Perspectives 18
1 Contexte et travail effectu´e
Les travaux que j’ai effectu´es jusqu’`a pr´esent concernent l’impl´ementation
d’algorithmes exacts connus sur le probl`eme de la recherche d’un ensemble stable
maximum dans les graphes, ainsi que l’´etude et l’utilisation de la librairie MA-
SCOPT pour l’impl´ementation des algorithmes. Ce rapport d´etaille les algo-
rithmes, explique l’impl´ementation de ceux-ci, et quels choix ont ´et´e retenus
pour la repr´esentation des structures de donn´ees. Il y sera ´egalement abord´e
des comparaisons d’impl´ementation avec d’autres librairies et/ou langage de
programmation (C++ notamment), ainsi que des tests de performance. Les al-
gorithmes sont d´etaill´es pour faire apparaˆıtre certaines op´erations non visibles
dans les algorithmes de base (facteur polynomial) pour ainsi avoir une vision
claire de la version impl´ement´ee. Une ´etude des r´esultats est ´egalement propos´ee
en derni`ere partie.
2 Algorithmes exacts pour le probl`eme du Stable
Maximum
2.1 Algorithme bas´e sur le travail de Moon and Moser
(1965)
Cet algorithme (voir Alg. 1) ´enum`ere tous les ensembles stables maximaux
d’un graphe et permet donc d’en d´eduire un plus grand (maximum). Sa com-
2

plexit´e en temps d’ex´ecution est born´ee en O∗(1,4423n). Un appel de MaxIS-
MM(G,∅) nous renvoie un stable maximum. Le facteur polynomial le plus ´elev´e
que l’on peut trouver dans l’algorithme est celui de la copie de graphe qui se
fait en O(n+m).
Algorithme 1 Maximum Independent Set - [MM65]
Method : MaxIS-MM(Graph G(V,E) , Set S)
Begin
if |V|>0then
Vertex v ←M inDegV ertex(G)
Set Smax ← ∅
for all Vertex u∈N[v]do
Graph G0(V0, E0)←copy(G(V, E))
V0←V0−N[u]
Set Stemp ←MaxIS-MM(G0, S ∪ {u})
if |Stemp|>|Smax|then
Smax ←Stemp
end if
end for
return Smax
else
return S
end if
End
2.2 Algorithme Degr´e Maximum
Cet algorithme (voir Alg. 2) utilise une r`egle de branchement qui, pendant les
appels r´ecursifs, v´erifie s’il ne reste plus que des sommets de degr´e 1 ou 2 (cycle
ou chemin) auquel cas on sait trouver le stable maximal en temps polynomial
(approche gloutonne par exemple). La m´ethode MaximalIndependentSet-
Greedy(G) renvoie un ensemble stable maximal de G. Comme cette m´ethode
n’est appliqu´ee qu’`a des cycles ou des chemins, il suffit de commencer par le
sommet de plus petit degr´e et de prendre un sommet sur 2 comme appartenant
au stable. Le facteur polynomial le plus ´elev´e que l’on peut trouver dans l’algo-
rithme est ´egalement celui de la copie de graphe (O(n+m)). La l´eg`ere diff´erence
avec l’algorithme de [MM65] est que l’on r´ealise 2 fois cette copie pour un appel
r´ecursif.
2.3 Algorithme Fomin, Grandoni and Kratsch (2009)
Cet algorithme utilise la m´ethode Mesurer pour conqu´erir [FGK09, FK10]
pour ´etablir le temps d’ex´ecution au pire cas et permet de trouver un ensemble
stable maximum dans un graphe avec une complexit´e en temps d’ex´ecution en
O∗(1,2201n). Celui-ci fait appel `a certaines op´erations sur les graphes comme la
domination, le pliage de noeud (folding), ou les noeuds mirroirs (mirroring). Ces
concepts sont adapt´es dans l’article de Fomin et al. `a partir d’autres m´ethodes
dont les r´ef´erences se trouvent dans [FGK09].
Note : l’algorithme original renvoie seulement la taille d’un stable maximum,
une version renvoyant le stable sera propos´ee par la suite.
3

Algorithme 2 Maximum Independent Set - MaxDegree
Method : MaxIS-MaxDeg(Graph G(V,E))
Begin
Integer degmax ←MaxDeg(G)
Set S ← ∅
if degmax ≥3then
Vertex v ←M axDegV ertex(G)
Graph G0(V0, E0)←copy(G(V, E))
V0←V0−N[v]
Set S ←MaxIS-MaxDeg(G0)∪{v}
Graph G”(V”, E”) ←copy(G(V, E))
Set S’ ←MaxIS-MaxDeg(G”− {v})
if |S0|>|S|then
S←S0
end if
else
S←MaximalIndependentSetGreedy(G)
end if
return S
End
Algorithme 3 Maximum Independent Set - [FGK09] (original version)
Method : mis(Graph G(V,E))
Begin
if |V| ≤ 1then
return |V|
end if
if ∃component C ⊂Gthen
return mis(C) + mis(G−C)
end if
if ∃vertices vand w / N[w]⊆N[v]then
return mis(G− {v})
end if
if ∃vertex vwith deg(v)=2 then
return 1 + mis( ˜ G(v)) {folding Gon v}
end if
select a vertex vof maximum degree, which minimizes |E(N(v))|
return max{mis(G− {v} − M(v)) , 1 + mis(G−N[v]) } {M(v) corresponds to mirrors of v}
End
4

L’algorithme de Fomin et al., bien que simple dans sa vision globale (voir
Alg. 3), se d´ecoupe en sous-probl`emes parfois coˆuteux (en terme polynomial)
avec dans l’ordre :
1. Recherche de composantes connexes dans un graphe
2. Recherche de noeuds domin´es
3. Pliage de noeuds (et d´epliage le cas ´ech´eant)
4. Recherche de noeuds mirroirs
2.3.1 Recherche de composantes connexes
Cette op´eration correspond `a un parcours en profondeur (DFS). Dans l’al-
gorithme, il suffit de renvoyer la premi`ere composante connexe trouv´ee. Je ne
d´etaille ici pas les op´erations d’un DFS (trivial). Il faut juste noter que le sommet
source est pris au hasard. La complexit´e d’un DFS est en O(n+m).
2.3.2 Recherche de noeuds domin´es
La recherche de noeuds domin´es est un peu plus coˆuteuse en temps que
l’op´eration pr´ec´edente. N´eanmoins, elle ne sera appel´ee qu’une seule fois par
appel r´ecursif et n’a besoin que de renvoyer un seul sommet domin´e (ou on peut
renvoyer l’ensemble des sommets domin´es pour nettoyer le graphe de tous ses
sommets domin´es `a un moment pr´ecis de l’algorithme, test effectu´e qui n’a pas
chang´e les temps d’ex´ecution). Afin de trouver des sommets vet wtels que
N[w]⊆N[v], on est oblig´e de visiter tous les voisinages du graphe dans le pire
des cas. Ensuite, le probl`eme de trouver un noeud domin´e revient `a chercher
un recouvrement total d’un ensemble (de sommets) par un autre. Une strat´egie
simple consiste `a trier par taille les ensembles de voisinages de G, de commencer
par le plus grand, v´erifier s’il ne recouvre pas un ensemble de voisinage (en
commen¸cant par le plus petit), et recommencer l’op´eration tant que ce n’est pas
le cas (Alg. 4). On consid`ere que la relation N[x]7→ xest repr´esent´ee par une
table de hachage et que d´eterminer `a quel sommet correspond un voisinage se
fait en temps constant. Si l’on consid`ere la complexit´e dans le pire des cas, la
m´ethode contient un QuickSort qui se fait en O(n2) (il est n´eanmoins connu
que le QuickSort se comporte plutˆot bien en moyenne (Θ(n·log(n))) ), et la
recherche de recouvrement qui se fait en O(n3). Cependant, mˆeme s’il faudrait
le d´emontrer, on est loin d’atteindre cette borne et on s’approche plutˆot d’un
O(n2/2) (constat´e en pratique).
2.3.3 Pliage de noeuds (folding)
Avant de plier un noeud, il faut tout d’abord en rechercher un de degr´e 2 (en
O(3n)'O(n)). Plier un noeud vde Gpour obtenir ˜ G(v) se fait en 4 ´etapes :
1. ajouter un sommet uij pour chaque anti-arˆete uiujde N(v)
2. ajouter une arˆete entre uij et chaque sommet de N(ui)∪N(uj)
3. ajouter une arˆete entre chaque paire de nouveaux sommets
5