Colorarea cografurilor folosind

descompunerea modulara

Cristian Frasinaru
acf@infoiasi.ro

Facultatea de Informatica
Universitatea Al. I. Cuza Iasi

Cuprins
1 Descompunerea modular
a
1.1 Definitii . . . . . . . . . .
1.2 Algoritmul brut . . . . . .
1.3 Algoritmi liniari . . . . . .
1.4 Recunoasterea cografurilor

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

2 Colorarea cografurilor
2.1 Ideea algoritmului . . . . . . . . . . .
2.2 Algoritmul de colorare a cografurilor
2.3 Corectitudinea . . . . . . . . . . . . .
2.4 Complexitatea . . . . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

3
3
4
9
9

.
.
.
.

11
11
11
14
14

Descompunerea modular
a

1.1

Definitii

Numim modul al unui graf neorientat G = (V, E) o multime de varfuri M

pentru care orice varf din V M fie este adiacent cu toate varfurile din M ,
fie nu este adiacent cu nici unul.
V , si {v}, v V se numesc module triviale.
Un graf care nu are decat module triviale se numeste graf prim.
Un modul care nu intersecteaza strict un alt modul (dar poate contine sau fi
continut n altul) se numeste modul tare. Un modul slab este un modul care
nu este tare.
Notam M (G) familia tuturor modulelor unui graf G.
Doua multimi se suprapun daca ele se intersecteaza dar nici una nu este
continuta n cealalta. Spunem ca un nod v distinge doua alte varfuri u, w
daca este adiacent cu unul dintre ele dar nu cu amandoua. Varfurile u, w
sunt n acord asupra lui v daca v nu distinge ntre u si w.
O definitie echivalenta a unui modul este: M este modul al unul graf G daca
nici un varf v V (G) M nu distinge ntre oricare doua varfuri m, m0 M .
Teorema 1 ([12]) Familia M (G) a modulelor unui graf neorientat are urm
atoarea
proprietati:
trivial V M (G), M (G) si v V {v} M (G)
intersectie M N M (G), N, M M (G).
reuniune M N M (G), N, M M (G), cu N M 6= .
diferenta M N M (G), M N M (G)N, M M (G), cu proprietatea ca M si N se suprapun.
Descompunerea modulara a unui graf este un proces recursiv de construire
a modulelor tari ale lui G, care porneste de la modulul trivial V si se va
termina cu obtinerea tuturor modulelor triviale corespunzatoare varfurilor
grafului. La pasul recursiv, pentru fiecare modul M deja construit, se executa
urmatoarea operatie:
1. Daca G[M ] nu este conex, M va fi descompus n componentele conexe
ale lui G[M ];
3

2. Daca G[M ] nu este conex, S va fi descompus n componentele conexe

ale lui G[M ];
3. Daca M nu se ncadreaza n primele doua cazuri, atunci l vom numi
modul prim. In aceasta situatie, vom descompune M n submodule
proprii maximale. Se poate demonstra ca orice varf al unui modul
prim nu poate apartine decat unui singur submodul propriu maximal,
deci descompunerea este unica.
Algoritmul de mai sus permite construirea unui arbore, numit si arborele
de descompunere modulara, n care fiecare nod corespunde unui modul tare al
lui G, frunzele arborelui fiind multimile singleton date de varfurile grafului.
In functie de cele trei situatii descrise mai sus, nodurile interne ale arborelui
vor fi etichetate astfel:
1. paralel
2. serie
3. prim
Primele doua tipuri de noduri se mai numesc si degenerate.
Teorema 2 ([12]) Orice modul al unui graf G este fie modul tare, fie reuniunea varfurilor corespunzatoare unei submultimi a fiilor unui nod degenerat.
Arborele de descompunere modulara este unic pentru un graf dat si ofera
o reprezentare n O(|V |) spatiu pentru modulele unui graf.

1.2

Algoritmul brut

Fie G = (V, E) graful pe care dorim sa-l descompunem.

Cazul 1.
Daca G nu este conex, descompunem graful n componentele sale conexe,
altfel
Daca G nu este conex, descompunem graful n componentele conexe ale lui G.
Cazul 2.
Suntem n situatia candG si G sunt conexe.
4

Pentru fiecare pereche de varfuri x, y se poate gasi usor, n O(n + m), modulul minimal M care le contine. Descompunem apoi graful (G M ) x si
nlocuim pe x cu descompunerea recursiva a lui M .
Analizand complexitatea algoritmului observam ca, n cazul 2, avem nevoie
de O(n2 m) operatii pentru a descompune graful. Complexitatea totala a algoritmului este deci O(n3 m).
Listing 1: Algoritmul brut de descompunere modulara
import
import
import
import

graph .*;
graph . algorithms .*;
graph . layout .*;
java . util .*;

public class ModularDeco m p o s i t i o n extends Algorithm {

Graph tree = null ;
Node root = null ;
public Tree getTree () {
execute () ;
return new Tree ( tree , root ) ;
}
public int execute () {
Graph g = getGraph () ;
tree = new Graph () ;
decompose (g , null ) ;
if ( isVisual () ) {
getWorkspace () . setGraph ( tree , " " ) ;
TreeLayout tl = new TreeLayout () ;
tl . setGraph ( tree ) ;
tl . execute () ;
}
return 0;
}
public Node addNode ( Node parent ) {
Node node = new Node () ;
tree . add ( node ) ;
if ( parent != null )
tree . add ( new Edge ( parent , node ) ) ;

return node ;
}
public void decompose ( Graph g , Node parent ) {
// Descompune V ( G ) si adauga arborele rezultat
// ca subarbore al lui parent
if ( isStopped () )
return ;
Node node = null ;
if ( g . N () == 1) {
Node v = g . node (0) ;
node = addNode ( parent ) ;
node . setLabel ( v . getLabel () ) ;
node . setData ( new Integer ( v . getId () ) ) ;
node . setFillColor ( v . getFillColor () ) ;
return ;
}
ConnectedComponents alg = new C on n e ct e d Co m po n e nt s () ;
alg . setGraph ( g ) ;
if (! alg . isConnected () ) {
node = addNode ( parent ) ;
if ( root == null )
root = node ;
node . setLabel ( " Paralel " ) ;
node . setData ( " Paralel " ) ;
node . setWidth (60) ;
Set blocks = alg . components () ;
for ( Iterator it = blocks . iterator () ; it . hasNext () ;) {
NodeSet cc = ( NodeSet ) it . next () ;
decompose ( g . subgraph ( cc ) , node ) ;
}
return ;
}
alg . setGraph ( g . complement () ) ;
if (! alg . isConnected () ) {
node = addNode ( parent ) ;
if ( root == null )
root = node ;

node . setLabel ( " Serie " ) ;

node . setData ( " Serie " ) ;
node . setWidth (60) ;
Set blocks = alg . components () ;
for ( Iterator it = blocks . iterator () ; it . hasNext () ;) {
NodeSet cc = ( NodeSet ) it . next () ;
decompose ( g . subgraph ( cc ) , node ) ;
}
return ;
}
NodeSet M = null ;
Node x = null , y = null ;
boolean found = false ;
for ( int i =0; i < g . N () && ! found ; i ++)
for ( int j = i +1; j < g . N () && ! found ; j ++) {
x = g . node ( i ) ;
y = g . node ( j ) ;
M = findModule (g , x , y ) ;
if ( M . size () < g . N () )
found = true ;
}
if ( found ) {
NodeSet S = g . nodes () ;
S . removeAll ( M ) ;
S . add ( x ) ;
decompose ( g . subgraph ( S ) , parent ) ;

Node xleaf
= tree . nodes () . find ( new Integer ( x . getId () )
);
Node xparent = xleaf . neighbors () . node (0) ;
tree . remove ( xleaf ) ;
decompose ( g . subgraph ( M ) , xparent ) ;
}
else {
node = addNode ( parent ) ;
if ( root == null )
root = node ;
node . setLabel ( " Prim " ) ;
node . setData ( " Prim " ) ;

node . setWidth (60) ;

for ( int i =0; i < g . N () ; i ++) {
Node u = g . node ( i ) ;
decompose ( g . subgraph ( new NodeSet ( u ) ) , node ) ;
}
}
}
private NodeSet findModule ( Graph g , Node x , Node y ) {
// Determina modulul minimal care contine x si y
NodeSet M = new NodeSet () ;
M . add ( x ) ;
M . add ( y ) ;
NodeSet nodes = g . nodes () ;
nodes . iterate () ;
while ( nodes . hasNext () ) {
Node u = nodes . next () ;
if ( u == x || u == y )
continue ;
int q = u . adjacentNodes ( M ) . size () ;
if ( q > 0 && q < M . size () ) {
M . add ( u ) ;
nodes . remove ( u ) ;
nodes . iterate () ;
}
}
nodes = g . nodes () ;
nodes . iterate () ;
while ( nodes . hasNext () ) {
Node u = nodes . next () ;
if ( M . contains ( u ) )
continue ;
NodeSet M1 = M . adjacentNodes () ;
M1 . remove ( u ) ;
NodeSet M2 = u . adjacentNodes () ;
M2 . removeAll ( M ) ;
if ( M1 . equals ( M2 ) )
M . add ( u ) ;

}
return M ;
}
}

1.3

Algoritmi liniari

In [5], [8], [9] sunt prezentati algoritmi pentru descompunerea modulara a

unui graf avand complexitatea O(n + m).

1.4

Recunoasterea cografurilor

Un cograf este un graf care nu contine nici un P4 indus. Clasa cografurilor

poate fi caracterizata ca fiind cea mai mica clasa de grafuri ce contine graful cu un singur varf si este nchisa la operatiile de reuniune disjuncta si
complement. Pornind de la aceasta caracterizare avem urmatorul rezultat:
Teorema 3 ([4]) Un graf G este cograf dac
a si numai dac
a arborele de descompunere modulara al lui G nu contine nici un nod prim (contine doar
noduri serie si paralele).

Listing 2: Recunoasterea cografurilor

import
import
import
import

graph .*;
graph . algorithms .*;
graph . layout .*;
java . util .*;

public class CographRecogn it io n extends Algorithm {

public int execute () {
ModularDecomposition md = new M o d u l a r D e c o m p o s i t i o n () ;
md . setGraph ( getGraph () ) ;
Tree tree = md . getTree () ;
if ( tree . findNode ( " Prim " ) != null )
println ( " NOT COGRAPH " ) ;
else

println ( " COGRAPH " ) ;

return 0;
}
}

10

Colorarea cografurilor

2.1

Ideea algoritmului

Dupa cum am vazut, arborele de descompunere modulara al unui cograf nu

contine decat noduri serie sau paralele. Pe baza acestei proprietati putem
contrui un algoritm de colorare pentru un cograf care sa ruleze n timp liniar.
Fie G un cograf si T arborele de descompunere modulara asociat. Fiecare
nod M T corespunde unui modul tare al grafului G. Sa notam M1 , ..., Mk
fii nodului M din arborele T , presupunand ca M nu este nod frunza. De
asemenea, vom nota G[M ] subgraful indus n G de nodurile frunza ale subarborelui lui T cu radacina M . Ideea algoritmului se bazeaza pe urmatoarele
relatii:
1. Daca M este nod paralel atunci:
(G[M ]) = maxi=1..k ((G[Mi ]))
2. Daca M este nod serie atunci:
(G[M ]) = sumi=1..k ((G[Mi ]))

2.2

Algoritmul de colorare a cografurilor

Algoritmul de colorare a cografurilor se va desfasura n doua etape.

Etapa 1: Construirea arborelui de descompunere modulara T corespunzator grafului de intrare G . In cazul n care T contine un nod
etichetate Prim atunci algoritmul se va opri, G nefiind cograf.
Etapa 2: Parcurgerea arborelui ncepand cu radacina, colorarea nodurilor
frunza si determinarea lui (G).
Modul de realizare al primei etape a fost analizat n sectiunea anterioara.
Sa vedem n continuare cum putem parcurge eficient arborele T pentru a
obtine o colorare a nodurilor frunza din arbore care sa induca o colorare
optima a grafului G.
Invariantul algoritmului va fi:
Fie M nodul din arborele T de la pasul curent. Atunci toate nodurile anterioare lui M dintr-o parcurgere preordine a arborlui T au fost analizate
11

iar nodurile frunza corespunzatoare acestora colorate. Mai mult, colorarea

curenta reprezinta o colorare optima a subgrafului lui G indus de nodurile
colorate deja.
Listing 3: Algoritm pentru colorarea unui cograf
import
import
import
import

graph .*;
graph . algorithms .*;
java . util .*;
java . awt .*;

public class CographColoring extends Algorithm {

Graph g ;
private static Color colors [];
public int execute () {
g = getGraph () ;
int n = g . N () ;
// Apelam algoritmul de descompunere modulara
ModularDecomposition md = new M o d u l a r D e c o m p o s i t i o n () ;
md . setGraph ( g ) ;
Tree tree = md . getTree () ;
if ( tree . findNode ( " Prim " ) != null ) {
println ( " Nu este cograf ! " ) ;
return -1;
}
/* Pregatim un set de culori pe care le vom
folosi pentru colorarea efectiva a nodurilor */
colors = new Color [ n ];
for ( int i =0; i < n ; i ++) {
colors [ i ] = Tools . randomColor () ;
}
// Apelam algoritmul de colorare , incepand cu radacina
int nc = color ( tree . root () , 0) ;
println ( " Culori necesare : " + nc ) ;
g . repaint () ;
return 0;
}

12

/* Metoda < color > coloreaza

folosind culori incepand cu
returneaza numarul minim de
public int color ( Node node ,

subarborele cu radacina < node > ,

numarul <k > si
culori necesare */
int k ) {

int nc = 0;
NodeSet kids = node . children () ;
// Nod paralel
if ( node . getData () . equals ( " Paralel " ) ) {
int max = 0;
for ( int i =0; i < kids . size () ; i ++) {
nc = color ( kids . node ( i ) , k ) ;
if ( nc > max )
max = nc ;
}
return max ;
}
// Nod serie
if ( node . getData () . equals ( " Serie " ) ) {
int suma = 0;
for ( int i =0; i < kids . size () ; i ++) {
Node kid = kids . node ( i ) ;
nc = color ( kid , k + suma ) ;
suma += nc ;
}
return suma ;
}
// Frunza
// Aflam nodul corespondent din graful g
Node gnode = g . node ((( Integer ) node . getData () ) . intValue () )
;
// Coloram efectiv nodul
gnode . setFillColor ( colors [ k ]) ;
return 1;
}
}

13

2.3

Corectitudinea

In urma rularii algoritmului prezentat, nodurile frunza sunt colorate dupa

urmatorul principiu. Oricare ar fi doua noduri frunza:
Daca cel mai recent stramos comun este de tip paralel, atunci au aceeasi
culoare.
Daca cel mai recent stramos comun este de tip serie, atunci au culori
diferite.
Sa presupunem ca solutia gasita de algoritm nu este optima. Aceasta
nseamna ca exista doua noduri frunza cu culori diferite dar care ar putea
fi colorate cu aceeasi culoare. Fie v1 , v2 aceste noduri si M cel mai recent
stramos comun al lor. Deoarec M este de tip serie, atunci modulele tari M1
si M2 corespunzatoare fiilor lui M n arbore cu v1 M1 , respectiv v2 M2
vor fi total adiacente, deci v1 este adiacent cu v2 n G si prin urmare nu pot
fi colorate la fel, contradictie.

2.4

Complexitatea

Fie G un cograf cu n noduri si m muchii. Dupa cum am mentionat deja, n

[5], [8], [9] sunt prezentati algoritmi pentru descompunerea modulara a unui
graf avand complexitatea O(n + m). Asadar prima etapa a algoritmului se
desfasoara n timp liniar.
Avand n vedere ca arborele de de descompunere modulara are drept
frunze nodurile lui G, numarul total al nodurilor sale este cel mult 2n 1.
Etapa a doua a algoritmului efectueaza o parcurgere a arborelui ce trece prin
fiecare nod exact o singura data, deci complexitatea sa este O(n).
Complexitatea totala a algoritmului este asadar O(n + m).

14

References
[1] M.C.Golumbic, Algorithmic Graph Theory and Perfect Graphs
[2] J. Spinrad, Efficient Graph Representation
[3] M.Habib, C.Paul, L.Viennot, Partiton refinment techniques: an interesting algorithmic toolkit
[4] M.Habib, C.Paul A new vertex splitting algorithm for cograph recognition
[5] R. McConnel, Jeremy Spinrad, Modular Decomposition and Transitive
Orientation
[6] R.McConnel, J. Spinrad Linear time transitive orientation
[7] R. McConnel, F.Montgolfier, PQ Trees and Modular Decomposition
[8] A.Counier, M.Habib, A new linear algorithm for modular decomposition
[9] M.Habib. F.Montgolfier, C.Paul, A simple linear-time modular decomposition algorithm for graphs, using order extending
[10] C.Capelle, Decomposition de graphes et permutations factorisantes, PhD
thesis, Univ. Montpellier, 1997
[11] F.Montgolfier, Trouver larbre de decomposition modulaire dun graphe
a partir dune permutation factorisante, 2000
[12] E. Dahlhaust, J. Gusted, R. McConnell Efficient and Practical Modular
Decomposition

15