A Wyk

Algorytmy
Norbert Jankowski
Katedra Informatyki Stosowanej
www.is.umk.pl/norbert/algorytmy
NJ (KIS) Algorytmy 1 / 222
Literatura
Literatura I
A. V. Aho, J. E. Hopcroft, J. D. Ullman.
Projektowanie i analiza algorytmw.
Helion, Warszawa, 2003.
A. V. Aho, J. E. Hopcroft, J. D. Ullman.
Projektowanie i analiza algorytmw.
Pastwowe Wydawnictwa Naukowe, Warszawa, 1983.
Niklaus Wirth.
Algorytmy + Struktury Danych = Programy.
Wydawnictwa NaukowoTechniczne, Warszawa, wydanie 2, 1989.
T. H. Cormen, C. E. Leiserson, R. L Rivest.
Wprowadzenie do algorytmw.
Wydawnictwa NaukowoTechniczne, Warszawa, 1997.
Literatura
Literatura II
A. V. Aho, J. D. Ullman.
Wykady z informatyki z przykadami w jzyku C.
Helion, Warszawa, 2003.
L. Banachowski, K. Diks, W. Rytter.
Algorytmy i struktury danych.
M. M. Syso, N. Deo, J. Kowalik.
Algorytmy optymalizacji dyskretnej.
Pastwowe Wydawnictwa Naukowe, Warszawa, 1993.
D. Harel.
Rzecz o istocie informatyki. Algorytmika.
Literatura
Literatura III
L. Banachowski, A. Kreczmar, W. Rytter.
Analiza algorytmw i struktur danych.
L. Banachowski, A. Kreczmar.
Elementy analizy algorytmw.
D. E. Knuth.
Sztuka Programowania, wolumen IIII.
Wydawnictwa NaukowoTechniczne, 2002.
Algorytmy z powrotami
Automatyczne rozwizywanie problemw, gdzie nie ma (prostych)
rozwiza analitycznych.
Podzia na pod-zadania + metoda prb i bdw.
Bardzo czsto rekurencja.
Niestety najczciej zoono eksponencjalna . . .
Algorytmy z powrotami Skoczek
Drogi skoczka szachowego
3 2
4 1
S
5 8
6 7
Skoczek (ko) porusza si zgodnie z reguami gry w szachy
Start z ustalonej pozycji
Zadanie odwiedzi kad pozycj dokadnie jeden raz
Zagadnienie mona zamieni na prb wykonania kolejnego ruchu
skoczkiem, jeli to tylko moliwe.
1 procedure PrbujNastpnyRuch
2 begin
3 zapocztkuj wybieranie ruchw;
4 repeat
5 wybierz nastpnego kandydata z listy ruchw;
6 if dopuszczalny then
7 begin zapisz ruch
8 if na szachownicy wolne pola then
9 begin PrbujNastpnyRuch
10 if nieudany then wykrel ostatni ruch
11 end
12 end
13 until ruch by udany OR nie ma nastpnego kandydata;
14 end
Zapamitujmy w macierzy h numery krokw wydawanych przez
skoczka
1 var h : array [1.. n ,1.. n] of integer;
h[x, y] = 0 pole nieodwiedzone
h[x, y] = i pole odwiedzone w i -tym kroku
Musimy mie moliwo przekazywania informacji o zewntrznych
wywoaniach. Czy ruch si powid? Bdziemy to robi poprzez
zmienn q (true=sukces)
Czy ruch jest dopuszczalny? = 1 u, v n AND h[u, v] = 0,
u,v - nowa pozycja skoczka
Czy s wolne pola? = i < n
2
1 procedure Prbuj(i:integer; x, y: integer; var q:boolean);
2 var u,v: integer;
3 begin zapocztkuj wybieranie ruchw;
4 repeat u, v wsprzdne nastpnego ruchu;
5 if (1<=u<=n) AND (1<=v<=n) AND (h[u,v]=0) then
6 begin h[u,v]:=i ;
7 if i <nn then
8 begin Prbuj(i+1, u,v, q);
9 if NOT q then h[u,v]:=0;
10 end
11 else q:=true;
12 end
13 until q OR nie ma nastpnego kandydata;
14 end
3 2
4 1
S
5 8
6 7
1 a[1]:= 2; b[1]:= 1;
2 a[2]:= 1; b[2]:= 2;
3 a[3]:=1; b[3]:= 2;
4 a[4]:=2; b[4]:= 1;
5 a[5]:=2; b[5]:=1;
6 a[6]:=1; b[6]:=2;
7 a[7]:= 1; b[7]:=2;
8 a[8]:= 2; b[8]:=1;
1 procedure Prbuj(i:integer; x, y: integer; var q:boolean);
2 var u,v, k:integer;
3 begin k:=0;
4 repeat k:=k+1;
5 u:=x+a[k]; v:=y+b[k];
6 if (1<=u<=n) AND (1<=v<=n) AND (h[u,v]=0) then
7 begin h[u,v]:=i ;
8 if i <nn then
9 begin Prbuj(i+1, u,v, q);
10 if NOT q then h[u,v]:=0;
11 end else q:=true;
12 end
13 until q OR nie ma nastpnego kandydata;
14 end
1 program skoczek;
2 ...
3 begin
4 a[1]:= 2; b[1]:= 1;
5 ...
6 for i :=1 to n do
7 for j :=1 to n do
8 h[ i , j ]:=0;
9 h[1,1]:=1;
10 Prbuj (2,1,1, q);
11 if q then
12 drukuj macierz h
13 else writeln(brak rozwizania);
14 end.
Wynik dla szachownicy 5x5
1 6 15 10 21
14 9 20 5 16
19 2 7 22 11
8 13 24 17 4
25 18 3 12 23
1 procedure PrbujOGLNYSZKIC;
2 begin
3 zapocztkuj wybieranie kandydatw;
4 repeat
5 wybierz nastpnego kandydata;
7 begin zapisz go;
8 if rozwizanie niepene then
9 begin PrbujOGLNYSZKIC;
10 if prba nieudana then usu zapis
11 end
12 end
13 until prba udana OR nie ma nastpnego kandydata;
14 end
Algorytmy z powrotami Problem omiu hetmanw
Problem omiu hetmanw
Na szachownicy umieci 8 hetmanw, ale tak aby aden nie
szachowa adnego innego.
Rozwizanie: analitycznie NIE, rekurencja+powroty TAK
Podzia problemu znw na prby i powroty
1 2 3 4 5 6 7 8
1 H
2 H
3 H
4 H
5 H
6 H
7 H
8 H
1 procedure Prbuj8H(i:integer)
2 begin
3 zapocztkuj wybieranie pozycji i tego hetmana;
4 repeat
5 dokonaj nastpnego wyboru pozycji ;
6 if bezpieczna then
7 begin ustaw hetmana;
8 if i <8 then
9 begin Prbuj8H(i+1);
10 if prba nieudana then usu hetmana;
11 end
12 end
13 until prba udana OR nie ma wicej pozycji;
14 end
Szach gdy:
w tej samej kolumnie
w tym samym wierszu
na tej samej przektnej(!)
Reprezentacja:
1 x: array [1..8] of integer; { pozycja w itej kolumnie }
2 a: array [1..8] of boolean;
3 { a[ j ] brak hetmana w jtym wierszu }
4 b:array[b1.. b2] of boolean;
5 { b[k] brak hetmana na ktej przektnej }
6 c: array[c1 .. c2] of boolean;
7 { c[k] brak hetmana na ktej przektnej }
Ustaw hetmana w pozycji: i-ta kolumna, j-ty wiersz:
x[ i ]:=j ; a[ j ]:=false ; b[ i +j]:=false; c[ i j]:=false;
Usu hetmana z pozycji i,j:
a[ j ]:=true; b[ i +j]:=true; c[ i j]:=true;
Warunek bezpieczna pozycja i,j:
a[ j ] AND b[i+j] AND c[ij]
1 procedure Prbuj8H(i: integer , q:boolean)
2 var j : integer ;
3 begin j :0;
4 repeat j :=j+1; q:=false;
5 if a[ j ] AND b[i+j] AND c[ij] then
6 begin x[ i ]:=j ;
7 a[ j ]:=false ; b[ i +j]:=false ; c[ i j]:=false ;
8 if i <8 then
9 begin Prbuj8H(i+1, q);
10 if NOT q then begin
11 a[ j ]:=true; b[ i +j]:=true; c[ i j]:=true;
12 end
13 end else q:=true;
14 end
15 until q OR (j=8);
16 end
Algorytmy z powrotami Algorytmy szukania z powrotami
Przeszukiwanie najpierw najlepszy i wizk
Nie zawsze (wrcz b. rzadko) mona pozwoli sobie na tak
dokadne przeszukanie przestrzeni rozwiza jak dla problemu
skoczka bd 8 hetmanw.
Powstay metody, ktre co prawda nie su do znajdowania
dokadanych (optymalnych) rozwiza, jak jest to konieczne w nie
ktrych problemach, ale potra za to znale podoptymalne
rozwizania, co w wielu zastosowaniach wystarcza (np. gry
strategiczne).
Takie algorytmy korzystaj z niemal identycznej struktury
algorytmu, lecz nie prowadz eksploracji wszystkich kandydatw lecz
ich podzbir, ktry jest wyznaczany odpowiednimi kryteriami
zalenymi od problemu.
Jako kryteriw okrelajcych zbir kandydatw ma kluczowe
znaczenie dla powodzenia algorytmu.
1 procedure SzukajNN;
2 begin
4 wybierz najlepszego dopuszczalnego kandydata;
5 zapisz go;
7 begin SzukajNN;
9 end
10 end
1 procedure SzukajWizk;
2 begin
4 wybierz podzbir (wizk) najlepszych kandydatw;
5 repeat
6 we nastpnego kandydata;
8 begin zapisz go;
10 begin SzukajWizk;
12 end
13 else zapisz rozwizanie ;
14 end
15 until podzbir kandydatw przeszukany;
16 end
, -obcicie
Inna wersja: , -obcicie gry strategiczne, poziomy obcicia dla
funkcji oceny ruchu swojego i przeciwnika.
1 procedure SzukajAB(i, rola)
2 begin
3 s = wszystkie ruchy;
4 s = s / niedopuszczalne;
5 foeach s
i
6 begin
7 nowyStan = staryStan + ruch s
i
;
8 f
i
= F(nowyStan, rola)
9 end
10 s = s / {s
i
: f
i
< AB};
11 repeat
12 zrb ruch + zapisz go;
13 if rozwizanie niepene & i < maxGboko then
14 begin
15 SzukajAB(i+1, !rola);
16 usu ruch;
17 end
18 else zapisz rozwizanie (czciowe );
19 until podzbir kandydatw przeszukany;
20 end
Operacje na zbiorach
Member(a,S) Czy a naley do S.
Insert(a,S) S = S a
Delete(a,S) S = S a
Union(A,B,C) Zastp zbiory A i B przez C.
Find(a) Podaje nazw zbioru do ktrego naley a.
Split(a,S) Rozdziela S na S
1
= b : b a b S i
S
2
= b : b > a b S.
Min(S) Podaje warto elementu minimalnego.
Gwnie interesuje nas wykonywanie cigw instrukcji typu:
Member , Insert, Delete
Zastosowania: sownikowe, wiele wiele operacji jedno- i
wielo-zbiorowych (np. algorytm Kruskala znajdowania minimalnego
drzewa rozpinajcego).
Dlatego: gwnie bdzie interesowaa nas zoono nie pojedynczej
instrukcji lecz caego cigu instrukcji .
Operacje na zbiorach Haszowanie
Haszowanie
Rozwamy instrukcje: Insert, Delete, Member.
Niech S bdzie pewnym duym zbiorem.
Haszowanie: umieszcza elementy zbioru S na odpowiedniej licie w
tablicy list:
A
0
1
.
.
.
m-1
Funkcja haszujca h(a) = i wyznacza, na ktrej licie tablicy
haszujcej A ma znale si element a.
Wykonanie Insert(a, S) to:
wyznaczenie h(a),
przeszukanie A[h(a)],
jeli ta lista nie zawiera a, naley na koniec listy dopisa a
Wykonanie Delete(a, S) to:
wyznaczenie h(a),
przeszukanie A[h(a)],
usunicie a z listy A[h(a)] (jeli tylko jest na licie).
Wykonanie Member (a, S) analogicznie
Zoono obliczeniowa:
Najgorszy przypadek: Moe si zdarzy, e dla rnych n instrukcji
Insert funkcja haszujca h(a) da tak sam warto i ,
wtedy (niestety) wszystkie poszczeglne elementy a znajd
si na tej samej licie tablicy haszujcej A[h(a)]. Oznacza
to, e wykonanie n instrukcji Insert ma zoono O(n
2
).
Czas oczekiwany haszowania: Zaoenie, e wartoci h(a) s jednakowo
prawdopodobne i e wstawiamy n m wartoci, to dla
i -tego wstawiania oczekiwana dugo listy A[h(a)] wynosi
(i 1)/m (< 1!).
Co prowadzi do zoonoci O(n) dla n instrukcji Insert.
Oglnie oczekiwany koszt 1 operacji: wynosi O(1 +), gdzie =
n
m
.
Funkcja haszujca h(a):
Wanym zaoeniem jest, e h(a) da si obliczy w O(1).
Wybr funkcji haszujcej jest kluczowy dla pniejszej pracy
algorytmu haszowania.
Oglnie funkcja haszujca powinna kady klucz z jednakowym
prawdopodobiestwem odwzorowywa w jedn zwartoci m:
a : h(a)=j
P(a) =
1
m
dla kadego j = 0, . . . , m 1
Jest to warunek prostego rwnomiernego haszowania.
Gdy zaoy, e wartoci a s jednakowo prawdopodobne i
ograniczone, np. [0, N], gdzie N m, to jako funkcji haszujcej
mona uy operatora modulo:
h(a) = a mod m
Z kolei gdy klucze a bd losowymi wartociami rwnomiernie
rozoonymi na przedziale 0 a < 1, to funkcja haszujca moe
przyj posta:
h(a) = am
Haszowanie przez mnoenie:
h(a) = m(aB mod 1)
najpierw klucz a (cakowite wartoci) mnoymy przez pewn sta
(0 B < 1) z czego pobieramy cz uamkow, a nastpnie
mnoymy przez rozmiar tablicy A (m) i zaokrglamy do caoci.
Dobre B (
5 1)/2 = 0, 6180339887 . . .
Czasami naley skorzysta z pewnych wasnoci heurystycznych przy
doborze funkcji haszujcej szczeglnie gdy nie znamy rozkadu P.
Dla podobnych napisw f. haszujca powinna zapewni dobry
rozkad rne wartoci h(a) dla podobnych napisw, np.
tablica1, tablicaX. Tu take zastosowanie mog mie funkcje
modularne.
Co gdy n = m?
Gdy liczba przechowywanych elementw w danym zbiorze S osignie
warto blisk (rwn lub wiksz) dugoci tablicy A naley zwikszy
pojemno tablicy haszujcej:
Utworzy now tablic A
2
dugoci 2m.
Przez powtrne haszowanie dokonujemy kopiowania elementw
A = A
1
do A
2
Usuwamy A
1
Gdy z kolei dojdzie do przepenienia A
2
naley postpi analogicznie. . .
Odwrotnie postpujemy, gdy liczba elementw w tablicy zmniejszya si
za bardzo.
Haszowanie otwarte
Tablica M jest zwyk tablic elementw, ktre s przechowywane w
zbiorze.
Nie ma wic list ani innych wskanikw.
Takie zaoenia prowadz jednak do kolizji, ktre musz by
eliminowane. Robi si to przez powtrne haszowanie.
1 procedure HashInsert(k)
2 begin
3 size ++;
4 i =0;
5 while( i != m )
6 j = h(k,i );
7 if ( M[j] == || M[j] == )
8 M[j]=k;
9 return j ;
10 else
11 i ++;
12 end
13 error (" przepenienie tablicy / reorganizacja ");
14 end
UWAGA: Te funkcje rwnie trzeba rozbudowa o mechanizm
rozszerzania i kurczenia tablicy M. Jednak prg nie moe by blisko
penej tablicy(!).
1 procedure HashSearch(k)
2 begin
3 i =0;
4 while( i != m )
5 j = h(k,i );
6 if ( M[j] == )
7 return 1;
8 if ( M[j] == k )
9 return j ;
10 else
11 i ++;
12 end
13 end
1 procedure HashDelete(k)
2 begin
3 i =0;
4 size ;
5 while( i !=m )
6 j = h(k,i );
7 if ( M[j] == )
8 return 1;
9 if ( M[j] == k )
10 M[j] = ;
11 return j ;
12 else i ++;
13 end
14 end
Funkcja haszujce dla haszowania otwartego
h(k, i ) = (h
1
(k) + ih
2
(k)) mod m
h
1
(k) = k mod m
h
2
(k) = 1 + (k mod m
)
np. m
= m 1
Operacje na zbiorach Drzewa przeszukiwa
Drzewa przeszukiwa binarnych dla operacji zbiorowych
Drzewa binarne.
n instrukcji (Insert, Delete, Member ) O(n
2
).
rednio O(n log n).
Drzewa zbalansowane (drzewa czerwonoczarne, AVL) n operacji
(Insert, Delete, Member ) daj zoono O(n log n).
Prosto i wolno . . .
Elementy zbioru: liczby cakowite od 1 do n.
Wykorzystuje: operacje Union i Find.
Niech R bdzie tablic i R[i ] = indeks zbioru.
Nazwy zbioru s nieistotne, przyjmujemy: R[i ] [1, n] (ekstremalnie
kady element naley do innego zbioru).
1 = 1, 3, 4, 6, 2 = 5, 3 = 2, 7
R
1 1
2 3
3 1
4 1
5 2
6 1
7 3
1 procedure Union(R,A,B,C)
2 var i : integer;
3 begin
4 for i :=1 to n do
5 if (R[ i ]=A) or (R[ i ]=B) then
6 R[ i ]:=C
7 end
Koszt jednej operacji Union to O(n), czyli cig n operacji oznacza
zoono O(n
2
).
Listy z dowizaniami
atwo jednak mona usprawni powyszy algorytm:
Uyjemy list z dowizaniami unikniemy przegldania caej tablicy.
Bdziemy docza mniejszy zbir do wikszego unikniemy
przegldania duszego ze zbiorw.
Teraz oprcz tablicy R bdziemy mieli take inne tablice.
LIST[A] lista z dowizaniami. LIST[A] wskazuje indeks
pierwszego elementu zbioru A w R.
NEXT[i] daje indeks kolejnego elementu tego samego zbioru co
element R[i ]. Niech j = LIST[A], wtedy NEXT[j ] to drugi
element zbioru A, NEXT[NEXT[j ]] to trzeci, etc.
SIZE[A] daje biec liczb elementw zbioru A.
EXTERNAL_NAME[A] to zewntrzna nazwa zbioru A (R[i] daje
wewntrzn nazw).
Przykad
Mamy zbiory: 1 = 1, 3, 5, 7, 2 = 2, 4, 8, 3 = 6
R NEXT
1 2 3
2 3 4
3 2 5
4 3 8
5 2 7
6 1 0
7 2 0
8 3 0
LIST SIZE EXT_NAME
1 6 1 3
2 1 4 1
3 2 3 2
INT_NAME
1 2
2 3
3 1
1 procedure Union2(I,J,K)
2 begin A:=INT_NAME[I]; B:=INT_NAME[J];
3 { dopisujemy krtsz do duszej }
4 if SIZE[A]>SIZE[B] then zamieniamy rolami A i B;
5 e := LIST[A];
6 while e<>0 do { przepisywanie elementw z A do B }
7 begin
8 R[e]:=B;
9 last :=e;
10 e:=NEXT[e];
11 end
12 NEXT[last]:=LIST[B];
13 LIST[B]:=LIST[A];
14 SIZE[B]:=SIZE[A]+SIZE[B];
15 INT_NAME[K]:=B; EXT_NAME[B]:=K;
16 end
Zoono Union2
Zoono wykonania n 1 instrukcji Union2 to O(n log n).
Taka zoono wynika z faktu, e kady element moe by przeoony
tylko do zbioru niemniej ni 2 razy wikszego.
Co oznacza, e kady element moe by przenoszony co najwyej log n
razy, daje to koszt O(log n) (dla pojedynczego elementu).
Zoono pojedynczego Find(i ) pozostaje O(1).
Operacje na zbiorach Union-Find
Struktury drzew dla problemu Union-Find
Rodzina zbiorw bdzie reprezentowana przez las drzew. Jedno
drzewo = jeden zbir.
Zbir A ma (tylko) korze T
A
.
Nazw zbioru ma korze drzewa.
Union(A,B,C) mona zrealizowa poprzez:
uczynienie korzenia T
A
synem T
B
,
zmian nazwy korzenia T
B
na C.
T
A
A
+
T
B
B
=
T
CB
T
A
A
B
Koszt czenia: O(1)
Find(i) mona zrealizowa poprzez:
odszukanie wierzchoka, ktry odpowiada i w pewnym drzewie T,
mona uy tablicy wskanikw na wzy drzewa: t[i] wsk. na i-ty
element
przejcie z wierzchoka do korzenia, w ktrym zapisana jest nazwa
drzewa do ktrego naley i .
Koszt Find: O(h), gdzie h, to wysoko drzewa
Koszt Find: jest rzdu dugoci cieki z wierzchoka i do korzenia
drzewa.
Rozpatrzmy cig instrukcji:
Union(1,2,2)
Union(2,3,3)
.
.
.
Union(n-1,n,n)
Find(1)
Find(2)
.
.
.
Find(n)
n
n-1
n-2
2
1
Cig instrukcji Union powoduje powstanie
drzewa listy:
Wtedy koszt wykonania n instrukcji Find wy-
nosi:
n1
i =0
i =
n(n1)
2
.
Taki koszt wymusza, aby czc minimalizo-
wa wysoko wynikowego drzewa poprzez
przyczanie mniejszego drzewa pod wiksze.
T
A
A
+
T
B
B
=
T
CA
A
T
B
B
Kompresja cieki
Kolejna modykacja polega na kompresji cieki podczas
wykonywania funkcji Find koszt tej funkcji jest duo wikszy ni
Union.
Koszt Find(i) jest zwizany z dugoci cieki od wierzchoka i do
korzenia r drzewa.
i , v
1
, v
2
, . . . , v
n1
, r cieka od i do r .
Kompresja cieki to uczynienie kadego wierzchoka v
j
synem
korzenia r :
r
T
r
k
T
k
j
T
j
i
T
i
r
T
r
k
T
k
j
T
j
i
T
i
Implementacja moe by oparta o tablice.
Inicjowanie:
COUNT[i ] = 1 1 i n liczno zbioru, ktremu odpowiada
i-ty wze
NAME[i ] = i 1 i n nazwa i-tego zbioru
FATHER[i ] = 0 1 i n czyli kade drzewo to pojedynczy
wze.
ROOT[i ] = i 1 i n id wza-korzenia i-tego zbioru
na pocztku wze = korze
1 procedure Find(i);
2 begin
3 oprnij list LIST;
4 v:=i ;
5 while FATHER[v] ,= do
6 begin
7 dodaj v do LIST;
8 v:=FATHER[v];
9 end
10 { v jest teraz korzeniem }
11 foreach w LIST do
12 FATHER[w]:=v;
13 return NAME[v];
14 end
1 procedure Union(i,j , k);
2 begin
3 if COUNT[ROOT[i]] > COUNT[ROOT[j]] then
4 zamieniamy rolami i z j ;
5 LARGE:=ROOT[j];
6 SMALL:=ROOT[i];
7 FATHER[SMALL]:=LARGE;
8 COUNT[LARGE]:=COUNT[LARGE]+COUNT[SMALL];
9 NAME[LARGE]:=k;
10 ROOT[k]:=LARGE;
11 end
Zoono
n instrukcji Union-Find teraz ma zoono: O(n log
n).
log
n = G(n) = arg min

i
F(i ) n
F(0) = 1,
F(i ) = 2
F(i 1)
i > 0
i F(i )
0 1
1 2
2 4
3 16
4 65536
5 2
65536
Algorytm Tarjana
Mamy drzewo T i chcemy wyznacza pierwszego wsplnego
przodka dla zadanych par wierzchokw drzewa. Czyli taki przodek
p i q, e jest przodkiem obu wierzchokw i ma najwyszy stopie
(najgbszy).
Algorytm oine: dla zadach z gry par wierzchokw znale
odpowiedzi.
Oznaczenia:
r korze drzewa.
n.children dzieci wierzchoka n.
P zbir par wierzchokw dla ktrych szukamy wsplnych przodkw.
W pierwszym kroku wykonywane jest wywoanie:
Tarjan(r)
Bdziemy korzysta z operacji na zbiorach rozcznych:
Find, Union, MakeSet
1 function Init (T)
2 foreach v in T
3 v. color = white;
4 end
1 function MakeSet(x)
2 x. parent = x;
3 x. size = 1;
4 end
a
g
i h
j
b
d c
1 function Tarjan(u)
2 MakeSet(u)
3 u. ancestor = u;
4 foreach v in u. children do
5 Tarjan(v);
6 Union(u,v);
7 Find(u). ancestor = u;
8 u. color = black;
9 foreach v such that u, v in P do
10 if v. color == black then
11 wynik += [(u,v) > Find(v).ancestor];
12 end
Jak optymalnie dobra struktur P? Set of sets. . .
Drzewa przedziaowe
Drzewo przechowuje pewne informacje o przedziaach a nie tylko
punktach/wartociach
Kady wierzchoek opisany jest wic przez punkt i dodatkowe
informacje. Np. szeroko przedziau, ale czsto i inne parametry
jak liczba punktw, wartoci rednie duych przedziaw/poddrzew.
Czasy operacji na drzewie: O(n log n) (zakada si, e mamy realizacj
przez drzewa binarne zrwnowaone, np. czerwonoczarne)
Przydatne w przernych zastosowaniach:
Aktywne przechowywanie zajtych przedziaw.
Czy punkt naley do ktrego z przedziaw?
Wszelkie inne dynamiczne operacje na przedziaach, jak czenie,
usuwanie, . . .
Ile jest punktw/kluczy pomidzy a i b?
Problem silnie spjnych skadowych
Grafy problem silnie spjnych skadowych
Silnie spjn skadow grafu G = (V, E) jest maksymalny zbir
U V taki, e dla kadej pary wierzchokw v i u istnieje cieka z
v do u i z u do v.
Cz algorytmw grafowych wykorzystuje algorytm podziau na
silnie spjne skadowe. Nastpnie rozwizuje w ramach skadowych
podproblemy i nalnie czy rezultaty.
Zobaczymy, e mona to zrobi za pomoc dwukrotnego
przeszukiwania w gb.
Transpozycja grafu G(V, E) to G
T
(V, E
T
) gdzie
E
T
= (u, v) : (v, u) E.
Wane: Zoono wyznaczenia G
T
wynosi O(V + E).
Wasno: G i G
T
skadaj si z tych samych silnie spjnych skadowych.
Jeli u i v s osigalne jeden z drugiego w G to i w G
T
.
W celu wyznaczenia silnie spjnych skadowych bdziemy stosowa dwa
przeszukiwania w gb, jedno dla grafu G a drugie dla grafu G
T
.
1 procedure SilnieSpjneSkadowe(G(V, E))
2 wykonaj DFS(G) zapamitujc f [u] (czas
3 przetworzenia kadego wierzchoka u);
4 wyznacz G
T
;
5 wykonaj DFS(G
T
(V, E
T
)), przy czym gwna ptla DFS
6 analizuje wierzchoki w kolejnoci malejcych
7 wartoci f [u];
8 wypisz wierzchoki z kadego drzewa lasu
9 przeszukiwania w gb dla G
T
jako oddzieln
10 skadow;
11 end
[skadowe = drzewa z czerwonych krawdzi]
G
a
13/14 b
11/16
c
1/10 d
8/9
e
12/15 f
3/4
g
2/7 h
5/6
G
T
a
b
c
d
e
f
g
h
G
skadowych
abe cd
fg
h
Warto zauway: jeli u i v nale do tej samej silnie spjnej
skadowej (sss) i wierzchoek w ley na ciece z u do v lub z v do
u,
to
w musi nalee do tej samej silnie spjnej skadowej.
Wiemy e istnieje u w,
mamy take: w v u = w u.
DFS zawsze umieci wierzchoki danej silnie spjnej skadowej w
tym samym drzewie przeszukiwania w gb.
Niech r bdzie pierwszym odwiedzonym wierzchokiem pewnej silnie
spjnej skadowej. Wtedy pozostae wierzchoki tej SSS s biae.
Z waciwoci DFS mamy, e kady wierzchoek osigalny
z r i nieodwiedzony bdzie odwiedzony i dopisany do drzewa do
ktrego naley r .
Z drugiej strony wiemy, e istnieje droga z r do kadego
wierzchoka silnie spjnej skadowej. Czyli drzewo z r zbudowane
przez DFS bdzie zawiera wszystkie osigalne z r wierzchoki.
Praprzodek (u) wierzchoka u:
(u) = w : u w f [w] jest najwiksze dla DFS(G)
f [w] czas przetworzenia w przez DFS(G) (nie G
T
!!).
Waciwoci praprzodka:
moliwe jest e: (u) = u.
co daje: f [u] f [(u)] ()
u v f [(u)] f [(v)]
poniewa w : v w w : u w.
Z powyszego: f [(u)] f [((u))], a z () mamy
f [(u)] f [((u))],
czyli: f [(u)] = f [((u))],
a ostatecznie mamy (u) = ((u)) (poniewa nie ma 2
wierzchokw o tym samym czasie przetworzenia).
W kadym przeszukiwaniu w gb praprzodek (u) jest przodkiem u.
gdy (u) = u oczywiste.
wpp. rozwaymy kolory (u) w kroku d[u]:
1 (u) niebieski (przetworzony)
wtedy: f [(u)] < f [u] sprzeczno z w. praprzodka.
2 (u) czerwony (przetwarzany), to jest przodkiem
(doszlimy z (u) do u!).
3 (u) biay (nieodwiedzony)
u...........biae..............(u) f [(u)] < f [u] (czyli nie jest
praprzodkiem)
u.......niebiay(t)..biae.....(u) tczerwony (od nieb. do
biaego nie ma krawdzi). Wtedy (u) stanie si potomkiem t co
daje: f [(u)] < f [t], czyli zy wybr praprzodka (sprzeczno).
Z powyszego i z denicji praprzodka:
u i (u) le w tej samej silnie spjnej skadowej (istnieje cieka z
u do (u) i odwrotnie).
Dwa wierzchoki u i v le w tej samej silnie spjnej skadowej
maj tego samego praprzodka. (!!)
Gdy u i v w tej samej skadowej, to kady w osigalny z u jest

osigalny z v i odwrotnie. Czyli (u) = (v).
(u) = (v). Wiemy te, e u i (u) nale do tej samej silnie

spjnej skadowej. To samo zachodzi dla v. Czyli u i v s w tej
samej sss.
Konkluzja: Praprzodek r + wierzchoki dla ktrych r jest
praprzodkiem tworz sss!
Przeszukiwanie DFS dla G
T
rozpoczyna si od wierzchoka r z
najwikszym czasem przetworzenia f [.]. Czyli r musi by
praprzodkiem.
Inne wierzchoki silnie spjnej skadowej z r , to te dla ktrych r
jest praprzodkiem!
Czyli s to wszystkie wierzchoki, dla ktrych r jest osigalne i nie
jest osigalny aden inny w. z f [.] wikszym od f [r ] (czyli wszystkie
v r ).
Czyli takie, ktre s osigalne z r w G
T
.
Po wyznaczeniu pierwszego drzewa z DFS dla G
T
(pierwszej
sss). DFS jest kontynuowane i rozpoczyna od nieodwiedzonego
jeszcze wierzchoka r
o maksymalnym f [.].
Jak poprzednio (nieodwiedzone) wierzchoki z ktrych r
jest
osigalny skadaj si na sss. Czyli wierzchoki nieodwiedzone
osigalne z r
w G
T
skadaj si na kolejn sss.
SSS, Punkty artykulacji i mosty
SSS vs drogi miasta wyznaczanie krytycznych odcinkw drg.
Punkt artykulacji = wierzchoek (skrzyowanie), ktrego usunicie
rozspjnia graf.
Most = krawd, ktrej usunicie rozspjnia graf.
Zadania
Analiza algorytmu.
Jak wyznaczy graf skadowych? Podaj algorytm.
Jak wyznaczy punkty artykulacji i mosty? Podaj algorytm.
Problem spenialnoci regu logicznych
Problem spenialnoci regu logicznych SAT
Problem SAT: Czy zadana regua logiczna L oparta o zmienne
logiczne x
1
, . . . , x
n
jest spenialna?
Czyli czy istnieje pewne przypisanie wartoci prawda lub fasz
zmiennym x
i
, dla ktrego regua L bya speniona?
W oglnoci wyraenie L moe skada si z rnych operatorw
logicznych: , , , =, XOR, , , . . .
Dla wikszo typw regu logicznych nie ma efektywnych
(wielomianowych) algorytmw. Co pozostawia testowanie 2
n
moliwych ukadw prawda/falsz.
Rne formy reprezentacji regu logicznych. Np. CNF i DNF
CNF (conjunction normal form)
L = (p
11
. . . p
1k
1
) (p
21
. . . p
2k
2
) . . . (p
n1
. . . p
nk
n
)
gdzie p
ij
to pewna zmienna x
q
lub x
q
.
DNF (disjunction normal form)
L = (p
11
. . . p
1k
1
) (p
21
. . . p
2k
2
) . . . (p
n1
. . . p
nk
n
)
k-CNF i 2-CNF
k-CNF (conjunction normal form)
L = (p
11
. . . p
1k
) (p
21
. . . p
2k
) . . . (p
n1
. . . p
nk
)
2-CNF (conjunction normal form)
L = (p
11
p
12
) (p
21
p
22
) . . . (p
n1
p
n2
)
Dla dowolnej postaci rgu logicznych problem jest NP-zupeny
Dla 3-CNF problem jest NP-zupeny
Dla 2-CNF problem ma efektywny algorytm!
Algorytm spenialnoci regu typu 2-CNF
Przejcie z 2-CNF do postaci koniunkcji implikacji
Analiza silnie spjnych skadowych
Ustalenie konsekwencji wynikajcych z SSS
Moliwo wyznaczenie wartoci zmiennych x
i
realizujcych
spenialno formuy, jeli tylko to moliwe.
Przejcie z 2-CNF do postaci koniunkcji implikacji
(x
0
x
3
) (x
0
= x
3
) (x
3
= x
0
)
p q p = q q = p p q
0 0 1 1 1
0 1 1 1 1
1 0 0 0 0
1 1 1 1 1
(x
0
x
2
) (x
0
x
3
) (x
1
x
3
) (x
1
x
4
)
(x
2
x
4
) (x
0
x
5
) (x
1
x
5
) (x
2
x
5
)
(x
3
x
6
) (x
4
x
6
) (x
5
x
6
)
1 function Test_2CNF(CNF_rule)
2 CNF_rule > Graf implikacji G
3 SSS = Silnie_spojne_skladowe(G)
4 foreach v in V do
5 if SSS[v] == SSS[v] then
6 return false ;
7 return true;
8 end
Zmienne nalece do jednej SSS skadowej musz mie tak sam
warto! Czyli nie mog do SSS nalee: x
k
i x
k
.
1 function Test_2CNF(CNF_rule)
2 CNF_rule Graf implikacji G
3 SSS = Silnie_spjne_skadowe(G)
4 foreach v in V do
5 if SSS[v] == SSS[v] then
6 return false ;
7 Tworzenie grafu silnie spjnych skadowych
8 L = list of SSS; porzdek zgodny z drugim DFS
9 foreach c in L do
10 if all v in c bez przypisanych wartoci
11 ustawi wszystkie v na false
12 ustawi w komplementarnych skadowych wartoci
13 v
na true
14 (tych do ktrych prowadz krawdzie)
15 return wektor wartoci zmiennych x;
16 end
Tak wyznaczone wartoci zmiennych logicznych speniaj regu.
Cykl Eulera
Cykl Eulera
Cyklem Eulera nazywamy taki cykl w grae G(V, E) (skierowany bd
nie), ktry przechodzi przez wszystkie krawdzie dokadnie raz i przez
kady wierzchoek przynajmniej raz.
Cykl Eulera
Dla grafu spjnego skierowanego:
Cykl Eulera istnieje wtedy i tylko wtedy gdy dla kadego wierzchoka
liczba krawdzi wchodzcych i wychodzcych jest rwna.
Dla grafu spjnego nieskierowanego:
Cykl Eulera istnieje wtedy i tylko wtedy gdy stopie kadego wierzchoka
jest parzysty.
Cykl Eulera
1 procedure CyklEulera(G, u)
2 push(STOS,u);
3 while STOS <> do
4 v:=top(STOS);
5 if S[v]= then
6 begin
7 pop(STOS);
8 LISTA v; {wstaw v na pocztek}
9 end else
10 begin
11 w:=pop(S[v]);
12 push(STOS,w);
13 end
14 return LISTA;
15 end
Cykl Eulera
12562341
3 6
4 2
1 5
3 8
4 2
1 7
5 6
12782341561
Problem maksymalnego przepywu
Sieci przepywowe
rdo (s) i ujcie (t)
Transport (przepyw) towaru od rda wytwarzania do ujcia
(miejsca zuycia).
v
1
v
3
s
t
v
2
v
4
16
12
20
13
10 4
14
9
4
7
Zastosowania:
Modelowanie przepywu cieczy w sieci kanaw, przepustowoci drug
publicznych.
Przepyw informacji w sieciach komunikacyjnych (Internet, telefonia
cyfrowa).
Modelowanie przepywu prdu w sieciach energetycznych.
Wierzchoki miejscowoci (czy komputery, routery, switche, . . . )
Krawdzie kanay przepywu (informacji, cieczy, towaru, . . . )
Waga krawdzi deniuje maksymaln przepustowo krawdzi
(cza).
Wierzchoki na ciekach pomidzy rdem i ujciem s
wykorzystywane do realizacji przepywu.
Szybko wpywania do wierzchoka musi by taka sama jak
wypywania (wasno zachowania przepywu)!
Towar/Informacja nie jest przetrzymywany(-a) w wierzchokach.
Maksymalny przepyw = maksymalna prdko z jak mona
transportowa towar ze rda do ujcia.
Sie przepywowa to graf G(V, E), gdzie dla kadej krawdzi (u, v)
mamy okrelone c(u, v) 0, co odpowiada przepustowoci krawdzi.
Jeli (u, v) , E to c(u, v) = 0.
Sie przepywowa ma wyrnione dwa wierzchoki: rdo s i ujcie t.
Przepyw sieci
Przepyw sieci G to funkcja f : V V , ktra spenia trzy warunki:
Warunek przepustowoci: dla wszystkich u i v mamy
f (u, v) c(u, v).
Oznacza to, e przepyw nie moe przekracza przepustowoci.
Warunek skonej symetrycznoci: dla wszystkich u i v mamy
f (u, v) = f (v, u).
Mamy wic: f (u, u) = f (u, u), czyli f (u, u) = 0.
Warunek zachowania przepywu: dla kadego u V s, t mamy
vV
f (u, v) = 0.
Warunek wymusza aby cay towar wpywajcy do u wypywa z u
Z warunku skonej symetrycznoci i zachowania przepywu mamy:
Dla kadego v V s, t
uV
f (u, v) = 0.
f (u, v) nazywa si przepywem netto z wierzchoka u do v (moe by
dodatni bd ujemny).
Warto przepywu [f [ deniuje si jako
[f [ =
vV
f (s, v)
czny przepyw netto wypywajcy ze rda s. Jak potem zobaczymy
bdzie rwny cakowitemu wpywowi do t.
v
1
v
3
s
t
v
2
v
4
16
12
20
13
10 4
14
9
4
7
przepyw / przepustowo
v
1
v
3
s
t
v
2
v
4
11/16
12/12
15/20
8/13
10
1/4
11/14
4/9
4/4
7/7
UWAGA: Prezentujemy TYLKO dodatni przepyw netto (f (u, v) > 0).
a
v
1
v
2
10 4
b
v
1
v
2
8/10
4
c
v
1
v
2
8/10 3/4
d
v
1
v
2
5/10
4
e
v
1
v
2
10
2/4
a przepustowoci G
b 8 z v
1
do v
2
c 8 z v
1
do v
2
i 3 z v
2
do v
1
d po REDUKCJI: 5 z v
1
do v
2
Czyli nie ma sensu woenie tego samego towaru z v
1
do v
2
i z v
2
do v
1
.
e dodatkowo 7 z v
2
do v
1
Sieci z wieloma rdami i wieloma ujciami
Problem maksymalnego przepywu mona take zdeniowa dla wicej
ni jednego rda i wikszej liczby uj.
Na szczcie problem maksymalnego przepywu w takim przypadku jest
tak samo trudny. Co wicej problemy s rwnowane.
Mona wprowadzi super-rda s ktre bdzie poczone z kadym
rdem s
i
(i = 1, . . . , n) krawdzi o przepustowoci . Wprowadzamy
analogicznie super-ujcie t, do ktrego wpadaj krawdzie z kadego
ujcia t
j
(j = 1, . . . , m) take o nieskoczonej przepustowoci.
s
1
s
2
t
1
s
s
3
t
2
t
s
4
t
3
s
5
10
5
14
11
12
8
7
2
3
6
13
15
20
18
Zmiana notacji:
V s V s
Niech
f (X, Y) =
xX
yY
f (x, y)
Wtedy prawo zachowania przepywu to: f (u, V) = 0 dla u V s t.
Lemat
Zachodz nastpujce wasnoci:
f (X, X) = 0 X V
f (X, Y) = f (Y, X) X, Y V
Niech X, Y, Z V i X Y = , wtedy:
f (X Y, Z) = f (X, Z) + f (Y, Z)
f (Z, X Y) = f (Z, X) + f (Z, Y)
Moemy pokaza, e
[f [ = f (V, t)
Czyli, e czny przepyw jest rwny cakowitemu wpywowi do ujcia.
[f [ = f (s, V)
= f (V, V) f (V s, V)
= f (V, V s)
= f (V, t) + f (V, V s t)
= f (V, t)
Problem maksymalnego przepywu Metoda Forda-Fulkersona
Metoda Forda-Fulkersona
Start:
u,v
f (u, v) = 0
cieka powikszajca cieka ze rda s w G do ujcia t po ktrej
moemy przesa wikszy przepyw.
Iteracyjnie, przepyw jest powikszany o moliwoci jakie daje kada
cieka powikszajca.
Koniec gdy nie istnieje adna cieka powikszajca z s do t.
1 procedure FordFulkerson
2 begin
3 inicjowanie f na 0
4 while istnieje cieka powikszajca p do
5 powiksz przepyw f wzdu p
6 return f
7 end
Jak wyznacza cieki powikszajce? Sieci residualne
Sie residualna dla grafu G skada si z krawdzi, ktre dopuszczaj
wikszy przepyw netto.
Przepustowoci residualn dla (u, v) nazywamy dodatkowy przepyw
w G zdeniowany poprzez:
c
f
(u, v) = c(u, v) f (u, v).
np. c(u, v) = 10, f (u, v) = 6, to c
f
(u, v) = 4
G
u
v2
6/10
G
f u
v2
4
Czyli przepustowo residualna to niewykorzystana przepustowo
krawdzi w sieci grafu G.
Gdy przepyw netto jest ujemny przepustowo residualna moe by
wiksza ni c(u, v).
np. c(u, v) = 10, f (u, v) = 6, to c
f
(u, v) = 16
G
u
v2
6/10
G
f u
v2
16
Sieci residualn dla G = (V, E) indukowan przez f nazywamy sie
G
f
= (V, E
f
) tak, e
E
f
= (u, v) V V : c
f
(u, v) > 0.
Czyli sie skada si z tych samych wierzchokw co G, ale krawdzie
tworz przepustowoci residualne czyli krawdzie umoliwiajce uzyskanie
dodatniego przepywu netto.
G, f
v
1
v
3
s
t
v
2
v
4
11/16
12/12
15/20
8/13
10
1/4
11/14
4/9
4/4
7/7
G
f
v
1
v
3
s
t
v
2
v
4
5
11
12
5
15
5
8
11 3
3
11
5
4
4
7
G, f

v
1
v
3
s
t
v
2
v
4
11/16
12/12
19/20
12/13
10
1/4
11/14
9
4/4
7/7
G, f

v
1
v
3
s
t
v
2
v
4
11/16
12/12
19/20
12/13
10
1/4
11/14
9
4/4
7/7
G
f
v
1
v
3
s
t
v
2
v
4
5
11
12
1
19
1
12
11 3
3
11
9
4
7
Liczba krawdzi residualnych [E
f
[ jest ograniczona z gry przez 2[E[.
Lemat
Mamy sie G, rdo s, ujcie t, przepyw f dla G, sie residualn G
f
dla
sieci G indukowan przez f . Niech f

oznacza przepyw w sieci G
f
wtedy
suma przepyww f + f

jest przepywem w sieci G o wartoci
[f + f

[ = [f [ +[f

[
Dowd:
1. skona symetryczno:
(f + f

)(u, v) = f (u, v) + f

(u, v)
= f (v, u) f

(v, u)
= (f (v, u) + f

(v, u))
= (f + f

)(v, u)
2. przepustowo
wiemy: f

(u, v) c
f
(u, v)
(f + f

)(u, v) = f (u, v) + f

(u, v)
f (u, v) + (c(u, v) f (u, v))
= c(u, v)
3. zachowanie przepywu
u V s t
vV
(f + f

)(u, v) =
vV
(f (u, v) + f

(u, v))
=
vV
f (u, v) +
vV
f

(u, v)
= 0 + 0
Warto przepywu [f + f

[ wynosi:
[f + f

[ =
vV
(f + f

)(s, v)
=
vV
(f (s, v) + f

(s, v))
=
vV
f (s, v) +
vV
f

(s, v)
= [f [ +[f

[
cieki powikszajce formalnie
Dla sieci G i przepywu f ciek powikszajc p jest kada cieka z
rda s do ujcia t w sieci residualnej G
f
.
G, f
v
1
v
3
s
t
v
2
v
4
11/16
12/12
15/20
8/13
10
1/4
11/14
4/9
4/4
7/7
G
f
v
1
v
3
s t
v
2
v
4
5
11
12
5
15
5
8
11 3
3
11
5
4
4
7
Przepustowo residualna cieki p:
c
f
(p) = minc
f
(u, v) : (u, v) ley na ciece p
Lemat
Mamy sie G, przepyw f sieci G, ciek powikszajc p w sieci G
f
.
Zdeniujmy funkcj f
p
: V V :
f
p
(u, v) =
c
f
(p) jeli (u, v) jest na p
c
f
(p) jeli (v, u) jest na p
0 wp.p.
Wtedy f
p
jest przepywem w sieci G
f
o wartoci [f
p
[ = c
f
(p) > 0.
Z powyszego lematu wynika, e dodajc przepyw f
p
do f
otrzymujemy wikszy przepyw w G.
Przekroje w sieciach
Mamy sie G = (V, E). Przekrojem (S, T) nazywamy taki podzia V na
S i T, e s S i t T, i T = V S.
Wtedy przepyw netto przez przekrj to f (S, T).
A przepustowo przekroju: c(S, T).
S i T
v
1
v
3
s
t
v
2
v
4
11/16
12/12
15/20
8/13
10
1/4
11/14
4/9
4/4
7/7
Niech f bdzie przepywem netto w G, a (S, T) przekrojem. Wtedy
przepyw przekroju rwny jest przepywowi sieci f(S,T)=|f|.
Dowd:
f (S, T) = f (S, V) f (S, S)
= f (S, V)
= f (s, V) + f (S s, V)
= f (s, V)
= [f [
Skd wnioskujemy:
Warto dowolnego przepywu f w G jest nie wiksza ni przepustowo
dowolnego przekroju w G.
Dowd:
[f [ = f (S, T)
=
uS
vT
f (u, v)
uS
vT
c(u, v)
= c(S, T)
Twierdzenie o maksymalnym przepywie i minimalnym
przekroju
Dla sieci G o rdle s i ujciu t nastpujce trzy warunki s rwnowane:
1
Przepyw f jest maksymalny.
2
Sie residualna G
f
nie zawiera cieek powikszajcych.
3
Dla pewnego przekroju (S, T) w G zachodzi: [f [ = c(S, T).
1 2
zamy przeciwnie: f przepyw maksymalny, a G
f
ma ciek
powikszajc. Wtedy jednak wiemy, e f + f
p
bdzie przepywem
wikszym ni f .
2 3
Niech S bdzie zbiorem wierzchokw osigalnych z s:
S = v V : s v w G
f
.
T = V S.
Poniewa nie istnieje cieka powikszajca z s do t w G
f
, to mamy
f (u, v) = c(u, v), gdy tylko u S i v T. W przeciwnym przypadku v
byby w S. Mamy wic: f (S, T) = c(S, T) = [f [.
3 1
dla kadego przekroju zachodzi: f c(S, T). Czyli [f [ = c(S, T)
oznacza, e jest to maksymalny pord moliwych przepyww.
1 procedure FordFulkerson(G,s,t)
2 begin
3 foreach (u, v) E do
4 begin f (u,v)=0; f(v,u)=0; end
5
6 while istnieje cieka p z s do t w G
f
(graf
7 residualny ) do
8 begin
9 c
f
(p) = minc
f
(u, v) : (u, v) jest na p
10 for kada krawd (u, v) na p do
11 begin f(u,v) = f(u,v) + c
f
(p);
12 f (v,u) = f(u,v)
13 end
14 end
15 end
Gdy zaoy, e przepustowo bdzie wyraana w liczbach cakowitych
to zoono algorytmu wynosi O(E[f

[), gdzie f

jest maksymalnym
przepywem.
Wynika to z faktu, i znalezienie cieki powikszajcej w G
f
jest
proporcjonalne do E (np. poprzez przeszukiwanie w gb), a kade
powikszenie cieki moe w najgorszym razie poprawi przepyw netto o
1.
Warto uywa, gdy [f

[ jest nie za due.
Zastpujc przeszukiwanie w gb na przeszukiwanie wszerz aby
znale ciek powikszajc w grae residualnym zoono redukuje
si do O(VE
2
)
Problem maksymalnego przepywu Metody przedprzepywowe
Metody przedprzepywowe
Aby wyobrazi sobie jak dziaa ta metoda lepiej myle o przepywie
wody, ktra moe pyn tylko w d.
Na potrzeby algorytmu kady wierzchoek bdzie mia zbiornik o
nieograniczonej pojemnoci. Kady wierzchoek wraz z przyczami
rur umieszczamy na specjalnej platformie, ktrej pozycja bdzie
podnoszona wraz z dziaaniem algorytmu.
Wysoko wierzchoka bdzie w istotny sposb wpywa na
przepyw!!!
Metoda przedprzepywowa nie bdzie utrzymywaa wasnoci
zachowania przepywu. Natomiast bdzie speniony warunek
sabszy: f (V, u) 0, ktry okrela sumaryczny wpyw do pewnego
wierzchoka u (u V s).
u bdzie wierzchokiem nadmiarowym, gdy f (V, u) > 0 (nadmiar:
e[u] = f (V, u)).
Przepyw jest realizowany tylko do wierzchoka pooonego niej, ale
funkcja przepywu moe mie wartoci dodatnie skierowane do
wierzchoka pooonego powyej.
Wysoko rda wynosi [V[, a ujcia 0 to nie podlega zmianie.
Wysokoci pozostaych wierzchokw s ustawione na pocztkow
warto 0 i bd rosy.
Startujemy z realizacj caego przepywu, wypywajcego ze rda
wypeniajc maksymalnie istniejce odprowadzajce rury.
Woda najpierw traa do zbiornika a nastpnie jest kierowana do
pooonych niej wierzchokw.
Jednak problem polega na tym, e aby woda pyna dalej
wierzchoek musi by powyej niewypenionych jeszcze innych
wierzchokw poczonych rurami. Tak moe nie by.
W takich przypadkach bdziemy podnosi wysoko wierzchoka,
aby nadmiar wody mg spyn niej.
Wysoko takiego wierzchoka podnosimy o 1 wicej ni wysoko
najniszego wierzchoka do ktrego prowadzi niewypeniona w
caoci rura.
Dziki temu pewien nadmiar wody bdzie mg spyn w d.
Po powtrzeniach tej operacji w kocu caa woda spynie do ujcia.
Jednak nie wicej ni to moliwe dziki ograniczeniu
przepustowoci krawdzi.
Jednake tak uzyskany przepyw moe by nielegalny poniewa
moe pozosta woda w zbiornikach wierzchokw, ktra nie ma jak
spyn.
Taki nadmiar cofany jest do rda poprzez podnoszenie wysokoci
wierzchokw powyej wysokoci rda [V[. A w algorytmie bdzie
to realizowane przez kasowanie przepyww nadmiarowych.
Po oprnieniu zbiornikw uzyskujemy legalny i maksymalny
przepyw.
Operacje PUSH i LIFT
Algorytm skada si z szeregu wykona operacji przesyania
nadmiaru wody (PUSH) i podnoszenia wysokoci wierzchokw
(LIFT).
Funkcja h : V N jest wysokoci w sieci G = (V, E) ze rdem
s i ujciem t, gdy:
h(s) = [V[,
h(t) = 0,
h(u) h(v) + 1, gdy (u, v) jest krawdzi residualn (u, v) E
f
.
Czyli gdy h(u) > h(v) + 1, to (u, v) nie jest krawdzi w grae
residualnym.
Operacj PUSH(u, v) mona stosowa u jest wierzchokiem
nadmiarowym (e[u] > 0) i h(u) = h(v) + 1 (tj. jest co do przelania
i u jest bezporednio nad v).
e[u] bdzie nadmiarem wody przechowywanym w wierzchoku u.
d
f
(u, v) przechowuje informacj o wielkoci przepywu jaki mona
przesa z u do v.
1 procedure PUSH(u,v)
2 d
f
(u, v) = min(e[u], c
f
(u, v))
3 f [u, v] = f [u, v] + d
f
(u, v)
4 f [v, u] = f [u, v]
5 e[u] = e[u] d
f
(u, v)
6 e[v] = e[v] + d
f
(u, v)
7 end
Warto zwrci uwag, e gdy f jest przedprzepywem to po
wykonaniu PUSH(u, v) te bdzie przedprzepywem.
Operacja PUSH(u, v) przesyania jest nasycajca, gdy po jej
wykonaniu c
f
(u, v) = 0.
Operacja LIFT(u) jest wykonywana gdy:
1
u jest nadmiarowy
2

v
(u, v) E
f
h[u] h[v] tj. woda nie moe si przela.
1 procedure LIFT(u)
2 h[u] = 1 + min(h[v] : (u, v) E
f
)
3 end
Operacja LIFT jest stosowana tylko, gdy woda moga by si przela
z wierzchoka u, ale nie moe.
1 procedure Initialize PreFlow(G,s)
2 foreach u V do
3 h[u]=0, e[u]=0;
4 foreach (u, v) E do
5 f [ u,v]=0, f [v, u]=0;
6 h[s]=[V[;
7 foreach u S[s] do
8 begin
9 f [ s , u]=c[s, u];
10 f [ u, s]=c[u,s];
11 e[ u]=c[s, u];
12 end
13 end
1 procedure GenericPreFlowPUSH(G)
2 Initialize PreFlow(G,s);
3 while mona stosowa operacj przesania
4 lub podniesienia do
5 wybierz jedn z operacji i wykonaj;
6 end
Zoono metody przedprzepywowej
Ograniczenie na liczb podnosze: < 2[V[
2
.
Ograniczenie na liczb przesa nasycajcych: < 2[V[[E[
Ograniczenie na liczb przesa nienasycajcych: < 4[V[
2
([V[ +[E[)
Ostatecznie zoono wynosi: O(V
2
E)
Od O(V
2
E) do O(V
3
) Podnie i przesu na pocztek
Aby osign powysz zoono nowy algorytm bdzie bazowa na
licie wierzchokw L, co bdzie regulowao cilej kolejnoci
wykonywanych operacji PUSH i LIFT.
Lista ta bdzie przegldana od pocztku w poszukiwaniu
wierzchoka nadmiarowego.
W nastpnym kroku nastpuje cakowite rozadowanie takiego
wierzchoka (poprzez wykonywanie operacji PUSH i LIFT a do
skutku).
Jeli wierzchoek podczas rozadowywania uleg podniesieniu zostaje
przeniesiony na pocztek listy L, a gwna ptla algorytmu
rozpoczyna prac od pocztku listy L (w poniszej implementacji
tak naprawd od drugiego wierzchoka).
1 procedure Discharge(u)
2 while e[u]>0 do
3 begin
4 v:=currentS[u];
5 if v=NIL then ( po ostatnim ssiedzie )
6 begin
7 LIFT(u);
8 currentS[ u]:=head[S[u ]];
9 end
10 else if c
f
(u, v) > 0 AND h[u]=h[v]+1 then
11 PUSH(u,v);
12 else currentS[ u]:=nextS[v ];
13 end
14 end
1 procedure LiftToFront(G,s,t)
2 Initialize PreFlow(G,s);
3 L:=Vst;
4 foreach v V s t do
5 currentS[u]:=head[S[u ]];
6 u:=head[L];
7 while u ,= NIL do
8 begin
9 oldHeight[u]:=h[u];
10 Discharge(u);
11 if h[u]>oldHeight then
12 przesu u na pocztek L;
13 u:=nextS[u];
14 end
15 end
Algorytmy plecakowe
Algorytmy plecakowe
Trzy rne problemy adowania"plecaka = trzy rne algorytmy
Niewielka zmiana denicji problemu = wielka zmiana koncepcji
optymalnego rozwizania, wielka rnica w zoonoci
Algorytmy plecakowe
Cigy problem plecakowy
Mamy plecak o pojemnoci W.
Mamy dany zbir N towarw. Kady towar ma swoj cen c
i
i
wielko w
i
.
Kadego towaru mona wzi dowoln ilo lecz nie wicej ni w
i
.
cznie nie mona wzi wicej towarw ni W.
Warto zaadowanego plecaka ma by najwiksza.
Co rozwizuje problem?
Algorytmy plecakowe
Wyznaczmy wzgldn warto towarw:
q
i
=
c
i
w
i
Teraz wiemy co jest najbardziej wartociowym towarem, czy to
zoto, czy biaa herbata, czy diamenty???
Sortujemy cig q
i
od najwartociowszego towaru.
Bierzemy kolejno towary, zgodnie z posortowaniem, ktre mieszcz
si w plecaku a do penego wypenienia.
Algorytmy plecakowe
1 procedure PlecakCiagly(W, N, w, c)
2 for i =1 to N do
3 q
i
= c
i
/w
i
4 sortowanie tablic w, c i q wzgldem q (od najwikszego)
5 x=0;
6 i =1;
7 while x < W && i <= N do
8 // we tyle towaru i do plecaka ile wejdzie ;
9 x += min(w_i, Wx)
10 i ++;
11 end
12 end
Zoono: O(N log N) z powodu sortowania.
Algorytmy plecakowe
Dyskretny problem plecakowy
i
i
wielko w
i
.
Kady towar w
i
mona wzi lub nie wzi.
Suma wielkoci zaadowanych towarw nie moe przekracza W.
Warto zaadowanego plecaka ma by moliwie najwiksza.
Peny przegld moliwoci: O(2
N
)
Problem NP zupeny!
Algorytmy plecakowe
Dynamiczne rozwizanie problemu dyskretnego
Rozwizanie pseudo-wielomianowe jest moliwe dziki pewnym
sprytnym zaoeniom. . .
Zamy, e W jest wartoci cakowit a take kade z wartoci w
i
jest cakowite.
Wtedy moemy inaczej spojrze na cao problemu:
Co zrobi moemy gdy mamy W
= 1 i jeden towar?
= 2 i jeden towar?
= 3 i jeden towar?
= 1 i dwa towary?
= 2 i dwa towary?
= 3 i dwa towary?
Algorytmy plecakowe
A(i ) najwiksza warto jak mona uzyska za pomoc plecaka o
pojemnoci i .
Mamy wtedy zaleno rekurencyjn:
A(0) = 0
A(i ) = maxc
j
+ A(i w
j
) : w
j
i
Wyznaczenie kolejno: A(0), A(1), . . . , A(W) rozwizuje zadanie w
zoonoci O(WN)
1 procedure PlecakDynamiczny1(W, N, w, c)
2 for i :=0 to W do
3 A[i ]:= 0
4
5 for i :=0 to W do
6 for j :=1 to N do
7 //czy j ty towar mieci si w plecaku o rozmiarze i
8 if ( w[j ] <= i ) then
9 A[ i ] = max(A[i], A[ i w[j]] + c[j ])
10 end
Algorytmy plecakowe
A(i , j ) najwiksza warto jak mona uzyska za pomoc pierwszych
i towarw i plecaka o pojemnoci j .
Mamy wtedy zaleno rekurencyjn:
A(0, j ) = 0
A(i , 0) = 0
A(i , j ) = A(i 1, j ) jeli w
i
> j
A(i , j ) = max(A(i 1, j )

bez i
, c
i
+ A(i 1, j w
i
)

z i
) jeli w
i
j
Algorytmy plecakowe
1 procedure PlecakDynamiczny2(W, N, w, c)
2 for i :=0 to N do
3 A[i ,0]:= 0
4 for j :=0 to W do
5 A[0, j ]:= 0
6
7 for i :=1 to N do
8 for j :=0 to W do
9 if ( w[i ] > j ) then
10 A[ i , j ] = A[i1,j]
11 else
12 A[ i , j ] = max(A[i1,j], A[ i 1,jw[i]] + c[ i ])
13 end
Zoono: O(NW)
Algorytmy plecakowe
Dyskretny problem plecakowy II
i
i
wielko w
i
.
Kady towar w
i
mona wzi lub nie wzi.
Suma wielkoci zaadowanych towarw musi by rwna W.
Warto zaadowanego plecaka ma by moliwie najwiksza.
Peny przegld moliwoci: O(2
N
)
Problem NP zupeny!
Klasy zoonoci
Jzyki formalne
Alfabet zbir symboli (liter)
np.: = 0, 1
sowo puste
zbir wszystkich sw
np.:
= , 0, 1, 00, 01, 10, 11, 000, . . . dla j.w.

Jzyk to podzbir
dla ustalonego zbioru symboli

np.: L = 1, 11, 111, 1111, . . .,
np.: L = 10, 1100, 111000, 11110000, . . .
Na jzykach mona wykonywa: sumy, przecicia, dopenienie,
domknicie Kleenea (L
)
L
= L L
2
L
3
. . ., gdzie
L
k
to k-krotna konkatenacja L z L.
Klasy zoonoci
Jzyk i Problem decyzyjny
Niech Q bdzie problemem decyzyjnym:
Q :
0, 1
Wtedy moemy zdeniowa jzyk:
L = x
: Q(x) = 1
Klasy zoonoci
Algorytm werykacji
deniowany jest jako algorytm o dwch argumentach.
Pierwszy to zwyke wejcie x (cig danych), a drugie to wiadectwo.
Algorytm werykuje cig x jeli istnieje wiadectwo y takie, e
A(x, y) = 1, czyli algorytm A werykuje x z pomoc wiadectwa y.
Jzyk L werykowany przez algorytm A to:
L = x 0, 1
: istnieje y 0, 1
, takie, e A(x, y) = 1
L skada si z takich sw x, dla ktrych istnieje y, ktre uyte przez A
daje mu moliwo werykacji przynalenoci x do L.
Jeli jaki x , L, to nie istnieje y za pomoc ktrego A zwerykowao by
pozytywnie x (a podsunicie faszywego wiadectwa y dla A te koczy
si klsk! Poniewa A potra werykowa).
Klasy zoonoci
Problem cyklu Hamiltona
Cykl Hamiltona dla grafu nieskierowanego G to cykl prosty zawierajcy
wszystkie wierzchoki z V.
Problem cyklu Hamiltona to sprawdzenie czy G ma cykl Hamiltona.
Mona zdeniowa jzyk formalny:
GCH = G : G jest grafem z cyklem Hamiltona
jako zbir swgrafw, ktre posiadaj cykl Hamiltona.
Zadanie algorytmu mona wtedy widzie jako sprawdzenie czy dany
graf G naley do jzyka GCH, czyli czy posiada cykl Hamiltona.
Klasy zoonoci
Natomiast zadaniem algorytmu werykacji jest sprawdzenie czy dla
grafu G i pewnego wiadectwa y, G jest grafem Hamiltonowskim. W
przypadku problemu grafu Hamiltonowskiego (zawierajcego cykl H.)
wiadectwem moe by lista wierzchokw cyklu H. (jeli istnieje . . . ).
Algorytm werykacji wtedy ma atwiejsze zadanie, werykuje tylko czy
wiadectwo jest prawdziwym cyklem dla danych, czyli grafu G. Co jest
ju prostym zadaniem (o zoonoci O(n
2
)).
Klasy zoonoci
Klasy zoonoci, algorytmy werykacji i problemy
nierozstrzygalne
Klasy zoonoci problemw:
P problemy, dla ktrych daje si skonstruowa algorytm o
zoonoci wielomianowej (O(n
k
), kconst) wzgldem rozmiaru
zadania n. Problemy te nazywa si atwymi.
NP intuicyjnie: problemy, dla ktrych nie s znane algorytmy o
zoonoci wielomianowej (O(n
k
), kconst) wzgldem rozmiaru
zadania n.
Formalnie: Problemy dla ktrych istnieje algorytm werykacji
dziaajcy w czasie wielomianowym.
Klasy zoonoci
Problemy NPzupene i NPtrudne
NPzupene. Podzbir problemw NP, ktre daj si redukowa do
innych nietrudniejszych problemw tej klasy w czasie
wielomianowym. Redukowa L
1
do L
2
(L
1

P
L
2
) oznacza
przeksztaca jeden problem w drugi w pewien formalny i
algorytmizowalny efektywnie (czas wielomianowy) sposb.
Formalnie L jest NPzupeny jeli:
1
L NP
2

L
NP
L
P
L
NPtrudne problemy ktre speniaj zaoenie 2 ale niekoniecznie
zaoenie 1.
Klasy zoonoci
Klasy zoonoci cd.
Nie jest znana odpowied na pytanie: Czy P = NP?
Wiemy, e P NP
Wiemy, e NPC NP
Wikszo sdzi, e P ,= NP.
Z innej strony gdyby si nawet okazao, e P = NP, to stopie
wielomianu funkcji zoonoci byby i tak bardzo wielki (tak e
algorytm byby niepraktyczny. . . ).
Klasy zoonoci
Problemy nierozstrzygalne
Problem nierozstrzygalny to taki problem dla ktrego nie tylko nie ma
szybkiego algorytmu, ale wrcz nie istnieje aden algorytm, ktry
rozwizuje dany problem.
Czy kto zna taki problem?
Klasy zoonoci
Problem stopu:
Odpowiedzie na pytanie:
Czy dla algorytmu/programu A i danych x algorytm/program
skoczy swe dziaania.
Problem domina:
Majc skoczony zbir wzorw kafelkw i nieograniczon iloci
kai kadego wzoru odpowiedzie na pytanie: Czy da si takimi
kaami pokry dowoln powierzchni zachowujc kolory kai na
styku krawdzi.
Wdomino (paszczyzna rozstrzygalny, ppaszczyzna
nierozstrzygalny, obszar ograniczony rozstrzygalny)
Problem rwnowanoci skadniowej dwch jzykw.
Klasy zoonoci
Inne problemy NP-zupene
Problem spenialnoci regu logicznych budowanych z bramek
ukadw (AND, OR, XOR, NOT), czy take spenialno regu
logicznych
Problem cieki i cyklu Hamiltona
Problem komiwojaera
Problem kliki
3-kolorowania grafu
Problem plecakowy na pene wypenienie okrelonej objtoci
podzbiorem towarw.
Klasy zoonoci
Problem komiwojaera (problem NP-zupeny) i algorytmy
aproksymacyjne
Znale cykl o najmniejszym koszcie, ktry jest okrelony przez sum
wag krawdzi cyklu Hamiltona.
Mona udowodni, e problem jest NPzupeny pokazujc, e inne
problemy s redukowalne do znajdowania cyklu Hamiltona. To mona
sprowadzi do redukcji znajdowania cyklu Hamiltona do p. komiwojaera.
Dla problemw NPzupenych czsto by rozwiza je efektywnie
poszukuje si algorytmw ktrych rozwizanie nie jest optymalne lecz
przyblione do optymalnego w pewnym stopniu. Algorytmy
aproksymacyjne to caa ga algorytmw, ktrych celem jest
poszukiwanie efektywnych algorytmw przybliajcych rozwizania
problemw NPtrudnych moliwie jak najlepiej, i nie rzadko z pewnymi
gwarancjami.
Klasy zoonoci
Dla praktycznych problemw, gdy wierzchoki s punktami przestrzeni
Euclidesowej koszt krawdzi moe by zdeniowany przez zwyk
odlego Euclidesow.
Mona skorzysta z algorytmu Primy do wyznaczenia minimalnego
drzewa rozpinajcego. Wtedy algorytm moe wyglda jak poniej.
1 procedure TSPPrima(G,c)
2 r:= wybierz wierzchoek korze ;
3 T:=MSTPrima(G,r);
4 niech L bdzie list wierzchokw
5 drzewa rozpinajcego T w kolejnoci preorder
6 return cykl zoony z wierzchokw znajdujcych
7 si w kolejnoci jak w L.
8 end
Klasy zoonoci
Preorder wywietla wierzchoki zgodnie z kolejnoci odwiedzin danego
wierzchoka w drzewie T.
Algorytm TSP-Prima znajduje cykl, ktry jest nieduszy ni
2-krotno optymalnej drogi komiwojaera.
Wyszukiwanie wzorca
Wyszukiwanie wzorca
Dane: alfabet , tablica T[1..n], tablicawzorzec P[1..m], wartoci
tablic T i P s elementami alfabetu .
Problem: Czy P jest podcigiem T, tj. czy istnieje s takie, e:
T[s + 1..s + m] = P[1..m]
T[s + i ] = P[i ] i = 1, . . . , m
Wyszukiwanie wzorca
Prosty algorytm wyszukiwania wzorca
1 procedure SzukajWzoraca(P,T)
2 n:=lenght(T);
3 m:=length(P);
4 for s=0 to nm do
5 if T[s+1..s+m] = P[1..m] then
6 return s ;
7 return 1; {brak wzorca}
8 end
Czas dziaania wiersza 5 (m). Implementacja powinna sprawdza do
pierwszej rnej pary.
cznie czas: ((n m + 1)m).
Wyszukiwanie wzorca Algorytm Rabina-Karpa
Algorytm Rabina-Karpa I
Bardzo dobrze zachowuje si rednio (w praktyce)
Cho jego pesymistyczna zoono te wynosi O((n m + 1)m)
Zamy, e na alfabet skadaj si cyfry 0, 1, . . . , 9 (algorytm
atwo uoglni na dowolny alfabet).
Wtedy T[s +1..s +m] mona interpretowa jako liczb dziesitn t
s
(dla innego alfabetu moe to by liczba w pewnym innym systemie).
Podobnie P[1..m] moe by widziane jako liczba dziesitna p.
Wartoci takich liczb mona wyznacza w czasie O(m):
p = P[m]+10(P[m1]+10(P[m2]+. . . +10(P[2]+10P[1]) . . .))
Algorytm Rabina-Karpa II
atwo zauway, e na podstawie t
s
mona szybko obliczy t
s+1
:
t
s+1
= 10(t
s
10
m1
T[s + 1]) + T[s + m + 1]
Aby uoglni wystarczy w miejsce 10 wpisa podstaw d.
Np.:
t
s
= 1234,
m = 4,
T[s + 1] = 5,
wtedy
t
s+1
= 10(1234 10
3
) + 5 = 2345
Warto zauway, e koszt wyznaczenia p to O(m), take koszt t
i
to
O(m). Cho koszt wyznaczenia wszystkich t
i
ogranicza si do
O(n + m).
Problem gdy m jest nie (bardzo) mae, a to trzeba wkalkulowa.
Rozwizaniem jest liczenie p i t
s
modulo q dla odpowiednio
dobranej wartoci q.
Po co? Jeli (p MOD q) ,= (t
s
MOD q) to nie ma szans, aby
P = T[s + 1..s + m]!
Jak wybra q?
Liczba pierwsza, dla ktrej 10q mieci si w sowie komputera.
Dlaczego tak?
Co daje nowy wzr na t
s+1
:
t
s+1
= (d(t
s
h T[s + 1]) + T[s + m + 1]) MOD q,
gdzie h = d
m1
MOD q odpowiada warto jedynki na
najwyszej pozycji (porwnaj wzr poprzedni).
UWAGA(!) Jednak po takich zmianach to, e t
s
= p MOD q nie
implikuje, e P = T[s + 1..s + m]. W takim przypadku trzeba
jednak sprawdzi czy rzeczywicie P = T[s + 1..s + m]
tradycyjnie. . .
1 procedure SzukajWzoracaRabinKarp(P,T,d,q)
2 begin
3 n:=lenght(T);
4 m:=length(P);
5 h:=d
m1
MOD q;
6 p:=0;
7 t
0
:=0;
8
9
10 for i =1 to m do
11 begin
12 p:=(dp+P[i]) MOD q;
13 t
0
:=(dt
0
+T[i]) MOD q;
14 end
15
16
17
18 for s=0 to nm do
19 begin
20 if p=t
s
then
21 if T[s+1..s+m] = P[1..m] then
22 return s ;
23 if s<mn then
24 t
s+1
:=(d(t
s
hT[s+1]) +T[s+m+1]) MOD q;
25 end
26 return 1; {brak wzorca}
27 end
Zoono
w.4 i 812 O(m)
w.18 O(m)
Razem: O((n m + 1n)m).
Natomiast oczekiwany czas tego algorytmu to O(n + m).
Algorytm o wiele bardziej godny polecenia!!!
Wyszukiwanie wzorca Algorytm KnuthaMorrisaPratta
Algorytm KnuthaMorrisaPratta
W stron algorytmu o zoonoci (n + m).
Funkcja preksowa wzorca P.
Cel: unikanie pustego/straconego szukania stosowanego w algorytmie
naiwnym.
T = b a c b a b a b a a b c b a b
P = a b a b a c a
-- s --- x
--- q ---
T = b a c b a b a b a a b c b a b
P = a b a b a c a
----- s ---- x
- k -
a b a b a
a b a
Szukanie minimalnego przesunicia s
wikszego od s, dla ktrego:

P[1 .. k] = T[s
+ 1 .. s
+ k]
s
+ k = s + q, q jest rwne dugoci wsplnego preksu dla P i

T[s + 1 .. s + m].
Wanie od takiego przesunicia warto kontynuowa dalsze szukanie
wzorca.
Co wicej pierwszych k znakw T
s
stanowi suks P
q
(P
q
= q
pierwszych znakw P).
Czyli s
= s + (q k) to dobry skok!
Funkcj preksingu deniujemy poprzez:
[q] = arg max
k<q
P
k
P
q
P
k
P
q
oznacza, e P
k
jest suksem P
q
(dla prexem).
Jak wida [q] zale tylko od P!
i [q] < q
i 1 2 3 4 5 6 7 8 9 10
P[i] a b a b a b a b c a
pi[i] 0 0 1 2 3 4 5 6 0 1
Dla q = 8, 6, 4, 2 otrzymujemy:
P
8
a b a b a b a b c a
P
6
a b a b a b a b c a
P
4
a b a b a b a b c a
P
2
a b a b a b a b c a
P
0
a b a b a b a b c a
[q] = q, [q],
2
[q], . . . ,
t
[q]
i
[q] =
q i = 0
[
i 1
[q]] i > 0
[8] = 8, 6, 4, 2, 0
[q] zbir preksw P bdcych suksami P

q
[q] = k : P
k
P
q

E
q1
= k : k
[q 1] P[k + 1] = P[q]
Oczywicie: E
q1

[q 1]
E
q1
zbir takich k, e P
k
P
q1
i P
k+1
P
q
czyli P
k
daje si
rozszerzy do P
k+1
i jest suksem P
q
.
[q] =
0 E
q1
=
1 + maxk E
q1

1 procedure SzukajWzoracaKMP(P,T)
2 n:=lenght(T);
3 m:=length(P);
4 :=ComputePrex(P);
5 k:=0;
6 for q=1 to n do
7 begin
8 while k>0 AND P[k+1]<>T[q] do
9 k:=[k];
10 if P[k+1]=T[q] then
11 k:=k+1;
12 if k=m then
13 Output qm; { return qm; }
14 k:=[k];
15 end
16 end
1 procedure ComputePrex(P);
2 m:=length(P);
3 [1]:=0;
4 k:=0;
5 for q=2 to m do
6 begin
7 while k>0 AND P[k+1]<>P[q] do
8 k:=[k];
9 if P[k+1]=P[q] then
10 k:=k+1;
11 [q]:=k;
12 end
13 return ;
14 end
Automaty i wyraenia regularne Automaty skoczone
Automaty skoczone
Automaty skoczone reprezentowane s poprzez grafy o skoczonej
liczbie wierzchokw i pewnej liczbie krawdzi.
Wierzchoki odpowiadaj stanom automatu a krawdzie
odpowiadaj za przejcia pomidzy stanem z ktrego prowadzi dana
krawd i stanem do ktrego prowadzi ta krawd. Krawdzie s
etykietowane pojedynczymi literami bd podzbiorem liter pewnego
alfabetu .
0 1
1
1
Dziaanie automatu polega na przechodzeniu przez stany automatu
zgodnie ze sowem wejciowym (dane wejciowe) i ukadem stanw i
przej pomidzy nimi (czyli krawdziami w grae).
Automat zaczyna prac w stanie pocztkowym (czsto oznaczonym
przez 0).
Nastpnie zgodnie z pierwsz liter wyrazu nastpuje przejcie ze
stanu zerowego do takiego stanu, do ktrego prowadzi krawd
zaetykietowana przez pierwsz liter wyrazu. Po czym
kontynuowany jest taki proces, czyli pobierana jest nastpna litera
wyrazu i automat przechodzi do takiego stanu, do ktrego da si
przej wanie z tak liter alfabetu.
0 1 2 3
a b
c
a b c

Automat koczy prac, gdy przeanalizuje cae zadane sowo
wejciowe lub zabraknie przej dla danych par stanlitera (automat
przechodzi z pewnego stanu q z liter l ). Gdyby zabrako przej
sowo wejciowe nie bdzie zaakceptowane.
Stany automatu dzielimy na stany akceptujce i nieakceptujce.
Zadaniem automatu jest zaakceptowanie bd nie zaakceptowanie
danego sowa wejciowego. Mianowicie, gdy automat skoczy prac
w stanie akceptujcym oznacza to, e sowo jest akceptowane
(rozpoznawane) przez automat skoczony. W przeciwnym wypadku
sowo nie jest akceptowane (nie jest rozpoznawane).
Kady automat skoczony rozpoznaje wyrazy, ktre nale do
pewnego jzyka L nad alfabetem .
A = Q, , , q
0
, F
Q zbir stanw
alfabet (zbir symboli)
: Q Q funkcja przejcia
q
0
stan pocztkowy
F Q zbir stanw akceptujcych
Q to wierzchoki grafu
deniuje krawdzie:
0 1
1
1
q l q
0 1 1
0 1 0
sowa w ktrych wystpuje a pniej jest te b i pniej jest i c
....a....b....c
0 1 2 3
a b
c
a b c
sowa, ktre rozpoczynaj si na a i kocz na b
0 1 2
a
b
b
b
b
wyrazy rozpoczynajce si od ab
0 1 2
a b
wyrazy rozpoczynajce si od a a nastpnie maj jedno lub wicej b

0 1 2
a b
b
sowo ab (tylko ab!)
0 1 2
a b
sowo zawierajce cho jedno wystpienie cigu ab
0 1 2
a b
a b
a
a

0 1
1
1

sowa z jedynk
0 1
1
1
s. z jedynk
tylko na kocu
0 1
1
1
s. z jedynek
0 1
1
1
1 1
s. z jedynk na kocu
Automaty niedeterministyczne
W automatach niedeterministycznych (w odrnieniu od
deterministycznych) moe istnie wicej ni jedno przejcie dla pary
stanlitera.
0 1
1

Oznacza to, e automat niedeterministyczny moe przechodzi
faktycznie do jednego lub wikszej iloci stanw. Z ktrych znw
moe da si przej na (cznie) pewn liczb sposobw, co jest
wykonywane.
Zakoczenie pracy automatu niedeterministycznego jest
zdeniowane tak samo jak automatu deterministycznego.
Automat niedeterministyczny akceptuje wyraz jeli cho jeden ze
stanw, w ktrych automat zakoczy prac jest stanem
akceptujcy.
0 1
1
1
1 1
[DA] s. z jedynk na kocu
0 1
1
[NDA] s. z jedynk na kocu

0 1 2 3
4 5 6
A l
a
K
o t
UWAGA: Kady automat niedeterministyczny mona zamieni na

deterministyczny (tj. akceptujcy sowa tego samego jzyka L).
Automaty i wyraenia regularne Wyraenia regularne
Wyraenia regularne
Wartoci wyraenia regularnego r jest pewien jzyk L(r ).
Mwimy take, e jzyk L(r ) skada si ze sw pasujcych do wyraenia
r ).
Oznaczenia:
pusty cig znakw
zbir pusty cigw znakw
. dowolny znak
Operatory
suma a[b
[a|k|p a, k, p
ala|kot|pies ala, kot, pies]
zoenie/konkatenacja ab
[ala, kot,
(Ala|Ela)ma(kota|psa) Alamakota, Elamakota, Alamapsa, Elamapsa]
domknicie a*
[a* , a, aa, aa, aaa, . . .
(a|b)* , a, b, aa, ab, aaab, babab, . . . ]
Kolejno realizacji operatorw
- domknicie
- zoenie
- suma
Przykady
0|1|2|3|4|5|6|7|8|9 cyfra
(a|b|. . . |z)* wyraz zbudowany z liter
ab.* cig znakw rozpoczynajcych si od ab
(a|b).* cig znakw rozpoczynajcych si od a lub b
.*ab.* cig znakw zawierajcy ab
.*(ab|AB).* cig znakw zawierajcy ab lub AB
(_|a|A|b|B|. . . |z|Z)(_|0|1|. . . |9|a|A|b|B|. . . |z|Z)* denicja
identykatora akceptowanego przez jzyki C i C++
Przejcie od wyrae regularnych do automatw skoczonych
(porednio przez automaty niedeterministyczne).
Bardzo przydatne!!! Patrz Unix, egrep, emacs, awk, pearl
Rozszerzenia rozmaite....
Kopce
Kopce
H = Make-heap()
Insert (H, x) wstawia wze x (z kluczem key[x]) do kopca H
Minimum (H)
Extract-Min(H) zwraca warto wskanika o minimalnym kluczu
Union(H1, H2) tworzy i zwraca nowy kopiec bdcy sum
kopcw H1 i H2
Decrease-key(H,x,k) zmiana wartoci wza x na k w kopcu H
Delete(H,x) usunicie wza x z kopca H
Kopce
Kopce zoonoci funkcji
Funkcja
Kopiec
binarny*
Kopiec
dwumianowy*
Kopiec
Fibonacciego**
Make-heap (1) (1) (1)
Insert (log n) (log n) (1)
Minimum (1) (log n) (1)
Extract-min (log n) (log n) (log n)
Union (n) (log n) (1)
Decrease-key (log n) (log n) (1)
Delete (log n) (log n) (log n)
Operacje Decrease-key i Delete wymagaj jako argumentu wskanika do
wza, nie tylko wartoci. W przeciwnym razie trzeba szuka, co jest
drosze.
* koszt pesymistyczny
** koszt zamortyzowany
Kopce Kopce Fibonacciego
Kiedy uywa kopcw innych ni binarne?
Gdy liczba operacji Extract-min jest nie mniejsza ni Insert, czy
Decrease-key lub Delete.
Gdy potrzebne s operacje Union na kopcach.
Po za tymi przypadkami nie warto stosowa kopcw bardziej
wyranowanych ni binarne. Jednak w takich przypadkach, jak powyej,
radykalnie przypieszaj potrzebne operacje.
Np.:
Prima, najkrtsze drzewo rozpinajce
Dijkstra, najkrtsze cieki
Struktura kopcw Fibonacciego
Tworzenie kopca i minimum
1 procedure FibMakeheap(H)
2 begin
3 n[H] = 0
4 min[H] = nil
5 end
1 function Minimum(H)
2 begin
3 return min[H]
4 end
Insert
1 procedure FIBHEAPINSERT(H, x)
2 degree[x] = 0
3 p[x] = NIL
4 child [ x] = NIL
5 left [x] = x
6 right [ x] = x
7 mark[x] = FALSE
8 concatenate the root list containing x with root list H
9 if min[H] = NIL or key[x] < key[min[H]] then
10 min[H] = x
11 n[H] = n[H] + 1
12 end
Dziki konkatenacji list dwukierunkowych: O(1).
Po dodaniu 21:
czenie kopcw
1 function FIBHEAPUNION(H1, H2)
2 H = MAKEFIBHEAP()
3 min[H] = min[H1]
4 concatenate the root list of H2 with the root list of H
5 if (min[H1] = NIL) or (min[H2] <> NIL and min[H2] < min[H1])
6 then min[H] = min[H2]
7 n[H] = n[H1] + n[H2]
8 free the objects H1 and H2
9 return H
10 end
1 function FIBHEAPEXTRACTMIN(H)
2 z = min[H]
3 if z <> NIL then
4 foreach child x of z do
5 add x to the root list of H
6 p[x] = NIL
7 remove z from the root list of H
8 if z = right [ z] then // z nie mia dzieci
9 min[H] = NIL
10 else
11 min[H] = right [ z]
12 CONSOLIDATE(H)
13 n[H]
14 return z
15 end
1 procedure CONSOLIDATE(H)
2 for i = 0 to D(n[H]) do
3 A[i ] = NIL
4 for each node w in the root list of H do
5 x = w
6 d = degree[x]
7 while A[d] <> NIL do
8 y = A[d] // Another node with the same degree as x.
9 if key[x] > key[y] then
10 exchange x and y
11 FIBHEAPLINK(H, y, x) // y become a child of x
12 A[d] = NIL
13 d = d + 1
14 A[d] = x
15 min[H] = NIL
16 for i = 0 to D(n[H]) do
17 if A[i ] <> NIL then
18 add A[i ] to the root list of H
19 if min[H] = NIL or key[A[i ]] < key[min[H]] then
20 min[H] = A[i]
21 end
Na szczcie: D(n[H]) = O(log n)
1 procedure FIBHEAPLINK(H, y, x)
2 remove y from the root list of H
3 make y a child of x
4 degree[x]++
5 mark[y] = FALSE
6 end
1 procedure FIBHEAPDECREASEKEY(H, x, k)
2 if k > key[x]
3 then error "new key is greater than current key"
4 key[x] = k
5 y = p[x]
6 if y <> NIL and key[x] < key[y] then
7 CUT(H, x, y)
8 CASCADINGCUT(H, y)
9 if key[x] < key[min[H]]
10 then min[H] = x
11 end
12 procedure CUT(H, x, y)
13 remove x from the child list of y,
14 degree[y]
15 add x to the root list of H
16 p[x] = NIL
17 mark[x] = FALSE
18 end
1 procedure CASCADINGCUT(H, y)
2 z = p[y]
3 if z <> NIL then
4 if mark[y] = FALSE then
5 mark[y] = TRUE
6 else
7 CUT(H, y, z)
8 CASCADINGCUT(H, z)
9 end
ab) 46 15 ce) 35 5
1 procedure FIBHEAPDELETE(H, x)
2 FIBHEAPDECREASEKEY(H, x, )
3 FIBHEAPEXTRACTMIN(H)
4 end
Geometria obliczeniowa & otoczka wypuka Funkcje pomocnicze
Geometria obliczeniowa
1 typedef long double real;
2 const real EPS = 1E9;
3 inline bool IsZero( real x)
4 {
5 return x >= EPS && x <= EPS;
6 }
1 struct POINT
2 {
3 real x, y;
4 bool undef;
5 bool paral ;
6 POINT(real wx=0, real wy=0) :x(wx), y(wy), undef(false),
7 paral ( false) { }
8 bool operator==(const POINT &b) const {
9 if (IsZero(xb.x) && IsZero(yb.y)) return true;
10 return false ;
11 }
12 bool operator!=(const POINT &b) const {
13 return !(( this)==b);
14 }
15 bool operator <(const POINT &p) const {
16 return x < p.x || (IsZero(xp.x) && y < p.y);
17 }
18 };
1 // skalarny a-b z a-c
2 inline real skal (POINT &a, POINT &b, POINT &c)
3 {
4 return (b.xa.x) (c. xa.x) + (b.ya.y) (c. ya.y);
5 }
6 inline real dist (POINT &a, POINT &b)
7 {
8 return sqrtl ( skal (a, b, b));
9 }
10 // a-c na a-b
11 inline real dlrzutu(POINT &a, POINT &b, POINT &c)
12 {
13 return skal (a, b, c)/ dist (a, b);
14 }
15 inline POINT rzut(POINT &a, POINT &b, POINT &c)
16 {
17 real f = skal(a, b, c) / skal (a, b, b);
18 return POINT(a.x + f (b.xa.x),a.y + f (b.ya.y));
19 }
1 inline real det(POINT &a, POINT &b, POINT &c)
2 {
3 return (b.xa.x) (c. ya.y) (b.ya.y) (c. xa.x);
4 }
5 inline real det(POINT &a, POINT &b, POINT &c, POINT &d)
6 {
7 return (det(a,d,b) + det(a,b,c))/2;
8 }
9 inline int sgn( real x)
10 { return x < EPS ? 1 : (x > EPS ? 1 : 0); }
11
12 inline int strona(POINT &a, POINT &b, POINT &c)
13 {
14 return sgn(det(a, b, c ));
15 }
16 inline real pole(POINT &a, POINT &b, POINT &c)
17 {
18 return fabsl (det(a, b, c))/2;
19 }
1 inline POINT przeciencie_punktow(POINT &a, POINT &b, POINT &p, POINT
2 {
3 real p1 = det(a,b,p,q), p2 = det(a,b,p)/2, st=p2/p1;
4 POINT res_p(0,0);
5 if (IsZero(p1)) { res_p.undef=true; return res_p; }
6 if (IsZero(p22 p1)) { res_p.paral=true; return res_p; }
7 return POINT(p.x + (q.xp.x)st, p.y + (q.yp.y)st);
8 }
9
10 // punkt przecicia odcinkw
11 inline POINT segments_intersection(POINT &a, POINT &b, POINT &c, POINT
12 {
13 POINT p = przeciencie_punktow(a,b,c,d);
14 if (p. paral || p.undef)
15 p.undef=true;
16 if (segment(a,b,p) != 0 || segment(c,d,p) != 0)
17 p.undef=true;
18 return p;
19 }
1 // gdzie jest c na lini a-b: przed, za, pomidzy
2 inline int segment(POINT &a, POINT &b, POINT &c)
3 {
4 if ( skal (a,b,c)<0)
5 return 1;
6 else if ( skal (b,a,c)<0)
7 return 1;
8 return 0;
9 }
Geometria obliczeniowa & otoczka wypuka Otoczka wypuka
Otoczka wypuka
1 procedure convexhull(point[] P)
2 Sort P // wzgldem x
3 // bd przechowyway wierzchoki grnej i dolnej czci
4 U,L = empty lists listy
5 for i =1 to n do
6 if L contains at least two points and the sequence of
7 last two points of L and the point P[ i ] does not make
8 a counterclockwise turn:
9 remove the last point from L
10 append P[i] to L
11 for i =1 to n do
12 if U contains at least two points and the sequence of
13 last two points of U and the point P[ i ] does not make
14 a counterclockwise turn:
15 remove the last point from U
16 append P[i] to U
17 Remove the last point of each list ( it s the same as the rst point of the
other list).Concatenate L and U to obtain the convex hull of P.end
1 enum direction { left , right };
2 vector<POINT> convex_hull(vector<POINT> P)
3 {
4 int n = P.size (), k = 0;
5 vector<POINT> H(2n);
6 // Sort points lexicographically
7 sort (P.begin(), P.end());
8 // Build lower hull
9 for (int i = 0; i < n; i ++) {
10 while (k >= 2 && strona(H[k2], H[k1], P[i]) != right) k;
11 H[k++] = P[i];
12 }
13 // Build upper hull
14 for (int i = n2, t = k+1; i >= 0; i) {
15 while (k >= t && strona(H[k2], H[k1], P[i]) != right) k;
16 H[k++] = P[i];
17 }
18 H. resize (k);
19 return H;
20 }
Drzewa suksowe
Drzewa suksowe
sux trees
Spis treci
1
Literatura
2
Skoczek
Problem omiu hetmanw
Algorytmy szukania z powrotami
3
Haszowanie
Drzewa przeszukiwa
Prosto i wolno . . .
Listy z dowizaniami
Union-Find
4
5
6
Cykl Eulera
7
Metoda Forda-Fulkersona
Metody przedprzepywowe
Spis treci
8
Algorytmy plecakowe
9
Klasy zoonoci
10
Wyszukiwanie wzorca
Algorytm Rabina-Karpa
Algorytm KnuthaMorrisaPratta
11
Automaty i wyraenia regularne
Automaty skoczone
Wyraenia regularne
12
Kopce
Kopce Fibonacciego
13
Geometria obliczeniowa & otoczka wypuka
Funkcje pomocnicze
Otoczka wypuka
14
Drzewa suksowe
15
Spis treci

A Wyk

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

A Wyk

Uploaded by

Copyright:

Available Formats

Algorytmy

n = G(n) = arg min

Gdy u i v w tej samej skadowej, to kady w osigalny z u jest

(u) = (v). Wiemy te, e u i (u) nale do tej samej silnie

= , 0, 1, 00, 01, 10, 11, 000, . . . dla j.w.

dla ustalonego zbioru symboli

wikszego od s, dla ktrego:

+ k = s + q, q jest rwne dugoci wsplnego preksu dla P i

[q] zbir preksw P bdcych suksami P

NJ (KIS) Algorytmy 172 / 222

wyrazy rozpoczynajce si od a a nastpnie maj jedno lub wicej b

NJ (KIS) Algorytmy 182 / 222

NJ (KIS) Algorytmy 185 / 222

[NDA] s. z jedynk na kocu

UWAGA: Kady automat niedeterministyczny mona zamieni na

You might also like