Construcia unui sistem de ci ferate a..

:
oricare dou staii s fie conectate
sistem economic


Construcia unui sistem de ci ferate a..:
oricare dou staii s fie conectate
sistem economic

Proiectarea circuitelor electronice
conectarea pinilor cu cost minim

conectare cu cost minim evitm
ciclurile

Deci trebuie s construim
graf conex + fr cicluri arbore
cu suma costurilor muchiilor minim
conectare cu cost minim evitm
ciclurile

Deci trebuie s construim
graf conex + fr cicluri arbore
cu suma costurilor muchiilor minim
G = (V, E) conex ponderat
w : E
+
funcie pondere (cost)





G = (V, E) conex ponderat
w : E
+
funcie pondere (cost)

Pentru A _ E




e A
w(A) = w(e)
e
G = (V, E) conex ponderat
w : E
+
funcie pondere (cost)

Pentru A _ E


Pentru T subgraf al lui G


e A
w(A) = w(e)
e
e ( )
w(T) = w(e)
E T e

Arbore parial de cost minim al lui G =
un arbore parial T
min
al lui G cu
min
w(T ) = min { w(T) | T arbore partial al lui G}
Reprezentarea grafurilor ponderate
Matrice de costuri (ponderi)
Liste de adiacen
Liste de muchii
Reprezentarea grafurilor ponderate
Matrice de costuri (ponderi)
Liste de adiacen
Liste de muchii
Reprezentarea grafurilor ponderate
Matrice de costuri (ponderi)
Liste de adiacen
Liste de muchii
Reprezentarea grafurilor ponderate
Matrice de costuri (ponderi)
Liste de adiacen
Liste de muchii

Cum determinm un arbore parial de
cost minim al unui graf conex ponderat?






1
5 3
4
2
6
11
10
15
8
9
20
5
2
3

La un pas este selectat o muchie de cost
minim care nu formeaz cicluri cu
muchiile deja selectate (care unete dou
componente)

Deci trebuie s construim
graf conex + fr cicluri arbore
cu suma costurilor muchiilor minim





Kruskal

Iniial: cele n vrfuri sunt
izolate, fiecare formnd o
component conex




Se unesc aceste
componente prin muchii
de cost minim

1
5
3
4
2
6





Kruskal
La un pas:
Muchiile selectate formeaz
o pdure





Kruskal
La un pas:
Muchiile selectate formeaz
o pdure






Este selectat o muchie de
cost minim care unete doi
arbori din pdurea curent
(dou componente conexe)





Kruskal
Iniial T= (V; C)
pentru i = 1, n-1
alege o muchie uv cu
cost minim a.. u,v sunt
n componente conexe
diferite (T+uv aciclic)
E(T) = E(T) uv
O prim form a algoritmului

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
2

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
8
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
8
9
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
11
8
9
2
3
1. Cum reprezentm graful n memorie?




1. Cum reprezentm graful n memorie?
2. Cum selectm uor o muchie:
de cost minim
care unete dou componente (nu
formeaz cicluri cu muchiile deja
selectate)




1. Reprezentarea grafului ponderat
List de muchii: memorm pentru
fiecare muchie extremitile i costul




2. Pentru a selecta uor o muchie de cost
minim ordonm cresctor muchiile dup
cost





3. Pentru a verifica dac o muchie unete
dou componente (nu formeaz cicluri cu
muchiile deja selectate) asociem fiecrei
componente un reprezentant (o culoare)
Operaii necesare:
Initializare(u)
Reprez(u) returneaz reprezentantul
(culoarea) componentei care conine pe u
Reuneste(u,v) unete componenta care v




3. Pentru a verifica dac o muchie unete
dou componente (nu formeaz cicluri cu
muchiile deja selectate) asociem fiecrei
componente un reprezentant (o culoare)
Trebuie s
- putem determina uor componenta creia
aparine un vrf
- reunim eficient dou componente conexe




Operaii necesare:
Initializare(u) - creeaz o component cu
un singur vrf, u




Operaii necesare:
Initializare(u) - creeaz o component cu
un singur vrf, u
Reprez(u) returneaz reprezentantul
(culoarea) componentei care conine pe u




Operaii necesare:
Initializare(u) - creeaz o component cu
un singur vrf, u
Reprez(u) returneaz reprezentantul
(culoarea) componentei care conine pe u
Reuneste(u,v) unete componenta care
conine u cu cea care conine v




O muchie uv unete dou componente
dac
Reprez(u) Reprez(v)




sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP; //break;
}

void Initial(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);
r2=Reprez(v);
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP; //break;
}

void Initial(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);
r2=Reprez(v);
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP; //break;
}

void Initial(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);
r2=Reprez(v);
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
Cum memorm reprezentantul / culoarea
componentei n care se afl un vrf




Varianta 1 memorm ntr-un vector
pentru fiecare vrf reprezentantul/culoarea
componentei din care face parte
r[u] = culoarea componentei care
conine vrful u



sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP //break;
}

void Initializare(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);
r2=Reprez(v);
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP //break;
}

void Initializare(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);
r2=Reprez(v);
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
STOP //break;
}

void Initializare(int u){
r[u]=u;
}
int Reprez(int u){
return r[u];
}
void Reuneste(int u,int v)
{
r1=Reprez(u);//r1=r[u]
r2=Reprez(v);//r2=r[v]
for(k=1;k<=n;k++)
if(r[k]==r2)
r[k]=r1;
}
Kruskal
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
(4,6)
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6)
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6)
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r(4) = r(6)
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) Reuneste(4, 6)
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r(2) = r(4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4)
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6)
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r(3) = r(5)
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
8
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
8
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r(3) = r(6)
(2,5)
(1,3)
(1,2)
(5,6)

2
3
8
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5)
(1,3)
(1,2)
(5,6)

2
3
8
9
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5)
(1,3)
(1,2)
(5,6)

2
3
8
9
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5) r(2) =r(5) -> NU
(1,3)
(1,2)
(5,6)

2
3
8
9
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5) r(2) =r(5) -> NU
(1,3)
(1,2)
(5,6)

2
3
8
9
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5) r(2) =r(5) -> NU
(1,3) r(1) = r(3)
(1,2)
(5,6)

2
3
8
9
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5) r(2) =r(5) -> NU
(1,3) r = [1,1,1,1,1,1]
(1,2)
(5,6)

2
3
8
9
11
1
5 3
4
2
6
11
10
15 8
9
20
5
2
3
1
5 3
4
2
6
r = [1,2,3,4,5,6]
(4,6) r = [1,2,3,4,5,4]
(2,4) r = [1,2,3,2,5,2]
(2,6) r(2) =r(6) -> NU
(3,5) r = [1,2,3,2,3,2]
(3,6) r = [1,3,3,3,3,3]
(2,5) r(2) =r(5) -> NU
(1,3) r = [1,1,1,1,1,1]
STOP
(1,2)
(5,6)

2
3
8
9
11
Complexitate


sorteaza(E)
for(v=1;v<=n;v++)
Initializare(v);
nrmsel=0
for(uv e E)
if(Reprez(u)!=Reprez(v))
{
scrie uv;
Reuneste(u,v);
nrmsel=nrmsel+1;
if(nrmsel==n-1)
break;
}

Kruskal
Complexitate
Sortare -> O(m log m) = O(m log n)
n * Initializare
2m * Reprez
(n-1) * Reuneste


Varianta 1 dac folosim vector de
reprezentani
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m)
(n-1) * Reuneste -> O(n
2
)
O(m log n + n
2
)
Varianta 1 dac folosim vector de
reprezentani
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m)
(n-1) * Reuneste -> O(n
2
)
O(m log n + n
2
)
Varianta 1 dac folosim vector de
reprezentani
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m)
(n-1) * Reuneste -> O(n
2
)
O(m log n + n
2
)
Varianta 1 dac folosim vector de
reprezentani
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m)
(n-1) * Reuneste -> O(n
2
)
O(m log n + n
2
)
Varianta 1 dac folosim vector de
reprezentani
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m)
(n-1) * Reuneste -> O(n
2
)
O(m log n + n
2
)
Varianta 2 memorm componentele
conexe ca arbori, folosind vectorul tata;
reprezentantul componentei va fi
rdcina arborelui
Reinem n plus i nlimea unui astfel de
arbore vectorul h



Varianta 2 memorm componentele
conexe ca arbori, folosind vectorul tata;
reprezentantul componentei va fi
rdcina arborelui

Trebuie ca arborii s rmn cu o
nlime ct mai mic



Reinem n plus i nlimea unui astfel de
arbore vectorul h
Reuniunea se va face n funcie de
nlimea arborilor (reuniune ponderat):
arborele cu nlimea mai mic
devine subarbore al rdcinii celuilalt
arbore


void Initializare(int u){
tata[u]=h[u]=0;
}

int Reprez(int u){
while(tata[u]!=0)
u=tata[u];
return u;
}

void Reuneste(int u,int v)
{
int ru,rv;
ru=Reprez(u);
rv=Reprez(v);
if (h[ru]>h[rv])
tata[rv]=ru;
else{
tata[ru]=rv;
if(h[ru]==h[rv])
h[rv]=h[rv]+1;
s}
}
Kruskal
void Initializare(int u){
tata[u]=h[u]=0;
}

int Reprez(int u){
while(tata[u]!=0)
u=tata[u];
return u;
}

void Reuneste(int u,int v)
{
int ru,rv;
ru=Reprez(u);
rv=Reprez(v);
if (h[ru]>h[rv])
tata[rv]=ru;
else{
tata[ru]=rv;
if(h[ru]==h[rv])
h[rv]=h[rv]+1;
s}
}
Kruskal
void Initializare(int u){
tata[u]=h[u]=0;
}

int Reprez(int u){
while(tata[u]!=0)
u=tata[u];
return u;
}

void Reuneste(int u,int v)
{
int ru,rv;
ru=Reprez(u);
rv=Reprez(v);
if (h[ru]>h[rv])
tata[rv]=ru;
else{
tata[ru]=rv;
if(h[ru]==h[rv])
h[rv]=h[rv]+1;
}
}
Kruskal
void Initializare(int u){
tata[u]=h[u]=0;
}

int Reprez(int u){
while(tata[u]!=0)
u=tata[u];
return u;
}

void Reuneste(int u,int v)
{
int ru,rv;
ru=Reprez(u);
rv=Reprez(v);
if (h[ru]>h[rv])
tata[rv]=ru;
else{
tata[ru]=rv;
if(h[ru]==h[rv])
h[rv]=h[rv]+1;
}
}
Kruskal
Complexitate dac folosim arbori
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m log n)
(n-1) * Reuneste -> O(n log n)
O(m log n)
Complexitate dac folosim arbori
Sortare -> O(m log m) = O(m log n)
n * Initializare -> O(n)
2m * Reprez -> O(m log n)
(n-1) * Reuneste -> O(n log n)
O(m log n)


1
5 3
4
2
6
11
10
15
8
9
20
5
2
3





Kruskal

Iniial: cele n vrfuri sunt
izolate, fiecare formnd o
component conex




Se ncearc unirea acestor
componente prin muchii
de cost minim
Prim

Iniial: se pornete de la
un vrf de start



Se adug pe rnd cte
un vrf la arborele deja
construit, folosind muchii
de cost minim

1
5
3
4
2
6
1





Kruskal
La un pas:
Muchiile selectate formeaz
o pdure
Prim
La un pas:
Muchiile selectate formeaz
un arbore






Kruskal
La un pas:
Muchiile selectate formeaz
o pdure
Este selectat o muchie de
cost minim care unete doi
arbori din pdurea curent
(dou componente conexe)
Prim
La un pas:
Muchiile selectate formeaz
un arbore
Este selectat o muchie de
cost minim care unete un
vrf din arbore cu unul care
nu este n arbore(neselectat)






Kruskal

Iniial T= (V; C)
pentru i = 1, n-1
alege o muchie uv cu
cost minim a.. u,v sunt
n componente conexe
diferite (T+uv aciclic)
E(T) = E(T) uv
Prim
s- vrful de start
Iniial T= ({s}; C)
pentru i = 1, n-1
alege o muchie uv cu cost
minim a.. ueV(T) i veV(T)
V(T) = V(T) {v}
E(T) = E(T) uv

O prim form a algoritmului

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
s =

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
3
11

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
3
11

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
11
8

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
11
8

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
6
11
8
9

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
6
11
8
9

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
6
11
8
9
2

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
6
11
8
9
2

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5 3
4
2
6
11
8
9
2
3

1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1
5
3
4
2
6
11
8
9
2
3
s=
Cum evitm s comparam de fiecare dat
toate muchiile cu o extremitate n arbore
i cealalt nu.
Exemplu: Dup ce 1 i 5 au fost adugate
n arbore, muchiile (2,1) i (2,5) sunt
comparate la fiecare pas, dei
w(2,1)>w(2,5), deci (2,1) nu va fi
selectat niciodat




Cum evitm s comparam de fiecare dat
toate muchiile cu o extremitate n arbore
i cealalt nu.
Exemplu:
Dup ce 1 i 5 au fost adugate n arbore,
muchiile (2,1) i (2,5) sunt comparate la
fiecare pas, dei w(2,1)>w(2,5), deci (2,1)
nu va fi selectat niciodat




Pentru un vrf (neselectat) memorm
doar muchia minim care l unete cu un
vrf din arbore (selectat)
acest vrf din abore penru care se
realizeaz minimul
Avem
cheie[u] = w(u, tata[u])



Asociem fiecrui vrf urmtoarele
informaii (etichete):
d[u] = costul minim al unei muchii de la
u la un vrf selectat deja n arbore
tata[u] = acest vrf din abore penru care
se realizeaz minimul
Avem
cheie[u] = w(u, tata[u])



Asociem fiecrui vrf urmtoarele
informaii (etichete):
d[u] = costul minim al unei muchii de la
u la un vrf selectat deja n arbore
tata[u] = acest vrf din arbore pentru
care se realizeaz minimul
Avem
cheie[u] = w(u, tata[u])



Avem
d[u] = w(u, tata[u])



Atunci algoritmul se modific astfel:
La un pas
se alege un vrf u cu eticheta d minim care
nu este nc n arbore i se adaug la arbore
muchia (tata[u], u)




Atunci algoritmul se modific astfel:
La un pas
se alege un vrf u cu eticheta d minim care
nu este nc n arbore i se adaug la arbore
muchia (tata[u], u)
- se actualizeaz etichetele vrfurilor v vecine
cu u astfel:
























dac w(u,v) < d[v] atunci
d[v] = w(u,v)
tata[v] = u




Muchiile arborelui vor fi n final
(u, tata[u]), u= s



Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
cheie[u] =
cheie[s] = 0
tata[s] = 0
cat timp Q C executa
u = extrage vrf cu cheie minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
cheie[s] = 0
tata[s] = 0
cat timp Q C executa
u = extrage vrf cu cheie minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u = extrage vrf cu cheie minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u = extrage vrf cu cheie minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u=extrage vrf cu eticheta d minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u=extrage vrf cu eticheta d minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<cheie[v] atunci
cheie[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u=extrage vrf cu eticheta d minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<d[v] atunci
d[v] = w(u,v)
tata[v] = u

Algoritmul lui Prim
Prim(G, w, s)
iniializeaz mulimea vrfurilor neselectate Q cu V
pentru fiecare ueV executa
d[u] = ; tata[u]=0
d[s] = 0
cat timp Q C executa
u=extrage vrf cu eticheta d minim din Q
pentru fiecare v adiacent cu u executa
daca veQ si w(u,v)<d[v] atunci
d[v] = w(u,v)
tata[v] = u
scrie (u, tata[u]), pentru u= s

Algoritmul lui Prim
Q poate fi
vector:
Q[u] = 1, dac u este selectat
0, altfel
min-ansamblu (heap)




Q poate fi
vector:
Q[u] = 1, dac u este selectat
0, altfel
min-ansamblu (heap)




Q poate fi
vector:
Q[u] = 1, dac u este selectat
0, altfel
min-ansamblu (heap)




1
5 3
4
2
6
11
10
15
8
9
20
5
2
3

d/tata= [0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11*/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11*/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: Q [1] = 1 (vom reprezenta prin -)Sel. 3: [
- , 15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: actualizm etichetele vecinilorSel. 3: [ - ,
15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8*/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9*/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2*/6 , - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2/6, - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2/6, - , - ]
Sel. 4: [ - , 3/5 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
4
2
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2/6, - , - ]
Sel. 4: [ - , 3/4 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
4
2
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2/6, - , - ]
Sel. 4: [ - , 3/4 , - , - , - , - ]
Sel. 2: [ - , 3/5, - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
4
2
2
3
1
5 3
4
2
6
11
10
15
8
9
20
5
2
3
1

d/tata= [ 0/0, /0, /0, /0, /0, /0 ]
Sel. 1: [ - , 15/1, 11/1, /0, /0, /0 ]
Sel. 3: [ - , 15/1, - , /0, 8/3, 9/3 ]
Sel. 5: [ - , 10/5 , - , /0, - , 9/3 ]
Sel. 6: [ - , 5/6 , - , 2/6, - , - ]
Sel. 4: [ - , 3/4 , - , - , - , - ]
Sel. 2: [ - , - , - , - , - , - ]

1 2 3 4 5 6
3
11
5
8
6
9
4
2
2
3
Complexitate
Iniializare Q
n * extragere vrf minim
actualizare etichete vecini


Varianta 1 reprezentarea lui Q ca vector
Q[u] = 1, dac u este selectat
0, altfel
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n
2
)
actualizare etichete vecini -> O(m)
O(n
2
)


Varianta 1 reprezentarea lui Q ca vector
Q[u] = 1, dac u este selectat
0, altfel
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n
2
)
actualizare etichete vecini -> O(m)
O(n
2
)


Varianta 1 reprezentarea lui Q ca vector
Q[u] = 1, dac u este selectat
0, altfel
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n
2
)
actualizare etichete vecini -> O(m)
O(n
2
)


Varianta 1 reprezentarea lui Q ca vector
Q[u] = 1, dac u este selectat
0, altfel
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n
2
)
actualizare etichete vecini -> O(m)
O(n
2
)


Varianta 1 reprezentarea lui Q ca vector
Q[u] = 1, dac u este selectat
0, altfel
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n
2
)
actualizare etichete vecini -> O(m)
O(n
2
)


Varianta 2 reprezentarea lui Q ca min-heap
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n log n)
actualizare etichete vecini -> O(m log n)
O(m log n)


Varianta 2 reprezentarea lui Q ca min-heap
Iniializare Q -> O(n)
n * extragere vrf minim -> O(n log n)
actualizare etichete vecini -> O(m log n)
O(m log n)


Ideea algoritmilor de determinare a unui
arbore parial de cost minim este:
Se selecteaz succesiv muchii, astfel nct
mulimea de muchii selectate
s aib costul ct mai mic


Ideea algoritmilor de determinare a unui
arbore parial de cost minim este:
Se selecteaz succesiv muchii, astfel nct
mulimea de muchii selectate
s aib costul ct mai mic
s fie submulime a mulimii muchiilor
unui arbore parial de cost minim


Fie A _ E o mulime de muchii care este
submulime a mulimii muchiilor unui
apcm al lui G
O muchie e e E A s.n sigur pentru A
dac A {e} este de asemenea
submulime a mulimii muchiilor unui
apcm al lui G



Idee algoritmilor apcm este deci:
pornim cu A C
pentru i = 1, n-1
se selecteaz o muchie sigur pentru A
i se adaug la A


Vom demonstra c, la fiecare pas, algoritmii
Kruskal i Prim aleg muchii sigure (pentru
mulimea muchiilor deja selectate).


Vom demonstra c, la fiecare pas, algoritmii
Kruskal i Prim aleg muchii sigure (pentru
mulimea muchiilor deja selectate).
Pentru aceasta, vom demonstra un criteriu
pentru ca o muchie s fie sigur.


Propoziie. Fie G=(V, E, w) un graf conex
ponderat i A _ E o submulime a mulimii
muchiilor unui apcm al lui G.
Fie S _ V a.. orice muchie din A are ambele
extremiti n S sau ambele extremiti n V-S .
Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


Propoziie. Fie G=(V, E, w) un graf conex
ponderat i A _ E o submulime a mulimii
muchiilor unui apcm al lui G.
Fie S _ V a.. orice muchie din A are ambele
extremiti n S sau ambele extremiti n V-S .
Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


Propoziie. Fie G=(V, E, w) un graf conex
ponderat i A _ E o submulime a mulimii
muchiilor unui apcm al lui G.
Fie S _ V a.. orice muchie din A are ambele
extremiti n S sau ambele extremiti n V-S .
Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


muchii
din A
V-S
S
Propoziie. Fie G=(V, E, w) un graf conex
ponderat i A _ E o submulime a mulimii
muchiilor unui apcm al lui G.
Fie S _ V a.. orice muchie din A are ambele
extremiti n S sau ambele extremiti n V-S .
Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


Propoziie. Fie G=(V, E, w) un graf conex
ponderat i A _ E o submulime a mulimii
muchiilor unui apcm al lui G.
Fie S _ V a.. orice muchie din A are ambele
extremiti n S sau ambele extremiti n V-S .
Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


Fie e=uv o muchie de cost minim cu o
extremitate n S i cealalt n V-S.
Atunci e este muchie sigur pentru A.


S V-S
de cost
minim
Fie G=(V,E, w) un graf conex ponderat
Propoziie. Algoritmul Kruskal determin un
apcm
Propoziie. Algoritmul Prim determin un
apcm




Marinescu Ghemeci Ruxandra