You are on page 1of 60

-

11


Directed acyclic graph ( )

-

, ?

- C
DFS

// Implementacija na netezinski nasocen graf so pomos na niza od listi na
sosednost Pri vlez grafot mora da e aciklicen
typedef int info_t;
typedef struct element {
int index;
info_t info;
struct element *link;
} node;
typedef struct graphAdjList{
int num_nodes;
node *adjList[MAXVERTS];
} graph;

- C
void topological_sort_dfs(graph *g){
int i;
int visited[MAXVERTS];
for (i=0;i<g->num_nodes;i++)
visited[i] = 0;
stackT *s;
stackInit(s);
for(i=0;i<g->num_nodes;i++)
dfsVisit(g,s,i,visited);
while(!stackEmpty(*s)){
printf("%d",stackTop(s));
stackPop(s);
}
}

- C
void dfsVisit(graph *g, stackT *s, int index, int visited[]){
node *p; int i;
if(!visited[index]) {
visited[index] = 1;
p=g->adjList[index];
while(p!=NULL) {
dfsVisit(g,s,p->index,visited);
p=p->link;
}
stackPush(s,index);
}
}

- Java
void topological_sort_dfs(){
boolean visited[] = new boolean[num_nodes];
for(int i=0;i<num_nodes;i++){
visited[i] = false;
}
Stack<Integer> s = new Stack<Integer>();
for(int i=0;i<num_nodes;i++){
dfsVisit(s,i,visited);
}


(
)

while(!s.isEmpty()){
System.out.println(adjList[s.pop()]);
}
}

- Java
void dfsVisit(Stack<Integer> s, int i, boolean[] visited){
if(!visited[i]){
visited[i] = true;
Iterator<GraphNode<E>> it = adjList[i].getNeighbors().iterator();
while(it.hasNext()){
dfsVisit(s, it.next().getIndex(), visited);
}
s.push(i);
}
}


(Minimum spanning
tree - MST)

10


( )
E,

.
(). ,

.
:
.
|V| 1.

(Kruskal)
(Prim).
.
11




|V| ( ).


.
(),
,
. ,

.
|V| 1 .

.

12

-
1. .
(g, h).

13

-
2. (c, i).
(c, i) .

14

-
3. (g, f) .
.

15

-
4. (a, b) .

16

-
5. (c, f)
.

17

-
6. (g, i),
().

18

-
7. (g, i), (c, d).

19

-
8. (h, i)
().

20

-
9. (h, i) (a, h).

21

-
10. , (b, c),
(). (d, e).

22

- C
typedef int info_t;
// struktura za reprezentacija na site vrski vo grafot
typedef struct granka
{
int vertex1, vertex2;
float tezina;
}branch;

// tezinski nasocen (i nenasocen) graf so pomos na niza od listi na sosednost


typedef struct element {
int index;
info_t info;
float tezina;
struct element *link;
} node;
typedef struct graphAdjList{
int num_nodes;
node *adjList[MAXVERTS];
} graph;

23

- C
void merge
if (p <
U[q]
else
U[p]
}

(int p, int q, int *U) {


q)
= p;
= q;

int find (int i, int *U) {


int j;
j = i;
while (U[j] != j)
j = U[j];
return (j);
}

24

- C
void kruskal(graph *g, branch *F){
int E[MAXEDGE][3];
// kompletno mnozestvo na vrski
// int F[MAXVERTS-1][3];
/* F - niza od strukturi branch vo koja ke se cuvaat site vrski koi
vleguvaat vo minimalnoto raspnuvacko drvo */
int
int
int
int

num_edges = 0;
next_edge = 0;
weight = 0;
a, b, c, i, j, k;

/* broj na vrski vo minimalnoto drvo */


/* sleden jazel koj ke se razgleduva */
/* tezina na minimalnoto drvo */

/* vrski - pomosna niza vo koja ke se vodi evidencija za drvata vo sumata.


Element so indeks i od nizata ima vrednost ednakva na jazelot so najmalo
info pole so jazelot i se naoga vo isto poddrvo */
int vrski[MAXVERTS];
k = 0;
node *p;

25

- C
// popolnuvanje na matricata E
for (i = 0; i < g->num_nodes; i++)
for (p = g->adjList[i]; p ; p =
if (i < p->info) {
E[k][0] = i;
E[k][1] = p->info;
E[k][2] = p->tezina;
k++;
}

p->link)
// prviot jazel od vrskata
// vtoriot jazel od vrskata
// tezinata na vrskata

/* sortiranje na mnozestvoto od vrski E[][] vo neopagacki redosled spored


tezinite */
for (i = k - 1; i > 0; i--)
for (j = 0; j < i; j++)
if (E[j][2] > E[j+1][2]) {
a = E[j][0]; b = E[j][1]; c = E[j][2];
E[j][0] = E[j+1][0];
E[j][1] = E[j+1][1];
E[j][2] = E[j+1][2];
E[j+1][0] = a;
E[j+1][1] = b;
E[j+1][2] = c;
}
26

- C
// inicijalizacija na pomosnata niza za evidencija, sekoj jazel e posebno drvo
for (i = 0; i < g->num_nodes; i++)
vrski[i]=i;
/* inicijalizacija na mnozestvoto na vrski od minimalnoto drvo(na pocetok e
prazno) */
for (i = 0; i < g->num_nodes - 1 ; i++) {
F[i].vertex1 = -1;
F[i].vertex2 = -1;
// '-1' oznacuva 'prazno'
F[i].tezina = -1;
}

27

- C
// naoganje na minimalnoto drvo
while (num_edges < g->num_nodes - 1) {
a = E[next_edge][0];
b = E[next_edge][1];
// naoganje na jazlite so minimalno info pole so koi a i b se naogaat vo
isto drvo
i = find(a, vrski);
j = find(b, vrski);
// proverka dali vrskata moze da se stavi vo minimalnoto drvo
if (i!=j)
{
merge (i, j, vrski);
// azuriranje na pomosnata niza za evidencija
// t.e. spojuvanje na dve drva
F[num_edges].vertex1= E[next_edge][0];
F[num_edges].vertex2 = E[next_edge][1];
F[num_edges].tezina = E[next_edge][2];
num_edges++;
}
next_edge++;
}
}
28

- Java
//Struktura koja pretstavuva rebro vo grafot
public class Edge{
private int fromVertex, toVertex;
private float weight;
public Edge(int from, int to, float weight){
this.fromVertex = from;
this.toVertex = to;
this.weight = weight;
}

public int getFrom(){


return this.fromVertex;
}
public int getTo(){
return this.toVertex;
}
public float getWeight(){
return this.weight;
}
}
29

- Java
// Metoda koja generira niza od site rebra vo grafot
public Edge[] getAllEdges() {
int totalEdges = 0;
for (int i = 0; i < this.num_nodes; i++) {
// za sekoe teme go dodavame brojot na sosedi koi gi ima
totalEdges += this.adjList[i].getNeighbors().size();
}
Edge[] edges = new Edge[totalEdges];
int index = 0;
for (int i = 0; i < this.num_nodes; i++) {
for (int j = 0; j < this.adjList[i].getNeighbors().size(); j++) {
int index1 = this.adjList[i].getIndex();
// se zemaat indeksot i tezinata na j-ot sosed na temeto i
int index2 = this.adjList[i].getNeighbors().get(j).node
.getIndex();
float weight = this.adjList[i].getNeighbors().get(j).weight;
edges[index++] = new Edge(index1, index2, weight);
}
}
return edges;
}

30

- Java
// Metoda koja gi sortira site dadeni rebra
private void sortEdges(Edge[] edges) {
for (int i = 0; i < edges.length - 1; i++) {
for (int j = i + 1; j < edges.length; j++) {
if (edges[i].getWeight() > edges[j].getWeight()) {
Edge tmp = edges[i];
edges[i] = edges[j];
edges[j] = tmp;
}
}
}
}

31

- Java
List<Edge> kruskal() {
/*
* Niza koja vodi evidencija za drvata vo sumata
* Elementite od isto poddrvo imaat ista vrednost
* vo ovaa niza
*/
int vrski[] = new int[this.num_nodes];
// niza koja kje gi sodrzi site rebra
Edge[] edges = this.getAllEdges();
// se sortiraat rebrata spored tezinite vo neopagjacki redosled
this.sortEdges(edges);
// inicijalizacija na pomosnata niza za evidencija,
// sekoj jazel si e posebno drvo
for (int i = 0; i < this.num_nodes; i++)
vrski[i] = i;
// lista koja kje gi sodrzi MST rebra
List<Edge> mstEdges = new ArrayList<Edge>();
32

- Java
for(int i=0; i<edges.length; i++){
//za sekoe rebro vo sortiran redosled
Edge e = edges[i];
if(vrski[e.getFrom()] != vrski[e.getTo()]){
//ako teminjata na ova rebro ne se vo isto poddrvo
//ova rebro e MST rebro
mstEdges.add(e);
//sega dvete teminja treba da se vo isto poddrvo
//t.e se pravi merge (unija) t.s. vo nizata vrski
//za site elementi od dvete poddrva
//go setira istiot (najmal) element od dvete poddrva
this.union(e.getFrom(), e.getTo(), vrski);
}
}
return mstEdges;
}

33

- Java
//Metoda koja pravi unija na dve drva
private void union(int u, int v, int[] vrski){
int findWhat, replaceWith;
if(u < v){
findWhat = vrski[v];
replaceWith = vrski[u];
}
else{
findWhat = vrski[u];
replaceWith = vrski[v];
}
//za dvete poddrva stava ist index
//t.e. gi spojuva
for(int i=0; i<vrski.length; i++){
if(vrski[i] == findWhat){
vrski[i] = replaceWith;
}
}
}
34





.
,

.
,
.
( )



( ).

35

36

37

38

- C
typedef int info_t;
// struktura za reprezentacija na site vrski vo grafot
typedef struct granka
{
int vertex1, vertex2;
float tezina;
}branch;

// tezinski nasocen (i nenasocen) graf so pomos na niza od listi na sosednost


typedef struct element {
int index;
info_t info;
float tezina;
struct element *link;
} node;
typedef struct graphAdjList{
int num_nodes;
node *adjList[MAXVERTS];
} graph;

39

- C
/* funkcija koja naoga na vrska so najmala tezina megu jazel koj veke e vo
drvoto i jazel koj ne e vo drvoto. Vraka tezina na taa vrska. */
float mincena(const graph *g, int * vert1, int * vert2, const int *v)
{ // vert1 i vert2 se indeksite na jazlite povrzani so vrskata so minimalna cena
float minc = 0.0;
node *p; int i;
for (i = 0; i < g->num_nodes ; i++) {
p = g->adjList[i];
while (p){
if (v[i]!=v[p->index]) // eden od jazlite seuste ne e vo minimalnoto
// drvo
if (minc == 0.0) {
minc = p -> tezina;
*vert1 = i; *vert2 = p->index;
}
else if (minc > p -> tezina){
minc = p -> tezina;
*vert1 = i; *vert2 = p->index;
}
p=p->link;
}
}
return (minc);
40
}

- C
float prim(graph * g, branch *mintree, int poc) {
/* mintree - niza od strukturi-branch vo koja ke se cuvaat site vrski koi
vleguvaat vo sklop na minimalnoto drvo pretstavnik; poc - index na jazelot
od koj se pocnuva so gradenje na drvoto */
float cena=0; node *p;
int v1,v2,i, intree[MAXVERTS]={0}; /* niza vo koja se cuva evidencija za
toa koi jazli veke se dodadeni vo minimalnoto drvo pretstavnik */
/* azuriranje na pomosnata niza deka prviot jazel e dodaden vo drvoto */
intree[poc] = 1;
/* dodavanje na vrski vo drvoto se dodeka ne se povrzat site jazli */
for(i = 0; i < g->num_nodes - 1; i++) {
mintree[i].tezina = mincena(g, &v1, &v2, intree);
cena += mintree[i].tezina;
mintree[i].vertex1 = v1; mintree[i].vertex2 = v2; // sledna granka
intree[v1] = intree[v2] = 1;// jazlite koi gi povrzuva se vo drvoto
}
return (cena);
}

// vkupnata cena na minimalnoto drvo pretstavnik


41

- Java
List<Edge> prim(int start_index) {
// lista koja kje gi sodrzi MST rebra
List<Edge> mstEdges = new ArrayList<Edge>();
//niza koja oznacuva koe teme e vekje vkluceno
boolean included[] = new boolean[this.num_nodes];
for(int i=0;i<this.num_nodes;i++)
included[i]=false;

included[start_index] = true;
for(int i=0;i<this.num_nodes-1;i++){
Edge e = this.getMinimalEdge(included);
included[e.getFrom()] = included[e.getTo()] = true;
mstEdges.add(e);
}
return mstEdges;
}

42

- Java
private Edge getMinimalEdge(boolean[] included){
int index1 = Integer.MAX_VALUE, index2 = Integer.MAX_VALUE;
float minweight = Float.MAX_VALUE;
for(int i=0;i<this.num_nodes;i++){
if(included[i]){
//ako e vkluceno temeto izmini gi negovite sosedi
Iterator<GraphNodeNeighbor<E>> it =
adjList[i].getNeighbors().iterator();
while(it.hasNext()){
GraphNodeNeighbor<E> pom = it.next();
//ako sosedot ne e poseten i ima do sega najmala tezina
if(!included[pom.node.getIndex()] &&
pom.weight<minweight){
index1 = i;
index2 = pom.node.getIndex();
minweight = pom.weight;
}
}
}
}
43

- Java
if(minweight<Float.MAX_VALUE){
Edge ret = new Edge(index1, index2, minweight);
return ret;
}
return null;
}

44


.

(Dijkstra)
45



.

,

.

X Z
X Y
Y Z.


.
46

-
1. G=(V, E),
s,
0.

47

-
2. ,
x u, 5 10 .
s, x.
5.

48

-
3. ,
, x.
x u, v y, 8, 14 7
.

49

-
4. x, y,
7 . y
.

50

-
5.
, y.
y v 13. u
, 8 .

51

-
6. v .
u (u, v).

52

- C
typedef int info_t;
// tezinski nasocen graf so pomos na niza od listi na sosednost
typedef struct element {
int index;
info_t info;
float tezina;
struct element *link;
} node;
typedef struct graphAdjList{
int num_nodes;
node *adjList[MAXVERTS];
} graph;

53

- C
/* Presmetuva najkusa pateka od jazolot from do site jazli vo grafot spored
algoritmot na Djikstra */
/* vo dist se smesteni min ceni od pocetniot jazol do sekoj jazol vo grafot */
void dijkstra(const graph *g, float *dist, int from)
{
int i,k,j, minit;
float minc;
int final[MAXVERTS];
/* dali za jazolot e najdena konecnata (minimalna) cena */
node *p;
for(i=0; i<g->num_nodes; i++) {
/* site tezini ne se presmetani i ne se konecni */
dist[i]=-1;
final[i] = 0;
}
final[from]=1; /* jazolot od koj trgnuvame ima konecna cena */
dist[from]=0; /* i taa e nula */

54

- C
for(i=1; i<g->num_nodes; i++) {
/* vo sekoj cekor za eden jazel se dobiva konecna

minimalna cena */

/* za site sledbenici na from presmetaj ja cenata */


for(p = g->adjList[from];p; p=p->link) {
/* ako grankata kon jazolot nema konecna cena */
if(!final[p->index])
{
/* ako ne e presmetana cena za jazolot */
if(dist[p->index]<=0)
/* ova e negovata cena */
dist[p->index]=dist[from]+p->tezina;
/* inaku, ako e pronajdena poniska */
else if(dist[from]+p->tezina < dist[p->index])
/* azuriraj ja cenata */
dist[p->index]=dist[from]+p->tezina;
}
}

55

- C
/* najdi jazol so min. cena koja ne e konecna */
minit=0; /* min. ne e inicijaliziran */
for(j=0; j<g->num_nodes; j++) /* proveri gi site jazli */
if(!final[j] && dist[j] != -1) /* ako cenata ne e konecna */
if(!minit) /* ako ne e inicijaliziran minmumot */
{
/* proglasi go ova e minimum */
minc=dist[k=j];
/* oznaci deka min e inicijaliziran */
minit=1;
}
/* proveri dali e pronajden jazol so pomala cena */
else if(minc>dist[j] && dist[j]>=0)
minc=dist[k=j];
/* azuriraj go minimumot */
final[from=k]=1; /* jazolot so min. cena e sledniot od koj ke barame
vo sledniot ciklus i negovata cena stanuva konecna */
}
}

56

- Java
float[] dijkstra(int from) {
/* Minimalna cena do sekoe od teminjata*/
float distance[] = new float[this.num_nodes];
/* dali za temeto e najdena konecnata (minimalna) cena */
boolean finalno[] = new boolean[this.num_nodes];
for (int i = 0; i < this.num_nodes; i++) {
distance[i] = -1;
finalno[i] = false;
}
finalno[from] = true;
distance[from] = 0;

57

- Java
// vo sekoj cekor za edno teme se dobiva konecna minimalna cena
for (int i = 1; i < this.num_nodes; i++) {
/* za site sledbenici na from presmetaj ja cenata (ako ne e konecna) */
Iterator<GraphNodeNeighbor<E>> it =
adjList[from].getNeighbors().iterator();
while (it.hasNext()) {
GraphNodeNeighbor<E> pom = it.next();
/* ako grankata kon sosedot nema konecna cena */
if (!finalno[pom.node.getIndex()]) {
/* ako ne e presmetana cena za temeto*/
if (distance[pom.node.getIndex()] <= 0) {
distance[pom.node.getIndex()] = distance[from]
+ pom.weight;
}
/* inaku, ako e pronajdena poniska */
else if (distance[from] + pom.weight < distance[pom.node
.getIndex()]) {
distance[pom.node.getIndex()] = distance[from]
+ pom.weight;
}
}
}
58

- Java
/* najdi teme so min. cena koja ne e konecna */
boolean minit = false; /* min. ne e inicijaliziran */
int k = -1;
float minc = -1;
/* proveri gi site jazli */
for (int j = 0; j < this.num_nodes; j++) {
if (!finalno[j] && distance[j] != -1) {
/*ako cenata ne e konecna*/
if (!minit) {
/* ako ne e inicijaliziran minimumot */
minc = distance[k = j];
minit = true;
}
/* dali e pronajdeno teme so pomala cena */
else if (minc > distance[j] && distance[j] > 0)
minc = distance[k = j];
}
}
finalno[from = k] = true;
}
return distance;
}

59


:


?

60