GRAFER - Universitetet i oslo · INF1020 − Algoritmer og datastrukturer Forelesning 20.9.2004 Ark 1 av 30 GRAFER Dagens plan: Deﬁnisjon av en graf (kapittel 9.1) Grafvarianter

INF1020 − Algoritmer og datastrukturer

Forelesning 20.9.2004

Ark

1 a

v 30

GRAFER

Dagens plan:

• Definisjon av en graf (kapittel 9.1)

• Grafvarianter

• Intern representasjon av grafer(kapittel 9.1.1)

• Topologisk sortering (kapittel 9.2)

• Korteste vei, en-til-alle, for:

— uvektet graf (kapittel 9.3.1)— vektet rettet graf uten negative

kanter (kapittel 9.3.2)— vektet rettet graf med negative

kanter (kapittel 9.3.3)


Forelesning 20.9.2004 Ark 2 av 30

Det første grafteoretiskeproblem:Broene i Königsberg

Er det mulig å ta en spasertur somkrysser hver av broene nøyaktig engang?

Dette problemet ble løst av Eulerallerede i 1736!



Eksempler på grafproblemer

• Labyrint

• Rundreise 0 1

23

4

5

7

1510

9

12

11

8

3

14

• Trær A

B

D E F

I

G H

C



Hva er en graf?• En graf G = (V, E) består av en

mengde noder, V, og en mengdekanter, E

• |V| og |E| er henholdsvis antall noderog antall kanter i grafen

• Hver kant er et par av noder, dvs.(u, v) slik at u, v ∈ V

• En kant (u, v) modellerer at u errelatert til v

• Dersom nodeparet i kanten (u, v) erordnet (dvs. at rekkefølgen harbetydning), sier vi at grafen er rettet,i motsatt fall er den urettet

Urettet graf Rettet graf

• Grafer er den mest fleksibledatastrukturen vi kjenner (“alt” kanmodelleres ved hjelp av grafer)



Hvorfor grafer?• De dukker opp i veldig mange

problemer i hverdagslivet:— Flyplassystemer— Datanettverk— Trafikkflyt— Ruteplanlegging— VLSI (chip design)— og mange flere . . .

• Grafalgoritmer viser veldig godt hvorviktig valg av datastruktur er mhp.tidsforbruk

• Det finnes grunnleggendealgoritmeteknikker som løser mangeikke-trivielle problemer raskt

London

OsloTromsø

Kairo

Stockholm



Definisjoner og grafvarianter• Node y er nabo-node (eller etter-

følger) til node x dersom (x, y) ∈ E

x

yz

nabo-node til z

yz

x og y er naboer,y og z er naboer,men x og z er ikke naboer

z er nabo-node til y,men y er ikke

• En graf er vektet dersom hver kanthar en tredje komponent, kaltkostnad eller vekt

x

yz2 5

9En vektet, rettet graf

• En vei (eller sti) i en graf er ensekvens av noder v1, v2, v3, . . . , vn slikat (vi, vi+1) ∈ E for 1 ≤ i ≤ n− 1

• Lengden til veien er lik antall kanterpå veien, dvs. n− 1

x

yz

w

<z, w, x> er en veimed lengde 2



• Kostnaden til en vei er summene avvektene langs veien

w

y

xmed kost 7<z, w, x> er en vei

25

1 z

• En vei er enkel dersom alle nodene(untatt muligens første og siste)på veien er forskjellige

• Våre grafer har vanligvis ikke“loops”, (v, v), eller “multikanter”(to like kanter):

loop multikant vanlig rettet graf

• En løkke (sykel) i en rettet graf er envei med lengde ≥ 1 slik at v1 = vn.Løkken er enkel dersom stien erenkel

• I en urettet graf må også alle kanteri løkken være forskjellige

x

yz

w

<x, y, z, w, x> eren enkel løkke



• En rettet graf er asyklisk dersom denikke har noen løkker

• En rettet, asyklisk graf blir ofte kalten DAG (Directed, Acyclic Graf)

• En urettet graf er sammenhengendedersom det er en vei fra hver node tilalle andre noder

ikke sammen-sammenhengendehengende



• En rettet graf er sterkt sammen-hengende dersom det er en vei frahver node til alle andre noder

• En rettet graf er svakt sammen-hengende dersom den underliggendeurettede grafen er sammenhengende

sterkt sammen-hengende

svakt sammen-hengende

• Graden til en node i en urettet grafer antall kanter mot noden

• Inngraden til en node i en rettet grafer antall kanter inn til noden

• Utgraden til en node i en rettet grafer antall kanter ut fra noden.

Utgrad(v)=4Inngrad(v)=1

vGrad(v)=3

v



Hvordan representere grafer?

5

12

3

4

Nabo-matrise

1 2 3 4 5

2

3

4

5

1 0 1 1 1 0

0 0 0 1 1

0 0 0 0 0

0 0 0 01

0 0 0 01

• Bra hvis “tett” graf, dvs. |E| = θ(|V|2)

• Tar O(|V|) tid å finne alle naboer



5

12

3

4

Nabo-liste

5

4

3

2

1 2 3 4

4 5

3

4

• Bra hvis “tynn” graf

• Tar O(Utgrad(v)) tid å finne allenaboer til v

• De fleste grafer i det virkelige liv ertynne!



Objekter & array

3

12

54

• I Java kan grafer også representeresved en kombinasjon av node-objekterog etterfølgerarrayer

• Arraylengden kan være en parameter tilnode-klassen:

class Node {int antEtterf;Node[ ] etterf; Float[ ] vekt;

Node(int ant) {etterf = new Node[ant]; vekt = new Float[ant];antEtterf = ant;

}}

• Må da vite antall etterfølgere når vigenererer noden

• Eventuelt kan vi estimere en øvre grenseog la siste del av arrayen være tom

• Vi trenger da en variabel som sier hvormange etterfølgere en node faktisk har



Topologisk sortering• En topologisk sortering er en

ordning (rekkefølge) av noder i enDAG slik at dersom det finnes en veifra vi til vj, så kommer vj etter vi iordningen

• Topologisk sortering er umulig hvisgrafen har en løkke

• Vanligvis er det flere muligeløsninger

Eksempel: forutsetter/bygger på graf

MA100/MA001

INF103

INF102

INF110

IN210MA-IN118

INF111

INF310

IN394

INF212

IN211

INF101

En liten del avIfi’s kursplan

MA008

• En topologisk sortering er en “lovlig”rekkefølge å ta alle kursene på Ifi i



Følgende enkle algoritme finner entopologisk sortering (dersom det ernoen):

1. Finn en node med inngrad = 0

2. Skriv ut noden, og fjern noden ogutkantene fra grafen (marker nodensom “ferdig” og reduser inngraden tilnabonodene)

3. Gå tilbake til punkt 1

Eksempel (figur 9.4):

2V

5V

7

V3

V1

V4

V6 V



MAW side 295, figur 9.5:

void topsort() {Node v;

for (int teller = 0; teller < ANTALL_NODER; teller++) {v = finnNyNodeMedInngradNull();

if (v == null) {error("Løkke funnet!");

} else {< Skriv ut v som node teller >for < hver nabo w til v > {

w.inngrad--;}

}}

}

• Denne algoritmen er O(|V|2) sidenfinnNyNodeMedInngradNull sergjennom hele node/inngrad-tabellenhver gang

• Dette er unødvendig mye, siden barenoen få av verdiene kommer ned til0 hver gang



En forbedring er å holde alle nodermed inngrad=0 i en boks.

Boksen kan implementeres som enstakk eller en kø:

1. Plasser alle nodene med inngrad=0 iboksen.

2. Ta ut en node v fra boksen.

3. Skriv ut v.

4. (Fjern v fra grafen og) redusererinngraden til alle etterfølgerne.

5. Dersom noen av etterfølgerne fårinngrad=0, settes de inn i boksen.

6. Gå tilbake til punkt 2.




void topsort() {Kø k = new Kø();Node v;

for < hver node v > {if (v.inngrad == 0) {

k.settInn(v);}

}

while (!k.isEmpty()) {v = k.taUt();< Skriv ut v >

for < hver nabo w til v > {w.inngrad--;if (w.inngrad == 0) {

k.settInn(w);}

}}

}

• Forutsatt at vi bruker nabolister, erdenne algoritmen O(|E|+ |V|).Kø/stakk-operasjoner tar konstanttid, og hver kant og hver node blirbare behandlet én gang.



Korteste vei, en-til-alle

x

yz2 5

9

• Korteste vei fra z til x uten vekt er 1.

• Korteste vei fra z til x med vekt er 7(via y).

I KORTESTE VEI problemet (en-til-alle)har vi gitt en (vektet) graf G=(V,E) ogen node s.

Vi ønsker å finne den korteste veien(med vekter) fra s til alle andre noder iG.

(Vi skal senere se på korteste veialle-til-alle, slik som f.eks. i NAF sveibok)

• Negative vekter (kost) i løkker kanskape problemer:

y

xz

5

5-12

vei fra x til z?Hvor mye koster korteste



Korteste vei i en uvektet graf

• Korteste vei fra s til t i en uvektetgraf er lik veien som bruker færrestantall kanter (tilsvarer at alle kanterhar vekt=1)

V3

V1

V4

V6 V

V2

7

V5



Følgende bredde-først algoritme løserproblemet:

1. Marker at lengden fra s til s er lik 0.

2. Se etter noder som er på avstand 1fra s ved å finne etterfølgere til s, ogsom ikke har fått markert noendistanse. Marker disse.

3. Se etter noder som er på avstand 2fra s ved å finne etterfølgerne tilnodene som er på distanse 1, ogsom ikke har fått markert noendistanse. Marker disse.

4. Se etter noder som er på avstand 3fra s ved å finne etterfølgerne tilnodene som er på distanse 2, ogsom ikke har fått markert noendistanse. Marker disse.

5. Forsett inntil alle noder er markert,eller vi har kommet til distanse lik|V| − 1.



Vi kan finne den korteste veien ved åsette bakoverpekere til den noden som«oppdaget» oss.

MAW side302, figur 9.16

void uvektet(Node s) {s.avstand = 0;

for (dist = 0; dist < ANTALL_NODER; dist++) {for < hver node v > {

if (!v.kjent && v.avstand = dist) {v.kjent = true;for < hver nabo w til v > {

if (w.avstand = UENDELIG) {w.avstand = dist + 1;w.vei = v;

}}

}}

}

}

Tidsforbruk: O(|V|2).



• Spar tid ved å plassere etterfølgernetil noden vi behandler i en kø

• Ta alltid ut første node i køen ogbehandle denne

• Det gjør at alle noder i avstand 1blir behandlet før alle i avstand 2,som igjen blir behandlet før alle iavstand 3 . . .

• Denne strategien ligner påbredde-først traversering av trær(først rotnoden, så alle noder på nivå1, så alle noder på nivå 2, osv.)

• Tidsforbruket blir O(|E|+ |V|) fordikøoperasjoner tar konstant tid oghver kant og hver node bare blirbehandlet én gang

• En implementasjon av algoritmen iJava følger på neste lysark



Bredde-først algoritme:


void uvektet(Node s) {Kø k = new Kø;Node v;

k.settInn(s);s.avstand = 0;

while (!k.isEmpty()) {v = k.taUt();v.kjent = true; // Egentlig ikke nødvendig!

for < hver nabo w til v > {if (w.avstand = UENDELIG) {

w.avstand = v.avstand + 1;w.vei = v;k.settInn(w);

}}

}}



V3

V1

V4

V6 V

V2

7

V5

1

v vei

2

3

4

5

6

7

kjent avstand



Korteste vei i en vektet grafuten negative kanter

• Graf uten vekter:— Velger først alle nodene med

avstand 1 fra startnoden, så allemed avstand 2 osv

— Mer generelt: Velger hele tiden enukjent node blant dem med minstavstand fra startnoden

• Den samme hovedidéen kan brukeshvis vi har en graf med vekter

• Akkurat som for uvektede grafer, servi bare etter potensielle forbedringerfor naboer som enda ikke er valgt(kjent)

Vi får da en algoritme kjent somDijkstras algoritme



Dijkstras algoritme

1. Sett avstanden fra startnoden s tilseg selv lik 0

2. Velg ukjent node v med minstavstand, og marker v som «kjent»

3. For hver ukjent nabonode w til v:

Dersom avstanden vi får ved å følgeveien gjennom v, er kortere enn dengamle avstanden til s

• reduserer avstanden til s for w

• sett bakoverpekeren i w til v

4. Så lenge det finnes ukjente noder,gå til punkt 2



Eksempel

V 2V

5V

7V6V

4V

1

V3

6

v7

veikjent

0

0v

0

00

0

88

0

0

8

avstandv

8

5v4v3v2v1v

F

8

F

F

F

F

F

F

Initielt:

8

4

5

2

8

1

4 6

2

31

2

10

v1

v2

v3

v4

v5

v6

v7

veikjent avstandv



Hvorfor virker algoritmen?

• Algoritmen har følgende invariant:Ingen ukjente noder har mindreavstand enn noen kjente nodene

• Det medfører at alle kjente noder harriktig korteste vei satt (avstanden erfaktisk den korteste avstanden)

• Vi plukker ut en ukjent node v medminst avstand (dv), markerer densom kjent og påstår at avstanden tilv er riktig

• Denne påstanden holder fordi— dv er den korteste veien som finnes

ved å bruke bare kjente noder— de kjente nodene har riktig

korteste vei satt— en vei til v som er kortere enn dv,

må nødvendigvis forlate mengdenav kjente noder et sted,men dv er allerede den kortesteveien fra kjente noder til v

• Dette argumentet holder fordi viikke har negative kanter



Tidsforbruk

• Hvis vi leter sekvensielt etter denukjente noden med minst avstandtar dette O(|V|) tid, noe som gjøres|V| ganger, så total tid for å finneminste avstand blir O(|V|2)

• I tillegg oppdateres avstandene,maksimalt en oppdatering per kant,dvs. til sammen O(|E|)

• Total tid: O(|E|+ |V|2) = O(|V|2)

Raskere implementasjon(for tynne grafer):

• Bruker en prioritetskø til å ta varepå ukjente noder med avstandmindre enn ∞• Vi må ta hensyn til at prioriteten til

en ukjent node forandres hvis vifinner en kortere vei til noden

• DeleteMin og DecreaseKey tarO(log |V|) tid

• Totalt tidsforbruk blirO(|V| log |V|+ |E| log |V|) = O(|E| log |V|)



Hva med negative kanter?

• Dersom den vektede grafen harnegative kanter, fungerer ikkeDijkstras algoritme(se oppgave 9.7a)

• En mulig løsning:— Nodene er ikke lenger «kjente»

eller «ukjente»— Vi har i stedet en kø som

inneholder noder som har fåttforbedret avstandsverdien sin

— Løkken i algoritmen gjør følgende:∗ Ta ut en node v fra køen∗ For hver etterfølger w, sjekk om

vi får en forbedring∗Oppdater i så fall avstanden,

og plasser w i køen(hvis den ikke er der allerede)

• Tidsforbruket blir O(|E| · |V|) som ermye verre enn Dijkstras algoritme

• Algoritmen fungerer ikke hvis det ernegative løkker

Documents

GRAFER - Universitetet i oslo · INF1020 − Algoritmer og datastrukturer Forelesning 20.9.2004 Ark 1 av 30 GRAFER Dagens plan: Deﬁnisjon av en graf (kapittel 9.1) Grafvarianter