METODY TWORZENIA ALGORYTMÓW

METODA PRZYROSTOWA

{Sortuje tablicę A[1..n] liczb rzeczywistych}

1. for j := 2 to n do begin2. pom := A[j] ;

{ wstaw A[j] w posortowany ciąg A[1 .. j-1] }

3. i:= j-1;4. while (i>0) and (A[i]>pom) do begin5. A[i+1]:= A[i];6. i:= i-1; end;

7. A[i+1]:= pom; end;

"DZIEL I ZWYCIĘŻAJ"

3 ETAPY :

1. DZIEL

2. ZWYCIĘŻAJ

3. POŁĄCZ

SORTOWANIE PRZEZ SCALANIE

5 2 4 6 1 3 2 6

2 5 4 6 2 61 3

5 2 4 6 1 3 2 6

5 2 4 6 1 3 2 6

2 4 5 6 1 2 3 6

1 2 2 3 4 5 6 6

5 2 4 6 1 3 2 6

MERGE-SORT ( A, p, k);{ Sortuje elementy w podtablicy A[p..k]; jeśli p >= k to podtablica jest już posortowana; jeśli p < k to dzielimy A[p..k] na dwie podtablice i sortujemy każdą z nich } begin if p < k then begin q := (p+k)/2 ;

MERGE-SORT ( A, p, q ); MERGE-SORT ( A, q+1, k ); MERGE (A, p, q, k);

end end;

MERGE-SORT( A, 1, n ) - sortuje tablicę A[1..n]

Złożoność : T(n) = (nlgn)

ALGORYTMY ZACHŁANNE

(GREEDY ALGORITHMS)

DANE : Z = {1, 2, ... n } - zbiór n zajęć , n>0

[ pi, ki ) pi - czas rozpoczęcia zajęcia i ki - czas zakończenia zajęcia i pi ki

WYNIK: Największy podzbiór PZ zbioru Z, który zawiera zajęcia zgodne,

tzn.: i, j PZ , to [ pi, ki ) [ pj, kj ) =

PLANOWANIE ZAJĘĆ

GREEDY-ACTIVITY-SELECTOR ( p, k);{ p- tablica początków zajęć, k- tablica końców zajęć; zakładamy, że k [1] k [2] ... k [n] }

begin

n := length [p]; PZ := {1}; j := 1;

for i := 2 to n do

if p [i] k [j] then begin PZ := PZ {i}; j := i end; return PZ; { PZ - największy podzbiór zajęć parami zgodnych }end;

PROGRAMOWANIE DYNAMICZNE

Rozwiąż "małe" problemy.

Zapamiętaj rozwiązania.

Użyj tych rozwiązań do rozwiązania "dużych" problemów

Liczby Fibonacciego

DANE : n N; n>=0

WYNIK : n - ta liczba Fibonacciego

metoda rekurencyjna - złożoność O(nn )

fib( n: integer) : integer; begin if ( (n =0) or (n= 1)) then fib := 1; else fib := fib(n-1) + fib(n-2) end;

Liczby Fibonacciego

metoda dynamiczna - złożoność O(n)

fib ( n: integer ) : integer; f1, f2, f, k : integer; begin if ( n = 0 )or( n=1 )then fib := 1 else begin f1 = f2 = 1; for k:= 2 to k := n-1 do begin f := f1 + f2; f2 := f1; f1 := f; end; end end;

Mnożenie ciągu macierzy

DANE : n N, p0, p1, ... , pn N

A1, ... , An - macierze prostokątne o elementach rzeczywistych, Ai ma rozmiar pi-1 * pi .

WYNIK : A1 * ... * An obliczony w sposób optymalny, tzn.: liczba wykonanych mnożeń elementów macierzy jest najmniejsza

Optymalne nawiasowanie

DANE : A1 - 10x100 A2 - 100x5 A3 - 5x50

WYNIK : A1A2A3 - optymalnie

(A1A2)A3

A1(A2A3)

A1A2 10x100x5 = 5000 => A1A2 (10x5)

(A1A2)A3 10x5x50 = 2500

7500

A2A3 100x5x50 = 25000 => A2A3 (100x50)

A1(A2A3) 10x100x50 = 50000

75000

Przykład :

Struktura optymalnego nawiasowania :

m [i,j] = minimalna liczba mnożeń potrzebna do obliczenia iloczynu Ai*...*Aj

0 dla i = j m [i,j] =

min { m [i,k] + m [k+1, j ] + p i-1 * pk * pj; } dla i < j i k < j

MATRIX-CHAIN-ORDER ( p );{ p[0..n] – tablica rozmiarów macierzy A1, ... , An , tzn .: Ai ma rozmiar p[i-1] * p[i] }

begin

n := length (p) - 1; for i := 1 to n do m [i,i] := 0;

for r := 2 to n do for i := 1 to n-r+1 do begin j := i + r – 1; m [i,j] := ; for k := i to j–1 do begin

q := m [i,k] + m [k+1, j ] + p i-1 * pk * pj;

if q < m [i,j ] then begin m [i,j ] := q ;

s [i,j] := k end end end return m and send ;

MATRIX-CHAIN-MULTIPLY ( A, s, i, j);{Oblicza optymalnie iloczyn Ai * A i+1 * ... * A j }

begin if j > i then begin X := MARTIX-CHAIN-MULTIPLY(A, s, i,s[i,j]); Y := MARTIX-CHAIN-MULTIPLY(A, s, s[i,j ] +1, j); Z := MATRIX-MULTIPLY ( X, Y ); return Z end else return Ai

end;

MATRIX-MULTIPLY ( A, B );{ Oblicza iloczyn : C = A * B }

begin if kol(A) <> rows(B) then error else for i := 1 to rows (A) do for j := 1 to kol (B) do begin C [i,j ] := 0; for k := 1 to kol (A) do C [i,j ] := C [i,j] + A [i,k] * B [k,j] ;

end; return C; end;