Obsah 10. přednášky: Souvislosti Složitost - úvod Výpočet časové složitosti Odhad složitosti - příklady Posuzování složitosti Asymptotická složitost - odhad Přehled technik návrhů algoritmů Tato tematika je zpracována v Záznamy přednášek: str. 167 194 Úlohy (řešení na konci přednášky) Př.1: Napište program pro výpočet funkce g(x) s přesností ε. g(x)= 1 + x/1! + x 2 /2! + x 3 /3! + x 4 /4! +... Př.2: Je možno najít takovou cestu, abychom prošli všemi mosty, ale každým z nich pouze jednou? (Euler: úloha o sedmi mostech města Královce) Př.3: Nalezněte všechny způsoby, kterými může šachová figurka jezdce proskákat všechna políčka šachovnice, přičemž může na každé políčko skočit pouze jedenkrát. Přednášky KIV/PPA1, A. Netrvalová, 2011 10. přednáška
Souvislosti Řešitelnost problému - zúžení na tzv. rozhodovací problém (Ano/Ne). Algoritmicky rozhodnutelný problém - algoritmus řeší rozhodovací problém, tj. pro vstup poskytne správný výstup v konečném čase Problémy - P, NP, převoditelnost, SAT (v PPA2) Efektivní algoritmus - řeší problém s minimálními nároky na hardware v co nejrychlejším čase, cílem je optimální využití existujících prostředků Nejjednodušší vs. nejrychlejší Nejjednodušší řešení - jednoduchá implementace - delší čas běhu Nejrychlejší řešení - náročná implementaci (časově kritické aplikace) Reálné aplikace kompromis Analýza efektivity - empiricky (porovnáním náhodná, nevhodná a reálná data) - exaktně (využití matematické analýzy) Cíl analýzy - porovnání algoritmů řešících stejný problém - odhad výkonnosti (?pro jaký typ vstupu) Strana 2 (celkem 20)
Složitost - úvod Složitost vztah algoritmu k prostředkům (čas a velikost paměti) Časová složitost - množina vstupních dat počet operací výpočtu - čas je dán počtem provedených operací (doba provedení operace nezáleží na rozsahu vstupních dat) Paměťová složitost - závislost paměťových nároků na vstupních datech Časová složitost časté potíže a omyly - podcenění nezkušenost, řešení triviálních úloh - použití rychlejšího PC problém vyřeší (NE) - zrychlení dílčími úpravami (NE) Řešení - použít rychlejší algoritmus (existuje-li) Výpočet časové složitosti stanovujeme v závislosti na - konkrétních datech - na základě rozsahu dat - analýzou algoritmu obvykle složité Příklad výpočtu u triviálního algoritmu Operace: p přiřazení,c porovnání, s součet Strana 3 (celkem 20)
static int soucetprvku(int pole){ int suma = 0; // p1 for(int i=0; i<pole.length; i++) { // p2+c1+s1+p3 suma += pole[i]; // s2+p4 return suma; C(n) = p1+p2+(n+1)c1+n(s1+p3)+n(s2+p4) pokud a = (p=c=s) C(n) = a+a+(n+1)a+n(a+a)+n(a+a)= 3a+5an a trvá jednotku času C(n) = 3+5n C(n) = n - lineární složitost int n = 100; int sum = 0; for (int i = 0; i < n; i++){ for (int j = 0; j < i; j++){ sum += i+j; n = 100; sum = 0; for (int i = 0; i < n; i++){ for (int j = 0; j < n; j++){ sum += i+j; PŘÍKLAD: Která programová sekvence proběhne rychleji? Strana 4 (celkem 20)
První kód: vnější cyklus 100x, vnitřní 1,2,...,99, celkem n(n-1)/2=100/2*99=4950x Druhý kód: vnější cyklus 100x, vnitřní cyklus 100, celkem 100*100=10000. První cyklus je rychlejší. Odhad složitosti - příklady Hrubý odhad orientace podle cyklů Př.1: Určete řádovou složitost následujícího algoritmu. Sledovanou operací je sčítání.... for(int i = 0; i < m; i++) { for(int j = 0; j < n; j++) { c[i][j] := a[i][j] + b[i][j]; Složitost algoritmu O(m *n) Př.2: Sledovanou operací je násobení ve výrazu j = j * 2 int n = 8; for(int i = 0; i < n; i++) { int j = 1; do { j = j * 2; while (j < n); Složitost algoritmu je O(n log 2 (n)) Strana 5 (celkem 20)
Př.3: Určete řádovou složitost následující programové sekvence.... min = a[0]; for(int i = 0; i < n; i++) { if (min < a[i]) { min = a[i]; max = a[0]; for(int i = 0; i < n; i++){ if (max > a [i]) { max = a [i]; Složitost algoritmu: O(2*n) Př.4: Určete řádovou složitost následujícího algoritmu. Sledovanou operací je: a = a / 3 final int n = 15; for(int i = 1; i < n ; i++) { float a = n; do { a = a / 3; while (a > 1); Složitost? Strana 6 (celkem 20)
Složitost algoritmu je O((n-1)*log 3 (n)). Př.5: Určete řádový odhad O následující funkce, pokud při zvětšení dat na n+1 dojde ke zvětšení počtu operací o 2 n. C1 = 2, Cn = 2 n + Cn 1 pro n > 1 C 1 = 2 C 2 = 2 2 + C1 = 2 2 + C 3 = 2 3 + C2 = 2 3 + 2 2 +... C n = 2 n + 2 ( n - 1) +... + 2 2 + 2 ( n + 1) n n Cn = 2 2 = i = 2 = n + i 1 2 2 2 n Složitost algoritmu je O(n 2 ). Posuzování složitosti - nejhorší případ: max(t1(n),t2(n),...,tn(n)) - průměrný případ: ~t(t1(n),t2(n),...,tn(n)) - nejlepší případ: min(t1(n),t2(n),...,tn(n)) Strana 7 (celkem 20)
Malý rozdíl mezi nejlepším a nejhorším případem - dobře navržený algoritmus Optimalizace algoritmu - zmenšení rozdílu Když nejlepší = nejhorší případ, nelze optimalizovat Asymptotická složitost - odhad Složitější algoritmy - přesné (algebraické) vyjádření složitosti algoritmu matematicky náročné Ve většině případů postačí vhodný odhad Strana 8 (celkem 20)
Asymptotická složitost ( pro n ) se limitně blíží k algebraické hodnotě složitosti Odhady - asymptotický horní odhad: O(g(N)) - asymptotický dolní odhad: Ω (g(n)) - asymptotický oboustranný odhad: Θ(g(N)) k, k1, k2 - konstanty, f(n) - fce, g(n) - odhad Strana 9 (celkem 20)
Strana 10 (celkem 20)
Př. 1: Problém s dobou řešení k n 2 je na řešen na PC pro n = 10000. Jak je možné zvětšit vstup, aby byla úloha vyřešena na 10x rychlejším PC v tomtéž čase? Staré PC: k 10000 2 ;nové PC 10 k 10000 2 10 k 10000 2 = k n 2 n = 1000000000 = 31622,7766. Poměr se zvětší 31623/10000 ~ 3 Př. 2: Algoritmus A1 - pro řešení úlohy použije 10000n + 40000 operací Algoritmus A2 - použije 12n 2 + 9 operací Pro jakou množinu dat je výhodnější použít A2? 12n 2 + 9 10000n + 40000 12n 2-10000n-39991 < 0, n 1 = -4; n 2 = 837 Pro n < 837 je vhodnější algoritmus A2. Ukázka časové složitosti Složitost n = 10 n = 100 n = 1000 logaritmická 1 2 3 lineární 10 100 1000 kvadratická 100 10000 1.0 10 6 kubická 1000 1.0 10 6 1.0 10 9 exponenciální 1024 1.3 10 30 1.1 10 301 faktoriálová 3.6 10 6 9.3 10 157 4.0 10 2567 Strana 11 (celkem 20)
P - polynomiální algoritmy. - výpočetně zvládnutelné problémy V praxi - nejčastěji O(n),O(n log(n),o(n 2 ),O(n 3 ) Problémy - aritmetické operace, řazení,vyhledávání, některé grafové algoritmy,... NP - nedeterministicky polynomiální algoritmy (bude v PPA2) Přehled technik návrhů algoritmů - Metoda hrubé síly (Brute Force Algorithm) - Rozděl a panuj (Divide and Conquer) - Heuristické algoritmy (Heuristic Algorithm) - Aproximační algoritmy - Pravděpodobnostní algoritmy Metoda hrubé síly Vyzkoušení všech variant řešení problému, vybráno nejlepší z nich. Počet operací nutných k nalezení řešení roste nepolynomicky (exponenciálně n c, s faktoriálem n!) Výhodou je jednoduchost implementace. Lze aplikovat pouze na malé datové soubory, pro rozsáhlé soubory nelze vyzkoušet všechny metody, nalezené řešení nemusí být nejlepší. Rozděl a panuj Založena na opakovaném rozdělování problému na menší a jednodušší podproblémy. Dělení prováděno dokud není řešení podproblému triviální. Takové řešení Strana 12 (celkem 20)
umíme zpravidla nalézt bez složitých výpočtu. Podproblémy řešeny nezávisle na sobě a poté jejich řešení spojena v celek, čímž získáme řešení původního problému. Odhad složitosti: Θ(n log n) Heuristické algoritmy Charakteristika heuristiky: - vygenerováno velké množství potenciálních řešení, v nich hledáno nejlepší možné řešení Vygenerovaná množina nemusí obsahovat nejlepší možné řešení. Řešení nemusí být nalezeno rychle, některé heuristiky pracují poměrně dlouho. Není zaručeno, že takové řešení bude vždy nalezeno Aproximační algoritmy - pro úlohy, pro které není k dispozici polynomiální algoritmus Cílem nalezení přípustného řešení, hodnocení kvality aproximace, snaha o co nejrychlejší konvergenci Pravděpodobnostní algoritmy Algoritmy zavádějí do procesu řešení nedeterministický prvek, tj. prvek náhodnosti. Opakovaný běh algoritmu nad stejnou vstupní množinou může poskytovat různé výsledky, proto se algoritmy spouštějí opakovaně Genetické algoritmy - princip evoluční biologie, techniky napodobující biologické procesy jako křížení, mutace, dědičnost,... k postupnému zlepšování dosaženého výsledku Strana 13 (celkem 20)
Úlohy Př.1 (existuje více algoritmů) - nevhodný: každý člen součtu pomocí funkcí public class EnaX { ŠPATNĚ static private Scanner sc = new Scanner(System.in); static final double EPS = 1e-5; static long fak(int n){ long vysledek = 1; for (int i=2; i<=n; i++){ vysledek *= i; return vysledek; static double spoctienax(int x){ double soucet = 1; double clen = 1; int i = 1; do { clen = Math.pow(x,i)/ fak(i); i++; soucet += clen; while(clen > EPS); return soucet; Zadej x:15 Vypocteny vysledek = 1823967.9211000332 Spravny vysledek = 3269017.3724721107 Strana 14 (celkem 20)
Řešení - použijte iterační výpočet (nepoužívejte opakovaný výpočet mocniny a faktoriálu): a 0 =1, a 1 = a 0 *x/1, a 2 = a 1 *x/2, a 3 = a 2 *x/3,... import java.util.*; public class EnaX { static private Scanner sc = new Scanner(System.in); static final double EPS = 1e-5; static double spoctienax(int x){ double soucet = 1; double clen = 1; // clen je scitanec int i = 1; // i-ty scitanec do { clen *= (double)x / i++ ; // spocti clen soucet += clen; // a přičti ho k součtu while( clen > EPS); // je-li mensi nez eps, hotovo return soucet; public static void main(string[] args) { DOBŘE System.out.print("Zadej x:"); int x = sc.nextint(); Zadej x:15 System.out.println("Vypocteno Vypocteny vysledek = " = + 3269017.3724691505 spoctienax(x)); System.out.println("Spravny Spravny vysledek vysledek = 3269017.3724721107 = " + Math.exp(x)); Strana 15 (celkem 20)
Př.2 Řešení neexistuje, tj. takovou cestu najít nelze Euler (r. 1741) - Eulerův tah (path) lze tehdy a jen tehdy, není-li žádný anebo jsou-li 2 vrcholy grafu lichého stupně (začátek a konec cesty) Alternativní úloha Eulerův uzavřený tah, tj. smyčka (circuit) - začátek a konec cesty v tomtéž vrcholu (nesmí být vrchol lichého stupně) (více v PPA2) Příklad na Eulerův tah: Strana 16 (celkem 20)
Př.3 Jednoduchá varianta: Úloha: Nalezněte nejkratší cestu šachovým koněm z jednoho pole (třeba D3) na všechna ostatní pole. Postup: 0. Na startovní pole zapiš číslo 0 1. Všechna dosud neoznačená pole dostupná jedním tahem z pole označeného 0 označ 1 2. Všechna dosud neoznačená pole dostupná jedním tahem z pole označeného 1 označ 2 3.... 2..... 3 atd. Nalezení cesty pak proveď odzadu (backtracking): Je-li cílové políčko označené N, hledáme políčko dostupné z něj jedním tahem a označené N-1 - až k políčku 0. Strana 17 (celkem 20)
Naše úloha 1. Prověříme všechny možnosti, tj. řešení hrubou silou - exponenciální složitost, neboť v ideálním případu můžeme skočit až na 8 polí O(8 n*n ) = 8 64 ~ 6 10 57 možností Pokud by ověření 1 možnosti trvalo jen 1ns, celý výpočet 2 10 41 let! 2. Zjednodušení - počet tahů je 63, ale skončíme neúspěchem mnohem dříve (po 4, 6, 8 tazích): 4 1 3 2 4 5 3 6 2 1 3 7 4 8 2 6 1 5 Strana 18 (celkem 20)
- z krajního políčka lze pokračovat 2, 3, 4 a 6 skoky - na 8 políček lze skočit pouze z 1. tahu (počet možností skoku z políčka je n-1, neboť skok musí být z přípustné pozice) - poslední tah má pouze jednu možnost, předposlední dvě možnosti,... - řada tahů budou tzv. vynucené zbude pouze jedna možnost pro celý řetězec tahů Zpřesněný horní odhad: 1 4 *2 8 *3 20 *5 16 *7 15 = 6 10 35 možností, tj. 20 10 18 let! Pro šachovnici 8x8 polí není úloha zcela řešitelná. V současné době (s použitím PC) je úloha kompletně řešitelná pro šachovnici 6x6 polí. Zpřesněný odhad: 1 4 *2 8 *3 12 *5 8 *7 3 = 18 10 15 možností, tj. 34 let. Skutečný výpočet (6x6): 188 888 353 094 možností - 2958 sec. Java Pentium Centrino 1,5 GHz Kvalifikovaný odhad pro 8x8: skutečné možnosti 10-5 z horního odhadu 6 10 35 10-5 = 6 10 30 možností, tj. 2 10 14 let. Strana 19 (celkem 20)
Úloha pro zájemce (prezentace řešení na další přednášce) Je dána posloupnost celých čísel a 1, a 2,... a n. Nalezněte celistvý úsek posloupnosti a i až a j, takový, aby součet hodnot těchto prvků byl maximální. Nezapomeňte, že indexy i, j představují pořadí prvků, tj. i, j > 0. Ilustrační příklady: {-2, 11, -4, 13, -5, 2 í = 2, j = 4, s = 20 {1, -3, 4, -2, -1, 6 í = 3, j = 6, s = 7 {-1, -3, -5, -7, -2 í = 0, j = 0, s = 0 Pro řešení tohoto problému lze napsat odlišné, více či méně efektivní algoritmy. Strana 20 (celkem 20)