Neumann János Tehetséggondozó Program Gráfalgoritmusok I.

Átírás

1 Neumann János Tehetséggondozó Program Gráfalgoritmusok I. Horváth Gyula A mindennapi életben számos olyan algoritmikus problémával találkozhatunk, amelynek a megoldása megoldaható gráf modellben. Az ilyen problémák esetén az adatok jellemző tulajdonsága, hogy az adathalmaz elemei között kapcsolatok vannak. Ezek a kapcsolatok fejezhetők ki a gráf matematikai fogalmával. A matematikai gráf fogalom azonban csak alap modell a problémát megoldó algoritmushoz. Lényeges eltérés a matematikai gráf fogalomtól, hogy az algoritmushoz a gráfot alkalmas adatszerkezetben tárolni kell, és műveleteket kell tudni végezni (hatékonyan) a gráfokon.

2 . Definíciók.. definíció. Irányított gráf G = (V, E) V : a gráf pontjainak halmaza E a gráf éleinek halmaza, rendezett (a,b) párok halmaza; E V V = {(a,b) : a V,b V }. 8. ábra. Irányított gráf. V = {,...,8}, E = {(,),(,),(,),(,),(,),(,),(,),(,),(,),(8,),(8,)}

3 .. definíció. Irányítatlan gráf G = (V, E) V : a gráf pontjainak halmaza E: az élek halmaza, rendezetlen {a,b},a,b V párok halmaza. 8. ábra. Irányítatlan gráf. V = {,...,8}, E = {{,},{,},{,},{,},{,},{,},{,},{,},{,},{8,},{8,}}

4 .. definíció. Irányított multigráf G = (V, E, Ind, Érk) Ind,Érk : E V az élek végpontjait megadó függvények Ind(e) az e él induló, Érk(e) az érkező pontja. 8. ábra. Irányított multigráf

5 .. definíció. Irányított multigráf G = (V, E) V : a gráf pontjainak halmaza E a gráf éleinek halmaza, rendezett (a,b) párok multihalmaza; E V V = {(a,b) : a V,b V }. 8. ábra. Irányított multigráf. V = {,...,8}, E = {(,),(,),(,),(,),(,),(,),(,),(,),(,),(,),(,),(8,),(8,)(,)}

6 .. definíció. Irányítatlan multigráf G = (V, E, Ind, Érk) Ind,Érk : E V az élek végpontjait megadó függvények Ind(e) az e él induló, Érk(e) az érkező pontja. 8. ábra. Irányítatlan multigráf. V = {,...,8}, E = {{,},{,},{,},{,},{,},{,},{,},{,},{,},{,},{,},{8,},{8,}}

7 .. definíció. Címkézett (súlyozott) irányított gráf G = (V, E,C) (V, E) (irányított/irányítatlan) gráf. C : E Címke súlyfüggvény Másképpen: E V V C = {(a,b,c) : a V,b V,c C} ábra. Súlyozott irányított gráf. V = {,...,8}, E = {(,,),(,,),(,,),(,,),(,,),(,,),(,,),(,,0),(,,),(8,,),(8,,8)

8 .. definíció. Címkézett (súlyozott) irányítatlan gráf G = (V, E,C) (V, E) (irányítatlan) gráf C : E Címke súly függvény ábra. Súlyozott irányítatalan gráf. V = {,...,8}, E = {({,},),({,},),({,},),({,},),({,},),({,},),({,},),({,},0),({,

9 Minden irányítatlan G = (V, E) gráf olyan irányított gráfnak tekinthető, amelyre teljesül, hogy ( p,q V )((p,q) E (q, p) E). Jelölések KiEl(G, p) = {q V : (p,q) E} : a kipontok halmaza, azaz minden olyan q pont, amelyre van p q él a G gráfban. BeEl(G, p) = {q V : (q, p) E} : a bepontok halmaza, azaz minden olyan q pont, amelyre van q p él a G gráfban. KiFok(G, p) = KiEl(G, p) : a kipontok száma BeFok(G, p) = BeEl(G, p) : a bepontok száma

10 .. Műveletek gráfokon A továbbiakban feltételezzük, hogy a gráf pontjait természetes számokkal azonosítjuk, pontosabban V = {,...,n} Milyen műveleteket akarunk gráfokon végezni? Pontokszáma Elekszáma KiFok(p) BeFok(p) PontBővít(p) PontTöröl(p) ÉlBővít(p, q) ÉlTöröl(p, q) VanÉl(p, q) for q in KiÉl(p) do M(p,q) //p-ből kinduló élek bejárása

11 . Gráfok ábrázolásai Szempontok az adatszerkezet megválasztásához.. Az adott probléma megoldásához ténylegesen mely műveletek szükségesek.. Melyek a releváns műveletek, amelyek alapvetően befolyásolják az algoritmus futási idejét.. A tárigény az adott probléma esetén.

12 8 8. ábra. Példa gráf Minden gráf megadható olyan hozzárendeléssel (függvénnyel), amely minden p ponthoz megadja a KiEl(p) halmazt. Multigráf esetén KiEl(p) multihalmaz. {, } {} {, } {} {, } {} {} 8 {, }

13 Tehát egy G = (V,E) gráf, ahol a gráf pontjainak halmaza V = {,...,n} megadható olyan tömb típussal, amelynek elemei halmazok. Pascal: const maxp=000; / / { a pontok max. száma} type Graf=array [.. maxp] of Halmaz ; C/C++: # define maxp 000 typedef Halmaz Graf [maxp ] ;

14 .. Szöveges ábrázolás Élek felsorolásával: Az állomány első sora két egész számot tartalmaz, a pontok n számát és az élek m számát. A további n sor mindegyike egy a b számpárt tartalmaz ( a,b n), a gráf egy élét. Kipontok soronkénti felsorolásával: Az állomány első sora egy egész számot tartalmaz, a pontok n számát. A további n sor tartalmazza az éleket. Az p + -edik sorban a KiEl(p) halmaz elemeit vannak felsorolva, a felsorolást a 0 zárja

15 .. Éltömb typedef i n t Cimketip ; / / { a súlyok típusa } typedef struct El { i n t ind, erk ; } El ; typedef El Graf [maxp ] ; typedef struct SEl { i n t ind, erk ; 8 Cimketip suly ; 9 } SEl ; 0 typedef SEl SGraf [maxp ] ; ind érk ábra. A példa gráf éltömb ábrázolása Pascal: type Cimketip=integer ; / / { a súlyok típusa } Graf=array [.. maxp] of record ind, erk :..maxp end ; SGraf=array [.. maxp] of record ind, erk :.. maxp, suly : Cimketip end ; C++:

16 Ez az ábrázolás nem támogatja a leggyakoribb műveletek hatékony megvalósítását, ezért csak a teljesség kedvéért említjük meg. Előfordulhat, hogy közbülső ábrázolásként használjuk; először a beolvasásákor ilyen ábrázolást állítunk elő, és ebből építünk fel hatékonyabb adatszerkezetet.

17 .. Kapcsolatmátrix (szomszédsági mátrix) Pascal: 0. ábra. Példa gráf. ábra. Kapcsolatmátrix type Graf=array [.. maxp,..maxp] of boolean ; SGraf=array [.. maxp,..maxp] of integer ; var G: Graf ; C++: typedef bool Graf [maxp ] [maxp ] ; typedef i n t SGraf [maxp ] [maxp ] ; Graf G;

18 A (p,q) pontpár akkor és csak akkor éle a gráfnak, ha G[p,q] = true. Tehát a vanél művelet hatékonyan megvalósítható (konstans idejű). Címkézett gráf esetén választani kell egy nem Cimke értéket, amely nem fordul elő semmilyen él címkéjeként. (p,q) akkor és csak akkor éle a címkézett gráfnak, ha G[p,q]! = nem, és a (p,q) él címkéjének értéke G[p, q]. A KiEl(p) kipontok bejárása nem hatékony, nem az elemszámmal arányos. Pascal: for q= to n do i f G[ p, q ] then M( p, q ) ; C++: for ( i n t q=;q<=n ; q++) i f (G[ p ] [ q ] ) M( p, q ) ; A tárigény n pontú gráf esetén n, ezért nagyméretű, (de kevés élet tartalmazó) gráf esetén nem alkalmazható.

19 .. Élhalmaz-tömb 8 G 8 8 KiFok 0 Pascal:. ábra. Példa gráf. ábra. Élhalmaz-tömb type Graf=array [.. maxp,..maxp] of 0..maxP; var G: Graf ; KiFok : array [.. maxp] of integer ; C++: typedef i n t Graf [maxp ] [maxp ] ; Graf G; i n t KiFok [maxp+];

20 A tárigény, csakúgy, mint a szomszédsági mátrixnál, n pontú gráf esetén n, ezért nagyméretű, (de kevés élet tartalmazó) gráf esetén nem alkalmazható. A KiEl(p) kipontok bejárása hatékony, az elemszámmal arányos. Pascal: for i = to KiFok [ p ] do M( p,g[ p, i ] ) ; C++: for ( i n t i =; i <=KiFok [ p ] ; i ++) M( p,g[ p ] [ i ] ) ; A vanél művelet persze nem konstans idejű lesz: Pascal: i :=; while ( i <=KiFok [ p ] and G[ p, i ]<>q ) do i := i +; vanel := i <=KiFok [ p ] ; C++: i =; while ( i <=KiFok [ p ] && G[ p ] [ i ]! = q ) i ++; vanel=i <=KiFok [ p ] ;

21 .. Élvégpontok felsorolása 8 KiFok 0 Kezd ábra. Példa gráf Elek ábra. Élhalmaz-lánc Pascal: const maxp=000; maxe=00000; var KiFok : array [.. maxp] of integer ; Kezd : array [.. maxp] of integer ; Elek : array [.. maxe] of integer ;

22 KiEl(G, p) bejárása Pascal: t o l :=Kezd [ p] for i := to KiFok [ p ] do begin q:= Elek [ t o l + i ] ; / /M( p, q ) / / { a p >q él feldolgozása } end ; C++: # define maxp 000 # define maxe i n t Kezd [maxp] ; i n t KiFok [maxp] ; i n t Elek [maxe] ; / / KiEl (G, p ) bejárása i n t t o l =Kezd [ p ] ; 8 for ( i n t i =0; i <KiFok [ p ] ; i ++){ 9 i n t q=elek [ t o l + i ] ; 0 / /M( ) ; / / a p >q él feldolgozása }

23 .. Élhalmaz-lánc G 8 8. ábra. Példa gráf. ábra. Élhalmaz-lánc

24 ... Statikus élhalmaz-lánc Pascal: const maxp=000; / / { a pontok max száma} maxe=00000; / / { az élek max. száma} type Lanc=longint ; Cella=record pont : longint ; csat : Lanc end ; Graf=array [.. maxp] of Lanc ; 8 var 9 G: Graf ; 0 Elek : array [.. maxe] of Cella ; n : longint ; / / a pontok száma m: longint ; / / az élek száma

25 / / Beolvasás és az adatszerkezet f e l é p í t é s e szabad, i, p, q, pql : longint ; readln ( n,m) ; szabad :=; for i := to n do G[ i ] : = 0 ; 8 for i := to m do begin 9 readln ( p, q ) ; / / { egy él beolvasása } 0 Elek [ szabad ]. pont :=q ; / / { becsatolás a láncba } Elek [ szabad ]. csat :=G[ p ] ; G[ p ] : = szabad ; inc ( szabad ) ; end ; KiEl(G, p) bejárása pql :=G[ p ] ; while pql <>0 do begin q:= Elek [ pql ]. pont ; / /M( p, q ) ; / / { az él feldolgozása } pql := Elek [ pql ]. csat ; end ;

26 C++: typedef i n t Lanc ; typedef struct { i n t pont ; Lanc csat ; } Cella ; typedef Lanc Graf [maxp ] ; typedef Cella Elek [maxe ] ; Graf G; Elek El ; / / Beolvasás és az adatszerkezet f e l é p í t é s e i n t p, q, szabad=0, pql ; 8 cin >>n>>m; 9 for ( i n t i =; i <=n ; i ++) G[ i ]=0; 0 for ( i n t i =; i <=m; i ++){ cin >>p>>q ; Elek [ szabad ]. pont=q ; / / { becsatolás a láncba } Elek [ szabad ]. csat=g[ p ] ; G[ p]=szabad++; } KiEl(G, p) bejárása Lanc pql=g[ p ] ; while ( pql! = 0 ) { q=el [ pql ]. pont ; / /M( p, q ) ; / / { a p >q él feldolgozása } pql=el [ pql ]. csat ; }

27 ... Dinamikus élhalmaz-lánc Pascal: const maxp=000; type Lanc=^Cella ; Cella=record pont. integer ; csat : Lanc end ; Graf=array [.. naxp ] of Lanc ; var 8 G: Graf ; 9 n,m: longint ; 0 pql : Lanc ; readln ( n,m) ; for i := to n do G[ i ] : = N i l ; for i := to m do begin readln ( p, q ) ; / / { egy él beolvasása } new( pql ) ; / / { új c e l l a l é t e s í t é s e } pql ^. pont :=q ; pql ^. csat :=G[ p ] ; / / { az új c e l l a becsatolás a láncba } 8 G[ p ] : = pql ; 9 end ;

28 KiEl(G, p) bejárása pql :=G[ p ] ; while pql <> N i l do begin q:= pql ^. pont ; / /M( p, q ) ; / / { a p >q él feldolgozása } pql := pql ^. csat ; end ;

29 .. Számított gráf Az élek halmazát explicite nem tároljuk, mert van olyan számítási eljárás, amely bármely két p, q V - re kiszámítja VanEl(p, q)-t. Vagy, van olyan számítási eljárás, amely minden p V -re kigenerálja a KiEl(G, p) halmaz elemeit. Például, ha egy n m-es négyzetrácsos hálózat mezőin lépkedhetünk, egy lépésben a szomszédos mezőre; fel, le, jobbra és balra. Tekincsük azt a G = (V,E) gráfot, amelynek pontjai a hálózat mezői, azaz V = {(x,y) : x n, y m}, tehát a pontokat a koordinátáikkal azonosítjuk. Ekkor (x,y) (u,v) akkor és csak akkor él a gráfban, ha x u + y v =

30 . Feladat: Terv Egy nagyszabású építkezés terve n különböző munka elvégzését írja elő. Minden munkát egy nap alatt lehet elvégezni. Egy napon több munkát is el lehet végezni párhuzamosan, feltéve, hogy a megelőzési feltételt betartjuk. Ez ezt jelenti, hogy vannak olyan előírások, hogy egy adott a munka elvégzése meg kell, hogy előzze más adott b munka elégzését. Tehát a b munkát csak akkor lehet elkezdeni, ha már az a munkát befejeztük. Kiszámítandó, hogy a teljes építkezést legkevesebb hány nap alatt lehet befejezni! Bemenet A standard bemenet első sora két egész számot tartalmaz, az elvégzendő munkák n számát ( n 0000), és a megelőzési előírások m számát (0 m 00000). Kimenet A standard kimenet első sora az összes munka elvégzéséhez szükséges napok k számát tartalmazza. Ha a megelőzési előírások miatt nem lehet elvégezni az összes munkát, akkor az első ás egyetlen sorba a 0 számot kell írni. A további k sor mindegyike egy napon elvégzendő munkák sorszámait tartalmazza egy-egy szóközzel elválasztva. Több megoldás esetén bármelyik megadható.

31 Példa bemenet és kimenet bemenet kimenet 8 0 9

32 ábra. A példa bemenet ábrája. A gráf pontjai az elvégzendő munkák, p q akkor és csak akkor él a gráfban, ha a p munkának meg kell előznie a q munkát.

33 Megoldás

34 Megoldás nap

35 Megoldás nap. nap

36 Megoldás nap. nap. nap

37 Megoldás nap. nap. nap. nap

38 Megoldás nap. nap. nap. nap. nap

39 Elvi algoritmus. Legyen G = (V,E) az a gráf, amelynek pontjai a munkák és élei a megelőzési feltételek. H() := {v V : BeFok(v) = 0}; {az első napi munkák } nap = while (H(nap) /0) and (V /0 )do begin KiIr(H(nap)); V := V H(nap) ; töröljük az E élekből minden olyan p q élet, amelyre p H(nap); nap = nap + ; H(nap) := {v V : BeFok(v) = 0}; end Akkor és csak akkor van megoldás, ha a megelőzési feltétel nem tartalmaz kört. Hogyan deríthető ez ki a fenti algoritmus során? Ha van kör, akkor a fenti algoritmusban az ismétlés úgy ér véget, hogy H(nap) = /0 de V /0. Fordítva is igaz, tehát ha az ismétlés úgy ér véget, hogy utána V /0, akkor van kör, mert nincs 0-befokú pont a megmaradtak között. Tehát elég megszámolni, hogy hány pont kerül bele az H halmazokba. A megelőzési előírások (gráfjának) ábrázolása. Milyen műveleteket kell végezni? Adott u-ra (hatékonyan) meg kell tudni adni mindazon v-ket, amelyeket u megelőz. Jelölje ezek halmazát KiEl(u). Vegyünk egy G tömböt, amelynek G[u] eleme olyan lánc fejére mutat, amely lánc a KiEl(u) halmaz elemeit tartalmazza.

40 G ábra. A példa megelőzési előírásainak ábrázolása láncokban.

41 Megvalósítás program Terv ; const maxp=0000; / / { a pontok max száma} maxe=00000; / / { az élek max. száma} type Pont =..maxp; Lanc=longint ; 8 Cella=record pont : longint ; csat : Lanc end ; 9 Graf=array [.. maxp] of Lanc ; 0 var N,M: longint ; G: Graf ; Elek : array [.. maxe] of Cella ; H: array [.. maxp] of 0..maxP; BeFok: array [.. maxp] of 0..maxP; Nap: longint ;.nap.nap.nap H eleje vége 0. ábra. A H halmazok ábrázolása

42 procedure Beolvas ; 8 / / Globalis : G, Elek, Befok 9 var 0 i, p, q : longint ; szabad : Lanc ; begin ReadLn(N, M) ; f o r p:= to N do begin G[ p ] : = 0 ; Befok [ p ] : = 0 ; end ; 8 szabad :=; 9 for i := to M do begin 0 Readln ( p, q ) ; readln ( p, q ) ; / / { egy él beolvasása } Elek [ szabad ]. pont :=q ; / / { becsatolás a láncba } Elek [ szabad ]. csat :=G[ p ] ; G[ p ] : = szabad ; inc ( szabad ) ; end{ for i } ; end{ Beolvas } ;

43 8 procedure K i I r ; 9 var i, ind : longint ; 0 begin WriteLn (Nap ) ; ind :=; for i := to Nap do begin repeat Write (H[ ind ], ) ; Inc ( ind ) u n t i l H[ ind ]=0; 8 Inc ( ind ) ; 9 WriteLn ( ) ; 0 end{ for i } ; end{ K i I r } ;

44 procedure Szamit ; var i, eleje, vege, p, q : longint ; El : Lanc ; begin Nap:=0; vege :=0; 8 f o r i := to N do { a 0 megelőzöjüek halmazának kiszámítása } 9 i f Befok [ i ]=0 then begin 0 Inc ( vege ) ; H[ vege ] : = i ; end ; Inc ( vege ) ; H[ vege ] : = 0 ; e l e j e :=;

45 while True do begin Inc (Nap ) ; 8 while H[ e l e j e ]<>0 do begin 9 p:=h[ e l e j e ] ; 0 Inc ( e l e j e ) ; El :=G[ p ] ; while El <>0 do begin { a p >q élek feldolgozása } q:= Elek [ El ]. pont ; El := Elek [ El ]. csat ; { továbblépés a láncban } Dec(BeFok[q ] ) ; i f BeFok[q]=0 then begin {q f e l v é t e l e az akt. napra } Inc ( vege ) ; 8 H[ vege ] : = q ; 9 end ; 0 end{ while El } ; end{ while e l e j e } ; i f vege= e l e j e then Break ; Inc ( vege ) ; H[ vege ] : = 0 ; Inc ( e l e j e ) ; end{ while } ; end{ Szamit } ;

46 8 begin {Program} 9 Beolvas ; 0 Szamit ; K i I r ; end.

47 .. Feladat: Kiút keresés labirintusban. Egy négyzetrácsos hálózattal leírható labirintusban adott start helyről adott cél helyre kell eljutni a lehető legrövidebb úton. A labirintusban minden mező vagy fal, vagy közlekedésre használható folyosó egy része. Egy lépésben szomszédos mezőre léphetünk, balra, jobbra, felfelé vagy lefelé ábra.

48

49

50

51

52

53

54

55

56

57 Megoldás Modell: Tfh. a labirintus sorainak száma n, oszlopainak száma m. Tekintsük azt a G = (V,E) gráfot, ahol V = {(x,y) : x n y m (x,y)nem fal} (x,y) (x,y) E akkor és csak akkor, ha x x + y y = valamint (x,y) és (x,y) nem fal. Vagyis az (x, y) mezőről egyetlen lépéssel juthatunk az (x, y) mezőre. Tehát a feladat nem más, mint egy (Xk,Y k) (Xc,Xc) legrövidebb út keresése, ha a start mező (Xk,Y k) a célmező pedig (Xc, Xc). A feladat tehát megoldható szélességi bejárással, a labirintus gráf számított-gráf árázolását használva. (x,y) (,0) (x,y ) (x,y) (x,y+) (0, ) (0,) (x+,y) (,0). ábra. A lehetséges lépések

58 .. Elemi gráfproblémák... Utak Legyen G = (V, E) irányított (irányítatlan) gráf... definíció. p,q V -re egy p-ből q-ba vezető út G-ben, jele: π : p q, olyan π = p 0, p,, p k pontsorozat, ahol p i p j, ha i j, p = p 0 és q = p k, továbbá p = q = p 0, vagy ( i {,...,k}) ((p i, p i ) E)... definíció. A π = p q út hossza, π = p q = k (az utat alkotó élek száma).. definíció. p-ből q-ba vezető legrövidebb út hossza, p és q távolsága: { ha nincs p q δ(p,q) = Min{ π : p q } π : p q ().. definíció. A π = p 0, p,, p k pontsorozatot a p 0 -ból p k -ba vezető sétának nevezzük, ha ( i {,...,k})(p i, p i ) E.. definíció. Ha G = (V,E,C) élei a C : E R függvénnyel súlyozottak, akkor a p q út hossza p q = k i= C(p i, p i ).

59 A p és q pont távolsága: { ha nincs p q δ(p,q) = Min{ π : p q } π : p q ().. definíció. A G = (V, E) (irányítatlan) gráfnak az F = (V, E) gráf a r V gyökerű feszítőfája, ha. F részgráfja G-nek (V V,E E,) és fa.. ( p V ) ha van r p G-ben, akkor és csak akkor, ha van r p F-ben... definíció. A G = (V,E) (irányítatlan, súlyozott) gráfnak az F = (V,E) gráf a r V gyökerű legrövidebb utak feszítőfája (LUF), ha. F r-gyökerű feszítőfája G-nek, és. p V -ra δ G (r, p) = δ F (r, p).

60 ... Útproblémák Vaneút?. Adott p,q V -re van-e p q út? Elérhető pontok. Adott p-re az Elr(p) = {q : p q} halmaz kiszámítása. Két pont közötti legrövidebb út. Adott p,q V -re δ(p,q) és egy p q legrövidebb út kiszámítása. Egy ponttból induló legrövidebb utak. Adott p-re minden q-ra δ(p,q) és egy p q legrövidebb út kiszámítása. Legrövidebb utak minden pontpárra. Minden p,q pontpárra δ(p,q) és egy p q legrövidebb út kiszámítása.

61 . Szélességi bejárás Bemenet: G = (V,E) (irányított vagy irányítatlan) gráf és egy r V pont. Kiszámítandó minden p pontra az r-ből p-be vezető legrövidebb út hossza, és legrövidebb út. Kimenet: D : V N, Apa : V V, hogy D(p) = δ(r, p) és az F = (V,E) gráf, ahol V = {p : Apa(p) null p = r}, E = {(p,q) : Apa(q) = p p null} Az F gráf a G gráf r-gyökerű legrövidebb utak feszítőfája (LUF)... Elvi algoritmus Legyen G = (V, E) terszőleges irányított, vagy irányítatlan gráf. Jelölje S(t) azon p pontok halmazát, amelyek t távolsára vannak r-től. S(t) = {p V : δ(r, p) = t} Nyilvánvaló, hogy S(0) = {r}. Jelölés: D(p) = δ(r, p) Nyilvánvaló, hogy minden t > 0-ra és minden q S(t) van olyan p S(t ), hogy (p,q) E Fordítva, ha p S(t ) és (p,q) E, akkor D(q) t +, hiszen van t + hosszú út r-ből q-ba, mert van t hosszú (legrövidebb) út r-ből p-be és van él p-ből q-ba: r p q. Tehát az S(t) halmaz előállítható az S(t ) halmazból.

62 In f := V ; //pontok száma for p V do D(p) := In f ; D(r) := 0; S := {r}; repeat St := /0; for p S do begin for q KiEl(p) do // minden p q élre if D(q) = In f then begin //q benemjárt D(q) := D(p) + ; Apa(q) := p; //p-ből megyünk q-ba St := St + {q}; end; end; S := St; until S <> /0 ;

63 A szélességi bejárás megvalósítása Pascal nyelven procedure SzeltBejar ( r : PontTip ; N: longint ; const G: Graf ; var D: array of longint ; var Apa: array of longint ) ; / / r ből induló legrövidebb utak meghatározása var S: Sor ; p, q : PontTip ; i : integer ; begin { SzeltBejar } 8 for p:= to N do D[ p ] : = I n f ; { i n i c i a l i z á l á s } 9 D[ r ] : = 0 ; Apa[ r ] : = 0 ; 0 Letesit (S ) ; Sorba (S, r ) ; while Elemszam( S) >0 do begin p:= SorBol (S ) ; for i := To KiFok [ p ] Do Begin { p >q élre } q:=g[ p, i ] ; i f D[ q]= I n f then begin { ha q meg nem e l é r t } Apa[ q ] : = p ; 8 D[ q ] : =D[ p]+; 9 Sorba (S, q ) ; 0 end ; end{ for p >q} ; end{ while } ; end{ SzeltBejar } ;

64 A Sor adattípus megvalósítása const SorMeret =0000; type PontTip=integer ; Sor=record Tar : Array [.. SorMeret ] of PontTip ; eleje, vege : integer ; 8 end ; 9 procedure Letesit ( var S: Sor ) ; 0 begin S. e l e j e :=; S. vege :=; end{ Letesit } ; procedure Sorba ( var S: Sor ; p : PontTip ) ; begin S. Tar [S. vege ] : = p ; Inc (S. vege ) ; end{ Sorba } ; 8 function SorBol ( var S: Sor ) : PontTip ; 9 begin 0 i f S. eleje >=S. vege then e x i t ; SorBol :=S. Tar [S. e l e j e ] ; inc (S. e l e j e ) ; end{ Sorbol } ;

65 function Elemszam( var S: Sor ) : integer ; begin Elemszam:=S. vege S. e l e j e ; End{Elemszam} ;

66 ... Egy legrövidebb út kiíratása procedure UtKiIro ( r, p : PontTip ) ; / / Globalis : Apa var u, i : longint ; Ut : array [.. maxp] of longint ; begin u:=0; while p<> r do begin 8 inc ( u ) ; 9 Ut [ u ] : = p ; 0 p:=apa[ p ] ; end ; write ( r ) ; f o r i :=u downto do begin write ( >, Ut [ i ] ) ; end ; writeln ( ) ; end ;

67 .. Feladat: Mérőkannák Egy gazdának két kannája van, az egyik A literes, a másik pedig B. Szeretne kimérni pontosan L liter vizet az első kannájába. Az alábbi műveleteket lehet végezni a kimérés során:. Az A-literes kanna teletöltése. A B-literes kanna teletöltése. Az A-literes kanna kiürítése. A B-literes kanna kiürítése. Áttöltés az A-literesből a B-literesbe (amíg az tele nem lesz, ill. van A-ban). Áttöltés a B-literesből az A-literesbe (amíg az tele nem lesz, ill. van B-ben) Adjunk olyan algoritmust, amely meghatároz egy (legkevesebb lépésből álló) kimérést! Bemenet A kimer.be szöveges állomány első sora a két egész számot tartalmaz, a két kanna ürtartalmát: AB(0 < A,B <= 00). A második sor a kimérendő mennyiséget tartalmazza. Kimenet A kimer.ki szöveges állomány első sora a kimérés lépéseinek (minimális) m számát tartalmazza. A második sor pontosan m egész számot tartalmazzon egy-egy szóközzel elválasztva, a kimérés lépéseit.

68 Példa bemenet és kimenet bemenet 9 kimenet 8

69

70

71

72

73

74

75

76

77

78 kezdő állapot: (0,0)

79 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,)

80 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0)

81 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,)

82 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,) öntéssel kapható állapotok: (,) (8,0)

83 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,) öntéssel kapható állapotok: (,) (8,0) öntéssel kapható állapotok: (,0) (8,)

84 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,) öntéssel kapható állapotok: (,) (8,0) öntéssel kapható állapotok: (,0) (8,) öntéssel kapható állapotok: (0,) (9,)

85 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,) öntéssel kapható állapotok: (,) (8,0) öntéssel kapható állapotok: (,0) (8,) öntéssel kapható állapotok: (0,) (9,) öntéssel kapható állapotok: (9,) (0,)

86 kezdő állapot: (0,0) öntéssel kapható állapotok: (9,0) (0,) öntéssel kapható állapotok: (9,) (,) (,0) öntéssel kapható állapotok: (,0) (,) öntéssel kapható állapotok: (,) (8,0) öntéssel kapható állapotok: (,0) (8,) öntéssel kapható állapotok: (0,) (9,) öntéssel kapható állapotok: (9,) (0,) 8 öntéssel kapható állapotok: (,) (,0) Megoldás Minden állapot azonosítható egy (x,y) számpárral (0 x A, 0 y B). A kezdő állapot (0, 0). Tudjuk, hogy egy adott (x, y) állapotból egyet öntéssel milyen állapotok keletkezhetnek. Tekinsük azt a G = (V,E) gráfot, amelynek pontjai az állapotok, tehát V = {(x,y) : 0 x A, 0 y B} és (x,y) (x,y) akkor és csak akkor él a G gráfban, ha az (x,y) állapot egyetlen öntéssel megkapható az (x, y) állapotból. Miden pontból legfeljebb él indul ki, és ezek végpontjai kiszámíthatók x, y függvényeként. Tehát számított gráf ábrázolás alkalmazható. Tehát a feladat olyan (0,0) (x,l) legrövidebb út keresése a G gráfban. A legrövidebb utak feszítőfáját az Apa : 0..A 0..B 0..A 0..B függvénnyel ábrázoljuk. Tehát Apa(p) = q azt jelenti, hogy az (0,0) p legrövidebb úton p előtt q szerepel, azaz (0,0) p = (0,0) q p. Ha nem létezik (0,0) p (kezdetben minden p <> (0,0)-ra) akkor Apa(p).x =. Az (x, y) párok ábrázolására rekord (struct) típust használunk; Allapot=record x,y:word end.

87 program Merokannak ; const MaxV=00; SorMeret =000; type Allapot= record x, y : integer end ; Sor=record 8 eleje, vege :Word; Tar : array [.. SorMeret ] of Allapot ; 9 end ; 0 procedure Letesit ( var S: Sor ) ; begin S. e l e j e :=; S. vege :=; end{ Letesit } ; Procedure Sorba ( var S: Sor ; v : Allapot ) ; begin S. Tar [S. vege ] : = v ; Inc (S. vege ) ; end ; 8 function Sorbol ( var S: Sor ) : Allapot ; 9 begin 0 SorBol :=S. Tar [S. e l e j e ] ; Inc (S. e l e j e ) ; end ; function Elemszam( var S: Sor ) : integer ; begin Elemszam:=S. vege S. e l e j e ; End{Elemszam} ;

88 var A,B, L :Word; 8 Apa: array [ 0.. MaxV, 0.. MaxV] of Allapot ; 9 S: Sor ; 0 Procedure Beolvas ; var BeF: Text ; begin Assign (BeF, kimer. be ) ; Reset (BeF ) ; ReadLn(BeF,A,B) ; ReadLn(BeF, L ) ; 8 Close (BeF ) ; 9 end{ Beolvas } ; 0 Procedure K i I r ; const maxa=0000; var KiF : Text ; x, y,m, i, lepes : integer ; Lehet : boolean ; szep : string ; 8 U, V: Allapot ; 9 Lepsor : array [.. MaxA] of Allapot ; 0 begin

89 Assign ( KiF, kimer. ki ) ; Rewrite ( KiF ) ; lehet := false ; for y:=0 to B do i f Apa[ L, y ]. x>0 then begin lehet := true ; U. y:=y ; break ; end ; i f not lehet then begin 8 writeln ( KiF, 0 ) ; 9 close ( KiF ) ; e x i t ; 0 end ; U. x:=l ; m:=0; while (U. x<>0)or (U. y<>0) do begin inc (m) ; LepSor [m] : =U; U:=Apa[U. x,u. y ] ; end ; U. x :=0; U. y :=0; 8 writeln ( KiF,m) ; 9 szep := ; 0 f o r i :=m downto do begin V:=LepSor [ i ] ; i f (V. x=a) and (U. y=v. y ) then begin lepes :=; end else i f (U. x=v. x ) and (V. y=b) then begin lepes :=;

90 end else i f (V. x=0)and (U. y=v. y ) then begin lepes :=; 8 end else i f (U. x=v. x ) and (V. y=0) then begin 9 lepes :=; 0 end else i f (V. x=0)and (V. y=u. x+u. y ) or (V. x=u. x (B U. y ) ) and (V. y=b) the lepes :=; end else begin lepes :=; end ; write ( KiF, szep, lepes ) ; szep := ; U:=V; 8 end{ for i } ; 9 writeln ( KiF ) ; 0 Close ( KiF ) ; end{ K i I r } ;

91 procedure Szamit ; var x, y :Word; U, V: Allapot ; begin { } for x:=0 to A do 8 for y:=0 to B do Apa[ x, y ]. x:= ; 9 Letesit (S ) ; 0 Apa [ 0, 0 ]. x :=0; U. x :=0; U. y :=0; Sorba (S,U) ;

92 while ( Elemszam( S) >0) do begin U:= Sorbol (S ) ; {minden U >V élre : } i f (U. x=l ) then break ; i f Apa[A,U. y ]. x<0 then begin {. lépés } 8 V. x:=a; V. y:=u. y ; 9 Apa[V. x, V. y ] : =U; 0 Sorba (S, V ) ; end ; i f Apa[U. x,b ]. x<0 then begin {. lépés } V. x:=u. x ; V. y:=b; Apa[V. x, V. y ] : =U; Sorba (S, V ) ; end ; i f Apa[ 0,U. y ]. x<0 then begin {. lépés } 8 V. x :=0; V. y:=y ; 9 Apa[V. x, V. y ] : =U; 0 Sorba (S, V ) ; end ; i f Apa[U. x, 0 ]. x<0 then begin {. lépés } V. x:=u. x ; V. y :=0; Apa[V. x, V. y ] : =U; Sorba (S, V ) ; end ;

93 i f U. x+u. y<=b then begin 8 V. x :=0; V. y:=u. x+u. y ; 9 end else begin 0 V. x:=u. x (B U. y ) ; V. y:=b; end ; i f Apa[V. x, V. y ]. x<0 then begin {. lépés } Apa[V. x, V. y ] : =U; Sorba (S, V ) ; end ; i f U. x+u. y<=a then begin V. y :=0; V. x:=u. x+u. y ; 8 end else begin 9 V. y:=u. y (A U. x ) ; V. x:=a; 0 end ; i f Apa[V. x, V. y ]. x<0 then begin {. lépés } Apa[V. x, V. y ] : =U; Sorba (S, V ) ; end ; end { While S< >[] } ; end{ Szamit } ; begin 8 Beolvas ; 9 Szamit ; 0 K i I r ; end.

94 . Mélységi bejárás.. Első képtár látogatás Egy sok teremből álló képtárban teszünk látogatást. Tudjuk, hogy a főbejárattól a képtár bármely termébe pontosan egy útvonalon keresztül lehet eljutni. Adjunk olyan bejárási stratégiát, amely biztosítja, hogy minden terembe eljutunk (minden képet pontosan egyszer nézünk meg)! ábra.

95 Megoldás A fal mellett mindig jobbra haladjunk. Tekintsük azt a G = (V,E) gráfot, amelynek pontjai (csúcsai) a képtár termei, V = {,...,}, ábra. (p,q) E akkor és csak akkor, ha p teremből nyílik ajtó a q terembe. Ez a gráf fa, ezért lehet a fenti stratégiával bejárni a képtár minden termét.

96 ábra.

97 ábra.

98 ábra.

99 .. Második képtárlátogatás Egy sok teremből álló képtárban teszünk látogatást. Adjuk meg egy bejárást, amely biztosítja, hogy minden terembe eljutunk és a végén visszaérkezünk a kiindulási terembe! Minden teremben kirakták a terem sorszámát és minden ajtón rajta van, hogy melyik terembe vezet ábra. A képtár termeinek alaprajza

100 Mit kell tudnunk?. Jártunk-e már az adott teremben?. Melyik teremből léptünk először az adott terembe?

101 Mit kell tudnunk?. Jártunk-e már az adott teremben?. Melyik teremből léptünk először az adott terembe? Minden p teremre Honnan(p) legyen annak a teremnek a száma, amelyből először lépünk a p terembe. Kezdetben legyen minden p-re Honnan(p) =. Így ha a p teremben vagyunk, és a q terembe vezet ajtó, a Honnan(q) értéke alapján el tudjuk dönteni, hogy jártunk-e q-ban.

102 8 9 terem honnan 8 9 utvonal

103 8 9 terem honnan 8 9 utvonal,

104 8 9 terem honnan 8 9 utvonal

105 8 9 terem honnan 8 9 utvonal

106 8 9 terem honnan 8 9 utvonal

107 8 9 terem honnan 8 9 utvonal

108 8 9 terem honnan 8 9 utvonal

109 8 9 terem honnan 8 9 utvonal

110 8 9 terem honnan 8 9 utvonal

111 8 9 terem honnan 8 9 utvonal

112 8 9 terem honnan 8 9 utvonal

113 8 9 terem honnan 8 9 utvonal 9

114 8 9 terem honnan 8 9 utvonal 9

115 8 9 terem honnan 8 9 utvonal 9 8

116 8 9 terem honnan utvonal 9 8

117 8 9 terem honnan utvonal 9 8 8

118 8 9 terem honnan utvonal 9 8 8

119 8 9 terem honnan utvonal 9 8 8

120 Az algoritmus: i t t := ; / / { az aktuális terem } Honnan [ ] = 0; / / { az utcáról léptünk a főbejárat termébe } while ( i t t!= 0) do begin { / / { amíg vissza nem értünk a bejárat / kijárathoz } i f ( i t t nek van benemjárt szomszédos terme : hova ) then begin Honnan[ hova ] := i t t ; i t t := hova ; / / { továbblépés a szomszédos terembe } end else else / / { nincs benemjárt szomszédos terem } 8 i t t := Honnan[ i t t ] ; / / { visszalépés } 9 end A gráf-modell: A gráf pontjai a termek, két terem között akkor és csak akkor van él, ha közöttük ajtó, amelyen át lehet menni egyikből a másikba (és fordítva).

121 ábra.

122 ábra ábra. A bejárás alkotta (mélységi) feszítőfa

123 .. Nemrekurzív megvalósítás A gráf élhalmaz-tömb ábrázolását használva. begin {Program} Beolvas ; for i := to n do begin Honnan[ i ] : = 0 ; Szomszed[ i ] : = 0 ; end ; i t t :=; 8 9 while i t t >0 do begin 0 write ( i t t, ) ; repeat { benemjárt szomszéd keresése } inc (Szomszed[ i t t ] ) ; u n t i l (Szomszed[ i t t ] >Fok [ i t t ] ) or (Honnan[G[ i t t, Szomszed[ i t t ] ] ] = 0 ) ; i f Szomszed[ i t t ]<=Fok [ i t t ] then begin {van benemjárt szomszéd} hova:=g[ i t t, Szomszed[ i t t ] ] ; Honnan[ hova ] : = i t t ; { i t t ből lépünk hova ba} i t t :=hova ; { i t t >hova átlépés } 8 end else { nincs benemjárt szomszéd} 9 i t t :=Honnan[ i t t ] ; { visszalépés } 0 end{ while } ; end.

124 .. Rekurzív megvalósítás procedure MelyBejar ( p : integer ) ; { Global : G, Fok, Apa} var i, q : integer ; begin write (,p ) ; for i := to Fok [ p ] do begin 8 q:=g[ p, i ] ; {p >q él?} 9 i f Apa[ q] <0 then begin {q ban még nem jártunk } 0 Apa[ q ] : = p ; {p ből jöttünk q ba} MelyBejar ( q ) ; { q ból elérhetők bejárása } write ( KiF,,p ) ; { vissza k e l l menni p be} end ; end{ for i } ; end{ MelyBejar } ;

125 .. Élek osztályozása Módisítsuk a mélységi bejárást úgy, hogy színezzük a bejárás során a gráf pontjait: kezdetben minden pont színe legyen Fehér, amikor először elérünk egy pontot, akkor színezzük Szürkére, amikor befejeztük a pontpol elérhető pontok bejárását, akkor színezzük a pontot Feketére. procedure MelyBejar ( p : integer ) ; { Global : G, Fok, Szin, Apa} var i, q : integer ; begin Szin [ p ] : = Szurke ; for i := to Fok [ p ] do begin 8 q:=g[ p, i ] ; {p >q él?} 9 i f Szin [ q]= Feher then begin {p >q f a é l } 0 Apa[ q ] : = p ; {p ből jöttünk q ba} MelyBejar ( q ) ; { q ból elérhetők bejárása } end else i f Szinq ]= Szurke then begin {p >q visszaél } end else begin {p q előreél vagy keresztél } end ; end{ for i } ; 8 Szin [ p ] : = Fekete ; 9 end{ MelyBejar } ;

126 Az p q él vizsgálatakor, Szin[q] alapján az osztályozás: Szin[q] = Feher akkor az él faél, Szin[q] = Szurke akkor az él visszaél, Szin[q] = Fekete és p-t előbb értük el, mint q-t, akkor az él előreél, Szin[q] = Feher és q-t előbb értük el, mint p-t, akkor az él keresztél ábra. Élek osztályozása: zöld: faél, piros: visszaél, kék: előreél, fekete: keresztél

127 Állítás: Minden G irányítatlan gráf bármely mélységi bejárása során minden él vagy faél, vagy visszél lesz. Bizonyítás: Legyen (p,q) tetszőleges él a gráfban és tegyük fel, hogy a p pontot értük el előbb a bejárás során. q biztosan elérhető a p pontból, ezért a bejárás során mind a p q mind a q p élet vizsgáljuk. Ha a p q élet vizsgáljuk előbb, akkor q színe Fehér, tehát faél lesz, ha a q p-t vizsgáljuk előbb, akkor, mivel p színe Szurke, az él visszaél lesz... Topologikus rendezés Egy G == V, E) irányított gráf topologikus rendezésén a gráf pontjainak egy olyan p,..., p n felsorolása, hogy bármely u v E él u = p i és v = p j esetén i < j. (Tehát u előbb szerepel a felsorolásban, mint v). Állítás: A G gráfnak akkor és csak akkor van topologikus rendezése, ha G körmentes. Állítás: A G gráfnak akkor és csak akkor van topologikus rendezése, ha G bármely mélységi bejárása során nincs visszaél. Állítás: Ha a mélységi bejárás során a pontokat a befejezési idő szerint (amikor a színét Fekete-re állítjuk) fordított sorrendben leírjuk, akkor egy topologikus rendezést kapunk. Valóban, amikor a Szin[p] := Fekete utasítást végrehajtjuk, akkor az összes olyan pontot már leírtuk a sorba, amelyek p-ből elérhetők.

128 procedure TopRend( const G: Graf ; const Fok : array of longint ; n : longint ; var T : array of longint ; var Van : boolean ) ; var m: longint ; procedure MelyBejar ( p : longint ) ; { Global : G, Fok, Szin, m, T} var 8 i, q : longint ; 9 begin { MelyBejar } ; 0 Szin [ p ] : = Szurke ; for i := to Fok [ p ] do begin q:=g[ p, i ] ; {p >q él?} i f Szin [ q]= Feher then begin {p >q f a é l } MelyBejar ( q ) ; { q ból elérhetők bejárása } i f m<0 then e x i t ; end else i f Szinq ]= Szurke then begin {p >q visszaél } m:= ; e x i t ; 8 end ; 9 end{ for i } ; 0 Szin [ p ] : = Fekete ; T [m] : = p ; dec (m) ; end{ MelyBejar } ; begin {TopRend} ; m:=n ;

129 for i := to n do Szin [ i ] : = Feher ; for i := to n do i f Szin [ i ]= Feher then 8 MelyBejar ( i ) ; 9 Van:=m=0; 0 end{toprend} ;

130 .. Utcaseprő A város elhatározta, hogy minden nap végigmegy a város utcáin az egyetlen utcaseprő gépe. A város minden utcája kétirányú, és az utcaseprőnek is be kell tartania a közlekedési szabályokat. Adjunk olyan útvonalat, amelyen haladva az utcaseprő minden utcában pontosan egyszer halad végig mindkét irányban.

131 . ábra.

132 . ábra. Mélységi felszítőfa alapján az útvonal:

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149 program Utcasepro ; const MaxN=00; type Paletta =( Feher, Szurke, Fekete ) ; var N, i : longint ; 8 G: array [.. MaxN,..MaxN] of longint ; 9 Apa, Fok : array [.. MaxN] of longint ; 0 Szin : array [.. MaxN] of Paletta ; procedure BeOlvas ; var i, x : longint ; BeF: Text ; begin ReadLn(N) ; for i := to n do begin Fok [ i ] : = 0 ; 8 Read( x ) ; 9 while ( x< >0) do begin 0 inc ( Fok [ i ] ) ; G[ i, Fok [ i ] ] : = x ; read ( x ) ; end ; end ; end { Beolvas } ;

150 procedure MelyBejar ( p : longint ) ; { Global : G, Fok, Apa} 8 var 9 i, q : longint ; 0 begin write (,p ) ; Szin [ p ] : = Szurke ; for i := to Fok [ p ] do begin q:=g[ p, i ] ; i f Szin [ q]= Feher then begin {q ban még nem jártunk } Apa[ q ] : = p ; {p ből jöttünk q ba} MelyBejar ( q ) ; { q ból elérhetők bejárása } 8 write (,p ) ; { vissza k e l l menni p be} 9 end else i f ( Szin [ q]= Szurke ) and ( q<>apa[ p ] ) then begin 0 write (,q,,p ) ; { >q >p} end ; end{ for i } ; Szin [ p ] : = Fekete ; end{ MelyBejar } ; begin {Program} Beolvas ; 8 for i := to n do Szin [ i ] : = Feher ; 9 MelyBejar ( ) ; 0 end.

151 . Euler-séta, Euler-kör.. definíció. A G = (V, E) (irányított vagy irányítatlan) gráfban Euler-séta olyan séta, amely a gráf minden élét pontosan egyszer tartalmazza... definíció. A G = (V, E) (irányított vagy irányítatlan) gráfban Euler-kör olyan séta, amely a gráf minden élét pontosan egyszer tartalmazza, és a séta első és utolsó pontja megegyezik... tétel. A G = (V, E) irányított gráfban akkor és csak akkor van Euler-séta, ha van G-ben olyan pont, amelyből bármely más pont elérhető, és vagy minden pont kifoka megegyezik befokával (ekkor a séta körséta), vagy van olyan a V és b V pont, hogy ( v V )(KiFok(v) = BeFok(v)) () KiFok(a) = BeFok(a) + és BeFok(b) = KiFok(b) + () ( v V )(v a v b KiFok(v) = BeFok(v)) ()

152 .. tétel. A G = (V, E) irányítatlan gráfban akkor és csak akkor van Euler-séta, ha összefüggő, és ( v V )(Fok(v) páros) () (ekkor a séta körséta) vagy van olyan a V és b V,a b pont van, hogy Fok(a) páratlan () Fok(b) páratlan (8) ( v V )(v a v b Fok(v) páros) (9)

153 Bizonyítás irányított gráfra Tfh. KiFok(a) = BeFok(a) + és BeFok(b) = KiFok(b) +. Vegyünk egy olyan vak sétát, amely az a pontból indul, tetszőlegesen haladunk, töröljük azokat az éleket, amelyeken áthaladunk. Addig menjünk, ameddig olyan ponthoz érünk, amelyből már nem indul ki (benemjárt) ét. A séta biztosan a b ponban ér véget, mert a séta minden belső p pontjára KiFok(p) = BeFok(p), így ha ilyen pontba léptünk be, akkor abból ki is tudunk lépni. Legyen u egy (az utolsó) olyan pont az a b sétában, amelyből indul ki benem járt él. Ha nincs ilyen, akkor a séta a gráf minden élét tartalmazza. Vegyünk egy vak sétát, amely az u pontból indul. Ez biztosan az u pontban végződik. Kapcsoljuk be ezt az a b sétába. Folytassuk ezt mindaddig, amíg van benemjárt él. a. ábra. b a u b. ábra.

154 / / / / / / /.

155 / / / / / / /.

156 / / / / / / /.

157 / / / / / / /.

158 / / / / / / /.

159 / / / / / / /.

160 / / / / / / /.

161 / / / / / / /.

162 / / / / / / /

163 / / / / / / /

164 / / / / / / /

165 / / / / / / /

166 / / / / / / /

167 / / / / / / /

168 / / / / / / /

169 / / / / / / /

170 / / / / / / /

171 / / / / / / /

172 / / / / / / /

173 / / / / / / /

174 / / / / / / /

175 / / / / / / /

176 / / / / / / /

177 / / / / / / /

178 / / / / / / /

179 / / / / / / /

180 .. Euler-séta keresés irányított gráfra Program EulerSeta ; { Euler séta keresés i r á n y í t o t t gráfra } Const MaxP=0000; { a pontok max. száma} MaxM=00000; { az élek max. száma} Null =0; Type PontTip = 0..MaxP; 8 Cella=Record 9 Pont : PontTip ; csat : 0..MaxM; 0 End; Graf=Array [.. MaxP] Of 0..MaxM; { a gráfábrázolás típusa } Uttip=array [ 0..MaxM] of 0.. MaxP; VeremT=record teto : longint ; Tar : array [.. MaxP] of longint end ; Var N, { a pontok száma } E: Longint ; { az élek száma} G: Graf ; 8 KiFok, BeFok: Array [.. MaxP] of longint ; 9 El : Array [.. MaxP] of Cella ; { az első aktív él : p >q=el [G[ p ] ]. pont } 0 Szabad : longint ; { az első szabad c e l l a } Ut : UtTip ; { a séta pontjai } V:VeremT;

181 Procedure Beolvas ; Var BeF: Text ; u, v : PontTip ; i : Longint ; Guv: longint ; 8 Begin 9 szabad :=; 0 Assign (BeF, eulerkor. be ) ; Reset (BeF ) ; ReadLn(BeF, N, E ) ; For u:= To N Do Begin { I n i c i a l i z á l á s } G[ u ] : = Null ; KiFok [ u ] : = 0 ; BeFok[u]:=0; End; For i := To E Do Begin { az input beolvasása } 8 ReadLn(BeF, u, v ) ; 9 Guv:=szabad ; inc ( szabad ) ; 0 El [Guv ]. pont :=v ; El [Guv ]. csat :=G[ u ] ; G[ u ] : =Guv; Inc ( KiFok [ u ] ) ; Inc (BeFok[ v ] ) ; End{ for i } ; Close (BeF ) ; End{ Beolvas } ;

182 Procedure K i I r ; Var 8 KiF : Text ; 9 i : longint ; 0 Begin Assign ( KiF, eulerkor. ki ) ; Rewrite ( KiF ) ; for i := to E do write ( KiF, Ut [ i ], ) ; Writeln ( kif ) ; Close ( KiF ) ; End{ K i I r } ;

183 Procedure VeremBe( p : longint ) ; 8 begin 9 inc (V. teto ) ; V. Tar [V. teto ] : = p ; 0 end ; Procedure Torol ; begin dec (V. teto ) ; end ; function Teteje : longint ; begin Teteje :=V. Tar [V. teto ] ; 8 end ; 9 function NemUres: boolean ; 0 begin NemUres:=V. teto >0; end ; Procedure Letesit ( ) ; begin V. teto :=0; end ;

184 procedure EulerSetaKeres ( var G: graf ; a : longint ; n : longint ; m: longint ; var U 8 {A G gráfban a ból induló Euler sétát készít } 9 var p : PontTip ; 0 k : longint ; begin Letesit (m) ; {verem l é t e s í t é s } VeremBe( a ) ; k:=m; while NemUres do begin { amíg a verem nem üres } p:= Teteje ; i f G[ p]= Null then begin { nincs már p ből benemjárt él } 8 Torol ; {p t t ö r ö l j ü k a veremből } 9 Ut [ k ] : = p ; 0 dec ( k ) ; end else begin { tovább a p >q élen } VeremBe( El [G[ p ] ]. pont ) ; G[ p ] : = El [G[ p ] ]. csat ; end ; end{ while } ; end{ EulerUt } ;

185 var a, b, i : longint ; 8 begin {Program} 9 Beolvas ; 0 a :=0; b:=0; for i := to n do begin i f BeFok[ i ]= KiFok [ i ] then continue ; i f BeFok[ i ]+= Kifok [ i ] then begin i f a=0 then a:= i else a:=n+; end ; i f BeFok[ i ]= Kifok [ i ]+ then begin i f b=0 then b:= i else b:=n+; 8 end ; 9 end ; 0 i f a=0 then a :=; i f ( a<=n ) and ( b<=n ) then begin EulerSetaKeres (G, a, n, E, Ut ) ; K i I r ; end else writeln ( Nincs Euler séta! ) ; end.

186 .. Euler-kör keresés irányítatlan gráfra Program EulerKor ; { Euler út ( kör ) keresés i r á n y í t a t l a n gráfra } Const MaxP=0000; { a pontok max. száma} MaxM=00000; { az élek max. száma} Az algoritmus lényege ugyan az, mint irányított esetben. Azonban a hatékony (élek számával arányos futási idejű) megvalósításhoz meg kell oldani az élek hatékony törlését. Mivel irányítatlan gráfot úgy ábrázolunk, hogy a (p,q) él esetén p q és q p szerepel az ábrázolásban, ezért ha a p q-t töröljük, akkor tötölni kell a q p-t is. Tehát konstans időben meg kell találni a másik irányú élet. Ezt megoldhatjuk úgy, hogy láncolt ábrázolást alkalmazunk, és minden cellában eltároljuk a másik irányú él cellájára mutató információt (címet). Továbbá, nem érdemes ténylegesen törölni, azaz a láncból eltávolítani, hanem csak megjegyezni, hogy törölve lett. G p... q q p. ábra. Gráf ábrázolása a p q és q p élek összekapcsolásával.

187 Null =0; Type PontTip = 0..MaxP; 8 Cella=Record 9 Pont : PontTip ; 0 masik : longint ; aktiv : boolean ; csat : 0..MaxM; End; Graf=Array [.. MaxP] Of 0..MaxM; { a gráfábrázolás típusa } Uttip=array [ 0..MaxM] of 0.. MaxP; Var N, E: Longint ; { a pontok száma, az élek száma } 8 G: Graf ; 9 El : Array [.. MaxP] of Cella ; { az első aktív él : p >q=el [G[ p ] ]. pont } 0 Szabad : longint ; { az első szabad c e l l a } Ut : UtTip ; { a séta pontjai } Fok : Array [.. MaxP] of longint ; a : PontTip ;

188 Procedure Beolvas ; Var BeF: Text ; u, v : PontTip ; i, Guv,Gvu: longint ; Begin 8 Assign (BeF, eulerkor. be ) ; Reset (BeF ) ; 9 ReadLn(BeF, N, E ) ; 0 For u:= To N Do Begin { I n i c i a l i z á l á s } G[ u ] : = Null ; Fok [ u ] : = 0 ; End; For i := To E Do Begin { az input beolvasása } ReadLn(BeF, u, v ) ; Guv:=szabad ; inc ( szabad ) ; Gvu:=szabad ; inc ( szabad ) ; El [Guv ]. pont :=v ; El [Guv ]. csat :=G[ u ] ; 8 El [Guv ]. masik:=guv; 9 G[ u ] : =Guv; 0 El [Gvu ]. pont :=u ; El [Gvu ]. csat :=G[ v ] ; El [Gvu ]. masik:=guv; G[ v ] : =Gvu; Inc ( Fok [ u ] ) ; Inc ( Fok [ v ] ) ; End{ for i } ; Close (BeF ) ; End{ Beolvas } ;

189 8 procedure EulerKor ( 9 var G: graf ; / / a gráf 0 n : word ; m: longint ; / / a pontok és élek száma a : PontTip ; / / van a ból induló Euler út var Ut : UtTip ) ; / / az út var p : PontTip ; q, k : longint ; begin Letesit (m) ; {verem l é t e s í t é s } VeremBe( a ) ; k:=m; while NemUres do begin { amíg a verem nem üres } 8 p:= Teteje ; 9 while (G[ p]<> Null ) and ( not El [G[ p ] ]. aktiv ) do G[ p ] : = El [G[ p ] ]. csat ; 0 i f G[ p]= Null then begin { nincs már p ből benemjárt él } Torol ; {p t t ö r ö l j ü k a veremből } Ut [ k ] : = p ; dec ( k ) ; end else begin { tovább a p >q élen } q:= El [G[ p ] ]. pont VeremBe( q ) ; / / El [G[ p ] ]. aktiv := false ; El [ El [G[ p ] ]. masik ]. aktiv := false ; 8 G[ p ] : = El [G[ p ] ]. csat ; 9 end ; 0 end{ while } ; end{ EulerKor } ;

190 Begin {Program} Beolvas ; Elokeszit ; EulerKor ; End.