2011/12 Programovanie (2) v Jave

Táto stránka obsahuje archívnu kópiu materiálov zo školského roku 2011/12. Niektoré odkazy nemusia byť funkčné. V ďalších školských rokoch sa obsah predmetu môže mierne alebo výraznejšie meniť.

Prehľad a obsah

• #Letný semester, úvodné informácie
• #Letný semester, pravidlá
• #Letný semester, test a skúška

Týždeň 13.-19.2.

Úvod do Javy

#Prednáška 26 · #Cvičenia 13 · #DÚ12

Týždeň 20.-26.2.

Úvod do objektovo-orientovaného programovania, JavaDoc

#Prednáška 27 · #Cvičenia 14 · #DÚ13

Týždeň 27.2.-4.3.

Dedenie, polymorfizmus, modifikátory, interface

#Prednáška 28 · #Cvičenia 15

Týždeň 5.-11.3.

Výnimky, generické programovanie

#Prednáška 29 · #Cvičenia 16

Týždeň 12.-18.3.

Collections, testovanie

#Prednáška 30 · #Cvičenia 17 · #DÚ14

Týždeň 19.-25.3.

Opakovanie OOP, úvod k Swingu

#Prednáška 31 · #Cvičenia 18

Týždeň 26.3.-1.4.

Swing (layout, menu, dialog)

#Prednáška 32 · #Cvičenia 19 · #DÚ15

Týždeň 2.-8.4.

Swing (kreslenie)

#Prednáška 33 · #Cvičenia 20 · #DÚ16

Týždeň 9.-15.4.

OOP v C++, intervaly

#Prednáška 34

Týždeň 16.-22.4.

Reprezentácia grafov, prehľadávanie do hĺbky

#Prednáška 35 · #Cvičenia 21

Týždeň 23.-29.4.

#Cvičenia 22 · #DÚ17

Týždeň 30.4.-6.5.

Prehľadávanie do šírky, najdlhšia cesta, ohodnotené grafy

#Prednáška 36 · #Cvičenia 22

Týždeň 7.-13.5.

Maximálna klika, orientované grafy, topologické triedenie, knižnica na skúšku

#Prednáška 37 · #Cvičenia 23

Týždeň 14.-20.5.

Zhrnutie, opakovanie, príprava na skúšku

#Prednáška 38 · #Cvičenia 24

Letný semester, úvodné informácie

Rozvrh

• Prednášky: Streda 9:50-11:20 v F1-247
• Cvičenia:
  • 1i1: Utorok 9:50 v M-217 (cvičí J. Budiš)
  • 1i2: Utorok 9:50 v M-218 (cvičí M. Králik)
  • 1i3: Streda 8:10 v M-218 (cvičí J. Budiš)
  • Rozdelenie na krúžky [1]

Vyučujúce

• RNDr. Jana Katreniaková PhD., miestnosť M-263,

Konzultácie v utorok 13:10-14:50 alebo po dohode e-mailom

• Mgr. Broňa Brejová, PhD., miestnosť M-163,

Konzultácie v stredu 13:00-14:00 alebo po dohode e-mailom

Cvičiaci

• Mgr. Martin Králik, miestnosť M-25 (oproti akváriu X),
• Mgr. Jaroslav Budiš, miestnosť M-25,
• Mgr. Marika Mitrengová, miestnosť M-258,

Ciele predmetu

• Predmet 1-INF-166 Programovanie (2) v Jave nadväzuje na predmet 1-INF-127 Programovavanie (1) v C/C++. Oba sú určené študentom prvého ročníka bakalárskeho študijného programu Informatika a tvoria alternatívu k povinným predmetom 1-INF-126 Programovanie (1) a 1-INF-165 Programovanie (2).
• Každý študent sa môže rozhodnúť, či absolvuje 1-INF-127 a 1-INF-166 alebo 1-INF-126 a 1-INF-165. Nie je však možné absolvovať obe verzie programovania ani sa po prvom semestri presunúť z jednej verzie do druhej.
• Predmety 1-INF-126 a 1-INF-165 sa vyučujú v jazyku FreePascal a majú na našej fakulte už dlhú tradíciu. Predmety 1-INF-127 a 1-INF-166 budú vyučované v jazykoch C resp. C++ a Java. Výhodou je, že tieto jazyky využijete aj v ďalších nadväzujúcich predmetoch (Systémové programovanie, Programovanie (3) a podobne) a sú to aj jazyky využívané v praxi. Nevýhodu je, že sa po prvom semestri budete musieť preorientovať na iný jazyk.

• Ciele predmetu 1-INF-166:
  • prehĺbiť a rozšíriť zručnosti v algoritmickom uvažovaní, písaní a ladení programov z predchádzajúceho semestra
  • oboznámiť sa so základnými programovými a dátovými štruktúrami jazyka Java
  • zvládnuť základy objektovo-orientovaného programovania a tvorby programov s grafickým užívateľským rozhraním
  • oboznámiť sa s ďalšími základnými algoritmami a dátovými štruktúrami

Literatúra

• Predmet sa nebude striktne riadiť žiadnou učebnicou. Prehľad preberaných tém a stručné poznámky nájdete na stránke predmetu, doporučujeme Vám si na prednáškach a cvičeniach robiť vlastné poznámky.
• Pri štúdiu Vám môžu pomôcť knihy o jazyku Java, o programovaní všeobecne a o algoritmoch preberaných na prednáške. Tu je výber z vhodných titulov, ktoré sú k dispozícii na prezenčné štúdium vo fakultnej knižnici:
  • Bruce Eckel: Thinking in Java. 4th edition Prentice-Hall, 2006. Signatúra I-INF-E-2
    • Staršie 2. vydanie v českom preklade v knižnici so signatúrou D-INF-E-1b, 3. vydanie v angličtine online, doporučujeme však radšej 4. vydanie
  • Michael T. Goodrich, Roberto Tamassia: Data Structures and Algorithms in Java. John Wiley & Sons, 2006. Signatúra D-INF-G-5
  • Robert Sedgewick: Algorithms in Java, Parts 1-4, Fundamentals, Data Structures, Sorting, Searching, Addison-Wesley, 2003. Signatúra D-INF-S-1/I-IVa
  • Robert Sedgewick: Algorithms in Java, Part 5, Graph Algorithms Addison-Wesley, 2004. Signatúra D-INF-S-1/V (I)
• Tutoriál k jazyku Java a referenčná príručka k štandardným knižniciam

Priebeh semestra

• Na prednáškach budeme preberať obsah predmetu. Prednášky budú dve vyučovacie hodiny do týždňa.
• Cvičenia budú dve vyučovacie hodiny do týždňa v počítačovej učebni a ich cieľom je aktívne si precvičiť učivo. Na začiatku cvičenia bude krátka diskusia o prípadných nejasnostiach ohľadom materiálu z minulého cvičenia. Potom nasleduje rozcvička (krátky test) písaný na papieri. Ďalšou časťou cvičenia je precvičovanie príkladov k predchádzajúcim prednáškam (spoločne alebo individuálne). Na konci cvičenia spravidla budete môcť začať pracovať na domácej úlohe, pričom cvičiaci Vám v prípade potreby odpovie na Vaše otázky.
• Domáce úlohy navrhujeme tak, aby Vám ich riešenie pomohlo osvojiť si a precvičiť si učivo, čím sa okrem iného pripravujete aj na záverečnú skúšku. Okrem tohto sú za domáce úlohy body do záverečného hodnotenia. Najviac sa naučíte, ak sa Vám domácu úlohu podarí samostatne vyriešiť, ale ak sa vám to napriek vášmu usilu nedarí, neváhajte sa spýtať o pomoc prednášajúcich alebo cvičiacich. Možno s malou radou od nás sa Vám podarí úlohu spraviť. Treba však na domácej úlohe začať pracovať v predstihu, aby ste nás v prípade problémov stihli kontaktovať.
• Cieľom vyučujúcich tohto predmetu je vás čo najviac naučiť, ale musíte aj vy byť aktívni partneri. Ak Vám na prednáške alebo cvičení nie je niečo jasné, spýtajte sa. Môžete nám klásť tiež otázky počas našich konzultačných hodín alebo emailom. Ak sa dostanete do väčších problémov s plnením študijných povinností, poraďte sa s vyučujúcimi alebo s tútorom, ako tieto problémy riešiť.
• 40% známky dostávate za prácu cez semester, preto netreba nechávať štúdium učebnej látky až na skúškové obdobie.

Letný semester, pravidlá

Známkovanie

• 20% známky je na základe rozcvičiek, ktoré sa píšu na (takmer) každom cvičení
• 20% známky je za domáce úlohy
• 30% známky je za záverečný písomný test
• 30% známky je za praktickú skúšku pri počítači
• 10% bonusových percent je za nepovinný projekt

Pozor, body získavané za jednotlivé príklady nezodpovedajú priamo percentám záverečnej známky. Body za každú formu známkovania sa preváhujú tak, aby maximálny získateľný počet zodpovedal váham uvedených vyššie. Úlohy označené ako bonusové sa nerátajú do maximálneho počtu získateľných bodov v danej aktivite.

Stupnica

• Na úspešné absolvovanie predmetu je potrebné splniť nasledovné tri podmienky:
  • Získať aspoň 50% bodov v celkovom hodnotení
  • Získať aspoň 50% zo záverečného písomného testu
  • Získať aspoň 50% zo skúšky
• Ak niektorú z týchto troch podmienok nesplníte, dostávate známku Fx.
• V prípade úspešného absolvovania predmetu získate známku podľa percent v celkovom hodnotení takto:

A: 90% a viac, B:80...89%, C: 70...79%, D: 60...69%, E: 50...59%

Rozcvičky

• Rozcvičky sú krátke testy (cca 15 minút), ktoré sa píšu na začiatku (takmer) každého cvičenia. Za každú rozcvičku môžete získať najviac 5 bodov.
• Pri rozcvičke môžete použiť ľubovoľné písomné materiály (poznámky, knihy,...), nie však počítače a iné elektronické pomôcky. Počas rozcvičky nie je možné zdieľať materiály so spolužiakmi.
• Ak bude počas semestra celkovo N rozcvičiek, do výslednej známky sa vám zaráta iba N-2 najlepších, t.j. dve rozcvičky, na ktorých ste získali najmenej bodov (alebo ste sa ich ani nezúčastnili) sa vám škrtajú.

Domáce úlohy

• Domáce úlohy budú vypisované v priemere raz za dva týždne. Maximálny počet bodov za domácu úlohu bude uvedený v zadaní a bude sa pohybovať spravidla v rozsahu 10-20 bodov podľa náročnosti úlohy.
• Domáce úlohy treba odovzdať elektronicky pomocou systému Moodle do termínu určeného v zadaní. Neskoršie odovzdané úlohy nebudú akceptované. Po odovzdaní si ešte raz skontrolujte pri príslušnej úlohe, že vaše súbory sa správne nahrali.
• Program, ktorý odovzdáte ako domácu úlohu by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. Budeme kontrolovať správnosť celkovej myšlienky, správnosť implementácie, ale aj štýl.

Nepovinný projekt

• Za nepovinný projekt môžete získať 10% bonus k vašej výslednej známke (musíte však stále splniť všetky tri podmienky ukočenia predmetu).
• Projekt sa bude odovzdávať v prvom týždni skúškového obdobia.
• Témy projektov a podrobnejšie pravidlá nájdete na zvláštnej stránke.
• Na získanie bodov za projekt musí byť vaša práca dostatočne rozsiahla a kvalitná, v opačnom prípade získate 0 bodov.

Záverečný písomný test

• Záverečný test bude trvať 90 minút a bude obsahovať úlohy podobné tým, ktoré sa riešili na cvičeniach.
• Riadny termín testu sa bude konať koncom semestra alebo začiatkom skúškového obdobia a cez skúškové obdobie bude aj opravný termín testu.
• Pri teste nemôžete používať žiadne pomocné materiály (písomné ani elektronické) okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách.

Skúška

• Na skúške budete riešiť 1-2 úlohy pri počítači v celkovom trvaní 2-3 hodiny.
• Na skúške nemôžete používať žiadne pomocné materiály okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách. Nebude k dispozícii ani internet. Budete používať rovnaké programátorské prostredie ako na cvičeniach.
• Po skončení skúšky sa koná krátky ústny pohovor s vyučujúcim, počas ktorého sa prediskutujú programy, ktoré ste odovzdali a uzavrie sa vaša známka.
• Opakovanie skúšky sa riadi študijným poriadkom fakulty.
• Ak si po konaní skúšky ešte opravíte body zo záverečného testu a nepotrebujete už opravovať samotnú skúšku, musíte prísť aj tak na ďalší ústny pohovor, ktorý sa vám bude rátať ako opravný termín skúšky.

Opisovanie

• Máte povolené sa so spolužiakmi a ďalšími osobami rozprávať o domácich úlohách a stratégiách na ich riešenie. Kód, ktorý odovzdáte, musí však byť vaša samostatná práca. Je zakázané opisovať kód z literatúry alebo z internetu a ukazovať svoj kód spolužiakom. Domáce úlohy môžu byť kontrolované softvérom na detekciu plagiarizmu.
• Počas rozcvičiek, testov a skúšok môžete používať iba povolené pomôcky a nesmiete komunikovať s žiadnymi osobami okrem vyučujúcich.
• Ak nájdeme prípady opisovania alebo nepovolených pomôcok, všetci zúčastnení študenti získajú za príslušnú domácu úlohu alebo test nula bodov (t.j. aj tí, ktorí dali spolužiakom odpísať). Opakované alebo obzvlášť závažné prípady opisovania budú podstúpené na riešenie dekanovi fakulty.

Neprítomnosť

• Účasť na cvičeniach veľmi silne doporučujeme a v prípade neprítomnosti stratíte body za rocvičky.
• V prípade kratšieho ochorenia alebo iných problémov môžete využiť možnosť, že dve najhoršie rozcvičky sa škrtajú a stratené body za domáce úlohy je možné dohoniť riešením bonusových príkladov.
• V prípade dlhšieho ochorenia (aspoň dva týždne alebo opakovaná neprítomnosť) alebo iných závažných prekážok sa príďte poradiť s prednášajúcimi o možných riešeniach. Treba tak spraviť čím skôr, nie až spätne cez skúškové. Prineste si potvrdenku od lekára.

Letný semester, test a skúška

Na túto stránku budeme postupne pridávať informácie týkajúce sa záverečného písomného testu a praktickej skúšky pri počítači v letnom semestri. Doporučujeme tiež si preštudovať:

• pravidlá predmetu
• rady a informácie na prednáške 38

Termíny

Písomný test (90 minút)

• Riadny termín pondelok 21.5. o 10:00 v posluchárni B
• Opravný/náhradný termín pondelok 4.6. o 10:00 v M VIII

Termíny skúšok vždy o 9:00, trvanie 2 hodiny a 45 minút (165 minút)

• 30.5.2012 (kapacita 30) H6
• 6.6.2012 (kapacita 15) M217, M218
• 20.6.2012 (opravný termín) H6
• 27.6.2012 (2. opravný termín) H3

Na termín skúšky sa zapisujte v systéme AIS. Ústna časť skúšky sa koná v poobedňajších hodinách ten istý deň, v prípade väčšieho termínu aj na druhý deň.

Písomný test

Na písomnom teste budú príklady na nasledujúce témy:

• Základné črty jazyka Java
• Objektovo-orientované programovanie (triedy, konštruktory, dedenie a polymorfizmus, interface,...)
• Výnimky
• Základy generického programovania, základy Collections (ArrayList, LinkedList, HashMap, Iterator)
• Testovacie vstupy (netreba JUnit, len tvorba vstupov ako takých)
• Grafy (reprezentácia, prehľadávanie grafu do hĺbky a šírky, topologické triedenie orientovaného grafu, úlohy na prehľadávanie s návratom)
• Všeobecné programátorské zručnosti, práca s poliami, zoznamami, stromami, rekurzia

Na písomnom teste nebudú príklady na Swing

Ukážkové príklady na písomný test

V texte nižšie je niekoľko príkladov, ktoré sa svojim charakterom a obtiažnosťou podobajú na príklady, aké budú na záverečnej písomke. Tieto ukážkové príklady sú prevažne vybrané z cvičení a prednášok, na skutočnej písomke však budú nové, zatiaľ nepoužité príklady.

• Príklad 1: Navrhnite triedu Polynomial, ktorá bude reprezentovať polynómy jednej premennej s celočíselnými koeficientami, ktorá bude mať nasledujúce metódy (napíšte kód celej triedy, vrátane premenných):
  • Konštruktor bez parametrov, ktorý vytvorí nulový polynóm
  • Konštruktor s dvoma celočíselnými parametrami a a i, ktorý vytvorí polynóm Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle ax^i}
  • Konštruktor, ktorý dostane pole a vytvorí polynóm, ktorého koeficienty budú prvky tohto poľa
  • Metódu getCoefficient(int i), ktorá vráti koeficient pri člene Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^i} .
  • Metódu add(Polynomial p), ktorá vráti nový polynóm, ktorý bude súčtom tohto polynómu a polynómu p.
  • Metódu evaluate(int value), ktorá vráti hodnotu polynómu, keď premenná bude mať hodnotu value.

• Príklad 2: Naprogramujte generickú triedu Matrix, ktorá reprezentuje obdĺžnikovú maticu prvkov nejakého neznámeho typu E.
  • Napíšte konštruktor, ktorý vytvorí maticu zadaných rozmerov a vyplní ju zadaným prvkom typu E.
  • Napíšte metódu get, ktorá vráti prvok matice nachádzajúci sa na zadanom mieste
  • Napíšte metódu set, ktorá na zadané miesto v matici zapíše zadaný prvok typu E
  • Ak metódam get alebo set užívateľ zadá súradnice mimo matice, hodia výnimku vašej vlastnej triedy MatrixIndexOutOfBoundsException (ktorú tiež naprogramujte)
  • Výnimka tejto triedy by v metóde getMessage mala vrátiť reťazec obsahujúci obidve súradnice, ako aj obidva rozmery matice.

• Príklad 3: Napíšte generickú statickú metódu kazdyDruhy, ktorá dostane LinkedList a vyhodí z neho každý druhý prvok. K LinkedListu pristupujte iba cez iterátor a jeho metódu remove.

• Príklad 4: Uvažujme prehľadávanie grafu do hĺbky, ktoré do poľa whenVisited čísluje vrcholy v poradí, v akom boli navštívené. Odsimulujte algoritmus na grafe vpravo a zistite, v akom poradí budú vrcholy navštívené, ak začneme prehľadávať vo vrchole 0. Predpokladajte, že adjIterator vracia susedov v poradí podľa čísla vrcholu.

• Príklad 5: Odsimulujte prácu prehľadávania do šírky na grafe vyššie, ak začneme prehľadávať vo vrchole 0. Predpokladajte, že adjIterator vracia susedov v poradí podľa čísla vrcholu. Uveďte, v akom poradí boli vrcholy vložené do queue a vypíšte výsledné polia dist a prev.

• Príklad 6: Nájdite všetky topologické usporiadania orientovaného grafu na obrázku vpravo.

• Príklad 7: Napíšte funkciu static int countIsolated(Graph g), ktorá v grafe g spočíta počet izolovaných vrcholov, teda takých, ktoré nemajú žiadnych susedov. Graph je interface z prednášok s metódami numVertices, numEdges, addEdge, existsEdge, adjIterator.

• Príklad 8: Navrhnite 5 testov pre metódu s hlavičkou a špecifikáciou uvedenou nižšie. Pre každý test uveďte obsah vstupných parametrov a a x, ako aj aký výstup by metóda mala vrátiť a stručne slovne popíšte význam testu. Pokryte obvyklé aj okrajové prípady.

    /** Z pola a vyhodi prvy vyskyt objektu rovneho x
     * pricom rovnost sa testuje metodou equals.
     * Vsetky dalsie prvky posunie o jedno dolava a na koniec
     * pola da null.
     * Vrati true, ak bolo pole modifikovane, inak false.
     * Ak a je null alebo x je null, vyhodi java.lang.NullPointerException
     */
    public static boolean remove(Object[] a, Object x) {

• Príklad 9: Uveďte, čo vypíše nasledujúci program:

class E0 extends Exception {}

public class Prog {
   static void f(int x) throws E0 {
       try {
           if(x==0)  throw new E0();
           System.out.print('A');
       } catch (E0 e) {
           System.out.print('B');
           throw new E0();
       }
   }

   public static void main(String[] args) {
       for(int x=0; x<=1; x++) {
           try {
               System.out.print(x);
               f(x);
               System.out.print(x);
           } catch (E0 e) {
               System.out.print('C');
           }
      }
   }
}

• Príklad 10: Uveďte, čo vypíše nasledujúci program:

class A {
  private int x;
  public A() { x = 0; }
  public void print() { System.out.println(x); }
  public void inc() { x++; }
  public void work() { inc(); print(); }
}
class B extends A {
  private int y;
  public B() { super(); y=0; }
  @Override public void inc() { y++; }
  public static void main(String[] args) {
     A a = new B(); a.work(); a.work();
     a = new A(); a.work(); a.work();
  }
}

• Príklad 11: Uveďte, čo vypíše nasledujúci program:

public class Prog {
    static void vypis(int[][] a) {
        if (a != null) {
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[i].length; j++) {
                    System.out.print(" " + a[i][j]);
                }
                System.out.println();
            }
        } else {
            System.out.println("null");
        }
    }

    static void vytvorMaticu(int[][] a) {
        if (a == null) {
            a = new int[2][];
        }
        a[0] = new int[2];
        a[1] = a[0];
        a[0][0] = 1;  // (*)
    }

    public static void main(String[] args) {
        int[][] a = new int[2][];
        vytvorMaticu(a);
        int[][] b = null;
        vytvorMaticu(b);
        vypis(a);
        vypis(b);
    }
}

Skúška pri počítači

Na skúške pri počítači dostanete k dispozícii program graphgui

• Do programu graphgui budete pridávať riešenia dvoch úloh
• Tieto úlohy bude možné riešiť nezávisle na sebe a budú mať rovnakú váhu, nemusia však byť pre vás rovnako ťažké
• V úlohe A bude treba doprogramovať niečo do grafického prostredia
  • Pozri napr. úlohu C na cvičeniach 24
• V úlohe B bude treba naprogramovať nejaký grafový algoritmus, väčšinou metódou prehľadávania s návratom
  • Pozri napr. úlohy D a E na cvičeniach 24

• Odovzdávate iba súbory Editor.java (úloha A) a GraphAlgorithm.java (úloha B), celé vaše riešenie by teda malo byť v týchto súboroch.
• Ak kvôli ladeniu meníte iné časti programu, ubezpečte sa, že odovzdané súbory pracujú aj s pôvodnou verziou programu graphgui.
• Súbor ExamSpecifics.java sa môže na každom termíne mierne líšiť, dôležité zmeny budú vysvetlené v zadaní.
• Viac informácií o knižnici nájdete na konci prednášky 37

Na skúške budete mať prístup aj k dokumentácii k Jave, ktorá je stiahnuteľná tu, resp. prezerateľná tu

• Nebude možné v dokumentácii vyhľadávať, naučte sa v nej preto pred skúškou orientovať navigáciou z farebnej tabuľky na úvodnej stránke

Letný semester, projekt

• Súčasťou bodovania je aj nepovinný projekt, za ktorý môžete dostať 10% bonus.
  • Je to príležitosť vyskúšať si písanie väčšieho programu, pričom v projekte máte väčšiu voľnosť ako pri domácich úlohách
  • Projekty, ktoré nebudú spĺňať podmienky uvedené nižšie, budú hodnotené 0 bodmi, nemá teda význam odovzdávať nedokončené programy

Požiadavky na projekt

• Projekt musí byť na jednu z tém nižšie. Témy však nepopisujú presné požiadavky, poskytujú len námety, z ktorých si môžete vybrať a prípadne ich ďalej rozšíriť.
• Projekt musí byť napísaný v Jave a spustiteľný v Netbeans v učebniach na fakulte a napísaný prehľadne s dostatkom komentárov.
• Používať môžete len štandardné javovské knižnice (a prípadne JUnit). Okrem toho samozrejme môžete používať kód poskytnutý v rámci predmetu. Zvyšok programu by mal byť z väčšej časti napísaný Vami. Ak použijete nejaké úryvky kódu z internetu alebo iných zdrojov, v komentároch jasne uveďte zdroj.
• Program by mal poskytovať grafické užívateľské prostredie, mal by byť príjemne ovládateľný a mal by sa vyrovnať aj s neobvyklým správaním používateľa (nemal by padať na chyby, okrem naozaj závažných neobvyklých situácií ako nedostatok pamäte).
• Váš program by mal byť schopný načítavať spracovávané dáta zo súboru a po ich prípadnej zmene ich opäť do súboru uložiť. Formát súboru si môžete zvoliť, program by však nemal padať, ak dostane súbor v zlom formáte alebo s nezmyselnými dátami.

Projekt spĺňajúci tieto požiadavky získa aspoň 5% bonusových bodov, pričom je možné získať až 10% v závislosti od náročnosti a kvality vypracovania projektu.

Termíny a odovzdávanie

• V prípade, že chcete robiť projekt, treba si najneskôr do 9.5. vybrať jednu z ponúkaných tém a ohlásiť to v Moodli.
  • Doporučujeme však toto rozhodnutie spraviť skôr, aby ste na projekt mali dosť času, koncom semestra býva veľa práce na všetkých predmetoch.
• Samotný projekt je potrebné odovzdať do 23.5. 22:00 v Moodli
• V Moodli odovzdajte
  • zip súbor obsahujúci zdrojový kód a ďalšie potrebné súbory, napr. bitmapy
  • jar súbor so skompilovaným projektom
  • zip súbor obsahujúci niekoľko príkladov vstupných súborov
  • popis projektu vo formáte txt alebo pdf. V tomto popise stručne vymenujte, aké možnosti váš program používateľovi poskytuje a popíšte štruktúru programu (hlavné triedy, prípadne ich najdôležitejšie metódy). Úlohou popisu je zjedodušiť opravovateľovi orientáciu vo vašom projekte.
• Projekt je tiež potrebné prísť predviesť vyučujúcim štvrtok 24.5. alebo piatok 25.5. poobede (cca 13:00-15:30) v miestnosti M218
  • Zapíšte sa v AIS na jeden z týchto termínov, každý má limit 15 študentov, zapisuje sa do 23.5. 22:30
  • 24.5. doobeda zverejníme odhadovaný časový rozvrh, aby ste vedeli, kedy približne prídete na radu
  • Vyučujúcim predvediete používanie vášho programu a hlavné časti zdrojového kódu, podobne ako na poobednajšej časti skúšky
  • Body oznámime prostredníctvom Moodlu až po prezretí všetkých projektov

Skupinové projekty (pridané 12.4.2012)

• Projekt môžu výnimočne robiť aj dvojice, ale len po predchádzajúcom schválení prednášajúcimi.
• Projekt robený dvojicou môže získať spolu až 20% bodov (pokiaľ je dvojnásobneho rozsahu ako projekty jednotlivcov), pričom získané body sa dvojici rozdelia v pomere určenom vyučujúcimi.
• Dvojica odovzdá projekt v Moodli iba raz a v popise projektu uvedie, že ide o prácu dvojice a akým spôsobom mali v dvojici rozdelenú prácu.

Témy projektov

• Rozšírte #DÚ12 (ostrovy) o grafické rozhranie, ktoré zobrazí mapu ostrovov, umožňuje užívateľovi túto mapu editovať a prezerať si vlastnosti jednotlivých ostrovov (napr. dĺžku pobrežia, plochu atď), prípadne vyhľadávať ostrovy v mape podľa zadaného rozsahu určitej vlastnosti. Pri editovaní mapy sa pokúste ponúknuť paletu viacerých nástrojov na vytváranie väčších plôch pevniny (alebo mora) buď pevne daného tvaru alebo s náhodným prvkom. Môžete rozšíriť program aj o detekciu jazier -- políčok vody uzavretých v ostrove a prípadne aj ostrovov vo vnútri týchto jazier.

• Rozšírte #DÚ13 (rozhodovacie stromy) o grafické rozhranie umožňujúce užívateľovi prezerať a modifikovať rozhodovací strom. Po kliknutí na určitý vrchol by sa mal užívateľ dozvedieť, aká je v ňom otázka a mal by mať možnosť túto otázku meniť. Program by mal tiež vedieť pre daný vrchol zobraziť, koľko trénovacích dát sa do tohto vrcholu dostane a aké majú triedy. Malo by byť tiež možné pridávať a uberať listy stromu, prípadne robiť ďalšie editovacie operácie.

• Rozšírte #DÚ14 (roboty) o grafické rozhranie, ktoré zobrazí hernú plochu a dovolí uživateľovi vytvoriť alebo editovať postupnosť robotov aj s ich nastaveniami (čas príchodu, typ) a potom simuluje roboty a vypisuje aktuálne štatistiky úspešnych a mŕtvych robotov. Môžete prípadne naprogramovať aj editor hernej plochy. Môžete tiež do hry pridať ďalšie typy robotov alebo políčok.

• Rozšírte #DÚ16 (mnohouholníky) o ďalšie možnosti editácie mnohouholníkov. Používateľ bude môcť okrem pridávania a mazania vrcholov a hrán aj vrcholy posúvať (pomocou napr. ľavého tlačidla myši). Tiež bude možnosť práce s celým mnohouholníkom (prípadne s jeho časťou vybranou časťou), ktorú bude možné posúvať, škálovať a otáčať podobne, ako to robia grafické editory s obrazkom. Môžete prípadne naprogramovať aj editor vrcholov mnohouholníka - tvar, farby.

Prednáška 26

Organizačné poznámky

Anketa

• Ďakujeme za ohlas v ankete
  • Budúci školský rok sa pokúsime vytvoriť test a špeciálne úlohy pre pokročilých
  • Aj napriek neobľúbenosti zostávame so systémom Netbeans, ale
    • Pre Javu je lepšie prispôsobený ako pre C/C++
    • Netbeans čisto pre Javu by mal byť jednoduchšie nainštalovateľný pod Windows
    • Ak viete ako, môžete používať aj v iné prostredia, napr. Eclipse, prípadne textový editor, problémom môže byť editor grafických prostredí. Pozor, na skúške len štandardné Linuxové prostredie v učebniach.

Ciele predmetu

• Prehĺbiť a rozšíriť zručnosti v algoritmickom uvažovaní, písaní a ladení programov z predchádzajúceho semestra
• Oboznámiť sa so základnými programovými a dátovými štruktúrami jazyka Java
• Zvládnuť základy objektovo-orientovaného programovania a tvorby programov s grafickým užívateľským rozhraním
• Oboznámiť sa s ďalšími základnými algoritmami a dátovými štruktúrami

Literatúra

• Knihy na prezenčné štúdium vo fakultnej knižnici:
  • B. Eckel: Thinking in Java. 4th edition Prentice-Hall, 2006. Signatúra I-INF-E-2
    • Staršie 2. vydanie v českom preklade v knižnici so signatúrou D-INF-E-1b, 3. vydanie v angličtine online, doporučujeme však radšej 4. vydanie
  • M. T. Goodrich, R. Tamassia: Data Structures and Algorithms in Java. John Wiley & Sons, 2006. Signatúra D-INF-G-5
  • R. Sedgewick: Algorithms in Java, Parts 1-4, Fundamentals, Data Structures, Sorting, Searching, Addison-Wesley, 2003. Signatúra D-INF-S-1/I-IVa
  • R. Sedgewick: Algorithms in Java, Part 5, Graph Algorithms Addison-Wesley, 2004. Signatúra D-INF-S-1/V (I)
• Dokumentácia k jazyku Java od firmy Oracle (používame verziu Java SE 6):
  • Tutoriál jazyka Java
  • referenčná príručka k štandardným knižniciam

Pravidlá na tento semester

• Podobné ako minulý semester
• Pozrite si pravidlá na stránke predmetu http://compbio.fmph.uniba.sk/vyuka/prog/ a prihláste sa na tento predmet v systéme Moodle (s tým istým heslom)
• Zmeny oproti minulému semestru:
  • Iba jedna prednáška do týždňa
  • Menej väčších úloh, vyžadujú priebežnú prácu
  • Nebudú bonusy na DÚ
  • Bude nepovinný bonusový projekt za 10%. Témy na projekt a bližšie informácie oznámime neskôr.
  • Na rozcvičkách môžu byť aj témy z minulého semestra (práca s poľami, zoznamami, stromami, rekurzia,...), ale v Jave

Odporúčania

• Doučte sa rekurziu
• Neopisujte
• Pracujte na DÚ priebežne, nie tesne pred termínom
• Ak niečomu nerozumiete alebo potrebujete poradiť s DÚ, pýtajte sa
• Skontrolujte si poriadne v Moodli, či je DÚ naozaj odovzdaná
• Reklamácie bodov riešte najskôr s tým, kto opravoval, ale v prípade problémov dajte vedieť niektorej vyučujúcej. Spravte tak čím skôr, nie až na skúške.

Začiatok semestra

• Prvá úloha zverejnená dnes
• Druhá úloha zverejnená budúci týždeň
• Prvá rozcvička o dva týždne

Hello world

V Netbeans

Vytvorenie projektu:

• V menu zvolíme New Project
• Na prvej obrazovke zvolíme Categories: Java a Projects: Java Application
• Na ďalšej obrazovke Project name: hello a Create Main Class: hello.Hello
• Do súboru Hello.java napíšeme text:

 
package hello;

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

• Potom spúšťame podobne ako program v jazyku C++

V Linuxe na príkazovom riadku

Ak chcete Javu skúsiť bez použitia Netbeans:

• Vytvoríme adresár hello, v ňom súbor Hello.java s rovnakým obsahom ako vyššie
• Kompilácia javac hello/Hello.java (vznikne súbor hello/Hello.class)
• Spustenie java hello.Hello
• Pozor, meno adresára musí sedieť s menom balíčka (hello), meno súboru s menom triedy (Hello)
• Ak vynecháme riadok package hello;, môžeme mať súbor Hello.java priamo v aktuálnom adresári.

Väčší program

• Ukážme si teraz väčší program, v ktorom bude aj načítanie vstupu, polia a rekurzia.
• Je to javová verzia C++ programu na generovanie variácií bez opakovania z minulého semestra.
• Jednotlivé jazykové konštrukty použité v programe rozoberieme nižšie v texte.

Najskôr v C++:

#include <iostream>
using namespace std;

void vypis(int a[], int k) {
    for (int i = 0; i < k; i++) {
        cout << a[i];
    }
    cout << endl;
}

void generuj(int a[], bool bolo[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * v poli bolo mame zaznamenane, ktore cifry su uz pouzite,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        vypis(a, k);
    } else {
        for (int x = 0; x < n; x++) {
            if (!bolo[x]) {
                a[i] = x;
                bolo[x] = true;
                generuj(a, bolo, i + 1, k, n);
                bolo[x] = false;
            }
        }
    }
}

int main(void) {
    int k, n;
    cin >> k >> n;
    int *a = new int[k];
    bool *bolo = new bool[n];
    for (int i = 0; i < n; i++) {
        bolo[i] = false;
    }
    generuj(a, bolo, 0, k, n);
    delete[] a;
    delete[] bolo;
}

• A teraz v Jave:

package hello;

import java.util.Scanner;

public class Hello {

    static void vypis(int[] a) {
        for (int x : a) {
            System.out.print(" " + x);
        }
        System.out.println();
    }

    static void generuj(int[] a, boolean[] bolo, int i, int n) {
        /* v poli a dlzky k mame prvych i cifier,
         * v poli bolo mame zaznamenane, ktore cifry su uz pouzite,
         * chceme vygenerovat vsetky moznosti
         * poslednych k-i cifier */
        if (i == a.length) {
            vypis(a);
        } else {
            for (int x = 0; x < n; x++) {
                if (!bolo[x]) {
                    a[i] = x;
                    bolo[x] = true;
                    generuj(a, bolo, i + 1, n);
                    bolo[x] = false;
                }
            }
        }
    }

    public static void main(String[] args) {
        int k, n;
        Scanner s = new Scanner(System.in);
        k = s.nextInt();
        n = s.nextInt();
        int[] a = new int[k];
        boolean[] bolo = new boolean[n];
        for (int i = 0; i < n; i++) {
            bolo[i] = false;
        }
        generuj(a, bolo, 0, n);
    }
}

Základy jazyka Java

Primitívne typy, polia a referencie

Primitívne typy (podobné na C/C++)

• int: 32-bitové číslo so znamienkom, hodnoty v rozsahu -2,147,483,648..2,147,483,647 (ďalšie celočíselné typy byte, short, long)
• double: 64-bitové desatinné číslo s pohyblivou desatinnou čiarkou (a 32-bitový float)
• boolean: hodnota true alebo false
• char: 16-bitový znak v kódovaní Unicode (podporuje teda napr. slovenskú diakritiku)

Lokálne premenné treba inicializovať, inak kompilátor vyhlási chybu:

int y;
System.out.println(y); // variable y might not have been initialized

V poliach a v objektoch kompilátor inicializuje premenné na 0, null, resp. false.

Polia

• Polia v Jave vedia svoju dĺžku, nemusíme ju ukladať v dalšej premennej
• Pole musíme alokovať príkazom new:

double[] a;                  // deklarujeme premennu typu pole desatinnych cisel, zatial ma neinicializoavu hodnotu
a = new double[3];           // alokujeme pole troch desatinnych cisel
for (int i = 0; i < a.length; i++) {  // do pola ulozime cisla 0..2
    a[i] = i;
}

• Alebo mu môžeme priradiť počiatočné hodnoty: double[] a = {0.0, 1.0, 2.0};
• Java kontroluje hranice polí, napr. System.out.println(a[3]); spôsobí chybu počas behu programu: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

Referencie

• Každá premenná v Jave obsahuje buď hodnotu primitívneho typu alebo referenciu.
• Referencia, podobne ako smerník V C, predstavuje adresu v pamäti.
• Referencia môže ukazovať na pole alebo objekt, ale nie na primitívny typ.
• Nefunguje smerníková aritmetika.
• Referencie môžu mať hodnotu null, ak neukazujú na žiadnu pamäť.
• Na jedno pole alebo objekt môžeme mať viac referencií:

double[] a = {0.0, 1.0, 2.0};
double[] b = a;  // skopiruje referenciu na to iste pole do b
a[1]+=2;         // zmenime pole, na ktore ukazuju a aj b
System.out.println(b[1]);  // vypise cislo 3.0
a = new double[2];  // a a b teraz ukazuju na rozne polia 

• V Java nemusíme polia odalokovať, program to spraví sám, keď ich už na nich nie je žiadna referencia (garbage collection)

Operátory, cykly, podmienky

• Operátory podobne ako C/C++, napr. aritmetické +, -, *, /, %, priradenie =, +=,..., ++, --, logické !, &&, ||, porovnávanie ==, !=, >=,...
• Pozor pri referenciách operátor == testuje, či ukazujú na tú istú pamäť, nie či je v tej pamäti tá istá hodnota
• Podmienky if, if else, switch rovnako ako v C
• Cykly for, while, do .. while podobne ako v C, podobne break a continue

Navyše Java má cyklus for ktorý ide cez všetky hodnoty v poli aj bez indexovej premennej

• Tu vidíme dva spôsoby ako vypísať obsah poľa

double[] a = {0.0, 1.0, 2.0};
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}
for (double x : a) {
    System.out.println(x);
}

• Pozor ale, takýto cyklus sa nedá použiť na zmenenie hodnôt v poli:

for (double x : a) {
    x = 0; // nemeni pole, iba lokalnu premennu x
}

Funkcie (statické metódy) a ich parametre

• Ak chceme písať menší program bez vlastných objektov, ako sme robili v C, použijeme statické metódy umiestnené v jednej triede
• Pred každé meno metódy okrem návratového typu píšeme slovo static
• Pred main píšeme aj slovo public, aby bola viditeľná aj mimo aktuálneho balíčku.
• Návratový typ funkcie main je void, argumenty sú v poli reťazcov (nie je tam meno programu ako v C)

• Parametre sa odovzdávajú hodnotou
  • Ak ide o primitívny typ, funkcii sa skopíruje jeho hodnota
  • Ak ide o referenciu na pole alebo objekt, funkcii sa skopíruje táto referencia, funkcia môže teda meniť tento objekt alebo pole
• Nedá sa teda napísať funkcia swap, ktorá vymení obsah dvoch premenných
• Tu je ilustratívny príklad:

(a) Situácia na začiatku vykonávania metódy pokus, (b) situácia na konci vykonávania metódy pokus.

static void pokus(int[] a, int x) {
    a[1] = 5;        // zmeni v poli na ktore ukazuje a aj b
    a = new int[3];  // a ukazuje na nove pole, b na stare
    System.out.println(a[1]);  // vypise 0
    x = 6;           // zmeni v x, y ostava ta ista  
}

public static void main(String[] args) {
    int[] b = {1, 2, 3};
    int y = 4;
    pokus(b, y);
    System.out.println(b[1]);  // vypise 5
    System.out.println(y);     // vypise 4

}

• Návratový typ void, primitívny typ alebo referencia
  • Príkaz return ako v C

Práca s maticami

• V poli môžeme mať aj referencie na iné polia, dostávame tak viacrozmerné matice, podobne ako v C-čku.
• Deklácia 3-rozmerného poľa: int[][][] a;
• Ak sú všetky rozmery známe, môžeme ho jedným príkazom alokovať, napr. a=new int[2][3][4];
• Môžeme však spraviť napr. trojuholníkovú maticu, v ktorej má každý riadok inú dĺžku:

package hello;
public class Hello {

    static void vypis(int[][] a) {
        /* vypiseme cisla v matici a na konzolu */
        for (int[] riadok : a) {
            for (int x : riadok) {
                System.out.print(" " + x);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] a = new int[3][];
        for (int i = 0; i < a.length; i++) {
            a[i] = new int[i+1];
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = i * j;
            }
        }
        vypis(a);
    }
}

Výstup:

 0
 0 1
 0 2 4

• Podobne 3-rozmerné pole s rôzne veľkými podmaticami a riadkami:

    static void vypis(int[][][] a) {
        /* vypiseme cisla v 3D poli a na konzolu */
        for (int[][] matica : a) {
            for (int[] riadok : matica) {
                System.out.print("[");
                for (int x : riadok) {
                    System.out.print(" " + x);
                }
                System.out.print(" ] ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][][] a = new int[3][][];
        for (int i = 0; i < a.length; i++) {
            a[i] = new int[i + 1][];
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = new int[j + 1];
                for (int k = 0; k < a[i][j].length; k++) {
                    a[i][j][k] = i * j * k;
                }
            }
        }
        vypis(a);
    }

Výstup:

[ 0 ] 
[ 0 ] [ 0 1 ] 
[ 0 ] [ 0 2 ] [ 0 4 8 ] 

Reťazce

• Objekt triedy String, po vytvorení sa nedá meniť
• Text medzi úvodzovkami je považovaný za String
• Inicializácia konštantným reťazcom: String greeting = "Hello world!";
• Operátor + konkatenuje reťazce. Ak je jeden operand reťazec, iné typy konvertuje na String:

int x=1;
String str = "Hodnota x: " + x;

Prístup k reťazcu:

• dĺžka sa počíta metódou length() a i-ty znak metódou charAt(i)

String str = "Ahoj!";
int len = str.length();  // dlzka retazca
for (int i = 0; i < len; i++) {
    System.out.println(i + ". znak: " + str.charAt(i));
} 

Výstup:

0. znak: A
1. znak: h
2. znak: o
3. znak: j
4. znak: !

• Porovnanie reťazcov na rovnosť metódou equals (Pozor, porovnanie == testuje, či ide o to isté miesto v pamäti)

String str1 = "abc";      // retazec abc
String str2 = str1;       // referencia na ten isty retazec
String str3 = str1 + "";  // vznikne novy retazec abc
if (str1 == str2) {       // true, lebo to iste miesto
    System.out.println("str1==str2"); 
}
if (str1 == str3) {       // false, lebo rozne miesta
     System.out.println("str1==str3"); 
}
if (str1.equals(str3)) {  // true, lebo zhodne retazce
     System.out.println("str1.equals(str3)"); 
}

• Veľa ďalších metód, pozri dokumentáciu
• Ak potrebujete reťazec meniť, napr. k nemu postupne pridávať, môžete použiť StringBuilder
  • Rýchlejšie ako stále vyrábať nové reťazce pomocou operátora + (pre spájanie malého počtu častí stačí String)
  • Napr. dva spôsoby ako vytvoriť reťazec abeceda obsahujúci písmená a..z:

// Pomocou String, postupne vytvorí 27 rôznych String-ov
String abeceda = "";
for (char c = 'a'; c <= 'z'; c++) {
     abeceda = abeceda + c;  // vytvori novy String, naplni ho novym obsahom
}

// Pomocou StringBuilder, vytvorí jeden StringBuilder a jeden String
StringBuilder buffer = new StringBuilder();
for (char c = 'a'; c <= 'z'; c++) {
     buffer.append(c);  // modifikuje objekt buffer
}
String abeceda = buffer.toString();  // vytvori novy String 

Vstup, výstup, súbory

• Java má rozsiahle knižnice, uvádzame len návod na základnú prácu s textovými súbormi.
• Vo väčšine prípadov potrebujeme triedy z balíčku java.io, takže si ich môžeme naimportovať všetky: import java.io.*;
  • Trieda Scanner je v balíčku java.util, použijeme teda import java.util.Scanner;
• V prípade, že pri práci so súbormi nastane nečakaná chyba, Java použije mechanizmus výnimiek (expection)
  • O výnimkách sa budeme učiť neskôr, nateraz len do metódy main (a prípadne ďalších metód) pridáme upozornenie, že výnimka môže nastať:

public static void main(String[] args) throws java.io.IOException { ... }

Písanie na konzolu

• System.out.print(retazec)
• System.out.println(retazec) - pridá koniec riadku
• Reťazec môžeme vyskladať z viacerých častí rôznych typov pomocou +
• Formátovanie podobné na printf c C-čku: System.out.format("%.1f%n", 3.15); vypíše číslo na jedno desatinné miesto, t.j. 3.2 a koniec riadku podľa operačného systému.
  • Viac detailov v dokumentácii alebo v tutoriáli

Čítanie z konzoly

• Objekt System.in je typu FileInputStream a podporuje iba čítanie jednotlivých bajtov resp. polí bajtov
• Lepšie sa pracuje, ak ho použijeme ako súčasť objektu, ktorý vie tieto bajty spracovať do riadkov, čísel a pod.
• Trieda BufferedReader umožňuje čítať celý riadok naraz ale aj znak po znaku. Tu je príklad jej použitia:

package hello;
import java.io.*;   // potrebujeme nejake triedy z balicka java.io
public class Hello {
    public static void main(String[] args)
            throws java.io.IOException {  // musime pridat oznam, ze moze vzniknut vynimka - chyba pri citani
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            // nacitame riadok do retazca
            String line = in.readLine();
            // skoncime, ked uzivatel zada prazdny riadok alebo ked prideme na koniec vstupu (null)
            if (line == null || line.equals("")) { 
                break;
            }
            // vypiseme nacitany riadok
            System.out.println("Napisali ste riadok \"" + line + "\"");
        }
        System.out.println("Koncime...");
    }
}

Príklad behu programu:

Ahoj
Napisali ste riadok "Ahoj"
1 2 3
Napisali ste riadok "1 2 3"

Koncime...

• Trieda Scanner rozkladá vstup na slová oddelené bielymi znakmi (medzery, konce riadku a pod.) a prípadne ich premieňa na čísla.
  • Príklad programu, ktorý vypisuje slová načítané od užívateľa, kým nezadá END alebo neskončí vstup

package hello;
import java.util.Scanner;
public class Hello {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);  // inicializujeme Scanner
        int num = 0;
        while (s.hasNext()) {        // kym neskonci vstup
            String word = s.next();  // nacitame slovo
            if (word.equals("END")) { // skoncili sme ak najdeme END
                break;
            }
            System.out.println("Slovo " + num + ": " + word); // vypiseme slovo
            num++;
        }
    }
}

Príklad behu programu:

Ahoj
Slovo 0: Ahoj
1 2 3 END
Slovo 1: 1
Slovo 2: 2
Slovo 3: 3

• Metóda nextInt() vráti ďalšie slovo konvertované na int (pozri program s rekurziou vyššie), overiť si, či nasleduje číslo, môžeme vopred metódou hasNextInt(). Podobne nextDouble().

Práca so súbormi

Čítanie zo súboru funguje podobne ako čítanie z konzoly, iba inak inicializujeme použitý objekt:

• Scanner vytvoríme príkazom Scanner s = new Scanner(new File("vstup.txt"));
  • File reprezentuje súbor s určitým menom, potrebujeme pridať import java.io.File; alebo import java.io.*;
• BufferedReader vytvoríme príkazom BufferedReader in = new BufferedReader(new FileReader("vstup.txt"));
• Scanner aj BufferedReader umožňujú zavrieť súbor metódou close()

Písanie do súboru môžeme robiť napr. triedou PrintStream

• Otvorenie súboru: PrintStream out = new PrintStream("vystup.txt");
• Potom používame staré známe metódy print, println, format ako pri System.out (napr. out.println("Ahoj"))
• Na konci zavoláme out.close()
• Tento spôsob otvárania súborov existujúci obsah premaže
• Ak chceme pridávať na koniec súboru, použijeme PrintStream out = new PrintStream(new FileOutputStream("vystup.txt",true));

Matematika a pseudonáhodné čísla

• V triede Math nájdete rôzne matematické konštanty a funkcie
• Napr. Math.PI, Math.cos(x), Math.min(x,y) Math.pow(x,y),...
• Triedy na prácu s veľkými číslami a ďalšie matematické funkcie nájdete v balíčku java.math

Pseudonáhodné čísla

• Math.random() vygeneruje double z intervalu [0,1)
• Väčšie možnosti poskytuje trieda Random v balíčku java.util (generuje celé čísla, bity), umožňuje nastaviť počiatočnú hodnotu

Cvičenia 13

Na tomto cvičení si vyskúšame spustiť program v Jave, pokúsime sa ho trochu modifikovať. Ďalšie detaily k jazyku Java budú na prednáške.

Spúšťanie programu Hello world

V Netbeans

Vytvorenie projektu:

• V menu zvolíme New Project
• Na prvej obrazovke zvolíme Categories: Java a Projects: Java Application
• Na ďalšej obrazovke Project name: hello a Create Main Class: hello.Hello
• Do súboru Hello.java napíšeme text:

 
package hello;

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

• Potom spúšťame podobne ako program v jazyku C++

V Linuxe na príkazovom riadku

Ak chcete Javu skúsiť bez použitia Netbeans:

• Vytvoríme adresár hello, v ňom súbor Hello.java s rovnakým obsahom ako vyššie
• Kompilácia javac hello/Hello.java (vznikne súbor hello/Hello.class)
• Spustenie java hello.Hello
• Pozor, meno adresára musí sedieť s menom balíčka (hello), meno súboru s menom triedy (Hello)
• Ak vynecháme riadok package hello;, môžeme mať súbor Hello.java priamo v aktuálnom adresári.

Väčší program

• Ukážme si teraz väčší program, v ktorom bude aj načítanie vstupu, polia a rekurzia.
• Je to javová verzia C++ programu na generovanie variácií bez opakovania z minulého semestra.
• Jednotlivé jazykové konštrukty použité v programe rozoberieme na prednáške, pokúste sa ale z kontextu pochopiť, čo sa na jednotlivých riadkoch programu asi deje.

Najskôr v C++:

#include <iostream>
using namespace std;

void vypis(int a[], int k) {
    for (int i = 0; i < k; i++) {
        cout << a[i];
    }
    cout << endl;
}

void generuj(int a[], bool bolo[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * v poli bolo mame zaznamenane, ktore cifry su uz pouzite,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        vypis(a, k);
    } else {
        for (int x = 0; x < n; x++) {
            if (!bolo[x]) {
                a[i] = x;
                bolo[x] = true;
                generuj(a, bolo, i + 1, k, n);
                bolo[x] = false;
            }
        }
    }
}

int main(void) {
    int k, n;
    cin >> k >> n;
    int *a = new int[k];
    bool *bolo = new bool[n];
    for (int i = 0; i < n; i++) {
        bolo[i] = false;
    }
    generuj(a, bolo, 0, k, n);
    delete[] a;
    delete[] bolo;
}

• A teraz v Jave:

package hello;

import java.util.Scanner;

public class Hello {

    static void vypis(int[] a) {
        for (int x : a) {
            System.out.print(" " + x);
        }
        System.out.println();
    }

    static void generuj(int[] a, boolean[] bolo, int i, int n) {
        /* v poli a dlzky k mame prvych i cifier,
         * v poli bolo mame zaznamenane, ktore cifry su uz pouzite,
         * chceme vygenerovat vsetky moznosti
         * poslednych k-i cifier */
        if (i == a.length) {
            vypis(a);
        } else {
            for (int x = 0; x < n; x++) {
                if (!bolo[x]) {
                    a[i] = x;
                    bolo[x] = true;
                    generuj(a, bolo, i + 1, n);
                    bolo[x] = false;
                }
            }
        }
    }

    public static void main(String[] args) {
        int k, n;
        Scanner s = new Scanner(System.in);
        k = s.nextInt();
        n = s.nextInt();
        int[] a = new int[k];
        boolean[] bolo = new boolean[n];
        for (int i = 0; i < n; i++) {
            bolo[i] = false;
        }
        generuj(a, bolo, 0, n);
    }
}

Úlohy

• Skompilujte program, spustite ho a zadajte dve čísla, napr. 3 a 2. Mal by vypísať všetky variácie druhej triedy bez opakovania z množiny {0,1,2}, t.j. dvojice navzájom rôznych čísel.
• Zmeňte program tak, aby vypísal aj celkový počet týchto variácií.
  • Zmeňte návratový typ metódy (funkcie) generuj z void na int a prepíšte ju tak, aby vrátila počet riešení, ktoré vypísala (vrátane tých vypísaných v rekurzívnych volaniach)
  • V metóde main si výsledok uložte do premennej pocet typu int a vypíšte ho príkazom System.out.println("Pocet rieseni je " + pocet);
• Zmeňte program tak, aby vypisoval kombinácie, t.j. podmnožiny veľkosti k z množiny {0,1,...,n-1}. Aby sme každú kombináciu vypísali iba raz, budeme vyžadovať, že prvky sú v poli a rastúcom poradí, teda pre k=3, n=5 povolíme v poli a napr. 0,1,4, ale nepovolíme 0,4,1.
  • V tomto programe môžete zrušiť pole bolo, ale zato musíte zmeniť cez aké hodnoty prechádza cyklus premennej x vo funkcii generuj.

DÚ12

max. 10 bodov, termín odovzdania streda 29.2. o 22:00

Cieľom tejto domácej úlohy je vyskúšať si prácu v Jave s poliami a súbormi a zopakovať si vyfarbovanie z minulého semestra.

Napíšte program v jazyku Java, ktorý načíta maticu predstavujúcu mapu ostrovov v oceáne, nájde jednotlivé ostrovy a pre každý spočíta jeho plochu a dĺžku pobrežia.

Vstupný súbor ostrovy.txt obsahuje každý riadok vstupnej mapy ako reťazec, v ktorom bodka znamená políčko s oceánom a písmeno X znamená políčko s ostrovom. Tu je príklad:

.......X..
.XX....XX.
..X.X.....
X...XXXX..
.X...XXX..
.....XXX..

Ostrov je súvislá oblasť políčok označených písmenom X, pričom dve políčka dotýkajúce sa rohom nepovažujeme za susedné a nemusia teda byť súčasťou jedného ostrova, ak nie sú prepojené cez iné políčka. Plocha ostrova je jednoducho počet políčok označených X v rámci tohto ostrova. Dĺžka pobrežia je počet hraníc medzi políčkom ostrova a susedným políčkom oceánu. Teda napríklad ostrov pozostávajúci iba z jedného políčka má dĺžku pobrežia 4. Predpokladajte, že okolo celej vstupnej matice je oceán a teda ostrovy, ktoré sa dotýkajú okraja matice, majú na tomto okraji pobrežie.

Výstupný súbor vystup.txt obsahuje najprv kópiu vstupnej mapy, ktorá je ale zmenená tak, že prvý ostrov je označený písmenami A, druhý ostrov písmenami B atď. Môžete predpokladať, že ostrovov je najviac 26 a teda Vám budú stačiť písmená A..Z. Pod mapou by mal byť voľný riadok a pod ním zoznam ostrovov s údajmi o ploche a dĺžke pobrežia vo formáte ako na príklade nižšie. Ostrovy by mali byť zoradené podľa toho, v akom poradí narazíme na ich prvé políčko, keď ideme po mape po riadkoch zhora nadol a v každom riadku zľava doprava (a v tomto poradí sú aj označené písmenami A,B,...). Výstup pre príklad vstupu uvedený vyššie:

.......A..
.BB....AA.
..B.C.....
D...CCCC..
.E...CCC..
.....CCC..

Ostrov A: plocha 3, pobrezie 8
Ostrov B: plocha 3, pobrezie 8
Ostrov C: plocha 11, pobrezie 16
Ostrov D: plocha 1, pobrezie 4
Ostrov E: plocha 1, pobrezie 4

Technické požiadavky:

• Odovzdávajte jeden súbor Ostrovy.java, ktorý bude obsahovať balíček ostrovy, v ňom jednu triedu Ostrovy s funkciou main. Všetky vytvorené metódy by mali byť statické metódy v tejto triede.
• Dodržujte mená súborov a ich formát podľa príkladu v zadaní.
• Dbajte na úpravu a čitateľnosť vášho programu.

Pomôcky:

• Doporučujeme inšpirovať sa funkciou na vyfarbovanie z prednášky 17 z prvého semestra.
• Doporučujeme si v programe uložiť mapu ako dvojrozmerné pole int-ov, pričom napr. more máte ako 0, ešte nepreskúmané ostrovy ako -1 a preskúmané ostrovy označené číslami 1,2,...
• Ak máte už každý ostrov označený iným číslom, dĺžku pobrežia všetkých ostrovov ľahko spočítate jedným prechodom matice, pričom si budete všímať susedné políčka s rôznymi hodnotami.
• Nakoľko veľkosť mapy nie je vopred daná, môžete predpokladať, že jej každý rozmer je najviac 100. Konštantu zapíšeme ako static final int MAX = 100; v triede Ostrovy. Po načítaní doporučujeme mapu skopírovať do matice akurátnej veľkosti, aby ste pomocou length vedeli zistiť rozmery matice.
• Ak chcete zmeniť číslo i na znak tak, aby i=0 dostalo A, i=1 dostalo B atď, môžete použiť výraz (char) ('A' + i)

Prednáška 27

Základné pojmy

Java je objektovo orientovaný jazyk a teda v podstate všetko čo budeme používať sú objetky.

• Trieda - definícia objektu: aký má typ dát, operácie ..

class Pes {
}

• Objekt je inštanciou triedy: napríklad Dunčo a Punťo sú inštancie psa

Pes dunco;

this je odkaz na ten konkrétny objekt s ktorým práve pracujem. Z toho vyplýva niekoľko vecí

• this.premenna je vlastne to isté ako premenna
• this.funkcia(...) to isté ako funkcia(...)

Trieda a jej prvky môžu byť odniekiaľ prístupné a odinakiaľ nie. Na to, aby sme to upravili tak ako potrebujeme používame modifikátory. Pre triedu budeme najbežnejšie používať nasledovné:

• keď nič nedáme - je prístupná z package kde sa nachádza
• public - je prístupná ľubovoľne

Premenné - dáta

premenné sú lokálne dáta danej triedy

• normálne (keď nič iné nepovieme) môžu k dátam pristupovať trieda a k nej spriatelené triedy
• ak by sme to nechceli poskytnúť nikomu (samozrejme okrem samotnému objektu danej triedy) použijeme modifikátor private
• ak by sme naopak chceli poskytnúť dáta ľubovoľne použijeme modifikátor public

okrem toho ešte poznáme ďalšie modifikátory protected, static, final o ktorých sa budeme baviť neskôr

Prístup k premenným je pomocou . a keďže java nepozná smerníky iba referencie nemusíme rozlišovať . a ->

Metódy objektu

• funkcia alebo procedúra, ktorú vie objekt vykonávať nad svojimi dátami
• na rozdiel od statických funkcií, ktoré sme videli doteraz metódy patria k objektu
• prístup k funkciám pomocou '.'

Parametre:

• ako bolo spomínané, parametre sa odovzdávajú hodnotou - teda sa vytvorí lokálna kópia parametra a jej zmenou nedocielim zmenenie pôvodnej premennej
• zmenu premenných môžeme docieliť tým, že ako parameter použijem referenciu a tú síce meniť nemôžem ale obsah pamäte kam ukazujem meniť samozrejme môžem
  • špeciálne pre základné premmné sa dá použiť tzv. wrapper class, teda trieda ktorá ich 'obalí' a umožní k nim pristupovať ako k objektom cez referenciu

  class MyInteger {
   private int x;                   // data
   public MyInteger(int xIn) { x = xIn; } // konštruktor
   public int getValue() { return x; }  // získanie hodnoty
   public void setValue(int xIn) { x = xIn;} // nastavenie hodnoty
  }
  static void swap(MyInteger rWrap, MyInteger sWrap) {
    // interchange values inside objects
   int t = rWrap.getValue();
   rWrap.insertValue(sWrap.getValue());
   sWrap.insertValue(t);
  }

Návratová hodnota funkcie:

• void, základný typ, referencia
• príkaz return vráti návratovú hodnotu - použitím príkazu return sa program ukončí
• ako vidno, vieme vrátiť iba jednu hodnotu (a navyše nevieme vrátiť hodnotu zmenou parametra!) - ak chceme vrátiť viac hodnôt, musíme si na to vytvoriť objekt a vrátiť referenciu naň

   static class MyReturn {
      public int x;                   // data
      public char c; 
   }

  static MyReturn funkcia(int x, char c){
      MyReturn temp=new MyReturn();
      temp.x=x;
      temp.c=c;
      return temp;
  }

  public static void main(String[] args) {
      MyReturn temp=new MyReturn();
      temp=funkcia(7,'a');   
      System.out.println(temp.x+" "+temp.c);
  } 

Modifikátory:

• bez modifikátora - je metóda prístupná vrámci package, v ktorej je definovaná jej trieda
• public - je prístupná odvšadiaľ
• private - je prístupná iba pre triedu
• protected,abstract, final - uvidíme neskôr

Pozor, môže byť viac funkcii s rovnakým názvom

• ktorú zavolá?

class Example {
    public int work(int data_){return data_;}
    public int work(int data_, int dat_){return data_+dat_;}
    public char work(char data_){return data_;}
    public String work(char c1,char c2){String temp=c1+""+c2; return temp;}
}

Example e=new Example();
System.out.println(e.work(7));
System.out.println(e.work('a','b'));
System.out.println(e.work(7,1));

Konštruktor

• Špeciálna metóda objektu, ktorá ten objekt vytvorí
• Názov konštruktora je názov triedy. Teda konštruktor triedy Pes bude teda funkcia Pes().
• Rozdiel medzi metódou objektu a konštruktorom.
  • Konštruktor nemá v hlavičke návratovú hodnotu. Návratovou hodnotou je tento objekt samotný, takže nie je potrebné túto návratovú hodnotu špeciálne definovať.
  • V tele konštruktora nie je kľúčové slovo return.
  • Prvý riadok konštruktora buď volá iný konštruktor tej istej triedy alebo triedy predchodcu (ak toto neurobíme, urobí to kompilátor za nás).
    • Volanie iného konštruktora tej istej triedy (často napríklad s menším počtom parametrov) voláme pomocou this()
  • Pozor! Tieto rozdiely sú niekedy nie úplne zrejmé pri pohľade do zdrojového kódu, preto sa v niektorých jazykoch používa kľúčové slovo "constructor", ale Java to nemá

• Defaultný konštruktor: V prípade, že nedefinujete pre triedu žiaden koštruktor, bude automaticky vygenerovaný konštruktor bez parametrov (s menom podľa názvu triedy), ktorý zavolá konštruktora predchodcu (o týždeň) a inicializuje premenné na defaultné hodnoty (nula pre číselné premenné, null pre referencie a false pre boolean).
• Defaultný konštruktor je vytvorený iba v prípade, že žiaden iný konštruktor neexistuje.

class Pes {
    String meno;
    Pes(){this("Dunco");}
    Pes(String meno_){meno=meno_;}
    Pes(String meno1, String meno2){this(meno1+" "+meno2);}
}

Vznik objektov

Pes punto=new Pes("Punto");

• dynamicky alokuje pamäť pre objekt
• nastaví štandardné hodnoty pre premenné (null, 0, false)
• zavolá konštruktor objektu - defaultný alebo ten, ktorý sedí s počtom parametrov
• vráti referenciu - pamäťovú adresu objektu

• niekedy nechceme urobiť konštruktor prístupný ľubovoľne a preto si urobíme továreň na naše objekty - funkciu, ktorá nám objekty bude vytvárať (takto funguje konštruktor napríklad v Delphi)

    public static Pes VytvorPsa(String meno) { return new Pes(meno); }//tovaren na psy

    Pes rex=Pes.VytvorPsa("Rex");

Veci z minulej prednáške

Na minulej prednáške sme sa objektom vyhýbali, ale oni tam aj tak sú - keďže v jave je všetko objekt

Základné typy - int, ..

• Aj základné typy majú svoje objektové varianty
• Jedná sa o wrapper typy - Integer, Double .. (viac pozri [2])

Polia

• Aj polia sú vlastne špeciálne objekty - ako vidno napríklad z metódy a.length()
• Preto napríklad b=a nefunguje tak ako by sme čakali - je to naozaj iba priradenie referencie

Ukážka zásobníku + zapuzdrenie

• Ukážeme si teraz ako spraviť napríklad zásobnik pomocou spájaného zoznamu.
• Vytvoríme si triedu Node, ktorá bude reprezentovať vrchol a prácu s ním

class Node {
    private int data;
    private Node next;
    
    public Node() {}
    public Node(int data_) {data=data_;}
    public Node(int data_, Node next_) {data=data_; next=next_;}
    
    public int getData() {return data;}
    public void setData(int data_) {data=data_;}
    public Node getNext() {return next;}
    public void setNext(Node next_) {next=next_;}
}

• Samotný zásobník bude opäť trieda

class Stack {
    private Node front;
    public Stack() {}    
    public void push(int data_){
        Node p=new Node(data_);
        if (front==null) front=p;
        else { p.setNext(front); front=p; }
    }
    public int pop(){
        if (front==null) return -1;
        int res=front.getData();
        front=front.getNext();
        return res;
    }
    public void printStack() {
     Node p=this.front;
     while (p!=null) {
         System.out.print(p.getData()+" ");
         p=p.getNext();
     }
         System.out.println();
    }    
    
}

• Teraz si triedu niekde použijeme.

public static void main(String[] args) {
        Stack s=new Stack();
        s.printStack();
        s.push(7);
        s.push(12);
        s.printStack();
        System.out.println(s.pop());
}

• A čo v prípade, že by sme sa teraz rozhodli to vytvoriť radšej pomocou poľa? Nič - proste by sme si to pomocou poľa naprogramovali a zvonku by sme si nič nevšimli.
• V ideálnom prípade by sme mali mať triedy zapuzdrené teda
  • zvonku vidno veci, ktoré sú súčasťou API
  • zvyšok je zvonku neprístupný

Binárny vyhľadávací strom

Podobne môžeme urobiť aj triedu vrchol stromu a binárny vyhľadávací strom.

class Node {
    private int data;
    private Node left, right;
    
    public Node() {}
    public Node(int data_) {data=data_;}
    public Node(int data_, Node left_, Node right_) {data=data_; left=left_; right=right_;}
    
    public int getData() {return data;}
    public void setData(int data_) {data=data_;}
    public Node getLeft() {return left;}
    public void setLeft(Node left_) {left=left_;}
    public Node getRight() {return right;}
    public void setRight(Node right_) {right=right_;}
    public Node getNext(int data_) {
        if (data_<this.data) return left; 
        else return right;
    }
    public void setNext(Node next_){
        if (next_.data<=this.data) this.setLeft(next_);
        else this.setRight(next_);       
    }
    
    public void outPrefix(){
        if (this!=null) {
           System.out.println(data);
           if (this.left!=null) left.outPrefix();
           if (this.right!=null) right.outPrefix();
        }
    }
    public void outInfix(){
        if (this!=null) {
           if (this.left!=null) left.outInfix();
           System.out.println(data);
           if (this.right!=null) right.outInfix();
        }
    }
}

class Tree {
    private Node root;
    
    public Tree() {}
    public Tree(Node root_) {root=root_;}
      
    public void addNode(int data_){
        Node p=new Node(data_);
        Node temp=this.root;
        if (temp==null) root=p;
        else {
            while (temp.getNext(data_)!=null) temp=temp.getNext(data_);
            temp.setNext(p);
        }
    }
    public void outPrefix(){if (this.root!=null) root.outPrefix();}
    public void outInfix(){if (this.root!=null) root.outInfix();}
}

Javadoc

• Javadoc slúži na vytváranie dokumentácie k aplikácii - hlavne na API
• Javadoc komentár začína /** a končí ako klasický komentár */ pričom každý riadok začína *
  • prvý riadok resp. odsek je slovný popis
  • ďalšie špeciálne vlastnosti sa popisujú pomocou tagov [3]

Ako z toho potom vytvoriť dokumentáciu

• automaticky vytvára dokumentáciu iba k public veciam (keďže tie asi tvoria API)
• vo vlastnostiach aplikácie časť Documenting sa dá zmeniť
• samotná stránka sa vygeneruje v časti Run, Generate Javadoc

Komentár triedy

/**
 * Popis triedy. 
 * 
 * @author      meno
 * @version     1.6
 */
class Trieda {
  // telo triedy
}

Komentár premennej

/**
 * Popis premennej.
 */
private int premenna = 0;

Komentár metódy

/**
 * Krátky popis.
 *
 * Dlhší popis, ktorý tu môže alebo aj nemusí byť. Môže byť dokonca
 * na viacerých riadkoch.
 *
 * @param  premenna bla bla bla.
 * @return co to vrati.
 * @throws java.io.IOException popis.
 */
public int funkcia(int premenna) throws java.io.IOException {
}

Cvičenia 14

• Odsimulujte nasledovný program a nakreslite, ako budú vyzerať premenné v pamäti v oboch prípadoch, keď sa vykonal riadok označený (*). Zistite, čo program vypíše.

package prog;
public class Prog {

    static void vypis(int[][] a) {
        if (a != null) {
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[i].length; j++) {
                    System.out.print(" " + a[i][j]);
                }
                System.out.println();
            }
        } else {
            System.out.println("null");
        }
    }

    static int[] vytvorRiadok() {
        return new int[2];
    }

    static void vytvorMaticu(int[][] a) {
        if (a == null) {
            a = new int[2][];
        }
        a[0] = vytvorRiadok();
        a[1] = a[0];
        a[0][0] = 1;  // (*)
    }

    public static void main(String[] args) {
        int[][] a = new int[2][];
        vytvorMaticu(a);
        int[][] b = null;
        vytvorMaticu(b);
        vypis(a);
        vypis(b);
    }
}

• Napíšte funkciu static int[][] transpose(int[][] a), ktorá transponuje danú maticu a, teda vytvorí a vráti novú maticu, ktorá bude mať v stĺpcoch uložené riadky matice a. Môžete predpokladať, že vstupná matica má všetky riadky rovnako dlhé.
• Napíšte program, ktorý zo súboru matica.txt načíta najprv počet riadkov a stĺpcov matice a potom jej jednotlivé prvky, ktoré sú všetky celé čísla. Do súboru matica2.txt vypíše transponovanú maticu k vstupnej matici v rovnakom formáte, teda najskôr počet riadkov a stĺpcov a potom jednotlivé riadky.
• Pozrite si dokomentáciu k triede Random v balíčku java.util a napíšte program, ktorý odsimuluje 10 hodov kockou, teda vypíše 10 náhodných celých čísel od 1 po 6.
• Spravte si generátor náhodných vstupov pre #DÚ12: program načíta od užívateľa rozmery matice a tri ďalšie parametre p, q a r, ktoré budú desatinné čísla od 0 po 1. Maticu vypĺňajte postupne po riadkoch. Keď vypĺňate políčko (i,j), pozrite sa, či na políčkach (i-1,j) a (i,j-1) je ostrov, alebo more (v prípade, že tieto políčka sú mimo matice, rátajte ich ako more). Ak sú obe tieto políčka more, na políčku (i,j) bude ostrov s pravdepodobnosťou p, ak je práve jedno z nich more, na políčku (i,j) bude ostrov s pravdepodobnosťou q a ak sú obe políčka ostrov, na políčku (i,j) bude ostrov s pravdepodobnosťou r. Maticu zapíšte do súboru v požadovanom formáte.
  Pomôcka: Ak sa chceme rozhodovať medzi dvoma vecami s určitou pravdepodobnosťou x, môžeme vygenerovať náhodné desatinné číslo z intervalu [0,1) a ak je toto náhodné číslo menej ako x, zvolíme jednu možnosť a ak viac ako x, zvolíme druhú.

DÚ13

max. 20 bodov, termín odovzdania streda 14.3. o 22:00

Cieľom tejto úlohy je vyskúšať si prácu s triedami a systémom JavaDoc, ale aj zopakovať si z minulého semestra stromy a rekurziu. Doporučujeme začať na tejto úlohe pracovať v dosť veľkom predstihu, nakoľko spája niekoľko potenciálne náročných podúloh:

• z textu nižšie naštudovať rozhodovacie stromy a popísaný algoritmus, ktorý budete implementovať
• naštudovať časť kódu, ktorá je už hotová
• vhodne navrhnúť použité triedy a ich metódy
• implementovať metódy, pričom niektoré budú rekurzívne
• program odladiť a okomentovať systémom JavaDoc.

Problém klasifikácie

Obr. 1: Malá sada trénovacích dát s 10 príkladmi, 3 triedami a 2 atribútmi

Strojové učenie (machine learning) je oblasť na pomedzí informatiky a štatistiky, ktorej cieľom je vyvíjať algoritmy, ktoré sa dokážu "učiť" z dostupných dát. My sa budeme zaoberať problémom klasifikácie. Učiaci algoritmus dostane trénovacie dáta, ktoré obsahujú N príkladov. Každý príklad pozostáva z vektora atribútov dĺžky K a z triedy. Na základe trénovacích dát by sme sa chceli naučiť nejaké pravidlo, ktoré na základe atribútov bude predpovedať triedu. Príklad veľmi malej sady trénovacích dát vidíme na obrázku 1 vpravo.

Na tejto domácej úlohe ako príklad použijeme problém rozpoznávania ručne písaných cifier. Naše atribúty reprezentujú obrázok ručne písanej cifry (po určitom predspracovaní) a trieda je jedno z čísel 0..9. Vo všeobecnosti budeme predpokladať, že všetky atribúty sú reálne čísla a trieda je celé číslo z množiny {0,1,..., T-1}, kde T je počet tried (v našom prípade T=10). Učiaci algoritmus sa teda na základe predložených trénovacích príkladov naučí nejaké pravidlo a to potom môžeme použiť na čítanie ručne písaných cifier: obrázok cifry sa predspracuje do atribútov rovnako ako trénovacie dáta a na základe naučeného pravidla sa z atribútov určí trieda. Učiace algoritmy však často nefungujú celkom spoľahlivo a výsledné pravidlo občas robí chyby. Preto po natrénovaní väčšinou pravidlo použijeme najskôr na testovacie dáta, pri ktorých poznáme správnu odpoveď a zistíme, na koľkých percentách naše pravidlo bude správne fungovať. Podľa toho usúdime, či je použiteľné v praxi.

Rozhodovacie stromy

Pravidlo, ktoré na základe vektora atribútov určí triedu, môže mať veľa rôznych foriem. My použijeme rozhodovacie stromy. Rozhodovací strom (decision tree) má v každom vnútornom vrchole otázku, pričom ľavý podstrom zodpovedá prípadu, že odpoveď na otázku je áno a pravý podstrom prípadu, že odpoveď je nie. Pre daný vektor atribútov začneme v koreni, určíme odpoveď na prvú otázku a podľa tejto odpovede sa posunieme do ľavého alebo pravého syna. V tomto vrchole opäť zistíme odpoveď na otázku a posunieme sa jedným smerom. Keď napokon prídeme do listu, nájdeme v ňom uloženú predpovedanú triedu.

Obr. 2: Príklad rozhodovacieho stromu s dvoma vnútornými vrcholmi a troma listami. Správne predpovedá všetky triedy z ukážky na obrázku 1, okrem príkladu (3.5,-1), ktorému namiesto triedy 1 predpovedá triedu 0.

Označme si vektor atribútov x[0],...,x[K-1], otázka v každom vrchole bude mať v našom prípade tvar "Je x[i]<=Y?", t.j. porovnávame i-ty atribút s nejakou prahovou hodnotou Y a ak je menší alebo rovný, posúvame sa do ľavého podstromu a ak je väčší, posúvame sa do pravého podstromu. Na špecifikovanie otázky nám teda stačí vo vnútornom vrchole uložiť čísla i a Y. Príklad rozhodovacieho stromu vidíme na obrázku 2 vpravo.

Učenie sa rozhodovacích stromov

Už teda vieme ako rozhodovací strom vyzerá a ako sa dá použiť na určenie triedy na základe vektora atribútov. Teraz si popíšeme, ako taký strom zostrojiť na základe trénovacích dát, v ktorých poznáme atribúty aj triedy. Strom budeme budovať zhora nadol. V prvom kroku sa pozrieme na všetky dáta a určíme nejakú otázku, ktorá bude v koreni. Podľa tejto otázky potom rozdelíme všetky trénovacie dáta na dve skupiny: tie, čo patria doľava (lebo ich odpoveď na otázku je áno) a tie, čo patria doprava (odpoveď nie). Pre každú skupinu potom rekurzívne tým istým algoritmom vybudujeme rozhodovací strom a tieto stromy zavesíme ako ľavý a pravý podstrom koreňa.

Majme teraz množinu dát pre nejaký vrchol stromu a chceme zvoliť otázku. Zvolíme ju tak, aby pokiaľ možno dávala dáta s rovnakou triedou spolu. Ak by napríklad polovica dát mala triedu 0 a polovica dát triedu 1, ideálna by bola otázka, ktorá dá všetky dáta triedy 0 do jedného podstromu a všetky dáta triedy 1 do druhého podstromu. Ak však taká otázka nie je (nie je možné určiť triedu len podľa jedného atribútu), uspokojíme sa aj s otázkou, ktorá dá napr. do každého podstromu 80% dát jednej triedy a 20% dát druhej triedy. To, nakoľko je trieda v danej množine dát homogénna, budeme vyjadrovať veličinou, nazývanou entropia, ktorá sa dá ľahko spočítať z počtov dát v jednotlivých triedach. Ak majú všetky dáta rovnakú triedu, entropia je 0 a ak jedna trieda vysoko prevažuje nad ostatnými, entropia je tiež pomerne blízko nule. Najväčšia entropia je pre T tried zastúpených rovnomerne, jej hodnota je potom Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle \log_2 T} . Snažíme sa nájsť takú otázku, aby po rozdelení dát na dáta pre ľavý a pravý podstrom bola v týchto častiach čo najnižšia entropia (konkrétne chceme, aby bol čo najnižší vážený priemer entropií týchto dvoch častí, kde váha každej časti je jej veľkosť). S výpočtom entropie a váženého priemeru si nemusíte robiť ťažkú hlavu, dostanete ich už naprogramované. Algoritmus bude skúšať všetky možné atribúty a pre každý atribút vyskúša ako prahovú hodnotu Y všetky hodnoty tohto atribútu, ktoré sa nachádzajú medzi dátami. Pre každú takúto možnú otázku spočíta, aká je vážená entropia po rozdelení dát a zvolí najlepšiu možnosť.

V každom kroku algoritmu sa tiež musíme rozhodnúť, či ideme vytvárať vnútorný vrchol s otázkou a ďalej dáta deliť na dve časti, alebo či vytvoríme list. Ak sa rozhodneme pre list, nájdeme triedu, ktorá má v dátach pre tento vrchol najviac výskytov, a túto triedu vyhlásime za odpoveď. Vnútorný vrchol vytvoríme len vtedy, ak nájdeme otázku, ktorá spĺňa nasledujúce dve podmienky:

• po rozdelení dát na dve časti (ľavú a pravú), bude v každej časti aspoň minSize príkladov.
• vážený priemer entropie týchto dvoch častí je aspoň o minImprovement nižší ako entropia všetkých dát vo vrchole.

Ak neexistuje žiadna otázka, ktorá spĺňa obidve tieto podmienky, vytvoríme list.

Príklad: uvažujme trénovacú množinu uvedenú na obrázku 1 a nastavenia minSize=3 a minImprovement=0.01. Algoritmus najskôr skúša pre atribút x[0] prahy 2.1, 2.5, 2.8, 3.0 a 3.5 a pre atribút x[1] prahy -3.4, -2.8, -2.1, -2.0 a -1.5. Najmenší vážený priemer entropií má rozdelenie podľa atribútu 0 s prahom 3.5. Hodnota priemeru je 0.6897 a entropia celej trénovacej množiny je 1.5710. Zlepšenie je teda o 0.8813, čo je viac ako náš prah 0.01. Algoritmus teda vytvorí koreň, v ktorom bude otázka x[0]<=3.5? V ľavej časti stromu bude prvých 7 príkladov, v pravej posledné 3. Pravú časť stromu sa nám už nepodarí ďalej rozčleniť na dve časti veľkosti aspoň 3, teda vytvoríme list, v ktorom bude hodnota triedy 2 (všetky príklady v tejto časti stromu majú túto hodnotu). V ľavej časti stromu znovu skúšame všetky atribúty a prahy, nakoľko máme ale len 7 prvkov, máme pre každý atribút len 2 prahy, ktoré rozdelia dáta tak, aby v každej časti boli aspoň 3 prvky. Z toho najlepšia otázka je x[1]<=-2.8?, ktorá zníži entropiu z 0.9852 na 0.4636. Opäť teda rozdelíme zvyšné dáta na dve časti. Vľavo budú tri príklady s triedou 1, vytvoríme teda list s touto triedou. Vpravo budú tri príklady s triedou 0 a jeden príklad s triedou 1, vytvoríme teda list s triedou 0. Dostávame rozhodovací strom na obrázku 2.

Poznámka: toto je len jednoduchý algoritmus pre účely tejto úlohy, v praxi sa rozhodovacie stromy učia mierne odlišnými algoritmami.

Úloha

Napíšte v Jave package decisionTree na prácu s rozhodovacími stromami. Mal by obsahovať triedu DecisionTree, ktorá bude poskytovať aspoň tieto metódy:

• Konštruktor, ktorý vytvorí rozhodovací strom na základe trénovacích dát vyššie uvedeným algoritmom. Okrem trénovacích dát dostane ako parametre aj hodnoty minSize a minImprovement
• Metódu, ktorá pre daný vektor atribútov určí triedu na základe rozhodovacieho stromu
• Metódu, ktorá strom zapíše do súboru vo formáte popísanom nižšie (alebo metódu toString, ktorá strom zapíše do reťazca, ktorý je potom už ľahké vypísať)
• Konštruktor, ktorý načíta strom zo súboru v tom istom formáte (alebo z objektu typu Scanner)

Okrem toho by ste mali napísať dve triedy s metódou main:

• Trieda TrainDecisionTree načíta trénovacie dáta zo súboru train.txt (formát a ukážky súboru nižšie), na základe nich zostaví strom a vypíše ho do súboru tree.txt. Parametre algoritmu nastavte ako minSize=3 a minImprovement=0.01.
• Trieda TestDecisionTree načíta strom zo súboru tree.txt a testovacie dáta zo súboru test.txt, na každom testovacom príklade nájde predpovedanú triedu podľa rozhodovacieho stromu a určí, či je správna. Na konci na konzolu vypíše štatistiku úspešnosti vo formáte uvedenom v príklade výstupu nižšie.

Podľa potreby si napíšte aj ďalšie triedy, napríklad triedu reprezentujúcu vrcholy stromu. Mnohé z metód na prácu so stromom budú rekurzívne, potrebujú teda konkrétny vrchol stromu. Môžete si napísať jednoduchú nerekurzívnu metódu pre strom, ktorá bude public a ktorá iba zavolá príslušnú rekurzívnu metódu pre koreň stromu.

Aby programovania nebolo priveľa, dostanete už naprogramovanú triedu DataSet, ktorá reprezentuje sadu trénovacích alebo testovacích dát. Pre túto sadu vie spočítať napríklad entropiu a najčastejšie sa vyskytujúcu triedu. Vie dokonca aj nájsť najlepšiu otázku, ktorá rozdelí sadu dát na ľavú a pravú časť. Takéto rozdelenie vráti v pomocnej triede DataSet.Split. Pozrite si dokumentáciu k týmto triedam, prípadne aj ich kód. Nakoľko sú názvy v angličtine, atribút nazývame anglickým pojmom feature, trieda je class. Slovo class je v Jave rezervované, preto používame pojem trueClass pre skutočnú správnu triedu daného príkladu. Súbor DataSet.java pokiaľ možno nemeňte. Ak však v ňom potrebujete spraviť nejaké zmeny, popíšte ich v komentári na vrchu súboru.

Štýl a komentáre

• Okrem správnosti ide v tejto úlohe aj o rozumný návrh tried, ich metód a premenných. Nemusíte používať dedičnosť.
• Dbajte o pekný programátorský štýl.
• Všetky triedy a ich metódy popíšte vo formáte JavaDoc.
• Ak nejakú časť úlohy neviete vyriešiť, pokúste sa napísať aspoň definície tried, ich premenných a metód a popíšte v systéme JavaDoc, čo by mali robiť. Za takúto kostru dostanete aspoň čiastočné body. Samozrejme, čím viac z metód aj implementujete, tým lepšie. Hotové metódy odlaďte a otestujte na malých vstupoch alebo umelo vytvorených stromoch.

Odovzdávanie

• Odovzdávajte jeden .zip súbor obsahujúci adresár decisionTree a v ňom všetky zdrojové súbory (*.java) vášho balíčka decisionTree
• Dodržiavajte mená tried a súborov uvedené v zadaní. Váš .zip súbor by mal teda obsahovať decisionTree/DataSet.java (tento súbor je už hotový), decisionTree/DecisionTree.java, decisionTree/TrainDecisionTree.java, decisionTree/TestDecisionTree.java a prípadne ďalšie .java súbory, ak potrebujete.

Súbory

Sady trénovacích a testovacích príkladov sú zadané v textovom súbore, ktorý obsahuje čísla oddelené bielymi znakmi (medzerami a koncami riadkov). Prvé tri hodnoty v tomto súbore určujú počet príkladov v sade, počet atribútov a počet tried. Za nimi nasleduje zoznam príkladov, pričom každý príklad je daný zoznamom atribútov a triedou.

Rozhodovacie stromy majú na prvom riadku počet atribútov. Potom nasleduje výpis jednotlivých vrcholov stromu v inorder poradí, t.j. vypíšeme najskôr koreň, potom rekurzívne celý ľavý podstrom a nakoniec celý pravý podstrom. Ak je vrchol vnútorný, v súbore je najskôr písmeno I a za medzerou číslo atribútu a prah. Ak je vrchol list, v súbore je písmeno L a za medzerou predpovedaná trieda pre tento list. V tomto formáte by ste mali vedieť stromy načítavať aj vypisovať. Príklad súboru nájdete v dátach na stiahnutie.

Výsledok testovania stromu na testovacích dátach vypisujte v nasledujúcom formáte (toto je výsledok ak strom na obr. 2 testujeme na sade dát na obr. 1):

The number of testing examples: 10
The number of correctly predicted examples: 9
Success rate: 0.9

Pre uľahčenie Vašej práce Vám poskytujeme viacero súborov v jednom zip súbore. Nájdete tam "malý príklad", ktorý pozostáva z identickej trénovacej a testovacej sady z obrázku 1 a zo stromu na obrázku 2, ako aj skutočný príklad s rozpoznávaním cifier, pre ktorý uvádzame trénovacie a testovacie dáta. Nájdete tam aj implementáciu triedy DataSet.

• Zip súbor s dátami a triedou DataSet
• JavaDoc dokumentácia k public metódam triedy DataSet

Pre zvedavých študentov

Toto zadanie je pomerne dlhé a text v tejto časti už na riešenie úlohy nepotrebujete, môže však byť zaujímavý, pre tých, čo chcú vedieť viac.

Detaily problému rozpoznávania cifier

Trénovacie a testovacie dáta pre problém rozpoznávania cifier sme zobrali zo stránky http://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits kde sa o nich môžete dozvedieť viac. Obrázok každej cifry je rozdelený na mriežku 8x8 a pre každé políčko tejto mriežky máme hodnotu od 0 po 16, ktorá vyjadruje, koľko z tohto políčka bolo čiernej farby. Obrázky pre všetky testovacie príklady nájdete tu (odtieň sivej vyjadruje číslo od 0 po 16, v ľavom hornom rohu je uvedená správna trieda). Môžete si napríklad pozrieť, ako vyzerajú príklady, na ktorých sa váš strom pomýlil.

Algoritmus na hľadanie najlepšej otázky

Keď hľadáme najlepšie rozdelenie sady dát na dve časti podľa nejakej otázky, najjednoduchší algoritmus je takýto:

• Skúšame jeden po druhom všetky atribúty
• Pre každý atribút uvažujeme ako prah všetky hodnoty, ktoré nadobúda v danej sade dát
• Pre každú kombináciu atribút i a prah Y:
  • rozdelíme množinu na dve časti (príklady kde platí x[i]<=Y a príklady, kde to neplatí)
  • v každej časti spočítame počet výskytov každej triedy
  • na základe týchto počtov spočítame vážený priemer entropií
  • hľadáme kombináciu i a Y, pre ktoré sú obe časti dosť veľké a vážený súčet entropií je najmenší možný

Ak máme N príkladov a K atribútov, budeme skúšať NK dvojíc i a Y a pre každú dvojicu budeme ešte prechádzať cez všetky príklady a rátať počty tried v pravej a ľavej časti. Celková časová zložitosť je teda O(KN^2).

V kóde je však implementovaný lepší algoritmus, ktorý si pre každý atribút najskôr utriedi všetky príklady podľa tohto atribútu. Potom prechádza hodnoty prahu Y od najmenšej po najväčšiu a udržuje si počty výskytov tried v ľavej a pravej časti. Ak prejde od jednej hodnoty Y k najbližšej vyššej, iba jeden príklad sa presunie z pravej časti do ľavej a teda stačí iba zvýšiť počet pre jeho triedu v ľavej časti a znížiť v pravej. Na základe poľa počtov už entropiu spočítame v čase O(T), kde T je počet tried. Celkový čas výpočtu je teda O(KN (log N + T)). Čas O(KN log N) totiž treba na K triedení podľa každého atribútu zvlášť a po utriedení potrebujeme na spracovanie jedného atribútu čast O(NT). Tento algoritmus je teda lepší, ako ten jednoduchší, ak (log N + T) je oveľa menej ako N. Pri rozpoznávaní cifier máme T=64 a N=3823, takže algoritmus s triedením sa oplatí.

Pri implementácii treba dávať pozor na to, že viacero príkladov môže mať tú istú hodnotu určitého atribútu. Detaily implementácie nájdete v DataSet.java súbore, pre lepšiu orientáciu uvádzame JavaDoc dokumentáciu všetkých metód a premenných, vrátane private:

• JavaDoc dokumentácia k všetkým metódam triedy DataSet

Môžete si všimnúť ako je vyriešené triedenie podľa zadaného atribútu pomocou pomocnej triedy DataSet.ExampleComparator

Prednáška 28

Objekty a dedenie

• Trieda Pes

class Pes {
    String meno;
    Pes(){this("Dunco");}
    Pes(String meno_){meno=meno_;}
    void ozviSa() { System.out.println("Haf!"); }
    void strazDom() {}
}

• Ak teraz chceme vytvoriť triedu Mačka vyzerá to jednoducho - veľa vecí má so psom podobných - spravíme Copy+Paste a vhodne upravíme

class Macka {
    String meno;
    Macka(){this("Mica");}
    Macka(String meno_){meno=meno_;}
    void ozviSa() { System.out.println("Mnau!"); }
    //macka zvacsa dom nestrazi
}

• Problém nastane, keď si vytvoríme viacero takýchto "podobných" tried a budeme chcieť meniť niečo, čo majú spoločné. Aby sme sa tomuto problému vyhli tak pre spoločné premenné a metódy, ktoré majú všetky zvieratá si vytvoríme triedu Zviera.

class Zviera {
    String meno;
    Zviera(){}
    Zviera(String meno_){meno=meno_;}
    void ozviSa() { System.out.println("?"); } // zviera vlastne nevie že ako sa ozvať, ale vie, že to vie urobiť
}

• Teraz sú Pes a Mačka potomkami triedy Zviera
• Čo sa v nich zmení?

Kľúčové slovo extends

• V jave sa dedí iba od jednej triedy (na rozdiel od napr. C++)
• Dedenie je však možné viacúrovňovo

class Pes extends Zviera {
}
class Civava extends Pes {
}

Premenné v potomkoch a predchodcoch

• Potomok obsahuje všetky premenné predchodcu
• Vie pristupovať k premenným predchodcu okrem privátnych

class Zviera {
    protected String meno;
}
class Pes extends Zviera {
    // obsahuje premennú meno a vie k nej pristupovať
    String vratMeno() { return meno; }
}

Konštruktor

• na začiatku konštruktora (pokiaľ to nie je napísané) sa zavolá super(), ktorý zavolá konštruktor nadradenej triedy
• podobne ako sme mohli v konštruktoroch používať this(..) môžeme aj my použiť super(..)

class Zviera {
// ma iba defaultný konštruktor
}
class Pes extends Zviera {
    Pes(String meno_){ 
        //super(); - automaticky urobi prekladac
        meno=meno_;
    }
}

Metódy

• Polymorfizmus v programovaní (hlavne pri OOP) je schopnosť funkcií chovať sa rôzne
• S polymorfizmom sme sa už stretli pri jednoduchých triedach, kde funkcia mohla v závislosti od parameterov robiť rôzne veci (tzv. overloading)
• Pri dedení navyše sa môže funkcia chovať rôzne v rôznych triedach - aj napriek tomu, že sa volá rovnako a je dedená z jednej konkrétnej funkcie u nadradenej triedy (overriding)
  • Ako to funguje keď zavolám funkciu f() v objekte typu T ( t.j. zavolám o.f() )
  • V prvom rade zistím, či T vie vykonať f() ak áno, vykonám ju
  • Ak ju T vykonať nevie zistíme, či T nemá nadtriedu a táto vie vykonať f().
  • Takto pokračujeme...
  • No dobre, v skutočnosti je tam tabuľka, ktorá rovno povie, ktorá sa vykoná

• Funkcie potomka prepíšu (nahradia) funkcie predchodcu

class Zviera {
    public void OzviSa() { System.out.println("He?"); }
}
class Pes extends Zviera {
    @Override
    public void OzviSa() { System.out.println("Haf!"); }
}

Príklad

class Zviera {
    protected String meno;
    public void OzviSa() { System.out.println("He?"); }
    public void Spi() { System.out.println("Chrrr!"); }
}

class Pes extends Zviera {
    Pes(String meno_){ meno=meno_; }
    @Override public void OzviSa() { System.out.println("Haf!"); }
}

class Civava extends Pes {
    Civava(String meno_){ super("Maly/a "+meno_); }
    @Override public void OzviSa() { System.out.println("Hif!"); }
}

class Macka extends Zviera {
    Macka(String meno_) { meno=meno_; }
    @Override public void OzviSa() { System.out.println("Mnau!");  }
    @Override public void Spi() { /*macka nechrape!*/ }
}

...
static void test() {
      Zviera x=new Civava("Dunco");
      Zviera y=new Macka("Mica");
      
      Pes alik=new Pes("Alik");
      Pes rex=new Pes("Rex");
     
      if (x instanceof Pes)           // x je Civava a teda je to aj Pes
      {
        Pes dunco=(Pes)x;             // budeme sa na Zviera x pozerat ako na psa
        System.out.println("x je pes");
        dunco.ozviSa()                // "Hif!" aj ked je pes je to stale Civava
      }
      //Pes mnau=(Pes)y; - spadne za behu
      if (y instanceof Pes)           // y nie je Pes (ani potomok psa)
      {
        Pes cica=(Pes)y;              // toto sa nikdy nestane
      }
      
      alik.OzviSa();                  // "Haf!"
      rex.OzviSa();                   // "Haf!"
      x.OzviSa();                     // "Hif!"  (aj keď je to zviera nepovie "He?" ani "Haf" ako pes)
      y.OzviSa();                     // "Mnau!" (aj keď je to zviera nepovie "He?")

      x.Spi();                        // "Chrrr!"
      y.Spi();                        // macky nechrapu!

      Zviera[] zvierata=new Zviera[2];
      zvierata[0]=alik;
      zvierata[1]=y;
      for(Zviera zviera:zvierata) { zviera.OzviSa(); }
    }

Modifikátory tried, premenných a metód

• niektoré modifikátory súvisia s dedením

Abstract, final

abstract class Zviera {
    protected String meno;
    public abstract void OzviSa(); 
    // nemusím písať zbytočne telo a stráži mi to, aby som nezabudla u potomka OzviSa()
    public abstract void Spi();
}
class Pes extends Zviera {
    @Override public void OzviSa() { System.out.println("Haf!"); }
    @Override public final void Spi() { System.out.println("Chrrrrrr!"); }
}
final class Civava extends Pes {
    @Override public void OzviSa() { System.out.println("Hif!"); }
    // uz nemozem urobit Spi() - všetci psi chrápu
}

Metódy dedené z Object

• Všetky triedy sú autoamticky potomkami triedy Object
• Object obsahuje virtuálne metódy (napr. toString()), ktoré môžeme preťažiť.

class Blabol /* extends Object */ { 
    public void print() { System.out.println("Blablabla"); }
    @Override public String toString() { return "Blebleble"; }
}
...
    Blabol b=new Blabol();
    System.out.println(b.toString());  

Aritmetický strom s využitím dedenia

abstract class Node {
    public abstract int Compute();
    public abstract String Print();
}

abstract class NularyNode extends Node {
}

abstract class UnaryNode extends Node {
    Node child;
    UnaryNode(Node child_){ child=child_; }
}

abstract class BinaryNode extends Node {
    Node left;
    Node right;
    BinaryNode(Node left_, Node right_) { left=left_; right=right_; }
}

class Constant extends NularyNode {
    int value;
    Constant(int value_) { value=value_;}
    @Override public int Compute() { return value;}
    @Override public String Print() { return new Integer(value).toString();}
}

class UnaryMinus extends UnaryNode {
    UnaryMinus(Node child_){ super(child_); }
    @Override public int Compute() { return -child.Compute();}
    @Override public String Print() { return "(-"+child.Print()+")";}
}

class Plus extends BinaryNode { 
    Plus(Node left_, Node right_) { super(left_,right_); }
    @Override public int Compute() { return left.Compute()+right.Compute();}
    @Override public String Print() { return "("+left.Print()+"+"+right.Print()+")";}
}

...
public static void main(String[] args) {
   Node expr=new Plus(new UnaryMinus(new Constant(2)),new Constant(3));
   System.out.println(expr.Print());
   System.out.println(expr.Compute());
}

Interface

• Interface je podobné ako abstraktný predok, ale
  • neobsahuje premenné a implementácie metód
  • trieda môže implementovať viacero rozhraní - pripomína "viacnásobná dedičnosť"

package javaapplication5;

interface IStack {
    void push(int data_);
    int pop();
}

interface IPrintable {
    void print();
}

class Stack implements IStack, IPrintable {
    static class Node {
        public int data;
        public Node next;

        public Node() {}
        public Node(int data_) {data=data_; }
        public Node(int data_, Node next_) {data=data_; next=next_;}
    }

    private Node front;
    
    public Stack() {}
    
    @Override public void push(int data_){
        Node p=new Node(data_);
        if (front==null) front=p;
        else { p.next=front; front=p; }
    }
    @Override public int pop(){
        if (front==null) return -1;
        int res=front.data;
        front=front.next;
        return res;
    }
    @Override public void print() {
        Node p=this.front;
        while (p!=null) {
            System.out.print(p.data+" ");
            p=p.next;
        }
        System.out.println();
    }    
    
}

class List implements IStack, IPrintable {
    static class Node2 {
        public int data;
        Node2(int data_){data=data_;}
    }

    private Node2[] a;
    private int n;
    
    List(){a=new Node2[100]; n=0;}
    List(int n){a=new Node2[n]; n=0;}
    
    @Override public void push(int data_){
        a[n]=new Node2(data_);
        n++;
    }
    
    @Override public int pop(){
        if (n<1) return -1;
        return a[n--].data;
    }
    @Override public void print(){
        for (int i=0; i<n; i++) System.out.print(a[i].data+" ");
        System.out.println();
    }
}

class Blabol implements IPrintable {
    @Override public void print() { System.out.println("Blablabla"); }
}

public class JavaApplication5 {
    static void fillStack(IStack stack)
    {
        stack.push(10);
        stack.push(20);
    }
    static void printTwice(IPrintable what)
    {
        what.print();
        what.print();
    }
    public static void main(String[] args) {
        Stack s1=new Stack();
        IStack s2=new List();
        Blabol b=new Blabol();
        fillStack(s1);
        fillStack(s2);
        printTwice(s1);
        //printTwice(s2); - s2 je IStack a nevie, že sa vie vypísať
        printTwice((List)s2);
        printTwice(b);
    }
}

Cvičenia 15

• Navrhnite triedu Polynomial, ktorá bude reprezentovať polynómy jednej premennej s celočíselnými koeficientami.
  • Implementujte vhodnú sadu konštruktorov, napr. konštruktor bez parametrov, ktorý vytvorí nulový polynóm, konštruktor s dvoma celočíselnými parametrami a a i, ktorý vytvorí polynóm Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle ax^i} a konštruktor, ktorý dostane pole a vytvorí polynóm, ktorého koeficienty budú prvky tohto poľa
  • Implementujte metódu na vypísanie koeficientov polynómu
  • Implementujte metódu getCoefficient(int i), ktorá vráti koeficient pri člene Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^i} .
  • Implementujte metódu add(Polynomial p), ktorá vráti nový polynóm, ktorý bude súčtom tohto polynómu a polynómu p.
  • Implementujte metódu evaluate(int value), ktorá vráti hodnotu polynómu, keď premenná bude mať hodnotu value.

• Na prednáške #Prednáška 27 bol popísaný binárny vyhľadávací strom pomocou tried Node a Tree.
  • Implementujte do triedy Tree metódu searchNode(int data_), ktorá vyhľadáva v strome vrchol s hodnotou data_. Skúste využiť metódy triedy Node.
  • Implementujte do triedy Tree metódu depth(), ktorá vráti hĺbku stromu. V prípade potreby urobte aj patričné úpravy v triede Node (premenné, metódy). Snažte sa čo najviac zachovať zapuzdrenie tried.

Prednáška 29

Výnimky

• Počas behu programu môže dôjsť k rôznym chybám a neobvyklým situáciám, napr.
  • neexistujúci súbor, zlý formát súboru
  • málo pamäte pri alokovaní polí, objektov
  • adresovanie mimo hraníc poľa, delenie nulou,...
• Doteraz sme v našich cvičných programoch ignorovali chyby
• Programy určené pre užívateľov a kritické programy, ktorých zlyhanie by mohlo spôsobiť škody, by sa s takýmito situáciami mali vedieť rozumne vyrovnať
• Ošetrovanie chýb bez požitia výnimiek
  • Do návratového kódu funkcie musíme okrem samotnej hodnoty zakoponovať aj ohlasovanie chýb
  • Po každom príkaze, ktorý mohol spôsobiť chybu, musíme existenciu chyby otestovať a vyrovnať sa s tým
  • Vedie to k neprehľadným programom

Malý príklad s načítaním poľa

Príklad: pseudokód funkcie, ktorá načíta zo súboru číslo n, naalokuje pole a načíta do poľa n čísel:

funkcia readArray {
otvor subor vstup.txt
if (nepodarilo sa nacitat) {
    return chybovy kod
}
nacitaj cislo n
if (nepodarilo sa nacitat n) {
    zatvor subor
    return chybovy kod
}
alokuj pole a velkosti n
if (nepodarilo sa alokovat pole) {
    zatvor subor
    return chybovy kod
}
for (int i=0; i<n; i++) {
     nacitaj cislo a uloz do a[i]
     if (nepodarilo sa nacitat) {
         zatvor subor
         odalokuj pole 
         return chybovy kod 
     }
}
zatvor subor
return naalokovane pole, beh bez chyby

• Premiešané príkazy, ktoré niečo robia a ktoré ošetrujú chyby
• Ľahko môžeme zabudnúť odalokovať pamäť alebo zavrieť súbor
• Volajúca funkcia musí analyzovať chybový kód, môže potrebovať rozlišovať napr. problémy so súborom a s pamäťou
• Chyba môže nastať aj pri zatváraní súboru

Jednoduché použite výnimiek v Jave

• Prepíšme náš predchádzajúci príklad s výnimkami

    static int[] readArray(String filename) {
        Scanner s = null;
        int[] a = null;
        try {
            s = new Scanner(new File(filename));
            int n = s.nextInt();
            a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = s.nextInt();
            }
            s.close();
            return a;
        } catch (Exception e) {
            if (s != null) {
                s.close();
            }
            e.printStackTrace();
            return null;
        }
    }

• Využívame konštrukty try a catch.
• Do try bloku dáme príkazy, z ktorých niektorý môže zlyhať.
• Ak niektorý zlyhá a vyhodí výnimku, okamžite sa ukončí vykonávanie bloku try a pokračuje sa blokom catch. V bloku catch túto výnimku spracujeme, v našom prípade len debugovacím výpisom.
• Ak sa podarilo čísla načítať do poľa, metóda vráti pole, inak vráti null

Ako všelijako môže zlyhať

Rôzne príklady, ako môže táto metóda zlyhať:

• Príkazu na inicializáciu Scannera pošleme meno neexistujúceho súboru:

java.io.FileNotFoundException: vstup.txt (No such file or directory)
        at java.io.FileInputStream.open(Native Method)
        at java.io.FileInputStream.<init>(FileInputStream.java:137)
        at java.util.Scanner.<init>(Scanner.java:653)
        at prog.Prog.readArray(Prog.java:17)
        at prog.Prog.main(Prog.java:10)

• V súbore sú nečíselné údaje:

java.util.InputMismatchException
        at java.util.Scanner.throwFor(Scanner.java:857)
        at java.util.Scanner.next(Scanner.java:1478)
        at java.util.Scanner.nextInt(Scanner.java:2108)
        at java.util.Scanner.nextInt(Scanner.java:2067)
        at prog.Prog.readArray(Prog.java:18)
        at prog.Prog.main(Prog.java:10)

• Ak nie je dosť pamäte na pole a (toto ani nie je Exception, ale Error, takže náš catch to nezachytil, pozri ďalej)

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at prog.Prog.readArray(Prog.java:19)
        at prog.Prog.main(Prog.java:10)

• Ak je číslo n v súbore záporné

java.lang.NegativeArraySizeException
        at prog.Prog.readArray(Prog.java:19)
        at prog.Prog.main(Prog.java:10)

• Súbor končí skôr ako sa načíta n čísel

java.util.NoSuchElementException
        at java.util.Scanner.throwFor(Scanner.java:855)
        at java.util.Scanner.next(Scanner.java:1478)
        at java.util.Scanner.nextInt(Scanner.java:2108)
        at java.util.Scanner.nextInt(Scanner.java:2067)
        at prog.Prog.readArray(Prog.java:21)
        at prog.Prog.main(Prog.java:10)

• A zrejme by sa dali vyrobiť aj ďalšie prípady (napr filename==null)
• V dokumententácii sa o každej metóde dočítame, aké výnimky produkuje za akých okolností

Rozpoznávanie typov výnimiek

• Možno by náš program mal rôzne reagovať na rôzne typy chýb, napr.:
  • Chýbajúci súbor: vypýtať si od užívateľa nové meno súboru
  • Zlý formát súboru: ukázať užívateľovi, kde nastala chyba, požiadať ho, aby ju opravil alebo zdala nové meno súboru
  • Nedostatok pamäte: program vypíše, že operáciu nie je možné uskutočniť vzhľadom na málo pamäte
• Toto vieme spraviť, lebo výnimky patria do rôznych tried dedených z triedy Exception (prípadne z vyššej triedy Throwable)
• K jednému príkazu try môžeme mať viacero príkazov catch pre rôzne triedy výnimiek, každý chytá tú triedu a jej podtriedy
  • Pri danej výnimke sa použije najvrchnejší catch, ktorý sa na ňu hodí
• Po blokoch try a catch môže nasledovať blok finally, ktorý sa vykoná vždy, bez ohľadu na to, či nastala výnimka a či sa nám ju podarilo odchytiť nejakým príkazom catch
  • V tomto bloku môžeme napr. pozatvárať otvorené súbory a pod.

Jednoduchý príklad, ktorý vypíše rôzne hlášky pre rôzne typy chýb:

    static int[] readArray(String filename) {
        Scanner s = null;
        int[] a = null;
        try {
            s = new Scanner(new File(filename));
            int n = s.nextInt();
            a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = s.nextInt();
            }
            return a;
        } catch (FileNotFoundException e) {
            System.err.println("Subor nebol najdeny");
            return null;
        } catch(java.util.NoSuchElementException e) {
            System.err.println("Zly format suboru");
            return null;
        } catch(OutOfMemoryError e) {
            System.err.println("Nedostatok pamate");
            return null;
        } catch(Throwable e) {
            System.err.println("Neocakavana chyba pocas behu programu");
            return null;
        } finally {
            if (s != null) {
                s.close();
            }
        }
    }

• catch pre java.util.NoSuchElementException chytí aj InputMismatchException, ktorá je jej podtriedou, takže zahŕňa prípady keď súbor nečakane končí, aj keď v ňom nie sú číslené dáta
  • do tejto kategórie by sme chceli zaradiť aj prípad, kedy je n záporné, ale ten skončí na všeobecnej Throwable
  • to vyriešime tým, že hodíme vlastnú výnimku

Hádzanie výnimiek, vlastné triedy výnimiek

• Výnimku vyhodíme príkazom throw, pričom musíme vytvoriť objekt nejakej vhodnej triedy, ktorá podtriedou Throwable
• V našom príklade pre záporné n môžeme vyhodiť objekt triedy java.util.NoSuchElementException, ktorý sa spracuje rovnako ako iné chyby s formátom súboru

            int n = s.nextInt();
            if(n<0) {
                throw new java.util.NoSuchElementException();
            }

• Nie je to však elegantné riešenie, lebo táto trieda reprezentuje iný typ udalosti
• Môžeme si vytvoriť aj vlastnú triedu, ktorá v premenných môže mať uložené podrobnejšie informácie o chybe, ktorá nastala.
  • Väčšinou to bude podtrieda triedy Exception

    static class WrongFormatException extends Exception {

        private String filename;

        public WrongFormatException(String filename_) {
            filename = filename_;
        }

        @Override
        public String getMessage() {
            return "Zly format suboru " + filename;
        }
    }

Propagácia a zreťazenie výnimiek

• Ak vznikne výnimka v príkaze, ktorý nie je vo vnútri try-catch bloku, alebo ak jej typ nie je zachytený žiadnym catch príkazom, hľadá sa ďalší try-catch blok, napr. vo volajúcej metóde
• Ak výnimku nikto nechytí, program skončí s chybovým výpisom zásobníka

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at prog.Prog.readArray(Prog.java:19)
        at prog.Prog.main(Prog.java:10)

• Pri spracovaní výnimky v bloku catch je možné hodiť novú výnimku (trebárs vhodnejšieho typu)
• Metóda musí deklarovať všetky výnimky, ktoré hádže, alebo ktoré v nej môžu vzniknúť a ich nechytá
  • Neplatí pre výnimky triedy RuntimeException a jej podtried a pre Throwable, ktoré nie sú výnimka

Nasledujúci program si pýta meno súboru, až kým nenájde súbor, ktorý vie načítať

• V metóde readArray spracuje chyby týkajúce sa formátu súboru a hodí novú výnimku typu WrongFormatException.
• V metóde main spracuje WrongFormatException a FileNotFoundException tak, že sa znovu pýta meno súboru.
• Iné nečakané udalosti, napr. málo pamäte, koniec vstupu od užívateľa a pod. spôsobia ukončenie programu s chybovou hláškou.

    public static void main(String[] args) {

        boolean fileRead = false;
        Scanner s = new Scanner(System.in);
        int[] a = null;
        while (!fileRead) {
            try {
                System.out.println("Zadaj meno suboru: ");
                String filename = s.next();
                a = readArray(filename);
                fileRead = true;
                System.out.println("Dlzka pola je " + a.length);
            } catch (WrongFormatException e) {
                System.out.println(e.getMessage());
            } catch (FileNotFoundException e) {
                System.out.println("Subor nebol najdeny.");
            } catch(Throwable e) {
                System.out.println("Neocakavana chyba.");
                System.exit(1);
            }
        }

    }

    static int[] readArray(String filename)
            throws WrongFormatException, FileNotFoundException {
        Scanner s = null;
        int[] a = null;
        try {
            s = new Scanner(new File(filename));
            int n = s.nextInt();
            if (n < 0) {
                throw new WrongFormatException(filename);
            }
            a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = s.nextInt();
            }
            return a;
        } catch (java.util.NoSuchElementException e) {
            throw new WrongFormatException(filename);
        } finally {
            if (s != null) {
                s.close();
            }
        }
    }

Zhrnutie

• Keď vznikne neočakávaná udalosť, môžeme ju signalizovať vyhodením výnimky pomocou príkazu throw.
• Výnimka je objekt triedy, ktorá je podtriedou Throwable
• Pri ošetrovaní sa nájde a vykoná najbližší vyhovujúci try..catch blok obkolesujúci príkaz throw, v tej istej alebo niektorej volajúcej metóde, ďalej sa pokračuje za týmto blokom
• Blok finally sa vykoná vždy, keď je aj keď nie je výnimka a aj ak sa výnimku nepodarilo chytiť. Slúži na zatváranie súborov a iné upratovacie práce
• Niektoré typy neodchytených výnimiek treba deklarovať v hlavičke funkcie

Ďalšie informácie

• Dokumentácia k triedam Throwable, Exception
• Kapitola z tutoriálu

Generické programovanie

• V minulom semestri sme videli rôzne abstraktné dátové typy a dátové štruktúry, napr. zásobník, rad, slovník, spájaný zoznam,...
• V každej sme museli zadefinovať, akého typu dáta bude obsahovať
• Ak teda potrebujeme zásobník intov aj zásobník reťazcov, museli sme všetky funkcie písať dvakrát, čo prináša problémy

Zásobník dát typu Object

• Dedenie nám prináša jedno riešenie tohto problému - zadefinovať typ dát ako Object a nakoľko všetky triedy sú podtriedami tejto triedy, môžeme ich v zásobníku skladovať

   class Node {
        private Object data;
        private Node next;
        public Node(Object data_, Node next_) {
            data = data_;
            next = next_;
        }
        public Object getData() {
            return data;
        }
        public Node getNext() {
            return next;
        }
    }

    class Stack {
        private Node front;
        public void push(Object data) {
            Node p = new Node(data, front);
            front = p;
        }
        public Object pop() {
            Object res = front.getData();
            front = front.getNext();
            return res;
        }
    }

Teraz môžeme do zásobníka dávať rôzne veci:

        Stack s = new Stack();
        s.push(null);
        s.push("Hello world!");  // String je potomok Object
        s.push(new int[4]);  // pole sa tiez vie tvarit ako objekt
        int x = 4;
        s.push(x);           // kompilator vytvori objekt typu Integer

Ale pozor, keď vyberáme zo zásobníka, majú typ Object, musíme ich teda pretypovať:

       int y = (Integer)s.pop();  // ok 
       int z = (Integer)s.pop();  // java.lang.ClassCastException

Pre pretypovaní teda môže dôjsť k chybe počas behu programu, radšej sme keď chybu objaví kompilátor.

Zásobník ako generická trieda

• Zadefinujeme parametrický typ class Stack <T>, kde T je parameter reprezentujúci typ objektov, ktoré do zásobníka budeme dávať.
• V definícii triedy namiesto konkrétneho typu (napr. Object), použijeme parameter T
• Keď vytvárame nový zásobník, špecifikujeme typ T: Stack<Integer> s = new Stack<Integer>();
  • Potom do neho môžeme vkladať objekty triedy Integer a jej podtried

    class Node <T> {
        private T data;
        private Node <T> next;
        public Node(T data_, Node<T> next_) {
            data = data_;
            next = next_;
        }
        public T getData() {
            return data;
        }
        public Node <T> getNext() {
            return next;
        }
    }

    class Stack <T> {
        private Node<T> front;
        public void push(T data) {
            Node<T> p = new Node<T>(data, front);
            front = p;
        }

        public T pop() {
            T res = front.getData();
            front = front.getNext();
            return res;
        }
    }

Použitie zásobníka:

        Stack<Integer> s = new Stack<Integer>();
        s.push(new Integer(4));
        s.push(5);        
        Integer y = s.pop();
        int z = s.pop();

V tom istom programe môžeme vytvoriť zásobníky veľa rôznych typov.

Generické metódy

Aj jednotlivé metódy môžu mať typový parameter, ktorý sa píše pred návratový typ.

Statická metóda, ktorá dostane zásobník s prvkami typu T a vyprázdni ho.

    static <T> void emptyStack(Stack<T> s) {
        while(!s.isEmpty()) {
            s.pop();
        }
    }

        Stack<String> s = new Stack<String>();
        s.push("abc");
        Prog.<String>emptyStack(s);  // alebo len emptyStack(s);

Statická metóda, ktorá dostane pole s prvkami typu E a naplní ho referenciami na prvok e.

    static <E> void fillArray(E[] a, E e) {
        for(int i=0; i<a.length; i++) {
            a[i] = e;
        }
    }

        Integer[] a = new Integer[3];
        fillArray(a, 4);

        int[] b = new int[3];
        //fillArray(b, 4);  // E musí byť objekt, nie primitívny typ

Generické triedenie, interface Comparable

Ukazovali sme si aj algoritmy na triedenie, aj tie pracovali s poľom konkrétneho typu.

• Triediaciu funkciu môžeme spraviť generickú, potrebujeme však prvky porovnávať
• Operátory <, <= atď pracujú len s primitívnymi typmi
• Použijeme teda špeciálnu metódu compareTo špecifikovanú v interface Comparable
  • x.compareTo(y) vráti zápornú hodnotu, ak x<y, nulu ak x=y a kladnú hodnotu ak x>y
  • potrebujeme, aby prvky poľa boli z triedy, ktorá implementuje tento interface, čo zapíšeme ako <E extends Comparable>

Jednoduché generické triedenie vkladaním:

    static <E extends Comparable> void sort(E[] a) {
        for (int i = 1; i < a.length; i++) {
            E prvok = a[i];
            int kam = i;
            while (kam > 0 && prvok.compareTo(a[kam - 1]) < 0) {
                a[kam] = a[kam - 1];
                kam--;
            }
            a[kam] = prvok;
        }
    }

    public static void main(String[] args) {
        Integer[] a = {3, 1, 2};
        sort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

Java Collections

• Java poskytuje štandardné triedy na mnohé často používané dátové štruktúry, používa generické programovanie
• Tutoriál
• Je dobré tieto triedy poznať a podľa potreby využívať
• Pochopením ich štruktúry si tiež môžeme precvičiť objektovo-orientované programovanie
• Na úvod si ukážeme zopár tried, viac nabudúce

ArrayList

ArrayList sa podobá na vector z C++ (existuje aj trieda Vector)

• ide o štruktúru reprezentujúcu pole, ktoré rastie podľa potreby
• na koniec poľa pridávame metódou add(prvok), konkrétny prvok adresujeme metódou get(index), veľkosť poľa je size()

import java.util.ArrayList;

...
        ArrayList<Integer> a = new ArrayList<Integer>();
        a.add(2);
        a.add(7);
        for (int i = 0; i < a.size(); i++) {
            System.out.println(a.get(i));  // vypiseme vsetky prvky pola
            a.set(i, -1);                  // a potom ich prepiseme na -1
        }

LinkedList

LinkedList je obojsmerný spájaný zoznam, ktorý môžeme použiť napr. ako zásobník alebo rad

• vie teda efektívne pridávať a uberať prvky z oboch koncov a tiež prejsť cez všetky prvky zoznamu pomocou iterátora
• hľadanie prvku na pozícii i niekde v strede zoznamu je pomalé

        LinkedList<Integer> a = new LinkedList<Integer>();
        a.addFirst(2);   // to iste ako push
        a.addLast(7);    // to iste ako add
        for (ListIterator<Integer> it = a.listIterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
        a.removeFirst(); // to iste ako pop
        a.removeLast();

Cvičenia 16

• Nižšie je uvedený kód abstraktnej triedy Progression, ktorá predstavuje celočíslenú postupnosť a dokáže jeden za druhým generovať jej členov, pričom si v premennej index pamätá index posledne vygenerovaného členu. Jediná public metóda tejto triedy je print, ktorá vypíše zadaných počet prvkov na obrazovku.
  • Všimnite si, že premenná index je pre podtriedy tejto triedy "read-only", lebo jej hodnotu môžu zistiť pomocou metódy getIndex, ale nemôžu ju meniť.

• Napíšte triedu ArithmeticProgression, ktorá bude podtriedou Progression a bude reprezentovať aritmetickú postupnosť, ktorá je v konštruktore zadaná nultým prvkom a rozdielom medzi dvoma nasledujúcmi prvkami.
  • Ak do main dáme Progression ap = new ArithmeticProgression(1, 3); ap.print(10);, program by mal vypísať 1 4 7 10 13 16 19 22 25 28
  • Stačí implementovať konštruktor a currentValue()

• Napíšte triedu FibonacciProgression, ktorá bude reprezentovať Fibonacciho postupnosť, ktorá má pre účely tohto cvičenia nultý prvok 1, prvý prvok 1 a každý ďalší prvok je súčtom predchádzajúcich dvoch. Prvý prvok sa dá tiež reprezentovať ako súčet nultého a fiktívneho mínus prvého s hodnotou nula.
  • Ak do main dáme Progression fp = new FibonacciProgression(); fp.print(10);, program by mal vypísať 1 1 2 3 5 8 13 21 34 55.
  • Implementujte konštruktor, currentValue, firstvalue, nextValue

• Nižšie nájdete aj implementáciu triedy ProgressionSum, ktorá reprezentuje postupnosť, ktorá vznikla ako súčet dvoch postupností, ktoré dostane na vstupe.
  • Ak do main dáme Progression ps = new ProgressionSum(fp, fp); ps.print(10);, chceli by sme dostať dvojnásobok Fibonacciho postupnosti, teda 2 2 4 6 10 16 26 42 68 110. Nie je to však tak. Prečo? Ako prebieha volanie nextValue() pre premennú triedy ProgressionSum? Aké všetky metódy sa volajú a v akom poradí?
  • Zmeňte riadok s vytvorením postupnosti ps tak, aby program mal požadované správanie

package prog;

/** Trieda reprezentujuca celociselnu postupnost. */
public abstract class Progression {

    /** Aktualny index prvku postupnosti.  */
    private int index;

    /** Konstruktor */
    protected Progression() {
        index = 0;
    }

    /** Vrati aktualny index prvku postupnosti */
    protected int getIndex() {
        return index;
    }

    /** Vrati hodnotu postupnosti pre aktualny index */
    protected abstract int currentValue();

    /** Restartuje index na 0 a vrati nulty prvok. */
    protected int firstValue() {
        index = 0;
        return currentValue();
    }

    /** Zvysi index o 1 a vrati aktualny prvok. */
    protected int nextValue() {
        index++;
        return currentValue();
    }

    /** Vypise prvych n prvkov postupnosti. */
    public void print(int n) {
        System.out.print(firstValue());
        for (int i = 1; i < n; i++) {
            System.out.print(" " + nextValue());
        }
        System.out.println(); 
    }

    public static void main(String[] args) {
    }
}

class ProgressionSum extends Progression {

    Progression p1, p2;

    ProgressionSum(Progression p1_, Progression p2_) {
        p1 = p1_;
        p2 = p2_;
    }

    @Override
    protected int currentValue() {
        return p1.currentValue() + p2.currentValue();
    }

    @Override
    protected int nextValue() {
        p1.nextValue();
        p2.nextValue();
        return super.nextValue();
    }

    @Override
    protected int firstValue() {
        p1.firstValue();
        p2.firstValue();
        return super.firstValue();
    }
}

Prednáška 30

Java Collections

Opakovanie: dve malé ukážky

ArrayList: pole s flexibilnou dĺžkou

        ArrayList<Integer> a = new ArrayList<Integer>();
        a.add(2);
        a.add(7);
        for (int i = 0; i < a.size(); i++) {
            System.out.println(a.get(i));  // vypiseme vsetky prvky pola
            a.set(i, -1);                  // a potom ich prepiseme na -1
        }

LinkedList: spájaný zoznam, zásobník, rad

        LinkedList<Integer> a = new LinkedList<Integer>();
        a.addFirst(2);   // to iste ako push
        a.addLast(7);    // to iste ako add
        for (ListIterator<Integer> it = a.listIterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
        a.removeFirst(); // to iste ako pop
        a.removeLast();

Prehľad Collections

• Dátové štruktúry a algoritmy na základnú prácu so skupinami dát
• Generické typy - môžeme vytvárať dátové štruktúry pre dáta rôznych typov
• Definované pomocou interface-ov, jeden interface môže mať viacero implementácií

Vybrané triedy:

Interface	Význam	Implementácie
Collection	skupina objektov
- Set	množina, skupina bez opakujúcich sa objektov	HashSet
-- SortedSet	množina s definovaným usporiadaním prvkov	TreeSet
- List	postupnosť objektov s určitým poradím	ArrayList, LinkedList
Map	slovník, asociatívne pole, mapuje kľúče na hodnoty	HashMap
- sortedMap	slovník s definovaným usporiadaním kľúčov	TreeMap

V metódach je dobré argumenty definovať najvšeobecnejším vhodným interfacom alebo triedou.

• Napr. chceme spočítať súčet viacerých Integer-ov:

// tato metoda sa da pouzit iba na ArrayList
public static Integer sum(ArrayList<Integer> a) { ... }
// tato metoda sa da pouzit na hocijaku Collection (LinkedList, HashSet...)
public static Integer sum(Collection<Integer> a) { ... }

Základné operácie pre Collection:

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object element);
    boolean add(E element);  // optional
    boolean remove(Object element); // optional
    Iterator<E> iterator();
    void clear(); // optional

    Object[] toArray();
    <T> T[] toArray(T[] a);

   // a dalsie...
}

Metódy add a remove vracajú true, ak sa Collection zmenila a false ak sa nezmenila.

Prechádzanie cez prvky Collection

Použitie cyklu for-each:

    public static Integer sum(Collection<Integer> a) {
        int sum = 0;
        for(Integer x : a) {
            sum += x;
        }
        return sum;
    }

Použitie iterátora:

    public static Integer sum(Collection<Integer> a) {
        int sum = 0;
        for (Iterator<Integer> it = a.iterator(); it.hasNext();) {
            sum += it.next();
        }
        return sum;
    }

• a.iterator() vráti objekt it implementujúci interface Iterator
• it.next() vráti ďalší prvok zo skupiny a, alebo hodí NoSuchElementException ak už ďalší nie je
• it.hasNext() vráti, či ešte je ďalší prvok
• it.remove() zmaže prvok, ktorý sme naposledy dostali pomocou next
• Poradie, v akom prvky navštívime, nie je definované

Pomocou iterátora môžeme napr. vymazať všetky nuly (môže byť pomalé):

    static void removeZeroes(Collection<Integer> a) {
        for (Iterator<Integer> it = a.iterator(); it.hasNext();) {
            if (it.next().equals(0)) {  // vynimka ak it.next() je null!
                it.remove();
            }
        }
    }

Interface List definuje ListIterator

• umožňuje aj hýbať sa dozadu it.previous()
• pridávať a meniť prvky it.add(x), it.set(x)
• zisťovať polohu it.nextIndex(), it.previousIndex()

Iterátor pre SortedSet vracia prvky v utriedenom poradí od najmenšieho po najväčší.

Použitie Map

public interface Map<K,V> {

    V put(K key, V value);  // klucu key prirad hodnotu value, vrati predch. hodnotu pre key
    V get(Object key);      // hodnota pre kluc key alebo null
    V remove(Object key);   // zmaz kluc key a jeho hodnotu
    boolean containsKey(Object key);  // obsahuje kluc key?
    boolean containsValue(Object value);
    int size();
    boolean isEmpty();

    void putAll(Map<? extends K, ? extends V> m);
    void clear();

    // Vrátia Set alebo Collection, cez ktorý môžeme iterovať
    public Set<K> keySet();  
    public Collection<V> values();
    public Set<Map.Entry<K,V>> entrySet();

    // Interface pre dvojice vo výsledku entrySet
    public interface Entry {
        K getKey();
        V getValue();
        V setValue(V value);
    }
}

Príklad použitia Map:

• vstup z konzoly rozložíme Scannerom na slová (kým užívateľ nezadá END) a počítame počet výskytov každého slova

   public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        Scanner s = new Scanner(System.in);  // inicializujeme Scanner
        while (s.hasNext()) {        // kym neskonci vstup
            String word = s.next();  // nacitame slovo
            if (word.equals("END")) { // skoncili sme ak najdeme END
                break;
            }
            Integer freq = map.get(word);
            if(freq==null) {
                map.put(word, 1);
            } else {
                map.put(word, freq+1);
            }            
        }

        System.out.println("Pocet roznych slov: " + map.size());
        System.out.println(map);

Tu je príklad výstupu:

one two three one two two END
Pocet roznych slov:3
{two=3, one=2, three=1}

HashMap vypisuje prvky v ľubovoľnom poradí. Ak typ zmeníme na TreeMap, dostaneme utriedené podľa kľúča:

{one=2, three=1, two=3}

Ak chceme vypísať zoznam slov a ich frekvencií v inom formáte, použijeme iterátor (alebo for)

        for(Iterator<Map.Entry<String,Integer>> it=map.entrySet().iterator(); it.hasNext();) {
            Map.Entry<String,Integer> e = it.next();
            System.out.println("Slovo " + e.getKey()
                    + " sa vyskytuje " + e.getValue() + " krat");
        }

Slovo two sa vyskytuje 3 krat
Slovo one sa vyskytuje 2 krat
Slovo three sa vyskytuje 1 krat

Porovnávanie objektov na rovnosť: equals

• Metódy z Collection contains(Object element), remove(Object element) a ďalšie potrebujú porovnávať objekty na rovnosť.
• Operátor == porovnáva referencie, t.j. či sú dva objekty na tej istej adrese v pamäti
• Collection používa namiesto toho metódu equals(Object obj) definovaná v triede Object
• Metóda equals() v triede Object tiež porovnáva len referencie, ostatné triedy ju môžu preťažiť
• Napr. v triedach ako String, Integer,... definovaná na porovnávanie reťazcov, čísel,...
• Rôzne triedy implementujúce Collection tiež väčšinou vedia porovnávať na rovnosť spúšťaním equals na jednotlivé prvky
• Metódy nevieme spúšťať na null, napr. contains(Object o) vracia true práve vtedy keď nejaký prvok e Collection spĺňa (o==null ? e==null : o.equals(e))
• Preťažená metóda equals by sa mala správať "rozumne", t.j. byť symetrická, tranzitívna a pod.

Porovnávanie objektov na nerovnosť: Comparable

• SortedMap a SortedSet potrebujú vedieť porovnávať prvky podľa veľkosti
• Používajú metódu compareTo definovanú v interface Comparable (videli sme na minulej prednáške)
• Ak naša trieda neimplementuje tento interface alebo chceme použiť iné usporiadanie, môžeme použiť vlastný komparátor, objekt implementujúci interface Comparator

Hashovacie funkcie: hashCode

• HashSet a HashMap potrebujú vedieť prekódovať ľubovoľný objekt do pozície v poli
• Používajú metódu int hashCode() definovanú v triede Object
• Object jednoducho použije adresu v pamäti ako hashCode
• Štandardné triedy preťažujú hashCode
• Ak preťažíte equals, treba preťažiť aj hashCode, lebo ak sa dva prvky rovnajú v equals, majú mať rovnaký hashCode

    static class Name {
        String givenName;
        String lastName;
        @Override
        public int hashCode () {
            return givenName.hashCode() + 31*lastName.hashCode();
        }
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            Name other = (Name) obj;
            return this.givenName.equals(other.givenName) && this.lastName.equals(other.lastName);
        }
   }

Algoritmy

• Triedy Collections a Arrays obsahujú statické metódy na prácu s Collections a poliami
• Napr. sort, shuffle (náhodne preusporadaj), reverse, fill, copy, swap, binarySearch, min, max,...

Zhrnutie

• Collections sú obrovská knižnica a veľmi užitočná
• Neváhajte ich používať v programoch, nájdite si v dokumentácii metódy, ktoré sa Vám hodia
• Pri spracovaní väčších dát pozor na to, že niektoré metódy sú pomalé
• Mali by ste ovládať (s pomocou ťaháka) aspoň základy práce s ArrayList, LinkedList, HashMap a s iterátormi
• Pre prácu s Collections môže byť potrebné preťažiť niektoré metódy z Object (equals, hashCode)
  • Ďalšie metódy z Object, ktoré sa často hodí preťažiť sú clone a toString

Testovanie programov

• Cieľom je nájsť chyby v programe, teda preukázať, že program nefunguje podľa špecifikácie (aby bolo možné potom chyby lokalizovať a opraviť)
• Test pozostáva zo vstupu, správneho výstupu a popisu jeho významu
• Program sa spustí na vstupe a jeho výsledok sa porovná so správnou odpoveďou

• Tradičný prístup: najprv sa napíše kód, potom sa vytvárajú testy
• Test-driven development: najprv sa napíšu testy, potom sa programuje kód, ktorý ich dokáže splniť

Black-box testing

• Vytvorenie sady testov len na základe špecifikácie
• Snažíme sa zachytiť okrajové aj typické prípady
• Napr.:

    /** Z pola a vyhodi prvy vyskyt objektu rovneho x
     * pricom rovnost sa testuje metodou equals.
     * Vsetky dalsie prvky posunie o jedno dolava a na koniec
     * pola da null.
     * Vrati true, ak bolo pole modifikovane, inak false.
     * Ak a je null alebo x je null, vyhodi java.lang.NullPointerException
     */
    public static boolean remove(Object[] a, Object x) {

Príklady testov:

• prázdne pole a
• pole obsahujúce iba x
• pole obsahujúce x na začiatku
• pole obsahujúce x na konci
• pole obsahujúce x v strede
• pole obsahujúce viacero kópií x
• pole obsahujúce null prvky
• pole obsahujúce objekty rôznych typov

White-box testing

Testy vytvárame na základe kódu, snažíme sa preveriť všetky vetvy výpočtu

• V cykle vyskúšame 0 iterácií, 1 iteráciu, maximálny počet iterácií
• V podmienke vyskúšame vetvu true aj false

Tento kód nespĺňa úplne špecifikáciu:

    /** Z pola a vyhodi prvy vyskyt objektu rovneho x
     * pricom rovnost sa testuje metodou equals.
     * Vsetky dalsie prvky posunie o jedno dolava a na koniec
     * pola da null.
     * Vrati true, ak bolo pole modifikovane, inak false.
     * Ak a je null alebo x je null, hodi java.lang.NullPointerException
     */
    public static boolean remove(Object[] a, Object x) {
        int i;
        for (i = 0; i < a.length; i++) {
            if (a[i].equals(x)) {
                break;
            }
        }
        if (i == a.length) {
            return false;
        }
        while (i < a.length - 1) {
            a[i] = a[i + 1];
            i++;
        }
        a[i] = null;
        return true;
    }

JUnit

• Systém JUnit umožňuje vytvárať špeciálne triedy obsahujúce testy iných tried
• Sadu testov môžeme ľahko automaticky spustiť a vyhodnotiť, vidíme všetky výsledky
• Môžeme program testovať po každej zmene
• Dobrá podpora v Netbeans
• Krátky návod: [4]

Príklad niekoľkých testov pre funkciu remove vyššie:

package prog;

import org.junit.Test;
import static org.junit.Assert.*;

public class ProgTest {

    @Test
    public void testEmpty() { 
        // hladame x v poli dlzky nula
        Object[] working = new Object[0]; // vstupne pole
        Object[] correct = new Object[0]; // spravna odpoved
        Object x = new Object();
        boolean result = Prog.remove(working, x); // spustime testovanu metodu
        assertEquals(result, false);              // testujeme navratovu hodnotu
        assertTrue(java.util.Arrays.equals(working,correct)); // testujeme pole
    }

    @Test
    public void testXOnly() {
        // hladame x v poli obsahujucom iba x
        Object[] working = {7};
        Object[] correct = {null};
        Object x = 7;
        boolean result = Prog.remove(working, x);
        assertEquals(result, true);
        assertTrue(java.util.Arrays.equals(working,correct));
    }

    @Test(expected = java.lang.NullPointerException.class)
    public void testANull() {
        // Testujeme, ci hodi vynimku ked je pole null
        Object[] working = null;
        Object x = 7;
        boolean result = Prog.remove(working, x);        
    }
}

Tento príklad je možné rôzne vylepšovať

• Opakujúce sa časti kódu môžeme dať do pomocných metód
• Môžeme pridať výpisy výsledkov, aby sme v prípade chyby videli, čo sa stalo
• Môžeme pridať premenné triede ProgTest, konštruktor, ako aj špeciálne metódy, ktoré sa vykonajú pred každým testom, prípadne po každom teste.

Cvičenia 17

• Naprogramujte generickú triedu Matrix, ktorá reprezentuje obdĺžnikovú maticu prvkov nejakého neznámeho typu E.
  • Prvky matice si v tejto triede uložte do premennej typu ArrayList<ArrayList<E>>, potrebujete si ešte udržiavať aj aktuálny počet riadkov a stĺcov.
  • Napíšte konštruktor, ktorý vytvorí maticu zadaných rozmerov a vyplní ju zadaným prvkom typu E.
  • Napíšte metódy, ktoré do matice pridajú nový stĺpec a nový riadok, vyplnený zadaným prvkom typu E.
  • Napíšte metódu get, ktorá vráti prvok matice nachádzajúci sa na zadanom mieste
  • Napíšte metódu set, ktorá na zadané miesto v matici zapíše zadaný prvok typu E

• Čo sa stane, ak metódu get zavoláte so súradnicami mimo rozsah matice?

• Prepíšte metódy get a set tak, aby pri zlých súradniciach hádzali výnimku vašej vlastnej triedy MatrixIndexOutOfBoundsException.
  • Výnimka tejto triedy by v metóde getMessage mala vrátiť reťazec obsahujúci obidve súradnice, ako aj obidva rozmery matice.
  • Skúste dva spôsoby implementácie:
    • v prvom odchytávajte vzniknuté výnimky a nahraďte ich svojou výnimkou
    • v druhom otestujte vhodnosť indexov hneď na začiatku metódy a v prípade potreby vyhoďte vlastnú výnimku

• Napíšte generickú triedu InfiniteMatrix, ktorá je podtriedou triedy Matrix a líši sa od nej v tom, že ak metóde get dáme súradnice mimo rozsah matice, vráti hodnotu null (a nevyhadzuje výnimku). Je to ako keby sme mali maticu nekonečnej veľkosti vyplnenú null-mi a v malom obdĺžniku s určitým počtom riadkov a stĺpcov máme nejaké uložené hodnoty, ktoré sa môžu líšiť od null.

• Vytvorte triedu IntScanner, ktorá v konštruktore dostane meno súboru a okrem konštruktoru obsahuje public metódy hasNextInt, nextInt a close, ktoré robia zhruba to isté ako v triede Scanner. Avšak ak je v súbore nejaký reťazec, ktorý nie je možné interpretovať ako číslo, metóda nextInt vyhodí výnimku vašej novej triedy, ktorá v metóde getMessage vráti reťazec obsahujúci číslo riadku, na ktorom chyba nastala aj reťazec, ktorý nebolo možné ako číslo interpretovať. Trieda Scanner nám neumožňuje zistiť číslo riadku, preto budeme mať v tejto triede tri premenné:
  • aktuálne číslo riadku
  • premennú typu BufferedReader, v ktorej na začiatku otvoríme zadaný súbor a vždy keď treba, načítame z neho riadok, zvýšime počítadlo a vytvoríme novú inštanciu triedy Scanner, ktorá bude čítať čísla z toho riadku
  • premennú triedy Scanner

DÚ14

max. 20 bodov, termín odovzdania streda 28.3. o 22:00

Cieľom tejto domácej úlohy je vyskúšať si prácu s programom, ktorý má väčší počet rôznych tried a využíva dedenie a polymorfizmus. Dostanete program, ktorý simuluje pohyb robotov v jednoduchom svete a vašou úlohou bude tento svet rozšíriť o ďalšie typy robotov a políčok. Táto simulácia bola inšpirovaná počítačovou hrou Lemmings.

Doporučujeme Vám nasledujúci postup:

• Prečítajte si celé zadanie
• Stiahnite si program a skúste si ho spustiť pre rôzne vstupy, aby ste videli, ako sa správa. Aby sa Vám lepšie robilo, zväčšite si v Netbeans okienko s výstupom z konzoly, alebo si výstup presmerujte do súboru a ten si potom otvorte v editore.
• Pozrite sa, ako je správanie robotov implementované. Pomôžu Vám zdrojové súbory, ale aj JavaDoc dokumentácia.
• Znovu si prečítajte zadanie a pracujte na jednotlivých rozšíreniach. Pokúste sa dokončiť jedno rozšírenie skôr, ako začnete ďalšie.
• Pre každé rozšírenie naprogramujte potrebné triedy a metódy a rozšírenie otestujte na rôznych vstupoch. Nezabudnite ho tiež okomentovať a dbať na dobrý štýl.

Nenechávajte si úlohu na poslednú chvíľu. Ak máte k zadaniu otázky alebo nájdete chybu v programe, kontaktuje čím skôr B.Brejovú.

Súbory

• Hotová časť programu
• Tri príklady vstupu a výstupu
• JavaDoc k hotovej časti programu

Základná verzia simulácie

Svet pozostáva z matice štvorčekov s n riadkami a m stĺpcami. Každý štvorček je buď prázdny, alebo obsahuje stenu. Jeden prázdny štvorček slúži ako vchod, kde sa objavujú noví roboti. Niektoré prázdne štvorčeky môžu byť označené ako východ, kadiaľ roboti miznú von z nášho sveta. Pre jednoduchosť sú na celom okraji sveta steny, aby nám roboty nevypadávali mimo hracej plochy. V každom kroku hry sa zvolí jeden robot a povolí sa mu spraviť jeden ťah. Počas ťahu sa robot môže posunúť na iné políčko, prípadne meniť prostredie prostriedkami, ktoré má k dispozícii. Dôsledkom toho môže on alebo aj ďalší roboti spadnúť nižšie, umrieť, alebo dosiahnuť východ. Keď sa skončí ťah jedného robota, prichádza na radu ďalší robot. Robot základného typu, ktorý už je implementovaný, sa správa nasledovne:

• Pamätá si svoje natočenie (doľava alebo doprava) a pokúša sa najskôr ísť o jedno políčko týmto smerom. Na začiatku hry je otočený doprava.
• Ak je políčko pred ním obsadené (stenou alebo iným robotom), otočí sa do opačného smeru a v ďalšom ťahu sa teda bude pokúšať ísť opačným smerom (v aktuálnom ťahu už však nič iné nerobí).
• Ak už robot spravil určitý počet ťahov T, zvyšok hry bude stáť na mieste (pod vplyvom externých podmienok môže napr. umrieť alebo začať padať, v svojom ťahu však nerobí ďalšie kroky doľava alebo doprava)

Ďalšie udalosti, ktoré treba zobrať do úvahy:

• Ak sa výsledkom ťahu robot dostal na políčko, pod ktorým je prázdne políčko, začne padať a padá, až kým pod ním nie je neprázdne políčko. Ak padne naraz o viac ako určitý počet políčok, umrie. Rovnako padajú aj roboti, ktorí síce nie sú na ťahu, ale ktorým zmizla pevná zem pod nohami.
• Ak robot dopadne alebo stúpi na iného robota, spodný robot umiera.
• Ak robot dosiahne políčko východ, hoci aj počas pádu, mizne z hry
• Ak robot umrie, tiež mizne z hry. Ak na neho predtým dopadol alebo stúpil iný robot, tento padne na miesto mŕtveho robota. Ide však už o ďalší pád, ktorého výška sa nesčítava s prípadným pádom, ktorým pristál na umretom robotovi.

Každý robot má tiež dané, v ktorom ťahu vkročí do sveta, pričom každý robot musí vchádzať v inom ťahu. Jeden ťah simulácie pozostáva z toho, že najskôr každý žijúci robot vykoná svoj ťah a nakoniec sa pridá robot, ktorý má v tomto ťahu príchod, ak taký je. Takýto robot sa objaví vo vchodovom políčku a prípadne padne nižšie, nevykonáva sa však jeho ťah. Ak je vchodové políčko obsadené, robot sa vôbec vo svete neobjaví a hneď umiera. Žijúci roboti majú pevné poradie, pričom noví roboti sa pridávajú na koniec tohto poradia. V tomto pevnom poradí sa vykonávajú ich ťahy.

Celá simulácia končí, ak nastane jedna z podmienok:

• Žiaden robot nie je nažive na ploche a nepríde už žiaden ďalší robot
• Vykonal sa určitý špecifikovaný počet ťahov

Nakonci sa vyhodnotí, koľkým robotom sa podarilo dosiahnuť úspešne východ a koľkí umreli. Celá simulácia sa dá chápať aj ako hlavolam, kde je úlohou pre daný svet navrhnúť príchody robotov tak, aby aspoň jeden, prípadne čo najviac z nich dosiahlo východ.

Implementácia základnej verzie

Aj keď správanie robotov v základnej verzii by sa dalo implementovať aj malým počtom funkcií operujúcich na jednoduchých dátových štruktúrach, v tejto domácej úlohe sme program rozdelili na väčší počet tried a jednoduchých metód. Takto navrhnutý program sa dá lepšie rozširovať o nové typy robotov a políčok a hlavne si na ňom lepšie precvičíte prácu s objektovo-orientovaným programovaním. Trieda Robots obsahuje metódu main a ďalšie statické metódy slúžiace na načítanie vstupných údajov. Stav sveta je uložený v triede World, ktorá obsahuje maticu štvorčekov a zoznam robotov a vie jednak zavolať ťahy jednotlivých robotov a jednak vypísať stav hry a rôzne štatistiky. Trieda Robot reprezentuje robota popísaného vyššie, pričom sa stará o jeho vnútorný stav a určuje, aké akcie chce počas ťahu vykonať. Robot však nevidí prostredie, preto tieto akcie, ako aj prípadné pády a podobne sú vyhodnocované samotným prostredím. Trieda Square a jej podtriedy predstavujú jednotlivé políčka sveta. Vyhodnocujú možnosť vykonania akcií robota a vykonávajú tieto akcie ako aj ich dôsledky. Základná trieda Square reprezentuje políčko typu stena, čo je najjednoduchší typ políčka, ktorý nič nevie robiť a nikdy sa nemení. Okrem toho máme triedy EmptySquare pre prázdne políčko (ktoré prípadne môže obsahovať robota), EntrySquare pre políčko so vstupom a ExitSquare pre políčko s výstupom. Okrem toho naša implementácia obsahuje už len jednoduchú triedu RobotException na ohlasovanie výnimiek, ktoré nastali kvôli chybám v implementácii. Správanie programu je ovplyvnené aj dvoma konštantami: Robots.MAXMOVES=1000 udáva maximálny počet ťahov hry a Robot.MAXHEIGHT=3 udáva maximálnu výšku, z ktorej môže robot padnúť a nezabiť sa. V odovzdanom program prosím nechajte týmto konštantám pôvodné hodnoty, váš program by mal však fungovať aj pre iné hodnoty týchto konštánt.

Samotný program načítava dva vstupné súbory. V súbore world.txt je hracia plocha, pričom každé políčko je dané jedným znakom. W znamená stenu (wall), bodka je voľné políčko, # je vstupné políčko (vyzerá ako dvere) a * je východ. Tu je príklad súboru:

WWWWWWWWW
W.#.....W
WWWWWWW.W
W.*.....W
WWWWWWWWW

V súbore robots.txt je zoznam robotov, každý na jednom riadku. Prvé číslo v riadku je ťah, v ktorom sa má robot objaviť vo vchode. Každý robot musí prísť v inom čase. Potom nasleduje písmeno (alebo slovo) označujúce typ robota, v našom prípade S, ako stopping robot. Potom nasleduje parameter T (po koľkých ťahoch robot zmení svoje správanie z chodenia na státie), v našom príklade je to 100. Posledné slovo na riadku je meno robota, ktoré je možné aj vynechať - program potom bude automaticky robotov číslovať v poradí ako sú na vstupe. Príklad súboru:

1 S 100 X01
2 S 100 X02

Program priebeh simulácie vypisuje na konzolu, pričom vždy vypíše, ktorý robot je na ťahu a upozorňuje na významné udalosti, ako pády, úmrtia a dosiahnutie východu. Po skončení ťahu jedného robota vypíše v textovom formáte stav celej plochy, pričom ak je na voľnom políčku robot, vypíše sa namiesto bodky tento robot v tvare < alebo > vyjadrujúcom jeho natočenie, prípadne ako !, ak už prekročil T ťahov a zastal.

Na vstupe vyššie najprv obaja roboti postupujú doprava do situácie

WWWWWWWWW
W.#..>>.W
WWWWWWW.W
W.*.....W
WWWWWWWWW

Potom prvý robot padne a v ďalšom ťahu sa otáča. Medzitým na neho padne robot X02 a zabije ho. Robot X02 však napokon úspešne dorazí do cieľa.

Ak by sme čas príchodu X02 zmenili z 2 na 3, obaja by úspešne dorazili do cieľa. Ak by sme potom ešte robotovi X01 znížili parameter T zo 100 na 10, zastaví tesne pred dosiahnutím cieľa a zablokuje tak cieľ aj pre X02, ktorý bude chodiť tam a späť v spodnej chodbe, až kým nedosiahne svoj počet ťahov T do zastavenia.

Úloha: tri rozšírenia

Vašou úlohou je do sveta doprogramovať tri rozšírenia popísané nižšie, ktoré pridávajú nové typy robotov a políčok. Vaša implementácia bude pozostávať najmä z pridania nových tried dediacich z existujúcich tried, niekedy však bude potrebné pridať do existujúcich tried nové metódy. Pokiaľ možno nemeňte existujúce metódy. Výnimkou sú statické metódy v triede Robots, ktoré je potrebné modifikovať na vytvorenie nových typov políčok a robotov.

Čiastočné body dostanete aj v prípade, ak sa Vám podarí implemetovať iba niektoré rozšírenia. Všetky rozšírenia, ktoré implementujete, by však mali byť súčasťou jedného funkčného programu, takže ak nejaké rozšírenie nedokončíte, upravte program tak, aby aspoň ostatné rozšírenia správne fungovali.

Štýl a komentáre

• Okrem správnosti ide v tejto úlohe aj o návrh tried, ich metód a premenných a vhodné použitie dedičnosti a polymorfizmu.
• Dbajte o pekný programátorský štýl.
• Všetky triedy a ich metódy popíšte vo formáte JavaDoc. Ak meníte existujúce triedy, pridajte do horného JavaDoc komentáru k celej triede, aké zmeny ste v nej robili.

Odovzdávanie

• Odovzdávajte jeden .zip súbor obsahujúci adresár robots a v ňom všetky zdrojové súbory (*.java) vášho balíčka robots (vrátane tých, ktoré ste vôbec nemenili).
• Dodržiavajte mená tried a metód uvedené v zadaní.
• Vo výstupe na konzolu nemeňte časti, ktoré vypisuje existujúci program. Ak chcete, môžete vždy medzi "Start of move..." (resp. "Adding robot...") a "Current situation:" pridať aj oznamy o výbuchoch, teleportáciách a pod., udržujte však počet oznamov na rozumnej miere.

Hlina a kopajúci robot

Pridajte do hry políčko typu hlina a kopajúceho robota. Hlina (soil) sa správa podobne ako stena, nedá sa do nej vojsť a dá sa na nej stáť. Avšak kopajúci robot vie urobiť akciu kopanie (digging), ktorou vie políčko s hlinou, ktoré je pod ním, premeniť na prázdne políčko, do ktorého vzápätí spadne (ak je pod hlinou prázdne políčko, môže padať aj ďalej). Kopať sa dá iba cez hlinu, nie však cez steny a iné typy políčok. Kopajúci robot prvých T ťahov chodí rovnako ako základný robot. Od ťahu T+1 sa správa nasledovne: Ak sa dá kopať (stojí na políčku s hlinou), vykope toto políčko, inak chodí rovnako, ako by chodil základný robot v prvých T ťahoch. Tento robot teda nikdy neostane dobrovoľne stáť.

V súbore world.txt je hlina označená ako S (soil). V súbore robots.txt je kopajúci robot označený písmenom D (digging). Kým sa nespraví T ťahov, kopajúci robot sa zobrazuje na výstupe ako < alebo >, potom sa zobrazuje ako d. Vytvorte triedy SoilSquare a DiggingRobot, ktoré budú podtriedami vhodne zvolených tried a implementujte metódy, ktoré treba preťažiť. Bude tiež potrebné pridať nové metódy triedy Square, ako napríklad actionDigging, ktorá slúži na spracovanie akcie kopajúceho robota a digging, ktorá slúži na samotné vykopanie políčka s hlinou. Políčka, ktoré nie sú hlina, budú na digging vracať false (podobne ako plné políčka vracajú false na receiveRobot). Po vykopaní by sa typ políčka mal zmeniť zo SoilSquare na EmptySquare. To sa dá dosiahnuť tak, že vytvoríme nové políčko typu EmptySquare a zapojíme ho do plochy namiesto starého políčka. Na to však treba pomeniť referencie na toto políčko u jeho susedov aj v matici v triede World (na to ešte svet nemá metódu, treba pridať). Treba samozrejme aj do hlavného programu doprogramovať vytváranie nových typov štvorčekov a políčok pri čítaní vstupu (metódy createSquare a createRobot).

Skala a vybuchujúci robot

Pridajte do hry políčko typu skala a vybuchujúceho robota. Skala (rock) sa správa podobne ako stena, ale dá sa zničiť výbuchom. Vybuchujúci robot vie konať akciu výbuch (explosion), ktorý zasiahne políčko s robotom a všetky štyri políčka susediace s ním hranou. Všetci roboti a skaly nachádzajúce sa na týchto políčkach budú zničené. Výbuch nemá vplyv na steny a zeminu. Vybuchujúci robot sa tiež prvých T ťahov správa ako základný robot a v ťahu T+1 vybuchne, pričom samozrejme zahynie.

Celkový výsledok hry môže ovplyvniť aj to, v akom poradí spracovávame udalosti vyvolané výbuchom. Najskôr je zničené samotné políčko s robotom a potom jeho štyri susedné políčka počínajúc políčkom nad ním a postupujúc v smere hodinových ručičiek. Pri zničení obsahu políčka sa najskôr vyrovnáme so všetkými jeho dôsledkami a potom pokračujeme zničením ďalšieho políčka. Napríklad ak máme vybuchujúceho robota x, nad ktorým je skala a nad ňou ďalší robot y, najskôr umrie robot x, potom vybuchne skala nad ním, dôsledkom čoho robot y padne na políčko, kde bol pôvodne x. Ak by roboti umierali pri páde z výšky 2, rovno by aj umrel, inak žije ďalej. Potom vybuchuje políčko napravo a potom políčko dole. Ak políčko dole obsahovalo skalu a robot y ešte žije, začne zase padať. Vysporiadame sa so všetkými dôsledkami jeho pádu a nakoniec riešime výbuch políčka naľavo od pôvodnej pozície robota x.

V súbore world.txt je skala označená ako R (rock). V súbore robots.txt je vybuchujúci robot označený písmenom E (exploding). Kým sa nespraví T ťahov, vybuchujúci robot sa zobrazuje na výstupe ako < alebo >, potom sa zobrazuje ako e. Vytvorte triedy RockSquare a ExplodingRobot, ktoré budú podtriedami vhodne zvolených tried a implementujte metódy, ktoré treba preťažiť. Bude tiež potrebné pridať nové metódy triedy Square, ako napríklad actionExploding, ktorá slúži na spracovanie akcie vybuchujúceho robota a exploding, ktorá slúži na samotné vybuchnutie príslušného políčka. Po výbuchu skaly treba nahradiť políčko novým políčkom typu EmptySquare, podobne ako pri kopaní hliny.

Teleport

Pridajte do hry dva špeciálne typy políčok, ktoré predstavujú teleport. Teleport môže mať viacero vstupov a vždy práve jeden výstup. Políčko, ktoré je výstupom pre teleport, sa správa ako obyčajné prázdne políčko. Ak robot vôjde do vstupu pre teleport, alebo ak cez neho padá dole, teleport ho zachytí a presunie ho na výstup teleportu, odkiaľ prípadne robot opäť padá nižšie. Ak robot do vstupu teleportu padol, pád sa tým preruší, t.j. nesčítava výška pádu pred vstupom a po výstupe. Ak sa robot dostane na vstup teleportu, ktorý má výstup zaplnený iným robotom, robot na vstupe umiera.

V súbore world.txt sú vstupy do teleportu označené ako F (from) a výstup je označený T (to). Buď na ploche nie je vôbec žiadny teleport, alebo je tam práve jeden teleportový výstup a potenciálne viacero vstupov. Po načítaní vstupu nájdite výstup teleportu a uložte referenciu na neho všetkým vstupom. Vytvorte triedy TeleportEntrySquare a TeleportExitSquare, ktoré budú podtriedami vhodne zvolených tried a implementujte metódy, ktoré treba preťažiť.

Prednáška 31

Opakovanie OOP

• Java je objektovo orientovaný jazyk - všetko sú objekty
• Program pozostáva z objektov, ktoré navzájom 'komunikujú' prostredníctvom svojich metód

Objekty, zapúzdrenie

• Trieda (class) definícia objektu

class MyClass {
premenné
konštruktory
metódy
}

• Konštruktor - vytváranie objektu
  • používanie this(..) resp. super(..) na volanie iného konštruktora tej istej triedy, resp. nadtriedy
  • Pes punto=new Pes("Punto");
• Úrovne prístupu - Modifikátory
• Zapuzdrenie - oddelenie rozhrania a implementácie
  • Nemení sa to, čo je viditeľné zvonku
  • Pozor na prístup k premenným

Dedenie objektov, polymorfizmus

• Trieda môže byť potomkom inej triedy - potom zdedí jej premenné a metódy
  • Dediť môžeme iba od jednej triedy (ale môžeme viacúrovňovo)
  • Triedy, ktoré nemajú predchodcu dedia všeobecnú triedu Object
  • Aj základné typy premenných majú svoje objektové varianty
• Metódy sú virtuálne a je možné ich preťažiť - potomok tým prepíše chovanie metódy
• Potomka je vždy možné použiť na mieste predka, keďže má všetky jeho 'vlastnosti' - spolu s virtuálnymi metódami umožňuje polymorfizmus

Interface

• Abstraktná trieda, ktorá nemá žiadnu metódu implementovanú
  • Trieda môže implementovať interface - musí implementovať všetky jej metódy
• Umožňuje "viacnásobnú dedičnosť" a zaručuje dobré zapuzdrenie

Generické programovanie

• Ako mať rôzne typy premenných vnútri nejakej štruktúry (napr. zásobník)
  • Bude skladovať Object a keďže potomka môžeme použiť namiesto predka môžeme tam skladovať čokoľvek - musíme pretypovávať
  • Generické programovanie: parametrický typ class Stack <T>, kde T je parameter reprezentujúci typ objektov, pri definícii povieme konkrétny typ

• Aj metódy môžu mať generické typy - typový parameter, ktorý sa píše pred návratový typ

   static <E> void fillArray(E[] a, E e)

• Generické funkcie (napr. triedenie) s využitím interface

   static <E extends Comparable> void sort(E[] a)

Swing

• Doteraz sme mali aplikácie, ktoré pracovali s textovým vstupom a výstupom - konzolové aplikácie
• Ukážeme si jednoduché aplikácie, ktoré majú grafické UI
  • Grafické okno, ovládacie prvky, ...
  • Udalosti, ktoré vedú k akciám

• Tutorial SWING

Program s jedným grafickým oknom

V klasickej java aplikácii (ako sme používali doteraz) môžeme jednoducho vytvoriť aj grafické okno.

• Potrebujeme importovať javax.swing.*
• V main následne vytvoríme frame - okno, ktoré je typu JFrame a s ním ďalej pracujeme

import javax.swing.*; 
 
public class JavaApplication { 
  public static void main(String[] args) { 
    JFrame frame = new JFrame("Hello Swing"); 
    frame.setSize(300, 100); 
    frame.setVisible(true); 
  } 
}

• JFrame frame = new JFrame("Hello Swing"); - vytvorenie okna pomocou konštruktora
• nastavíme veľkosť a okno zobrazíme
• napriek tomu,že okno zavrieme program nám beží ďalej potrebujeme povedať, že uzavretie okna znamená zároveň ukončenie programu

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Text v okienku

• Do takto vytvoreného okna si môžeme vytvárať grafické (ovládacie) prvky label, button, ...
  • pochopiteľne pre tieto prvky má Java vlastné triedy, ktorých inštancie vytvárame
• Pre jednoduchosť začneme textovým popiskom - label, ktorý je inštanciou JLabel

    JLabel label = new JLabel("Label"); 
    frame.add(label); 

• Ďalej môžeme s týmto popiskom pracovať (napríklad mu zmeniť text)
  • V našom prípade si počkáme napr. sekundu a potom text zmeníme

import javax.swing.*; 
import java.util.concurrent.*; 
 
public class HelloLabel { 
  public static void main(String[] args) throws Exception { 
    JFrame frame = new JFrame("Hello Swing"); 
    JLabel label = new JLabel("Label"); 
    frame.add(label); 
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    frame.setSize(300, 100); 
    frame.setVisible(true); 
    TimeUnit.SECONDS.sleep(1); 
    label.setText("Changed Label"); 
  } 
}

• Toto má už trochu problém. My totiž meníme text niečomu, čo môže práve pracovať a meníme to za behu.
• Grafické okno beží v samostatnom vlákne, kde spracováva všetko, čo sa deje v tomto okne nezávisle od toho, čo robí main.
  • A čo sme my urobili je, že sme menili niečo v grafickom okne mimo vlákna, ktoré zodpovedá práci v grafickom okne.
• Aby sme pridali niečo do vlákna, ktoré pracuje (a v čase, kedy sa to môže vykonať) použijeme funkciu SwingUtilities.invokeLater();
  • Parametrom funkcie je inštancia triedy, ktorá implementuje interface Runnable
  • Interface Runnable má jedinú funkciu, ktorú je nutné implementovať - funkciu run, ktorá hovorí, čo sa to vlastne má vykonať

   static class myClass implements Runnable {
        JLabel label;
        @Override public void run(){ label.setText("Changed Label"); }
        myClass(JLabel label_) { this.label=label_; }
   }

   public static void main(String[] args) throws Exception {
        JFrame frame= new JFrame("Hello Swing");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        frame.setSize(300,300);
        frame.setVisible(true);
        
        final JLabel label = new JLabel("Label");
        frame.add(label);
        TimeUnit.SECONDS.sleep(1);
        myClass c=new myClass(label);
        SwingUtilities.invokeLater(c);

• Vytvárať si kvôli každému volaniu inštanciu triedy je trochu nepraktické a preto namiesto toho môžeme použiť ako parameter funkcie
  • SwingUtilities.invokeLater(new myClass(label));
• Nemusíme si dokonca kvôli tomu vytvárať ani celú tú triedu - môžeme využiť tzv. anonymnú triedu

 SwingUtilities.invokeLater(new Runnable() { @Override public void run() { label.setText("Changed Label"); }});

• Každým jedným použitím SwingUtilities.invokeLater() vlastne hovoríme, čo sa má v grafickom okne vykonať (okrem akcií, ktoré si grafické okno spravuje samé)
• Teda by sme mali nejakým spôsobom prepísať aj samotné vytvorenie okna
  • Najjednoduchšia možnosť by bola použiť presne to isté, ako pri zmene nápisu - vytvorenie anonymnej triedy
  • Problém je, že vytvorenie frame a label (pomocou new) musí byť mimo tejto triedy, aby sme k nim mohli pristupovať

final JFrame frame = new JFrame("Hello Swing");
final JLabel label = new JLabel("Label");
SwingUtilities.invokeLater(new Runnable() { @Override public void run() { 
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    frame.setSize(300,300);
    frame.setVisible(true);
    frame.add(label);
}});

• Nie je to však veľmi pekné riešenie, aj keď je korektné, lebo vytvorením frame a label ešte vlastne nevykonávame nič naozaj 'Swingové'.
• Môžeme si však vytvoriť novú neanonymnú triedu, ako sme to robili pred tým a v nej implementovať run. Táto trieda bude mať premenné frame a label.

static class theWindow implements Runnable {
    JFrame frame;
    JLabel label;
    @Override public void run(){ 
        frame = new JFrame("Hello Swing");
        label = new JLabel("Label");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        frame.setSize(300,300);
        frame.setVisible(true);
        frame.add(label);
    }
}

...

final theWindow window=new theWindow();
SwingUtilities.invokeLater(window);
TimeUnit.SECONDS.sleep(1);
SwingUtilities.invokeLater(new Runnable() { @Override public void run() { window.label.setText("Changed Label"); }});

Button a jeho stlačenie

• Doteraz sme síce menili grafické okno, ale nemali sme (okrem zavretia) žiadnu interakciu s používateľom
• Ukážeme si najjednoduchší ovládací prvok - Button a jednoduchú akciu - stlačenie gombíka
  • Button pridáme podobne ako Label pomocou frame.add()
  • Stlačenie gombíka je akcia, ktorá sa môže alebo aj nemusí stať - záleží od používateľa - preto na ňu musíme čakať a v prípade, že nastane nejako ju spracovať
  • Použijeme na to interface, ktorý implementujeme anonymnou triedou. V našom prípade potrebujeme interface ActionListener, ktorý má jedinú funkciu actionPerformed() s parametrom ActionEvent, ktorý hovorí parametre tej udalosti (na ktorom objekte nastalo a nejaké bližšie informácie)

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class JavaApplication7 {    
    static class theWindow implements Runnable {
        JFrame frame;
        JButton button;
        @Override public void run(){ 
            frame = new JFrame("Hello Swing");
            button = new JButton("Button");

            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
            frame.setSize(300,300);
            frame.setVisible(true);
            frame.add(button);
            
            button.addActionListener(new ActionListener() {
                @Override public void actionPerformed(ActionEvent e){ System.err.println("action!");  }
            });
        }
    }

    public static void main(String[] args) {
        final theWindow window=new theWindow();
        SwingUtilities.invokeLater(window);
    }
}

• beží to v SWINGu - teda vo vlákne, grafického okna - zaraďuje to akcie priamo do fronty
  • môžeme priamo - t.j. bez invokeLater pracovať s objektami grafického okna
  • kým sa to spracováva tak grafické okno 'zatuhne'

button.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e){
        button.setText("Ha!");
        ((JButton)e.getSource()).setText("He!");
    }
});

• Jeden ActionListener môžem nasadiť aj na viac objektov - napríklad niekoľko gombíkov
  • Urobím si triedu, ktorá implementuje ActionListener a používam ju neanonymne
  • vďaka ActionEvent a jej funkcii getSource viem identifikovať, kde daná udalosť nastala

Viac akcií

• Pre rôzne ovládacie prvky existujú rôzne akcie, ktoré sa môžu vykonať - v závislosti od konkrétneho ovládacieho prvku
  • zoznam je dlhý link title
• Už pre gombík môžeme okrem stlačenia pozorovať napríklad pohyb myši - interface MouseListener
  • tento interface však má nie jednu ale 5 funkcií, ktoré môžu nastať - mouseClicked, mouseEntered, mouseExited, mousePressed, mouseReleased
  • je možné, že nás všetky nezaujímajú, ale napriek tomu (keďže je to interface) ich musíme všetky implementovať (aspoň prázdnou funkciou)

button.addMouseListener(new MouseListener() {
    @Override public void mouseClicked(MouseEvent e) { System.err.println("click!"); }
    @Override public void mouseEntered(MouseEvent e) { System.err.println("enter!"); }
    @Override public void mouseExited(MouseEvent e) { System.err.println("exit!");}
    @Override public void mousePressed(MouseEvent e) { System.err.println("press!"); }
    @Override public void mouseReleased(MouseEvent e) { System.err.println("release!"); }
});

• Takýmto spôsobom môžeme mať na jeden prvok zavesených viacerých, ktorí čakajú na nejakú svoju udalosť (napríklad ActionListener a MouseListener)

Adaptéry

• Je nepraktické implementovať aj funkcie, o ktoré vôbec nemám záujem - potrebujem si zohnať ich zoznam a vytvorí to kopu zbytočného kódu
• Navyše sa môže ľahko stať, že časom nejaké funkcie pribudnú a program sa stane neskompilovateľným (lebo nami vytvorená trieda nebude implementovať všetky funkcie)
• Preto existuje defaultná implementácia každého listenera - tzv. adaptér, ktorý každú funkciu implementuje prázdnou funkciou
• My môžeme potom iba vytvoriť (anonymnú alebo neanonymnú) triedu, ktorá rozširuje tento adaptér a preťažuje tie funkcie, ktoré ma zaujímajú

button.addMouseListener(new MouseAdapter() {
    @Override public void mouseClicked(MouseEvent e) { System.err.println("click2!"); }
});

• Zaujímavé je, že na jeden objekt môžeme dokonca nasadiť aj viacerých, ktorí očakávajú tú istú udalosť (listeneri sa sčítajú a nerušia navzájom)

Swing naklikaním

• V Netbeans a v iných editoroch je možnosť si GUI aj naklikať - vytvoríme projekt typu Desktop Application
• Vytvoria sa tri základné súbory
  • DesktopApplication.java - obsahuje nastavenia pred štartom SWINGu a samotné spustenie SWINGu
  • DesktopApplicationView.java - priamo práca grafického okna - nastavenie prvkov, udalosti
  • DesktopApplicationAboutBox.java - čo sa objaví keď chcem About
• V nich sa vytvorí rovno potrebný zdroják
  • vytvorenie objektov jButton1 = new javax.swing.JButton();
  • ich inicializácia jButton1.setText(resourceMap.getString("jButton1.text"));
  • vytvorenie listenerov

jButton1.addMouseListener(new java.awt.event.MouseAdapter() {
    public void mouseClicked(java.awt.event.MouseEvent evt) {
        jButton1MouseClicked(evt);
    }
});

• Pre akcie, ktoré sme si naklikali (vybrali z menu Properties) sa vytvoria prázdne funkcie, ktorých obsah (pozor nie deklaráciu) budeme dopĺňať
  • nemôžem napríklad pridat throws Exception!

private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {                                      
    System.err.println("Click");
    try { Thread.sleep(10000);} catch(Exception e) {}
}                                     

Cvičenia 18

• Napíšte generickú statickú metódu prienik, ktorá dostane dve SortedSet (s tým istým typom prvkov E) a vráti SortedSet obsahujúcu ich prienik, t.j. prvky, ktoré sa nachádzajú v oboch. Použite algoritmus podobný na Merge, pričom sa posúvate dvoma iterátormi (iterátory pre SortedSet vracajú prvky v utriedenom poradí).
  • Vyskúšajte si pre túto funkciu napísať niekoľko testovacích vstupov pomocou JUnit.

• Napíšte generickú statickú metódu kazdyDruhy, ktorá dostane List a vyhodí z neho každý druhý prvok. K Listu pristupujte iba cez iterátor a jeho metódu remove.

• Napíšte triedu Zlomok, ktorá bude implementovať zlomok s celočíselným čitateľom a menovateľom. Triede spravte konštruktor a preťažte equals tak, aby správne testovala rovnosť zlomkov a hashCode tak, aby bol konzistentný s equals. Vaša trieda by tiež mala implementovať interface Comparable s bežným porovnaním zlomkov podľa veľkosti. Skúšajte potom zlomky vkladať do TreeSet a HashSet a skontrolujte, že dostávate správne výsledky. Pozor na záporné čísla. Môže sa vám zísť Euklidov algoritmus na nájdenie najväčšieho spoločného deliteľa:

    // ratame nsd(a,b)
    while(b != 0) {
        int x = a % b;
        a = b;
        b = x;
    }
    // vysledok je v premennej a

Prednáška 32

Pozície a layouty

• Na cvičení ste menili pozície a veľkosť gombíkov a textu. V prípade, že ste to robili naklikaním, nebol s tým problém, ale ak ste skúšali napísať si program sami, veselo vás ignoroval.
• Súvisí to s rôznym rozložením ovládacích prvkov - layoutami.
• Na to, aby sa dalo meniť polohy prvkov, potrebujeme nastaviť frame.setLayout(null);

frame.setLayout(null);
label=new JLabel("Label");
button=new JButton("Button");
label.setLocation(10, 10);
label.setSize(50,30);
button.setLocation(100, 10);
button.setSize(100,30);
frame.add(button);
frame.add(label);

• Pozície, na ktoré sú umiestňované jednotlivé komponenty normálne nie sú určené priamo súradnicami, ale Layout managerom
  • Layout nastavíme pomocou setLayout(...), ktoré môžeme použiť pre frame, window, dialog ...
  • Rôzne layouty spôsobia rôzne veľkosti, tvary a umiestnenia prvkov
  • Navyše rozloženie a veľkosť prvkov ovplyvňuje aj veľkosť okna - pri zmene sa môžu meniť aj prvky
• Ukážeme si umiestňovanie gombíkov do zopár layoutov
  • Layouts

Border Layout

• Defaultné nastavenie Layout managera
• Má 5 možností, kam umiestniť prvok (CENTER, NORTH, SOUTH, EAST, WEST)
  • Default je CENTER
  • Ak umiestnime viacero prvkov na jedno miesto, budú cez seba

//    frame.setLayout(new BorderLayout());  -- defaultný layout pre frame
button=new JButton("BUTTON");               // defaultné umiestnenie je borderLayout.CENTER
frame.add(new JButton("NORTH"),BorderLayout.NORTH);
frame.add(new JButton("SOUTH"), BorderLayout.SOUTH);        

Flow layout

• Vkladá prvky do radu v poradí, ako sú vkladané.
  • Môže sa vkladať zľava doprava alebo naopak
  • Používa prirodzené alebo preferované veľkosti prvkov
  • Prvky sú defaultne v riadku vycentrované
• V prípade, že sa nezmestia pokračuje ďalším radom.

Kombinácia Layoutov

• Väčšinou preddefinované layouty nepostačujú na to, čo chceme vytvoriť - prečo sú potom také?
• Layouty nepoužívame samotné, ale nejakú ich kombináciu.
  • Samotné okno má ako default BorderLayout, ktorý zodpovedá rozloženiu rôznych menu v základnom okne
  • Do stredu potom potrebujeme vložiť taký prvok, ktorý bude vhodne rozkladať prvky, vnútri - JPanel, Box ...
  • Týmto prvkom môžeme zadať ich Layout (a defaultný Layout majú iný ako má Jframe)

panel=new JPanel();
//    panel.setLayout(new FlowLayout()); - default pre Panel je FlowLayout
frame.add(panel);
panel.add(new JButton("BUTTON");
panel.add(new JLabel("LABEL"));
frame.add(new JButton("HORNY GOMBIK"), BorderLayout.NORTH);
frame.add(new JButton("DOLNY GOMBIK"), BorderLayout.SOUTH);        

Menu

static class theWindow implements Runnable {
        JFrame frame;

    @Override
    public void run() {
        frame = new JFrame("Hello Swing");
        JMenuBar menubar = new JMenuBar();
        JMenu menu1 = new JMenu("Riadok1");
        JMenuItem eMenuItem = new JMenuItem("Exit");
        eMenuItem.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent event) {
                System.exit(0);
            }
        });
        // mam obrazok icon.gif v Source Packages
        ImageIcon icon = new ImageIcon(getClass().getResource("icon.gif"));
        JMenuItem iconMenuItem = new JMenuItem("Ikonka",icon);
        iconMenuItem.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent event) {
                System.err.println("Mam ikonku.");
            }
        });

        menu1.add(iconMenuItem);
        menu1.add(eMenuItem);
        menubar.add(menu1);
        
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 300);
        frame.setVisible(true);
        frame.add(menubar,BorderLayout.NORTH);
    }
}

• JMenuBar obsahuje JMenu a to obsahuje JMenuItem.
• Namiesto JMenuItem môžem pridávať znovu JMenu a tým vytvoriť submenu

Viacoknové aplikácie a dialogy

• Doteraz sme robili aplikácie, ktoré mali jedno okno, v ktorom sa všetko odohrávalo.
• Niekedy potrebujeme nejakú akciu vyvolať v inom okne

Dialógové okno

• Najjednoduchšie dialógové okno je MessageDialog, ktorý má iba jednu možnosť ako ďalej pokračovať a to, že zavrieme okno a informáciu sme vzali na vedomie

JOptionPane.showMessageDialog(frame, "Haf!", "Dialog Haf", JOptionPane.INFORMATION_MESSAGE, new ImageIcon(getClass().getResource("icon.gif")));
JOptionPane.showMessageDialog(frame, "Haf!", "ERROR HAF", JOptionPane.ERROR_MESSAGE);
JOptionPane.showMessageDialog(frame, "Mnau!");

• Ak chceme odozvu, máme niekoľko možností: OptionDialog, ConfirmDialog alebo InputDialog [5]
• Ich návratovú hodnotu už vieme používať ďalej v programe

if (JOptionPane.showConfirmDialog(frame, "Haf?", "Dialog Haf", JOptionPane.YES_NO_OPTION)==0) 
    JOptionPane.showMessageDialog(frame, "Haf!");
else 
    JOptionPane.showMessageDialog(frame, "Mnau!");

JDialog a JFrame

• Ak chcem vytvoriť viacero okien, mám v zásade dve možnosti - ďalší JFrame a JDialog
• JFrame sa správa ako klasické okno s tým, že mi nebráni prepnúť do pôvodného okna bez ukončenia

JFrame frame2=new JFrame("2nd Frame");
frame2.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
frame2.setVisible(true);

• JDialog sa môže správať rovnako ako klasický frame, nemá však možnosť maximalizácie, minimalizácie ...
• Výhodou JDialogu je možnosť nastavenia jeho modality - t.j. že sa nedá bez ukončenia pokračovať v programe
  • setVisible(true) pre okno, ktoré je modálne sa zablokuje kým sa okno nezavrie

JDialog frame2=new JDialog(frame, "2nd Frame - Dialog");
frame2.setModal(true);
frame2.setVisible(true);

• Z vedľajších okien často potrebujeme dostať nejakú informáciu - vyplnený text, ktorý gombík bol stlačený ...
• Keďže aj pri zatvorení okno zostane v pamäti môžeme pristupovať k jeho položkám a volať jeho metódy
• V prípade, že potrebujeme infomáciu z akcie tak si to uložíme ako parameter nášho rozšírenia JDialog/JFrame

class myYesNoDialog extends JDialog{
    JTextField field;
    boolean res;
    myYesNoDialog(JFrame owner, String title) {
        super(owner);
        setModal(true);
        res=false;
        JPanel panel = new JPanel();
        JButton yes = new JButton("yes");
        JButton no = new JButton("no");
        field = new JTextField(10);
        final myYesNoDialog dialog=this; // implemntačný problém ako dostať túto triedu do anonymných tried k akciám
        yes.addActionListener(new ActionListener() {
            @Override public void actionPerformed(ActionEvent event) {
                dialog.res=true;
                dialog.setVisible(false);
            }
        });
        no.addActionListener(new ActionListener() {
            @Override public void actionPerformed(ActionEvent event) {
                dialog.res=false;
                dialog.setVisible(false);
            }
        });
        add(panel);
        panel.add(yes);
        panel.add(no);
        panel.add(field);
        pack();            // nastaví veľkosť dialogu tak, aby sa všetko zmestilo
        setVisible(true);  // zablokuje volajúceho až kým sa okno nezavrie
    }
    public boolean result() { return res; }
    public String value() { return field.getText(); }
}

...

myYesNoDialog d = new myYesNoDialog(this.frame,"Yes or no?");
if (d.result()) JOptionPane.showMessageDialog(this.frame, "Yes - "+d.value());
else JOptionPane.showMessageDialog(this.frame, "No - "+d.value());

Zložitejší príklad

• Zložitejší layout - nebojte sa kombinovať
• Niekoľko zložitejších ovládacích prvkov
  • JTextField - v našom prípade iba ak stlačíme gombík pracujeme s textom v ňom
  • JList - zoznam z ktorého môžeme vyberať (ale ho aj meniť za behu)
  • každý JList má vlastný ListModel (čo s tým zoznamom môžeme robiť - v našom prípade pridávanie a mazanie na konkrétnych miestach zoznamu)
  • ScrollPane - obdoba JPanel, ktorý v prípade potreby prida scrollbar - už pri vzniku potrebuje vedieť prvok, ktorý bude na ňom
• Využitie dedenia - štruktúra vlastných tried aj dedenie od ovládacích prvkov
  • Pes a jeho podtriedy Civava a Bernardin
  • Dedenie od JButton v prípade, že chceme rozšíriť napr. o tag - v našom prípade informáciu ku ktorej triede gombík prislúcha

Zdrojový kód programu

package javaapplication10;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class JavaApplication10 {

    static class Dog
    {
        String name;
        public String bark() { return "Haf!"; }
        public String getName() { return name; }
        protected Dog(String name) { this.name=name; }
        public @Override String toString() { return name; }
    }
    
    static class StBernard extends Dog
    {
        public StBernard(String name) { super(name); }
        @Override
        public String bark() { return "HAF!"; }
    }

    static class Chihuahua extends Dog
    {
        public Chihuahua(String name) { super(name); }
        @Override
        public String bark() { return "Hif..."; }
    }

    static class DogButton extends JButton implements ActionListener
    {
        Dog dog;
        public DogButton(Dog dog_)
        {
            super(dog_.getName());
            addActionListener(this);
            dog=dog_;
        }
        @Override 
        public void actionPerformed(ActionEvent event) {
            JOptionPane.showMessageDialog(this, dog.bark(),dog.getName()+" says:",JOptionPane.INFORMATION_MESSAGE);
        }
        public Dog getDog() { return dog; }
    }
    
    static class theWindow implements Runnable
    {
        @Override
        public void run() {
            final JFrame frame = new JFrame("Playground");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

            final JMenuBar menu = new JMenuBar();
            final JMenu menuFile=new JMenu("File");
            final JMenuItem menuExit = new JMenuItem("Exit");
            menu.add(menuFile);
            menuFile.add(menuExit);
            menuExit.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    System.exit(0);
                }
            });
            frame.add(menu,BorderLayout.NORTH);
            
            final JPanel panel = new JPanel();
            panel.setLayout(new BoxLayout(panel,BoxLayout.PAGE_AXIS));
            frame.add(panel);
            
            final JPanel top_panel = new JPanel();
            final JPanel middle_panel = new JPanel();
            final JPanel bottom_panel = new JPanel();
            middle_panel.setPreferredSize(new Dimension(0,50));
            middle_panel.setLayout(new BoxLayout(middle_panel,BoxLayout.LINE_AXIS));
            panel.add(top_panel);
            panel.add(middle_panel);
            panel.add(bottom_panel);
            
            final JTextField field = new JTextField(10);
            top_panel.add(field);

            final DefaultListModel model = new DefaultListModel();
            
            final JButton addButton = new JButton("Add big");
            addButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Dog dog=new StBernard(field.getText());
                    middle_panel.add(new DogButton(dog));
                    middle_panel.revalidate();
                    model.add(model.getSize(), dog);
                }
            });
            top_panel.add(addButton);

            final JButton addButton2 = new JButton("Add small");
            addButton2.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Dog dog=new Chihuahua(field.getText());
                    middle_panel.add(new DogButton(dog));
                    middle_panel.revalidate();
                    model.add(model.getSize(), dog);
                }
            });
            top_panel.add(addButton2);
            
            final JList list = new JList();
            list.setModel(model);
// scrollPane vyzaduje svoj obsah ako argument, nepouziva klasicky add            
            final JScrollPane scroll = new JScrollPane(list);
            bottom_panel.setLayout(new BorderLayout());
            bottom_panel.add(scroll);
            final JButton deleteButton=new JButton("Delete");
            deleteButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (list.getSelectedIndex()!=-1)
                    {
                        for(Component x : middle_panel.getComponents())
                        {
                            if (x instanceof DogButton)
                            {
                                if (((DogButton)x).getDog()==list.getSelectedValue())
                                {
                                    middle_panel.remove(x);
                                    middle_panel.revalidate();
                                    model.remove(list.getSelectedIndex());
                                    break;
                                }
                            }
                        }
                    }
                }
            });
            bottom_panel.add(deleteButton,BorderLayout.LINE_END);
            
            frame.pack();
            frame.setVisible(true);
        }
    }
    
    public static void main(String[] args) {
        final theWindow window=new theWindow();
        SwingUtilities.invokeLater(window);
    }
}

Cvičenia 19

• Vytvorte aplikáciu, ktorá bude mať jeden gombík a bude do konzolového okna vypisovať, koľký krát bol gombík stlačený.
  • Ako by ste rozlíšili rôzne typy stlačení - myšou/klávesnicou
  • Aplikáciu skúste vytvoriť oboma spôsobmi - vlastným naprogramovaním aj naklikaním aplikácie

• Skúste, ako môžete meniť polohu a veľkosť prvkov v okne.
  • Potrebujete nastaviť frame.setLayout(null)
  • setLocation, setSize, .. pozrite si aj ostatné vlastnosti prvkov
  • Vytvorte aplikáciu, ktorá vytvorí v okne veľkosti 500x500 gombík veľkosti 20x20 v strede. Pomocou šípok meňte polohu gombíka.
  • Vytvorte text, ktorý sa bude sám hýbať po obrazovke v istých časových intervaloch. Premyslite si čím text zastavíte resp. ako aplikáciu ukončiť.

DÚ15

max. 10 bodov, termín odovzdania streda 4.4. o 22:00.

Cieľom tejto úlohy je precvičiť si prácu s Collections, iterátormi, generickým programovaním a testovaním pomocou JUnit.

V tejto úlohe sa budeme zaoberať Josephusovým problémom: V kruhu stojí n ľudí odsúdených na smrť. Kat začne na určitom mieste a v každom kroku preskočí k-1 ľudí v kruhu a k-teho popraví. Potom sa kruh zmenší a proces pokračuje od miesta, kde sa skočilo. Napríklad, ak ľudia stáli v poradí (A,B,C,D) a k=3, kat najskôr sa preskočí A a B a popraví C, potom preskočí D a A a popraví B, potom preskočí D a A a popraví D a posledný popravený bude A.

Vašou úlohou je

• naprogramovať simuláciu tohto procesu, pričom implementujte triedu JosephusIterator a jej metódy podľa špecifikácie uvedenej v komentároch nižšie.
• napísať aspoň 10 testov v systéme JUnit, ktoré budú testovať rôzne okrajové aj typické prípady použitia rôznych metód triedy JosephusIterator (vrátane hádzania výnimiek tam, kde to komentáre k metódam špecifikujú). Ku každému testu napíšte krátky komentár, aký prípad testuje. Snažte sa pokryť čo najviac situácií, ktoré by mohli byť pre implementácie tejto triedy problematické.

Trieda JosephusIterator reprezentuje špeciálny iterátor, ktorý pri volaní next vždy preskočí k-1 prvkov nejakej Collection a vráti ten ďalší, pričom ak medzitým prišiel na koniec Collection, začne znova od začiatku. Vie tiež vymazať posledný vrátený prvok z Collection. Tento iterátor by mal fungovať pre každú Collection, ktorá má svoj vlastný iterátor s implementovanou metódou remove (napr. ArrayList, LinkedList, TreeSet,...). Samotný Josephusov proces vyraďovania potom pomocou JosephusIteratora simulujte v statickej metóde josephus. Váš program nemusí mať metódu main, stačí použiť JUnit testy.

Odovzdávajte zip súbor s dvoma súbormi: JosephusIterator.java a JosephusIteratorTest.java.

Špecifikácia a kostra triedy JosephusIterator:

package josephus;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Collection;

/** Trieda, ktorá umožňuje iterovať cez Collection tak,
 * že v každom kroku sa preskočí k-1 prvkov Collection a vráti sa k-ty a
 * keď príde na koniec, začne znovu od začiatku.
 * Napr. ak Collection obsahuje zoznam (1,2,3,4) a k=3,
 * tak prvé volanie next() vráti 3, druhé volanie vráti 2,
 * tretie 1, štvrté  4, piate opäť 3 a odvtedy
 * sa situácia cyklicky opakuje donekonečna (za predpokladu,
 * že nič nebudeme mazať).
 */
public class JosephusIterator<E> implements Iterator<E> {
    // VASE PREMENNE


    /** Konštruktor, ktorý vytvorí Josephusov iterátor pre
     * Collection c a parameter preskakovania k>=1. */
    public JosephusIterator(Collection<E> c, int k) {
       // VAS KOD
    }

    /** Vráti true, ak next() vráti ďalší prvok Collection,
     * čo je pravda vždy ak Collection nie je prázdna. */
    public boolean hasNext() {
       // VAS KOD
    }

    /** Vráti ďalší prvok z Collection, pričom vždy k-1 prvkov preskočí
     * a keď príde na koniec, pokračuje od začiatku.
     * @throws NoSuchElementException ak hasNext je false.  */
    public E next() {
       // VAS KOD
    }

    /** Zmaže prvok z Collection vrátený pomocou predchádzajúceho volania next
     * @throws IllegalStateException ak next ešte nebola zavolaná alebo ak remove
     * bola už zavolaná od posledného volania next. */
    public void remove() {
        // VAS KOD
    }

    /** Na Collection c simuluje Josephusov proces vyraďovania
     * a vráti ArrayList prvkov v tom poradí, ako boli vyradení.
     * Na konci bude Collection c prázdna.
     */
    public static <E> ArrayList<E> josephus(Collection<E> c, int k) {
       // VAS KOD
    }
}

Prednáška 33

Kreslenie so SWINGom

Vo SWINGu neexistuje priamo Canvas, ktorý by bol určený čisto na vykresľovanie. Vykresliť však môžeme na rôzne komponenty napríklad na JPanel. Každý komponent má funkciu paintComponent, ktorý ho vykreslí. Tento si my môžeme v našej triede rozšíriť podľa potreby.

Jednoduché nakreslenie prvkov na plochu

• Vytvoríme si teda vlastný grafický panel MyPanel, ktorý bude rozšírením JPanel.
• Potrebujeme preťažiť jeho funkciu paintComponent.
  • Najprv zavoláme samotné vykreslenie komponentu (predchodcu).
  • Potom môžeme využívať funkcie na rôzne vykreslenia prvkov - textu, štvorca, kruhu..
• Týmto dostávame okno, v ktorom je niečo vykreslené, ale nie je to 'aktívne'.

import javax.swing.*;
import java.awt;

class MyPanel extends JPanel {
    public MyPanel() { setBorder(BorderFactory.createLineBorder(Color.black)); }
    @Override public Dimension getPreferredSize() { return new Dimension(250,200); }
    @Override public void paintComponent(Graphics g) {
        super.paintComponent(g);       
        // Draw Text
        g.drawString("This is my custom Panel!",10,20);
        // Draw Rectangle
        g.drawRectange(50,50,50,50);
    }  
}

Aktívne prekresľovanie

• Keď chceme meniť to, čo je vykreslené, nemôžeme odhocikiaľ zavolať nakreslenie textu, štvorca ...
• Vykreslenie (t.j. zavolanie paintComponent) sa volá vždy, keď sa okno nejakým spôsobom zmení - zmena veľkosti ...
• Čo však môžeme urobiť je odniekiaľ oznámiť, že sa má okno prekresliť
  • Doteraz sme to robili pomocou revalidate, ktoré skúsilo odznovu zmeniť layout, ale keďže v paneli sa nič nezmenilo, tak sa ani nebude volat paintComponent.
  • Môžeme ho k tomu donútiť napríklad zmenou veľkosti mp.setSize(mp.getWidth()+1,mp.getHeight()); ale je to mierne nepraktické.
  • Pre prekreslenie - t.j. zavolanie paintComponent, bez zmeny layoutu vieme použiť funkciu repaint(), čo prekreslí celý panel.
  • Môžeme prekresliť iba tú časť, ktorá je zaujímavá (t.j. pôvodný štvorec a nový štvorec) s použitím repaint s vhodnými parametrami.

class MyPanel extends JPanel {
    private int squareX = 50;
    private int squareY = 50;
    private int squareW = 20;
    private int squareH = 20;
    public MyPanel() {
        setBorder(BorderFactory.createLineBorder(Color.black));
        addMouseListener(new MouseAdapter() {
            @Override public void mousePressed(MouseEvent e) { moveSquare(e.getX(),e.getY()); }
        });
        addMouseMotionListener(new MouseAdapter() {
            @Override public void mouseDragged(MouseEvent e) { moveSquare(e.getX(),e.getY()); }
        });        
    }
    private void moveSquare(int x, int y) {
        int OFFSET = 1;
        if ((squareX!=x) || (squareY!=y)) {
            repaint(squareX,squareY,squareW+OFFSET,squareH+OFFSET);
            squareX=x; squareY=y;
            repaint(squareX,squareY,squareW+OFFSET,squareH+OFFSET);
        } 
    } 
    @Override public Dimension getPreferredSize() {  return new Dimension(250,200);  }
    @Override protected void paintComponent(Graphics g) {
        super.paintComponent(g);       
        g.drawString("This is my custom Panel!",10,20);
        g.setColor(Color.RED);
        g.fillRect(squareX,squareY,squareW,squareH);
        g.setColor(Color.BLACK);
        g.drawRect(squareX,squareY,squareW,squareH);
    }  
}

• Ako to, že vo funkcii moveSquare to funguje?
  • Volanie repaint totiž neznamená priamo volanie paintComponent v tom okamihu, ale iba akési označenie, čo chcem prekresliť, keď na to bude čas.
• Program si upravíme, aby sa dal využiť kúsok všeobecnejšie. Vytovoríme si triedu červený štvorček, ktorá bude vedieť svoju veľkosť a bude sa vedieť vykresliť.

class MyRedSquare{
    private int xPos = 50;
    private int yPos = 50;
    private int width = 20;
    private int height = 20;

    public void setX(int xPos){ this.xPos = xPos;  }
    public int getX(){ return xPos; }
    public void setY(int yPos){ this.yPos = yPos;  }
    public int getY(){ return yPos; }
    public int getWidth(){ return width; } 
    public int getHeight(){ return height; }

    public void paintSquare(Graphics g){
        g.setColor(Color.RED);
        g.fillRect(xPos,yPos,width,height);
        g.setColor(Color.BLACK);
        g.drawRect(xPos,yPos,width,height);  
    }
}

...
private MyRedSquare sq=new MyRedSquare();
...
@Override public void paintComponent(Graphics g) {
    super.paintComponent(g);       
    sq.paintSquare(g);
}

• Teraz máme už rozumnú štruktúru programu
  • v MyPanel.paintComponent vykreľujeme všetko, čo potrebujeme vykresliť (pomocou metódy paintXYZ konkrétneho objektu XYZ)
  • MyPanel má tiež MouseListener, ktorý pri akcií zavolá metódu move objektu

Viacero vykreslených objektov

• Samozrejme v prípade, že máme objektov viac ja potrebné pri akcii myši rozmýšľať, ktorého objektu sa akcia má týkať.
• Vytvoríme si preto celé pole objektov, ktoré sa budú vykresľovať a pri akcii budeme rozhodovať, či sa vykoná na nejakom objekte alebo na paneli.

class MySquare{
..
    public void paintSquare(Graphics g){..}
    public void changeColor(){..}
    boolean inSquare(int x, int y){..}
}

class MyPanel extends JPanel {

    private ArrayList<MySquare> squares=new ArrayList<MySquare>();

    public MyPanel() {
        setBorder(BorderFactory.createLineBorder(Color.black));
        addMouseListener(new MouseAdapter() {
            @Override public void mousePressed(MouseEvent e) {
                boolean wasChanged=false;
                int index=0;
                // zisťujem ktorý štvorček má zmeniť farbu
                for (int i = 0; i < squares.size(); i++) {
                    if (squares.get(i).inSquare(e.getX(),e.getY())){
                        squares.get(i).changeColor();
                        wasChanged=true;
                        index=i;
                    }   
                }
                // pri kliknutí mimo štvorčekov sa pridá nový
                if (!wasChanged) {
                    squares.add(new MySquare(e.getX(),e.getY(),20,20));
                    index=squares.size()-1;
                }
                MySquare sq=squares.get(index);
                repaint(sq.getX(),sq.getY(), sq.getWidth()+1, sq.getHeight()+1);
            }    
         });
   @Override public void paintComponent(Graphics g) {
        super.paintComponent(g);               
        for (int i = 0; i < squares.size(); i++) {
            MySquare sq=squares.get(i);
            sq.paintSquare(g);
        }
    }  
}

• Voláme repaint síce iba nejaký výsek z paintComponent, ale prečo to naozaj nevykreslí všetko odznovu? Graphics si pamätá Clip, t.j. časti, ktoré sa majú prekresliť. Keď vyvolám maľovanie, tak sa prekreslí iba to, ktoré je v Clipe.

• Jednoduchým rozšírením vieme napríklad dosiahnuť iba jeden vybraný prvok, s ktorým môžeme potom niečo robiť (vypísať jeho vlastnosti, vymazať...
  • #Program vykresľovanie

Rôzne tvary

• Čo keď chcem robiť okrem veľa štvorčekov aj kolieska?
  • Môžeme si skopírovať kód pre štvorčeky a upraviť na kolieska - a potom nám prídu trojuholníky
  • Alebo sa zamyslím, čo majú štvorčeky a kolieska spoločné.

abstract class MyShape {
    protected int xPos;
    protected int yPos;
    protected int width;
    protected int height;
    protected Color col;
    
    public MyShape(int x, int y, int width, int height){ ... }
    
    public void setX(int xPos){ this.xPos = xPos;  }
    public int getX(){ return xPos; }
    public void setY(int yPos){ this.yPos = yPos;  }
    public int getY(){ return yPos; }
    public int getWidth(){ return width; } 
    public int getHeight(){ return height; }

    abstract public void paint(Graphics g); // ako sa kreslí musí vedieť každý tvar sám

    public void changeColor(){ ...  }
    boolean inBoundingBox(int x, int y){ ...  } 
}

...
    private ArrayList<MyShape> shapes=new ArrayList<MyShape>();
...
    if (!wasChanged) {  // ale ktorý pridávam
      shapes.add(new MyCircle(e.getX(),e.getY(),20,20));
      shapes.add(new MySquare(e.getX(),e.getY(),20,20));
    }

Doplňujúce informácie k akcii

Ako pri klinutí získam navyše informácie (napríklad v predchádzajúcom informáciu, či vytváram štvorce alebo kruhy)?

Dopredu nastavené

• Jednoduchá možnosť, ako vedieť, aký typ mám vytvárať je mať v okne nastavenie.
  • Na začiatku (bez používateľovej akcie) je nastavený nejaký default.
  • Prepínaním gombíka, listu, radio gombíka a pod. môže používateľ toto nastavenie zmeniť

Súčasť akcie

• Ako sme si povedali každý event má niekoľko vlastností ako konkrétne nastal - môžeme teda kontrolovať, či bolo stlačené pravé alebo ľavé tlačítko a podľa toho vybrať akciu
  • a čo keď budem mať aj trojuholníky?

Dialóg

• Pri kliknutí na plochu sa môže vyvolať nejaké nové okno alebo dialóg, kde si používateľ vyberie doplňujúce informácie.
• Treba vyriešiť, čo sa stane, ak si nevyberie nič alebo zavrie okno (napr. vtedy môže nastať default - v našom prípade kruh).

private Object[] possibilities = {"circle", "square"};
...
final MyPanel tmp=this; 
...
addMouseListener(new MouseAdapter() {
    @Override public void mousePressed(MouseEvent e) {
...
        String s = (String)JOptionPane.showInputDialog(
                tmp,
                "Choose the shape",
                "Shape Dialog",
                JOptionPane.PLAIN_MESSAGE,
                null,
                possibilities,
                "circle");
        if (("square").equals(s)) shapes.add(new MySquare(e.getX(),e.getY(),20,20));
        else shapes.add(new MyCircle(e.getX(),e.getY(),20,20));
...

Popup menu

• Popup menu sa konštruuje podobne ako klasické menu a pomocou neho si môžeme vybrať niektorú položku alebo nastavenie.
• JPopupMenu obsahuje podobne ako klasick0 menu jednotlive JMenuItem, na ktoré môžem jednoducho pripojiť čakanie na akciu - výber tejto položky

final JPopupMenu pop=new JPopupMenu();
JMenuItem menu1=new JMenuItem("Square");
JMenuItem menu2=new JMenuItem("Circle");
pop.add(menu1);
pop.add(menu2);
menu1.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e) {
     // vybrali sme štvorec
    }
});
menu2.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e) {
     // vybrali sme kruh
    }
});

• Zavolanie (vyskočenie) popup menu potom vykonáme v MouseListener na MyPanel. Pre popup je potrebné vedieť predka(v našom prípade tento MyPanel) a miesto, kde má okno vyskočiť.

final MyPanel tmp=this; 
addMouseListener(new MouseAdapter() {
    @Override public void mousePressed(MouseEvent e) {
         ...
         pop.show(tmp,e.getX(),e.getY());
         ...
     }
}

• Na rozdiel od dialogového okna nás nič nenúti dostať odpoveď (a ani sa na túto odpoveď nečaká), preto je rozumné po vyskočení okna už nepredpokladať ďalšie udalosti závislé od odpovede (tie by mali byť v reakciách na jednotlivý výber z menu)
• Ďalšia vec, ktorá môže byť miernym problémom je potom samotné vytvorenie vzniknutého kruhu/štvorca
  • Z predchádzajúceho je jasné, že nemôže toto vytvorenie byť za pop.show()
  • Vykonáme to teda v menu.addActionListener(), kde už vieme, čo máme vytvoriť (a že naozaj)
  • Na tomto mieste však nevieme, kde máme kruh/štvorec urobiť - musíme na to myslieť dopredu a pozíciu si uložiť

final Point p=new Point(0,0);
menu1.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e) {
         MyShape sq=new MySquare((int)p.getX(),(int)p.getY(),20,20);
         shapes.add(sq);
         repaint(sq.getX(),sq.getY(), sq.getWidth()+1, sq.getHeight()+1);
    }
});

...

// v mieste vyskočenia okna
pop.show(tmp,e.getX(),e.getY());
p.setLocation(e.getX(),e.getY());
return;
...

• P33prog2

Program vykresľovanie

package javaapplication12;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;


public class JavaApplication12 {
   
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override public void run() {
                createAndShowGUI(); 
            }
        });
    }

    private static void createAndShowGUI() {
        JFrame frame = new JFrame("Swing Paint Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel panel = new JPanel();   
        final MyPanel mypanel = new MyPanel();
        JButton delButton = new JButton("Delete");
        delButton.addActionListener(new ActionListener() {
            @Override public void actionPerformed(ActionEvent event) {
                mypanel.removeSelectedSquare();
            }
        });
        frame.add(panel,BorderLayout.EAST);
        frame.add(mypanel);
        panel.add(delButton);
        frame.pack();
        frame.setVisible(true);
    }
    
}

class MySquare{
    private int xPos;
    private int yPos;
    private int width;
    private int height;
    private Color col;
    
    public MySquare(int x, int y, int width, int height){
        col=Color.RED;
        this.xPos=x; this.yPos=y; this.height=height; this.width=width;
    }
    
    public void setX(int xPos){ this.xPos = xPos;  }
    public int getX(){ return xPos; }
    public void setY(int yPos){ this.yPos = yPos;  }
    public int getY(){ return yPos; }
    public int getWidth(){ return width; } 
    public int getHeight(){ return height; }

    public void paintSquare(Graphics g){
        g.setColor(col);
        g.fillRect(xPos,yPos,width,height);
        g.setColor(Color.BLACK);
        g.drawRect(xPos,yPos,width,height);  
    }
    
    public void changeColor(){
        if (col==Color.RED) col=Color.BLUE;
        else col=Color.RED;
    }
    
    boolean inSquare(int x, int y){
        if ((x>=this.xPos)&&(x<=this.xPos+this.width)&&(y>=this.yPos)&&(y<=this.yPos+this.height)) return true;
        else return false;
    }
}

class MyPanel extends JPanel {
    private ArrayList<MySquare> squares=new ArrayList<MySquare>();
    
    private int selected=-1;
    public int getSelected() { return this.selected; }
    
    public MySquare getSelectedSquare() {
        if ((selected>-1)&&(selected<squares.size())) return this.squares.get(selected);
        else return null;
    }
    
    public void removeSelectedSquare(){
        if ((selected>-1)&&(selected<squares.size())) {
            MySquare sq=squares.get(selected);
            squares.remove(selected);
            repaint(sq.getX(),sq.getY(), sq.getWidth()+1, sq.getHeight()+1);

        }        
        selected=-1;        
    }
    
    public MyPanel() {
        setBorder(BorderFactory.createLineBorder(Color.black));
        
        addMouseListener(new MouseAdapter() {
            @Override public void mousePressed(MouseEvent e) {
                boolean wasChanged=false;
                int index=0;
                int index2=0;
                for (int i = 0; i < squares.size(); i++) {
                    if (squares.get(i).inSquare(e.getX(),e.getY())){
                        index=i; index2=selected;
                        if (selected==-1) {
                            squares.get(i).changeColor();
                            selected=i;
                        }
                        else if (selected==i) {
                            squares.get(i).changeColor();
                            selected=-1;
                        }
                        else {
                            squares.get(i).changeColor();
                            squares.get(selected).changeColor();
                            selected=i;
                        }
                        wasChanged=true;                    
                    }   
                }
                if (!wasChanged) {
                    squares.add(new MySquare(e.getX(),e.getY(),20,20));
                    index=squares.size()-1;
                }
                MySquare sq=squares.get(index);
                repaint(sq.getX(),sq.getY(), sq.getWidth()+1, sq.getHeight()+1);
                if ((index2>-1)&&(index2<=squares.size()-1)){
                    sq=squares.get(index2);
                    repaint(sq.getX(),sq.getY(), sq.getWidth()+1, sq.getHeight()+1);
                }
            }    
        });        
        
  }

    @Override public Dimension getPreferredSize() {
        return new Dimension(250,200);
    }

    @Override public void paintComponent(Graphics g) {
        super.paintComponent(g);       
        
        for (int i = 0; i < squares.size(); i++) {
            MySquare sq=squares.get(i);
            sq.paintSquare(g);
        }
    }  
}

Cvičenia 20

• Urobte v hlavnom okne 10 gombíkov, z ktorých každý bude vypisovať svoje číslo. Skúste urobiť v rôznych layoutoch (napr. null, Border, Box, Flow, Grid) aby ste videli, ako sa gombíky umiestňujú.
  • Vyskúšajte úlohu aj všeobecne (t.j. bez použitia 10 konkrétnych premenných typu JButton).

• Vytvorte aplikáciu, v ktorej zadáte do textového poľa uhol v stupňoch a vypíše do vedľajšieho textového poľa hodnotu v radiánoch. Vyskúšajte si rovnakú úlohu aj so zadávaním hodnoty do dialógového okna a s odpoveďou v dialógovom okne.

• Vytvorte v hlavnom okne JList, do ktorého budete po stlačení gombíka Add pridávať postupne čísla počínajúc od 0 a po stlačení gombíka Delete vybrané číslo zmaže.

• Vytvorte v hlavnom okne gombík Add a ScrollPane, na ktorom bude Panel s BoxLayoutom. Na tento po každom stlačení Add pribudne ďalší gombík.

DÚ16

max. 20 bodov, termín odovzdania štvrtok 26.4. o 22:00.

Cieľom tejto úlohy je precvičiť si tvorbu GUI a prácu so SWINGom.

Úlohou je vytvoriť grafické prostredie pre vytváranie a manipuláciu s mnohouholníkmi.

Popis prostredia

V úvodnom okne bude menu, grafický panel, zoznam vrcholov a štyri gombíky ako je na obrázku.

• V grafickom okne budeme zobrazovať mnohouholník (vrcholy aj úsečky medzi nimi).

• Zoznam vrcholov obsahuje súradnice jednotlivých vrcholov mnohouholníka. Vybraný vrchol zo zoznamu (ak taký je) bude mať inú farbu ako zvyšné vrcholy.
  • Vybrať vrchol možno aj klinutím naň v grafickej ploche.
  • Pomocou tlačítok HORE(^) a DOLE(v) je možné meniť poradie vrcholov mnohouholníka - vybraný vrchol sa v zozname posunie vyššie alebo nižšie, čo ovplyvní aj následné vykreslenie strán mnohouholníka.

• Tlačidlo DELETE vybraný vrchol zo zoznamu aj z mnohouholníka zruší.

• Tlačidlo INSERT otvorí dialog, ktorý umožní zadať súradnice nového (posledného v poradí) vrcholu.
  • Okrem toho je možné vrchol (posledný) pridať aj pomocou myši - kliknutím na plochu. Vrchol sa pridá na mieste, kde sme klikli.

• Menu má položky New, Open, Save a Exit.
  • New otvorí dialógové okno a umožní vybrať N (0..12) a vytvorí v grafickom paneli pravidelný N-uholník.
  • Open otvorí súbor mnohouholnik.txt, v ktorom sú súradnice vrcholov nejakého mnohouholníka. Tento zobrazíme v okne a vypíšeme do zoznamu.
    • Vstupný súbor má na začiatku N (počet vrcholov mnohouholníka) a na každom ďalšom riadku dvojicu súradníc vrchola.
  • Save uloží do súboru mnohouholnik.txt aktuálne vytvorený mnohouholník.
  • Exit ukončí program.

Podmienky

Program si musí vedieť poradiť aj s nesprávnymi vstupmi od používateľa (alebo zabezpečiť, aby nenastali).

• Príkladmi takýchto potenciálnych problémov môžu byť napríklad:
  • Pokus o vytvorenie vrchola na divných súradniciach
  • Vybratie prvého vrchola a jeho posun hore (alebo naopak posledného dolu)
  • Zmazanie bez vybraného vrcholu
  • Zlý formát vstupného súboru
  • A iné...

Odovzdávanie

• Odovzdávajte jeden .zip súbor obsahujúci adresár gui a v ňom všetky zdrojové súbory (*.java) vášho balíčka.

Prednáška 34

Dve témy na dnes:

• Objektovo-orientované programovanie v C++ (nebudeme skúšať, ale môže sa zísť v budúcnosti)
• Ilustračný príklad: použitie triedenia, spracovanie intervalov (môže sa vyskytnúť v Jave na rozcvičke alebo teste)

Dva príklady na prácu s intervalmi

Máme danú množinu intervalov [a1,b1],[a2,b2],...

• Môžu predstavovať napríklad nejaké udalosti v kalendári (prednášky, rozpis služieb,...)
• Napríklad {[2,4],[1,3],[6,7],[5,8]}

Jednoduchá úloha: Pretínajú sa nejaké dva intervaly v množine?

• Kedy sa pretínajú intervaly [a,b] a [c,d]?

Jednoduchý algoritmus:

• porovnáme každé dva intervaly
• zložitosť O(n^2)

Rýchlejší algoritmus:

• utriedime intervaly podľa začiatku {[1,3],[2,4],[5,8],[6,7]}
• porovnávame len susedné dvojice
• ak sa žiadne nepretínajú, nepretínajú sa ani žiadne iné

Časová zložitosť:

• Triedenie O(n log n), napr. MergeSort
• Prechod poľom O(n)
• Spolu O(n log n)

Triedenie nám často umožní spraviť rýchlejší alebo jednoduchší algoritmus

Výpočet dĺžky zjednotenia intervalov

• Chceme zrátať dĺžku zjednotenia množiny
  • Napr, koľko hodín do týždňa prebiehajú na matfyze prednášky
• Príklad:
  • množina intervalov {[2,4],[1,3],[6,7],[5,8]}
  • zjednotenie intervalov {[1,4],[5,8]}
  • dĺžka zjednotenia 6 (dva disjunktné intervaly dĺžky 3)

Ako na to:

• Utriedime intervaly podľa začiatku: {[1,3],[2,4],[5,8],[6,7]}
• Prechádzame zoznam intervalov a pamätáme si aktuálny interval zo zjednotenia [a,b]
• Ak sa práve prezeraný interval [c,d] zo vstupu pretína s intervalom [a,b], pridáme ho k nemu, t.j. do [a,b] uložíme zjednotenie [a,b] a [c,d]
• Ak sa nepretínajú, znamená to, že b<c, a teda ani žiadny ďalší interval zo vstupu sa nebude s [a,b] pretínať
  • Dĺžku [a,b] teda pridáme k doteraz spočítanej dĺžke a do [a,b] priradíme [c,d]
• Zložitosť opäť O(n log n)

Implementácia v C++

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

/** Trieda reprezentujuca uzavrety interval s celociselnymi
 * suradnicami oboch koncov. */
class Interval {
public:
    /** Konstruktor so zadanymi suradnicami zaciatku a konca */
    Interval(int newStart, int newEnd);

    /** Vrati lavy koniec intervalu */
    int getStart() const;

    /** Vrati pravy koniec intervalu */
    int getEnd() const;

    /** Vrati dlzku intervalu */
    int length() const;

    /** Porovna intervaly najprv podla laveho konca,
     * pri rovnosti podla praveho. */
    bool operator <(const Interval &other) const;

    /** Spocita najmensi interval obsahujuci zadane dva intervaly */
    Interval operator +(const Interval &other) const;

private:
    int start;
    int end;
};

Interval::Interval(int newStart, int newEnd)
: start(newStart), end(newEnd) {
}

int Interval::getStart() const {
    return start;
}

int Interval::getEnd() const {
    return end;
}

int Interval::length() const {
    return end - start;
}

bool Interval::operator<(const Interval& other) const {
    return start < other.start || (start == other.start && end < other.end);
}

Interval Interval::operator +(const Interval& other) const {
    return Interval(min(start, other.start), max(end, other.end));
}

/** Pre vektor intervalov utriedenych podla zaciatku
 * spocita dlzku pokrytu ich zjednotenim. */
int unionLength(const vector <Interval> &a) {
    if (a.empty()) {
        return 0;
    }

    int length = 0;       // doteraz namerana dlzka 
    Interval cur = a[0];  // aktualny interval zo zjednotenia
    for (int i = 1; i < (int) a.size(); i++) {
        if (a[i].getStart() > cur.getEnd()) {  // cur a a[i] sa nepretinaju
            length += cur.length();  
            cur = a[i];           
        } else {       // cur a a[i] sa pretinaju
            cur = cur + a[i];  // do cur dame zjednenie s a[i]
        }
    }
    length += cur.length();
    return length;
}

int main() {
    vector <Interval> a;
    Interval i1(2, 4), i2(1, 3);
    Interval *pi = new Interval(6, 7);
    a.push_back(i1);
    a.push_back(i2);
    a.push_back(*pi);
    a.push_back(Interval(5, 8));
    sort(a.begin(), a.end());

    cout << unionLength(a) << endl;
}

Základy OOP v C++

Viac informácií nájdete napríklad v týchto dvoch tutoriáloch:

• http://pages.cs.wisc.edu/~hasti/cs368/CppTutorial/
• http://www.horstmann.com/ccj2/ccjapp3.html
• Základy použitia STL knižnice (generické triedy) pozri #Prednáška 25

Niektoré rozdiely medzi triedami v Jave a C++:

• V C++ oddeľujeme deklaráciu triedy (premenné a hlavičky metód) od implementácie metód
  • Implementáciu niektorých veľmi krátkych metód môžeme dať priamo do deklarácie
• V dlhšom programe dáme deklaráciu napr. do súboru Interval.h a implementácie metód do súboru Interval.cpp
  • Ak chceme používať intervaly, dáme do hlavičky #include "Interval.h"
  • Na rozdiel od Javy pomenovanie súborov nemusí sedieť s menani tried
• Deklarácia triedy rozdelená na časti public, private, protected, za deklaráciou bodkočiarka
• Pri implementácii musíme pred názov dať meno triedy napr. Interval::length
• Štruktúra struct je skoro to isté ako trieda, iba default prístup je public

Konštruktor

• premenné objektu môžeme inicializovať pred začiatkom tela konštruktora

Interval::Interval(int newStart, int newEnd)
: start(newStart), end(newEnd) {
}

• môžeme to však spraviť aj obyčajnými priradeniami

Interval::Interval(int newStart, int newEnd) {
  start = newStart;
  end = newEnd;
}

• prvý spôsob vhodný ak premenná je objekt - do zátvorky dáme parametre konštruktora

class SomeClass {
  Interval myInterval;
  SomeClass(int start, int end);
  ...
}; 

SomeClass::SomeClass(int start, int end) 
  : myInterval(start, end) {
}

• použitie konštruktora:
  • inicializácia lokálnej premennej i1: Interval i1(2, 4)
  • vytvorenie nového objektu pomocou new: Interval *pi = new Interval(2, 4);
  • vytvorenie anonymnej dočasnej premennej, ktorá sa inicializuje a nakopíruje do vektora: a.push_back(Interval(5, 8));

Preťaženie operátorov

• Väčšinu operátorov, ktoré majú aspoň jeden operand objekt, môžeme preťažiť, teda vymyslieť im vlastný význam
• V našom príklade preťažujeme < (využije sa pri triedení) a + (vytvára najmenší interval pokrývajúci oba operandy)
• Viac #Prednáška 25

Const

• Niektoré metódy sú označené ako const, čo znamená, že nemenia objekt
• Naopak parametre metód môžu byť const referencie
  • Nemusia sa kopírovať ale máme zaručené, že nebudú zmenené

bool Interval::operator<(const Interval& other) const {
    return start < other.start || (start == other.start && end < other.end);
}

Aritmetický strom v C++

• verzia v Jave, pozri #Prednáška 28

class Node {
public: 
    virtual int evaluate() const = 0; // abstraktna metoda
    virtual void print() const = 0;  // abstraktna metoda
    virtual ~Node() { }  // destruktor s prazdnym telom
};

class BinaryNode : public Node {
public :
    BinaryNode(Node *newLeft, Node *newRight);
    virtual ~BinaryNode();
protected:
    Node *left, *right;
};

BinaryNode::BinaryNode(Node *newLeft, Node *newRight)
 : left(newLeft), right(newRight) {
}

BinaryNode::~BinaryNode() {
    delete left;
    delete right;
}

class ConstantNode : public Node {
public :
    ConstantNode(int newValue);
    virtual int evaluate() const;
    virtual void print() const;
private:
    int value;
};

ConstantNode::ConstantNode(int newValue)
    : Node(), value(newValue) {
}

int ConstantNode::evaluate() const {
    return value;
}

void ConstantNode::print() const {
    cout << value;
}

class PlusNode : public BinaryNode {
public:
    PlusNode(Node *newLeft, Node *newRight);
    virtual int evaluate() const;
    virtual void print() const;
};

PlusNode::PlusNode(Node* newLeft, Node* newRight)
: BinaryNode(newLeft, newRight) {
}

int PlusNode::evaluate() const {
    return left->evaluate()+right->evaluate();
}

void PlusNode::print() const {
    cout << "(";
    left->print();
    cout << "+";
    right->print();
    cout << ")";
}

void treeTest() {
    Node * tree = new PlusNode(new PlusNode(new ConstantNode(2), new ConstantNode(1)),
            new ConstantNode(5));
    tree->print();
    cout << endl << tree->evaluate() << endl;
    delete tree;
}

OOP v C++ (pokračovanie)

Dedenie

• BinaryNode je podtriedou Node:

class BinaryNode : public Node {
public :
    BinaryNode(Node *newLeft, Node *newRight);
    virtual ~BinaryNode();
protected:
    Node *left, *right;
};

• V hornej časti konštruktora môžeme zavolať konštruktor nadtriedy:

PlusNode::PlusNode(Node* newLeft, Node* newRight)
: BinaryNode(newLeft, newRight) {
}

• Pozor, ak chceme, aby sa metódy správali polymorfne, musia byť deklarované ako virtual
• Abstraktné metódy sa píšu takto: virtual int evaluate() const = 0;

Deštruktor

• Špeciálna metóda, opak konštruktora
  • spúšťa sa automaticky pri zániku objektu (keď na objekt spustíme delete alebo ak objekt v lokálnej premennej a funkcia končí)
  • zvyčajne sa používa na odalokovanie pamäte, prípadne ďalšie upratovanie
  • deštruktory sú často virtuálne
  • po skončení deštruktora sa zavolá deštruktor nadtriedy

BinaryNode::~BinaryNode() {
    delete left;  // rekurzivne zavolá deštruktor na ľavý podstrom
    delete right;
}

Uloženie v pamäti

V Jave:

• každá premenná buď primitívny typ alebo referencia na objekt/pole
• všetky objekty alokované cez new
• odalokované automaticky
• do premennej typu nejaká trieda môžeme priradiť aj referenciu na objekt z podtriedy

V C++:

• premenná môže priamo obsahovať objekt, alebo referenciu na objekt alebo smerník
• naopak smerník môže ukazovať aj na primitívny typ,
• objekty alokované cez new treba zmazať
• do premennej typu nejaká trieda sa objekty kopírujú
  • môžeme predefinovať operátor priradenia a copy konštruktor, aby fungovali ako treba
  • nemôžeme priradiť objekt podtriedy, lebo by sa nemusel zmestiť
• smerníky fungujú podobne ako referencie v Jave, použijeme ak chceme využiť polymorfizmus

Ešte jedna úloha s intervalmi

Daná množina intervalov, nájdite bod, ktorý je pokrytý najväčším počtom intervalov

• napr. interval predstavuje čas, keď má niekto voľno, hľadáme vhodný čas na stretnutie

Prednáška 35

Organizačné poznámky

• Budúci týždeň cviká v utorok, streda dekanské voľno (študentská vedecká konferencia), termín DÚ16 (posunutý na štvrtok), zadanie DÚ17
• Týždeň 30.4.-6.5. utorok sviatok, cviká + prednáška v stredu
• Týždeň 7.-13.5. utorok sa presúva na piatok, termín DÚ17, prihlásenie sa na projekt
• Týždeň 14.-20.5. posledný týždeň semestra
• Týždeň 21.-27.5. riadny termín písomky, odovzdávanie nepovinných projektov

Študentská vedecká konferencia

• Študenti prezentujú výsledky svojho výskumu
• Hlavne bakalárske práce a diplomovky, prípadne doktorandi, ale aj na iné projekty
• Na konferencii resp. na posteroch zistíte, čo robia školitelia, môže Vám to pomôcť nájsť si školiteľa bakalárky, príp. aj ročníkového projektu

Úvod

• Zvyšok semestra sa budeme venovať práci s grafmi
• Grafy poznáte z predmetu Úvod do kombinatoriky a teórie grafov
• Ďalšie algoritmy pre grafy v treťom ročníku na predmete Tvorba efektívnych algoritmov
• Ďalšia teória grafov + nejaké algoritmy povinne voliteľný predmet pre tretí ročník Teória grafov

Príklady využitia grafov

• Mapa, cestná sieť: vrcholy sú križovatky, mestá, obce, hrany sú cesty (podobne železnice, letecká sieť, ulice v rámci mesta ...)
• Počítačové siete, elektrické obvody, siete potrubí
• Web: vrcholy sú webstránky, hrany sú odkazy (podobne napríklad vedecké články a citácie medzi nimi)
• Sociálne siete: vzťahy, kontakty medzi ľudmi, šírenie správ
• Závislosti medzi činnosťami: ak máme vykonať niekoľko činností, ale niektoré sa dajú vykonať iba ak sú iné už hotové, ako ich usporiadať
• Preferencie: napr. pri tvorbe rozvrhu sa určitý predmet môže konať len v určité časy, môžeme spájať hranou predmety a časy

Anglická terminológia:

• graf = graph, vrchol = vertex (mn.č. vertices), hrana = edge

Reprezentácia grafov

Na dnešnej prednáške budeme uvažovať neorientovaný graf s vrcholmi očíslovanými 0,1,...,n-1.

• Príklad: V={0,...,6}, E={{0,5},{1,2},{2,3},{1,3},{3,4}}

Do akých dátových štruktúr takýto graf uložíme?

• V našom prípade množinu hrán reprezentujeme jednoduchom počtom vrcholov n, zostáva uložiť hrany

Zoznam hrán

• Najjednoduchšia reprezentácia je ako zoznam hrán
• Vytvoríme si pomocnú triedu pre hranu, ktorá obsahuje čísla jej koncových vrcholov
• Všetky hrany uložíme do poľa alebo spájaného zoznamu (ArrayList, LinkedList)

(0,5), (1,2), (2,3), (1,3), (3,4)

Matica susednosti (adjacency matrix)

• Matica nxn napr typu boolean
• Políčko a[i][j]=true ak {i,j} je hrana
• Pre neorientovaný graf symetrická matica

   0 1 2 3 4 5 6
0  F F F F F T F
1  F F T T F F F
2  F T F T F F F
3  F T T F T F F
4  F F F T F F F
5  T F F F F F F
6  F F F F F F F

Zoznamy susedov (adjacency lists)

• Pre každý vrchol zoznam jeho susedov
• Uložíme ako pole potrebnej veľkosti alebo spájaný zoznam (ArrayList, LinkedList)

0: 5
1: 2,3
2: 1,3
3: 1,2,4
4: 3
5: 0
6:

Graf ako abstraktný dátový typ: Interface Graph

• Ukážeme si konkrétne implementácie pre maticu a zoznamy susedov, potrebujeme však vedieť, aké operácie by mal graf poskytovať.
• To je príklad jednoduchého interface-u pre graf, do ktorého vieme pridávať hrany, testovať či hrana existuje a prechádzať cez susedov určitého vrcholu

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

Príklad použitia: vypísanie grafu v poradí počet vrcholov, počet hrán a potom zoznam hrán, každá daná koncovými vrcholmi:

    /** Graph g vvypíše do výstupného streamu */
    static void printGraph(Graph g, PrintStream out) {
        int n = g.numVertices();
        out.println(n + " " + g.numEdges());
        for (int u = 0; u < n; u++) {
            Iterator<Integer> it = g.adjIterator(u);
            while (it.hasNext()) {
                int v = it.next();
                if (u < v) {
                    out.println(u + " " + v);
                }
            }
        }
    }

Napr. pre graf vyššie

7 5
0 5
1 2
1 3
2 3
3 4

Implementácia pomocou zoznamov susedov: Trieda AdjListsGraph

• Pre každý vrchol si udržiavame zoznam susedných vrcholov v ArrayListe
• Ako iterátor cez susedov použijeme jednoducho iterátor z ArrayListu

/** Trieda reprezentujúca neorientovaný graf pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class AdjListsGraph implements Graph {

    /** Zoznam susedov pre každý vrchol */
    private ArrayList<ArrayList<Integer>> adjLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjListsGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Integer>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Integer>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        adjLists.get(from).add(to); // pridaj hranu v oboch smeroch
        adjLists.get(to).add(from);
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return adjLists.get(from).contains(to); // pozri do zoznamu susedov pre from
    }

    public Iterator<Integer> adjIterator(int vertex) {
        return adjLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }
}

Implementácia pomocou matice susednosti: Trieda AdjMatrixGraph

• V konštruktore vyrobíme maticu vyplnenú false
• O niečo zložitejší iterátor
  • Dal by sa spraviť aj vlastnou triedou bez použitia pomocného poľa

/** Trieda reprezentujúca neorientovaný graf pomocou matice susednosti. */
class AdjMatrixGraph implements Graph {

    /** Matica susednosti */
    private boolean[][] matrix;
    /** Počet hrán grafu */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjMatrixGraph(int numVertices) {
        matrix = new boolean[numVertices][numVertices];
        for (int i = 0; i < numVertices; i++) {
            for (int j = 0; j < numVertices; j++) {
                matrix[i][j] = false;
            }
        }
        numEdges = 0;
    }

    public int numVertices() {
        return matrix.length;
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        if (existsEdge(from, to)) { // nepridava existujuce hrany
            return false;
        }
        matrix[from][to] = true;  //prida hranu v oboch smeroch
        matrix[to][from] = true;
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return matrix[from][to];
    }

    public Iterator<Integer> adjIterator(int vertex) {
        // vytvori pomocne pole a,
        // vlozi do neho vsetkych susedov a vrati jeho iterator
        ArrayList<Integer> a = new ArrayList<Integer>();
        for (int i = 0; i < matrix[vertex].length; i++) {
            if (matrix[vertex][i]) {
                a.add(i);
            }
        }
        return a.iterator();
    }
}

Vytvorenie grafu

• Vytvoríme prázdny graf s určitým počtom vrcholov, po jednom pridávame hrany

/** Zo scannera s načíta graf vo formáte: počet vrcholov,
     * počet hrán a zoznam hrán zadaných koncami vrcholov.
     * Ak je matrix true, uloží ho ako AdjMatrixGraph,
     * inak ako AdjListsGraph. */
    static Graph readGraph(Scanner s, boolean matrix) {
        int n = s.nextInt();
        int m = s.nextInt();
        Graph g;
        if (matrix) {
            g = new AdjMatrixGraph(n);
        } else {
            g = new AdjListsGraph(n);
        }
        for (int i = 0; i < m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            g.addEdge(u, v);
        }
        return g;
    }

Porovnanie reprezentácií

• Majme graf s n vrcholmi a m hranami
• Počet hrán m môže byť od 0 po n(n-1)/2
• Vyjadríme čas rôznych operácií v O-notácii:
  • O(1): robíme len konštantný počet operácií bez ohľadu na veľkosť grafu
  • O(n): čas operácie rastie v najhoršom prípade lineárne s počtom vrcholov grafu
  • O(m): čas operácie rastie v najhoršom prípade lineárne s počtom hrán grafu
  • Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} : čas operácie rastie v najhoršom prípade kvadraticky s počtom vrcholov grafu
• Väčšinou máme viac hrán ako vrcholov, takže O(1) je lepšie ako O(n), to je lepšie ako O(m) a to je lepšie Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}

	Zoznam hrán	Matica susednosti	Zoznamy susedov
Pamäť	O(m)	Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}	O(n+m)
Vytvoriť graf bez hrán	O(1)	Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}	O(n)
addEdge	O(1)	O(1)	O(1)
existsEdge	O(m)	O(1)	O(n)
Prejdenie susedov vrchola	O(m)	O(n)	O(stupeň)
Výpis grafu pomocou adjIterator	O(nm)	Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}	O(n+m)

• Matica susednosti
  • Rýchla operácia existsEdge
  • Ak je graf riedky (málo hrán), zaberá zbytočne veľa pamäte a dlho trvá prejdenie susedov vrchola
• Zoznamy susednosti
  • Vhodný aj pre riedke grafy
  • Dlho trvá nájdenie konkrétnej hrany, ale všetkých susedov vrchola vieme prejsť rýchlo
  • Najvhodnejšia reprezentácia na väčšinu algoritmov, ktoré uvidíme

Poznámky a obmeny

Orientované grafy

• Ak v metóde addEdge pridáme hranu iba jedným smerom, dostaneme orientovaný graf
• adjIterator vráti iterátor cez vychádzajúce hrany

Grafy s násobnými hranami

• AdjMatrixGraph nepovoľuje násobné hrany
  • Ak chceme prirobiť, museli by sme v matici mať int-y vyjadrujúce násobnosť hrany
• AdjListsGraph nekontroluje násobnosť hrany, dovoľuje opakovanie
  • Kontrola násobnosti by dlho trvala - pri addEdge by sme museli pozrieť, či už v poli nie je

Metóda remove v iterátore

• Iterátor špecifikuje nepovinnú metódu remove na mazanie prvkov
• Ak nie je implementovaná, mala by hádzať výnimku
• V našom prípade sa dá spustiť, ale nerobí to, čo by sme chceli
  • Preto ju nie je vhodné používať
  • Takýto stav však nie je ideálny, ľahko vediet k chybám
• Náprava: adjIterator by mohol vracať našu vlastnú iterátorovú triedu, ktorá remove nedovoľuje (alebo ho robí poriadne)

Ohodnotené grafy

• V grafe si pre jednotlivé vrcholy a hrany môžeme chcieť pamätať ďalšie dáta
• Napr. ak modelujeme cestnú sieť, hrana môže mať určitú dĺžku
• Vrcholy môžu mať mená, súradnice a pod.
• Nabudúce pridáme takéto dáta do implementácie

Dynamické grafy

• Náš graf možno meniť len pridaním hrán
• V grafe môžeme chcieť robiť aj iné zmeny
  • Mazanie hrán by sa ľahko doplnilo, rýchle pre maticu, pomalšie pre zoznamy susedov
  • Pridávanie a mazanie vrcholov ťažšie -- potrebujeme číslovanie 0..n-1
• Neskôr si ukážeme všeobecnejšiu štruktúru, ktorá to umožňuje

Súvislosť grafu, prehľadávanie do hĺbky (depth-first search, DFS)

• Zameriame sa na zisťovanie, či sú dva vrcholy spojené v grafe cestou, t.j. či sú v tom istom komponente súvislosti (v neorientovanom grafe)
• Napr. vrchol 1 je v komponente súvislosti s vrcholmi 2,3,4
• Použijeme prehľadávanie do hĺbky, podobné ako sme použili na vyfarbovanie súvislých oblastí v matici (ostrovy)
  • Mapu ostrovov môžeme zapísať ako graf, pričom každé políčko ostrovu bude vrchol a dve políčka budú spojené hranou, ak spolu susedia
  • Ostrovy sú potom komponenty súvislosti

Existuje cesta z u do v?

• Poďme teda zisťovať, či sú u a v tom istom komponente
• Rekurzívne prehľadávame začínajúc od vrcholu u
• Vytvoríme si pole booleanov visited, v ktorom si značíme už navštívené vrcholy
• Z každého vrcholu rekurzívne prehľadáme zatiaľ nenavštívených susedov

    /** Pomocná metóda pre metódu connected.
     * Dostane graf g, vrchol vertex
     * a pole s poznačenými navštívenými vrcholmi, pričom
     * visited[vertex] by malo byť false.
     * Rekurzívne prehľadá nenavštívené vrcholy, ktoré sa z
     * vrcholu vertex dajú dosiahnuť. */
    static void search(Graph g, int vertex, boolean[] visited) {
        visited[vertex] = true;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (!visited[neighbor]) {                
                search(g, neighbor, visited); // navstivime ho rekurzivne
            }
        }
    }

    /** Metóda, ktorá zistí, či sú vrcholy from a to v grafe g
     * spojené cestou. */
    static boolean connected(Graph g, int from, int to) {
        // vytvor pole visited vyplnené false
        boolean[] visited = new boolean[g.numVertices()];
        for (int i = 0; i < visited.length; i++) {
            visited[i] = false;
        }
        search(g, from, visited); // zavolaj rekurziu
        return visited[to];       // dostali sme sa do vrchola to?
    }

Hľadanie komponentov súvislosti

• Ak by sme chceli testovať spojenie medzi veľa dvojicami vrcholov, oplatí sa nám nájsť komponenty súvislosti v celom grafe naraz.
• Komponenty očísľujeme 0,1,...,k-1. Pre každý vrchol máme v poli číslo jeho komponentu.
• Potom dva vrcholy sú spojené cestou práve vtedy keď majú rovnaké číslo komponentu.
• Toto robí nasledujúca trieda

/** Trieda obsahujuca rozdelenie vrcholov grafu do komponentov suvislosti */
class Components {

    /** Pre kazdy vrchol cislo jeho komponentu 0..pocet komponentov-1 */
    private int[] componentId;
    /** pocet komponentov grafu */
    private int numComponents;
    /** samotny graf */
    private Graph g;

    /** Konstruktor, ktory dostane graf a prehladavanim do hlbky
     * hlada komponenty suvislosti */
    public Components(Graph g) {
        this.g = g;  // uloz graf
        numComponents = 0;  // inicializuj pocet koponentov
        int n = g.numVertices();  // pocet vrcholov grafu
        // vytvor pole cisel koponentov a inicializuj na -1 - nevyfarbene
        componentId = new int[n];
        for (int i = 0; i < n; i++) {
            componentId[i] = -1;
        }
        // prechadzaj cez vrchola a ak najdes nevyfarbeny, spusti prehladavanie
        for (int i = 0; i < n; i++) {
            if (componentId[i] == -1) {
                search(i, numComponents); // vyfarbi cislom numComponents
                numComponents++;          // zvys numComponents
            }
        }
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore na vyfarbenie
     * jedneho komponentu cislom id. */
    private void search(int vertex, int id) {
        componentId[vertex] = id;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (componentId[neighbor] == -1) {
                search(neighbor, id); // navstivime ho rekurzivne
            }
        }
    }

    /** Vrati true ak vrchol from a to su v tom istom koponente */
    public boolean connected(int from, int to) {
        return componentId[from] == componentId[to];
    }

    /** Vrati pocet kponentov grafu */
    public int numComponents() {
        return numComponents;
    }
}

• Čas výpočtu pri použití zoznamov susedov je O(n+m)
• Vedeli by sme triedu obohatiť aj o iterovanie cez vrcholy v jednotlivých komponentoch

Zhrnutie

• Grafy sa používajú na veľa problémov
• Reprezentujeme ich ako zoznamy susedov, prípadne ako maticu susednosti
• V neorientovanom grafe vieme prehľadávaním do hĺbky nájsť komponenty súvislosti
• Ako je to v orientovaných grafoch?
• Celý program (vrátane prehľadávania do šírky z ďalšej prednášky) pozri nižšie

Zdrojový kód programu, grafy

Program k prednáškam: #Prednáška 35 a #Prednáška 36

• dve reprezentácie grafu, prehľadávanie do hĺbky a do šírky

package prog;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

/** Trieda reprezentujúca neorientovaný graf pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class AdjListsGraph implements Graph {

    /** Zoznam susedov pre každý vrchol */
    private ArrayList<ArrayList<Integer>> adjLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjListsGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Integer>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Integer>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        adjLists.get(from).add(to); // pridaj hranu v oboch smeroch
        adjLists.get(to).add(from);
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return adjLists.get(from).contains(to); // pozri do zoznamu susedov pre from
    }

    public Iterator<Integer> adjIterator(int vertex) {
        return adjLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }
}

/** Trieda reprezentujúca neorientovaný graf pomocou matice susednosti. */
class AdjMatrixGraph implements Graph {

    /** Matica susednosti */
    private boolean[][] matrix;
    /** Počet hrán grafu */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjMatrixGraph(int numVertices) {
        matrix = new boolean[numVertices][numVertices];
        for (int i = 0; i < numVertices; i++) {
            for (int j = 0; j < numVertices; j++) {
                matrix[i][j] = false;
            }
        }
        numEdges = 0;
    }

    public int numVertices() {
        return matrix.length;
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        if (existsEdge(from, to)) { // nepridava existujuce hrany
            return false;
        }
        matrix[from][to] = true;  //prida hranu v oboch smeroch
        matrix[to][from] = true;
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return matrix[from][to];
    }

    public Iterator<Integer> adjIterator(int vertex) {
        // vytvori pomocne pole a,
        // vlozi do neho vsetkych susedov a vrati jeho iterator
        ArrayList<Integer> a = new ArrayList<Integer>();
        for (int i = 0; i < matrix[vertex].length; i++) {
            if (matrix[vertex][i]) {
                a.add(i);
            }
        }
        return a.iterator();
    }
}

/** Trieda obsahujuca rozdelenie vrcholov grafu do komponentov suvislosti */
class Components {

    /** Pre kazdy vrchol cislo jeho koponentu 0..pocet komponentov-1 */
    private int[] componentId;
    /** pocet komponentov grafu */
    private int numComponents;
    /** samotny graf */
    private Graph g;

    /** Konstruktor, ktory dostane graf a prehladavanim do hlbky
     * hlada komponenty suvislosti */
    public Components(Graph g) {
        this.g = g;  // uloz graf
        numComponents = 0;  // inicializuj pocet koponentov
        int n = g.numVertices();  // pocet vrcholov grafu
        // vytvor pole cisel koponentov a inicializuj na -1 - nevyfarbene
        componentId = new int[n];
        for (int i = 0; i < n; i++) {
            componentId[i] = -1;
        }
        // prechadzaj cez vrchola a ak najdes nevyfarbeny, spusti prehladavanie
        for (int i = 0; i < n; i++) {
            if (componentId[i] == -1) {
                search(i, numComponents); // vyfarbi cislom numComponents
                numComponents++;          // zvys numComponents
            }
        }
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore na vyfarbenie
     * jedneho komponentu cislom id. */
    private void search(int vertex, int id) {
        componentId[vertex] = id;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (componentId[neighbor] == -1) {
                search(neighbor, id); // navstivime ho rekurzivne
            }
        }
    }

    /** Vrati true ak vrchol from a to su v tom istom koponente */
    public boolean connected(int from, int to) {
        return componentId[from] == componentId[to];
    }

    /** Vrati pocet kponentov grafu */
    public int numComponents() {
        return numComponents;
    }
}

/** Trieda, ktorá reprezentuje najkratšie cesty a vzdialenosti
 * z jedného vrchola do ostatných. */
class ShortestPaths {

    /** Graf, v ktorom ratame cesty */
    private Graph g;
    /** Startovaci vrchol, z ktoreho ratame najkratsie cesty */
    private int start;
    /** Pre kazdy vrchol v grafe vzdialenost od startu
     * alebo -1 ak je v inom komponente. */
    private int[] dist;
    /** Pre kazdy vrchol u predchadzajuci vrchol na ceste zo start do u */
    private int[] prev;

    /** Konstruktor, ktory dostane graf a startovaci vrchol a najde najkratsei cesty */
    public ShortestPaths(Graph g, int start) {
        this.g = g;
        this.start = start;
        int n = g.numVertices();
        // inicializacia poli - vyplnime -1
        dist = new int[n];
        prev = new int[n];
        for (int i = 0; i < n; i++) {
            dist[i] = -1;  
            prev[i] = -1;  
        }

        // prehladavanie do sirky
        // vytvorime rad a vlozime do neho startovaci vrchol
        LinkedList<Integer> queue = new LinkedList<Integer>();
        queue.addLast(start);
        dist[start] = 0;  // sam od seba ma vzdialenost 0

        while (!queue.isEmpty()) {
            // vyberieme prvok na zaciatku radu
            int vertex = queue.removeFirst();
            // prejdeme cez jeho susedov a ak este neboli navstiveni
            // urcime im vzdialenost a pridame ich do radu
            Iterator<Integer> it = g.adjIterator(vertex);
            while (it.hasNext()) {
                int other = it.next();
                if (dist[other] < 0) {
                    dist[other] = dist[vertex] + 1;
                    prev[other] = vertex;
                    queue.addLast(other);
                }
            }
        }
    }

    /** Je vrchol vertex spojeny so startovacim vrcholom? */
    public boolean connected(int vertex) {
        return dist[vertex] >= 0;
    }

    /** Vrati vzdialenost vrcholu vertex od starovacieho vrcholu.
     * Ak su v roznych komponentoch, vrati -1. */
    public int distance(int vertex) {
        return dist[vertex];
    }

    /** Vrati najkratsiu cestu zo startovacieho vrcholu
     * do vrcholu vertex (postupnost vrcholov, cez ktore cesta ide).
     * Ak su v roznych komponentoch, vrati null. */
    public int[] shortestPath(int vertex) {
        if (!connected(vertex)) {  // vybav rozne koponenty
            return null;
        }
        int[] path = new int[dist[vertex] + 1];  // alokujeme cestu
        int v = vertex;   //posledny vrchol bude vertex
        path[dist[vertex]] = v;
        for (int i = dist[vertex] - 1; i >= 0; i--) { // odzadu pridavame vrcholy
            v = prev[v];      // posunieme sa na predchadzajuci vrchol na ceste
            path[i] = v;
        }
        return path;
    }
}

public class Prog {

    /** Zo scannera s načíta graf vo formáte: počet vrcholov,
     * počet hrán a zoznam hrán zadaných koncami vrcholov.
     * Ak je matrix true, uloží ho ako AdjMatrixGraph,
     * inak ako AdjListsGraph. */
    static Graph readGraph(Scanner s, boolean matrix) {
        int n = s.nextInt();
        int m = s.nextInt();
        Graph g;
        if (matrix) {
            g = new AdjMatrixGraph(n);
        } else {
            g = new AdjListsGraph(n);
        }
        for (int i = 0; i < m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            g.addEdge(u, v);
        }
        return g;
    }

    /** Graph g vvypíše do výstupného streamu */
    static void printGraph(Graph g, PrintStream out) {
        int n = g.numVertices();
        out.println(n + " " + g.numEdges());
        for (int u = 0; u < n; u++) {
            Iterator<Integer> it = g.adjIterator(u);
            while (it.hasNext()) {
                int v = it.next();
                if (u < v) {
                    out.println(u + " " + v);
                }
            }
        }
    }

    /** Pomocná metóda pre metódu connected.
     * Dostane graf g, vrchol vertex
     * a pole s poznačenými navštívenými vrcholmi, pričom
     * visited[vertex] by malo byť false.
     * Rekurzívne prehľadá nenavštívené vrcholy, ktoré sa z
     * vrcholu vertex dajú dosiahnuť. */
    static void search(Graph g, int vertex, boolean[] visited) {
        visited[vertex] = true;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (!visited[neighbor]) {
                search(g, neighbor, visited); // navstivime ho rekurzivne
            }
        }
    }

    /** Metóda, ktorá zistí, či sú vrcholy from a to v grafe g
     * spojené cestou. */
    static boolean connected(Graph g, int from, int to) {
        // vytvor pole visited vyplnené false
        boolean[] visited = new boolean[g.numVertices()];
        for (int i = 0; i < visited.length; i++) {
            visited[i] = false;
        }
        search(g, from, visited); // zavolaj rekurziu
        return visited[to];       // dostali sme sa do vrchola to?
    }

    public static void main(String[] args) throws FileNotFoundException {
        Scanner s;
        Graph g;
        PrintStream out;

        // nacitame graph ako maticu susedov a vypiseme
        s = new Scanner(new File("graph-in.txt"));
        g = readGraph(s, true);
        s.close();
        out = new PrintStream("graph-out1.txt");
        printGraph(g, out);
        out.close();

        // nacitame graf ako zoznamy susedov a vypiseme
        s = new Scanner(new File("graph-in.txt"));
        g = readGraph(s, false);
        s.close();
        out = new PrintStream("graph-out2.txt");
        printGraph(g, out);
        out.close();

        // ratame pre dvojice vrcholov ci su spojene jednorazovou funkciou
        System.out.println("Are 1 and 4 connected? " + connected(g, 1, 4));
        System.out.println("Are 0 and 1 connected? " + connected(g, 0, 1));

        // predpocitame komponenty, potom zistime ich pocet a testujeme spojitost
        Components comp = new Components(g);
        System.out.println("The number ofconnected components: " + comp.numComponents());
        System.out.println("Are 1 and 4 connected? " + comp.connected(1, 4));
        System.out.println("Are 0 and 1 connected? " + comp.connected(0, 1));

        // najdeme najkratsie vzdialenosti z 1 do ostatnych vrcholov
        ShortestPaths paths = new ShortestPaths(g, 1);
        System.out.println("Are 1 and 4 connected? " + paths.connected(4));
        System.out.println("Distance of 1 and 4: " + paths.distance(4));
        System.out.println("Shortest path from 1 to 4: " + Arrays.toString(paths.shortestPath(4)));
    }
}

Cvičenia 21

Na týchto cvičeniach sa vrátime k stromom a rekurzii, ale pripomenieme si aj Collections a výnimky. Nižšie nájdete triedu Node reprezentujúcu vrchol binárneho stromu, ktorý obsahuje okrem referencií na ľavý a pravý podstrom aj dátovú premennú typu int. Všimnite si, že po vytvorení vrchola už ho nie je možné existujúcimi metódami meniť.

Úloha 1

Napíšte metódu static Node generate(int n), ktorá vygeneruje najväčší možný strom s týmito vlastnosťami:

• V koreni má uložené číslo 0.
• Ak má nejaký vrchol ľavého syna, v tomto synovi je uložené číslo 1.
• Ak má nejaký vrchol pravého syna, v tomto synovi je uložené číslo 2.
• Súčet čísel vo vrcholoch na každej ceste z koreňa do niektorého listu je n.

Jednotlivé cesty z koreňa do listov teda zodpovedajú všetkým spôsobom, ako zapísať číslo n ako súčet jednotiek a dvojok, pričom záleží na poradí. Napr. pre n=2 bude strom vyzerať takto:

    0
   / \
  1   2
 /
1

Návod: použite rekurziu, možno budete potrebovať pomocnú rekurzívnu metódu s ďalšími parametrami.

Úloha 2

Napíšte triedu PreorderTreeIterator, ktorá bude implementovať interface Iterator<Node>. Metóda remove vyhodí výnimku typu UnsupportedOperationException. Metóda next by mala postupne vracať všetky vrcholy stromu v prefixovom poradí a metóda hasNext by mala testovať, či je ešte nejaký nenavštívený vrchol. Konštruktor triedy dostane koreň stromu.

Návod: V iterátore si vytvorte zásobník vrcholov, ktoré ešte treba spracovať. Použite na to generickú triedu LinkedList, ktorá má metódy push a pop.

Overte, že nasledujúci kód vypíše to isté ako volanie metódy tree.outPrefix():

PreorderTreeIterator it = new PreorderTreeIterator(tree);
while (it.hasNext()) {
    System.out.print(" " + it.next().getData());
} 

Úloha 3

Aj keď trieda Node reprezentuje vrchol stromu, nie je zaručené, že ide skutočne o strom. Napríklad nasledujúcimi dvoma príkazmi môžeme spraviť strom t1, v ktorom je vrchol t0 použitý dvakrát, ako ľavé aj pravé dieťa t1:

Node t0 = new Node(0, null, null);
Node t1 = new Node(1, t0, t0);

Napíšte metódu static boolean uniqueNodes(Node tree), ktorá vráti true, ak v danom strome nie je žiaden vrchol použitý viackrát.

Návod: prejdite strom (rekurzívne alebo iterátorom) a ukladajte si navštívené vrcholy napr. do HashSet. Nakoľko sme v triede Node nepreťažili metódu hashCode, vrcholy budú porovnávané len podľa adresy v pamäti, čo je v tomto prípade žiadané správanie.

Úloha 4

Zmeňte triedu Node tak, aby nebolo možné jeden vrchol použiť ako dieťa viacerých vrcholov, čím sa zabráni prípadom ako v predchádzajúcej úlohe. Pri volaní konštruktoru, ktoré by k takejto situácii viedlo, konštruktor vyhodí výnimku.

Návod: vrchol si pamätá svojho otca, na vhodných miestach sa táto informácia kontroluje a mení.

Trieda Node

class Node {

    private int data;
    private Node left, right;

    public Node(int data_, Node left_, Node right_) {
        data = data_;
        left = left_;
        right = right_;
    }

    public int getData() {
        return data;
    }

    public Node getLeft() {
        return left;
    }

    public Node getRight() {
        return right;
    }

    /** Vypise v prefixovom poradi */
    public void outPrefix() {
        if (this != null) {
            System.out.print(" " + data);
            if (this.left != null) {
                left.outPrefix();
            }
            if (this.right != null) {
                right.outPrefix();
            }
        }
    }
}

Cvičenia 22

• Nižšie je verzia prehľadávania do hĺbky, ktorá do poľa whenVisited čísluje vrcholy v poradí, v akom boli navštívené. Odsimulujte algoritmus na grafe nakreslenom vpravo a zistite, v akom poradí budú vrcholy navštívené, ak začneme prehľadávať vo vrchole 0. Predpokladajte, že adjIterator vracia susedov v poradí podľa čísla vrcholu.

• Do reprezentácie grafu pomocou zoznamov susedov z prednášky pridajte metódu addVertex, ktorá pridá do grafu nový vrchol.

• Máme danú šachovnicu n x m, na ktorej sú niektoré políčka obsadené figúrkami. Na políčku (i,j) stojí kôň. Na ktoré políčka šachovnice vie preskákať, pričom môže použiť aj viacero ťahov, ale môže chodiť iba po prázdnych políčkach?
  • Použite prehľadávanie do hĺbky na grafe, v ktorom sú vrcholy jednotlivé políčka a hrany spájajú dvojice voľných políčok, medzi ktorými môže kôň skočiť. Môžete vytvoriť graf v niektorej reprezentácii, alebo to riešiť priamo v matici visited n x m.
  • Šachový kôň môže z pozície (i,j) skočiť na jednu z pozícií (i+2,j+1), (i+2,j-1), (i-2,j+1), (i-2,j-1), (i+1,j+2), (i+1,j-2), (i-1,j+2), (i-1,j-2)

• Reprezentáciu grafu pomocou matice susednosti z prednášky zmeňte tak, aby adjIterator vrátil objekt vašej vlastnej triedy implementujúcej Iterator<Integer>. Tento objekt by si pamätal iba číslo vrchola, cez ktorého susedov iterujeme a pozíciu v príslušnom riadku matice susednosti. Pri každom volaní next hľadá ďalšiu hodnotu true v tomto riadku. Iterátoru tiež správne implementujte metódu remove, aby mazala hranu (obidve jej kópie).

Prehľadávanie s číslovaním pre prvý príklad

/** Trieda obsahujuca prehladavanie do hlbky s cislovanim vrcholov */
class Search {

    /** Pre kazdy vrchol poradove cislo kedy bol navstiveny */
    private int[] whenVisited;
    /** Pocet navstivenych vrcholov */
    private int numVisited;
   /** samotny graf */
    private Graph g;

    /** Konstruktor, ktory dostane graf a prehladava do hlbky 
     * so zaciatkom vo vrchole start */
    public Search(Graph g, int start) {
        this.g = g;      // uloz graf
        numVisited = 0;  // inicializuj pocet navstivenych vrcholov
        int n = g.numVertices();  // pocet vrcholov grafu
        whenVisited = new int[n]; // vytvor a inicializuj pole
        for (int i = 0; i < n; i++) {
            whenVisited[i] = -1;
        }
	search(start); // prehladavaj rekurzive
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore 
     * na rekurzivne prehladavanie. */
    private void search(int vertex) {
        whenVisited[vertex] = numVisited;
        numVisited++;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (whenVisited[neighbor] == -1) {
                search(neighbor); // navstivime ho rekurzivne
            }
        }
    }

    @Override    
    public String toString() {
	String res = "";
	for(int i=0; i<g.numVertices(); i++) {
	    res = res + i + ": " + whenVisited[i] + "\n";
	}
	return res;
    }
}

DÚ17

max. 10 bodov, termín odovzdania štvrtok 10.5. o 22:00.

Cieľom tejto domácej úlohy je precvičiť si prácu s grafmi a prehľadávaním do hĺbky.

Vrátime sa k červíkovi, ktorého sme stretli v domácej úlohe 7 v minulom semestri. Tentokrát ale budeme uvažovať hraciu plochu, v ktorej sú iba prázdne políčka a prekážky (teda žiadne jedlo) a navyše červík má vždy dĺžku presne 2. Poloha červíka je teda daná súradnicami jeho hlavy a smerom (hore, dole, vľavo, vpravo), v ktorom sa nachádza chvost vzhľadom na hlavu. V každom ťahu sa červík môže hlavou posunúť na jedno zo susedných voľných políčok (teda takých, kde nie je prekážka ani chvost) a chvost sa posunie na to políčko, kde bola hlava.

Úlohou je zistiť, či sa červík vie dostať z jednej zadanej polohy do druhej. Váš program by mal načítať vstup zo súboru vstup.txt. Na prvom riadku súboru sú dve čísla udávajúce počet riadkov a počet stĺpcov hracej plochy. Nasleduje samotná plocha, pričom bodka znamená prázdne políčko a X znamená prekážku. V posledných dvoch riadkoch súboru je potom zadaná počiatočná a cieľová poloha červíka. Obidve polohy sú zadané ako štyri čísla udávajúce riadok a stĺpec hlavy a riadok a stĺpec chvosta (riadky a stĺpce číslujeme od nuly). Môžete predpokladať, že obidve polohy sú platné, t.j. hlava aj chvost sú na susedných prázdnych políčkach hracej plochy. Môžete tiež predpokladať, že na kraji hracej plochy sú všade prekážky.

Tu je príklad vstupného súboru:

3 6
XXXXXX
X....X
XXXXXX
1 2 1 1
1 1 1 2

V tomto príklade sa pýtame, či sa červík vie otočiť, t.j. vymeniť polohu hlavy a chvosta. Nakoľko však stojí v úzkej uličke, nie je to možné.

Váš program by mal na konzolu vypísať dve hodnoty, každú do zvláštneho riadku: boolean (true alebo false) vyjadrujúci, či sa červík vie dostať do cieľovej polohy a počet polôh, do ktorých sa červík vie dostať z počiatočnej polohy (vrátane počiatočnej polohy samotnej). Pre príklad na vstupe by teda mal vypísať

false
3

lebo jediné, čo červík vie spraviť, je posúvať sa doprava a môže sa posunúť najviac dvakrát.

Ešte jeden príklad pridaný 1.5.2012: Pre vstup

4 8
XXXXXXXX
X......X
XXXX..XX
XXXXXXXX
1 3 1 2
1 1 1 2

je správny výstup

true
14

lebo červík sa vie vo výklenku vpravo otočiť a dostať sa tak až na ľavý okraj. Tam už však je vždy otočený iba doľava. Naopak sa môže rozhodnúť ísť aj na pravý okraj hornej chodby. Všimnite si, že aj keď na obrázku je iba 8 voľných políčok, máme až 14 dosiahnuteľných polôh, lebo na niektorých políčkach je viacero možných polôh chvosta.

Celú situáciu si vieme reprezentovať ako orientovaný graf, v ktorom vrcholy zodpovedajú polohe červíka a orientované hrany idú z jednej polohy do druhej, ak sa tak červík vie posunúť v jednom ťahu. Pre červíka uprostred väčšej prázdnej plochy teda máme tri vychádzajúce hrany pre tri voľné smery, štvrtý smer je blokovaný chvostom.

Prehľadávaním do hĺbky môžeme aj v orientovanom grafe nájsť všetky vrcholy dosiahnuteľné zo zadaného vrcholu. Pre každý navštívený vrchol pozrieme všetky hrany z neho vychádzajúce a ak ešte príslušné vrcholy neboli navštívené, navštívime ich rekurzívne. (Pozor, komponenty súvislosti v orientovanom grafe nie sú tak jednoduché definovať, lebo ak sa viem dostať z jedného vrcholu do druhého, neznamená to, že viem ísť aj naspäť).

V tomto príklade sa ponúkajú dve možnosti ako graf reprezentovať:

• Použijete zoznamy susedov z prednášky, pričom ich mierne upravíte pre orientované grafy. Po načítaní vstupu vytvoríte graf s potrebnými vrcholmi a hranami a spustíte prehľadávanie do hĺbky podobne ako na prednáške. Dôležité je pri vytváraní grafu zistiť čísla vrcholov pre počiatočnú a cieľovú polohu.
• Druhá možnosť je nevytvárať graf explicitne. Použijete iba maticu visited pre všetky polohy, pričom táto matica môže byť trojrozmerná, kde prvé dva rozmery zdpovedajú súradniciam hlavy a tretí rozmer vyjadruje smer, v ktorom je od hlavy chvost. Aktuálny vrchol vo vyhľadávaní bude tiež zadanými týmito troma údajmi. Z matice reprezentujúcej hernú plochu potom vieme určiť, ktoré zo susedných políčok môže červ navštíviť a tie rekurzívne prehľadáme. Hrany grafu teda generujeme za behu a nikde ich neukladáme.

Odovzdávanie

• Váš balíček nazvite worm a v ňom triedu s metódou main nazvite Worm.
• Odovzdávajte jeden .zip súbor obsahujúci adresár worm a v ňom všetky zdrojové súbory (*.java) vášho balíčka.

Prednáška 36

Oznamy

• Budúci utorok je voľno, utorkové cvičenia sa presúvajú na piatok 11.5.
• Do budúcej stredy 9.5. si v prípade záujmu vyberte tému nepovinného projektu.
• Do budúceho štvrtka 10.5. odovzdávajte domácu úlohu 17. Pre spresnenie pridaný ešte jeden príklad vstupu a výstupu.

Opakovanie

Reprezentácia grafov

Neorientovaný graf s vrcholmi očíslovanými 0,1,...,n-1.

• Príklad: V={0,...,6}, E={{0,5},{1,2},{2,3},{1,3},{3,4}}

Interface Graph

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

Matica susednosti (adjacency matrix), trieda AdjMatrixGraph

• Matica nxn napr typu boolean
• Políčko a[i][j]=true ak {i,j} je hrana

   0 1 2 3 4 5 6
0  F F F F F T F
1  F F T T F F F
2  F T F T F F F
3  F T T F T F F
4  F F F T F F F
5  T F F F F F F
6  F F F F F F F

Zoznamy susedov (adjacency lists), trieda AdjListsGraph

• Pre každý vrchol zoznam jeho susedov
• Uložíme ako pole potrebnej veľkosti alebo spájaný zoznam (ArrayList, LinkedList)
• Lepšia reprezentácia pre väčšinu algoritmov, obzvlášť ak je graf riedky, t.j. má pomerne málo hrán

0: 5
1: 2,3
2: 1,3
3: 1,2,4
4: 3
5: 0
6:

Prehľadávanie do hĺbky, komponenty súvislosti

• Vrcholy neorientovaného grafu vieme rozdeliť na komponenty súvislosti
• V grafe existuje cesta z vrcholu u do vrcholu v práve vtedy keď sú v tom istom komponente súvislosti
• Prehľadávanie do hĺbky začne z jedného vrcholu a rekurzívne prehľadá celý komponent.
• Môžeme teda postupným volaním prehľadávania očísľovať komponenty 0,1,...,k-1 a pre každý vrchol uložiť číslo jeho komponentu.
• Potom dva vrcholy sú spojené cestou práve vtedy keď majú rovnaké číslo komponentu.
• Dáta potrebné počes rekurzie a výsledky si uložíme do pomocnej triedy

/** Trieda obsahujuca rozdelenie vrcholov grafu do komponentov suvislosti */
class Components {

    /** Pre kazdy vrchol cislo jeho komponentu 0..pocet komponentov-1 */
    private int[] componentId;
    /** pocet komponentov grafu */
    private int numComponents;
    /** samotny graf */
    private Graph g;

    /** Konstruktor, ktory dostane graf a prehladavanim do hlbky
     * hlada komponenty suvislosti */
    public Components(Graph g) {
        this.g = g;  // uloz graf
        numComponents = 0;  // inicializuj pocet koponentov
        int n = g.numVertices();  // pocet vrcholov grafu
        // vytvor pole cisel koponentov a inicializuj na -1 - nevyfarbene
        componentId = new int[n];
        for (int i = 0; i < n; i++) {
            componentId[i] = -1;
        }
        // prechadzaj cez vrchola a ak najdes nevyfarbeny, spusti prehladavanie
        for (int i = 0; i < n; i++) {
            if (componentId[i] == -1) {
                search(i, numComponents); // vyfarbi cislom numComponents
                numComponents++;          // zvys numComponents
            }
        }
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore na vyfarbenie
     * jedneho komponentu cislom id. */
    private void search(int vertex, int id) {
        componentId[vertex] = id;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (componentId[neighbor] == -1) {
                search(neighbor, id); // navstivime ho rekurzivne
            }
        }
    }

    /** Vrati true ak vrchol from a to su v tom istom koponente */
    public boolean connected(int from, int to) {
        return componentId[from] == componentId[to];
    }

    /** Vrati pocet kponentov grafu */
    public int numComponents() {
        return numComponents;
    }
}

Príklad použitia prehľadávania do hĺbky: valec lesom

• Ukážeme si trochu netradičný príklad, v ktorom sa dajú grafy a prehľadávanie použiť
• Máme daný obdĺžnikový pozemok obohnaný plotom, na ktorom rastú stromy, ktoré si predstavíme ako body rovine
• Pri západnom okraji pozemku stojí valec s polomerom r (t.j. v rovine si ho predstavíme ako kruh), pričom pri západnej strane plotu je dosť miesta, aby popri nej valec prešiel od severu na juh
• Cieľom je zistiť, či sa valec dá pretlačiť pomedzi stromy na východnú stranu pozemku

Na prvý pohľad geometrická úloha sa prevedie na grafovú takto:

• Vytvoríme vrcholy S a J reprezentujúce severnú a južnú stranu pozemku
• Vytvoríme tiež vrchol pre každý strom
• Vrcholy pre dva stromy spojíme hranou ak sú bližšie ako 2r, t.j. valec sa medzi ne neprepchá
• Podobne vrchol pre strom spojíme hranou s vrcholom S alebo J, ak je k príslušnému okraju pozemku bližšie ako 2r.
• Ak S a J sú v tom istom komponente súvislosti, valec nie je možné cez les prepchať, lebo existuje lomená čiara spájajúca stromy na ceste z S do J, cez ktorú valec nevie prejsť
• Ak S a J nie sú v tom istom komponente súvislosti, valec môžeme posúvať po južnej strane komponentu obsahujúceho vrchol S
• Na odpoveď či sa dá valec presunúť lesom teda stačí spustiť connected(g,S,J).

Najkratšie cesty, prehľadávanie do šírky (breath-first search, BFS)

Graf s kostrou najkratších ciest pre vrchol 0

• Ak sú dva vrcholy v jednom komponente súvislosti, mohli by sme chcieť vypísať aj cestu, ktorá ich spája
• Najlepšie najkratšiu cestu, teda takú, ktorá obsahuje najmenej hrán
• To nám prehľadávanie do hĺbky nenájde, použijeme prehľadávanie do šírky
• Začneme v nejakom vrchole s
• V prehľadávaní do šírky najprv navštívime všetky vrcholy vo vzdialenosti 1 od s, potom vo vzdialenosti 2, ...
• Pre každý navštívený vrchol v spočítame jeho vzdialenosť od s aj predposledný vrchol na najkratšej ceste z s do v
• Hrany medzi v a pred[v] tvoria strom (kostru grafu ak je súvislý)
• Ak chceme vypísať cestu, po strome sa pohybujeme smerom k jeho koreňu vo vrchole s
• Algoritmus používa rad (frontu, queue), do ktorej dáva vrcholy, ktoré už majú známu vzdialenosť, ale ešte sme nepozreli ich susedov
• V rade sú v každej chvíli vrcholy najviac dvoch vzdialeností od s: najprv nejaké vrcholy vo vzdialenosti d, potom nejaké vrcholy vo vzdialenosti d+1
• Zložitosť je tiež O(n+m) ak použijeme zoznamy susedov

/** Trieda, ktorá reprezentuje najkratšie cesty a vzdialenosti
 * z jedného vrchola do ostatných. */
class ShortestPaths {

    /** Graf, v ktorom ratame cesty */
    private Graph g;
    /** Startovaci vrchol, z ktoreho ratame najkratsie cesty */
    private int start;
    /** Pre kazdy vrchol v grafe vzdialenost od startu
     * alebo -1 ak je v inom komponente. */
    private int[] dist;
    /** Pre kazdy vrchol u predchadzajuci vrchol na ceste zo start do u */
    private int[] prev;

    /** Konstruktor, ktory dostane graf a startovaci vrchol a najde najkratsie cesty */
    public ShortestPaths(Graph g, int start) {
        this.g = g;
        this.start = start;
        int n = g.numVertices();
        // inicializacia poli - vyplnime -1
        dist = new int[n];
        prev = new int[n];
        for (int i = 0; i < n; i++) {
            dist[i] = -1;  
            prev[i] = -1;  
        }

        // prehladavanie do sirky
        // vytvorime rad a vlozime do neho startovaci vrchol
        LinkedList<Integer> queue = new LinkedList<Integer>();
        queue.addLast(start);
        dist[start] = 0;  // sam od seba ma vzdialenost 0

        while (!queue.isEmpty()) {
            // vyberieme prvok na zaciatku radu
            int vertex = queue.removeFirst();
            // prejdeme cez jeho susedov a ak este neboli navstiveni
            // urcime im vzdialenost a pridame ich do radu
            Iterator<Integer> it = g.adjIterator(vertex);
            while (it.hasNext()) {
                int other = it.next();
                if (dist[other] < 0) {
                    dist[other] = dist[vertex] + 1;
                    prev[other] = vertex;
                    queue.addLast(other);
                }
            }
        }
    }

Prehľadávanie s návratom (backtracking) na grafoch

• Prehľadávanie s návratom sme videli minulý semester napr. na riešenie sudoku
• Riešenie úlohy je nejaká postupnosť, rekurzívne skúšame pridať všetky možnosti ďalšieho prvku postupnosti
• Prehľadávame exponenciálny počet možností, algoritmus môže byť veľmi pomalý
• Veľa úloh na grafoch však nevieme riešiť rýchlymi algoritmami, backtrackingom vieme spočítať odpoveď aspoň pre malé vstupy
• Snažíme sa ukončiť prehľadávanie vždy, keď už nie je šanca dosiahnuť platné riešenie

Hľadanie ciest dĺžky k

• Cesta v grafe je postupnosť vrcholov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_0,v_1,...,v_k} taká, že každé dva za sebou idúce vrcholy Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_i} a Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_{i+1}} sú spojené hranou a žiaden vrchol sa na ceste neopakuje. Dĺžka tejto cesty je k, t.j. počet hrán na ceste.
• Prehľadávaním do šírky vieme nájsť najkratšiu cestu z u do v.
• Čo chceme nájsť cestu z u do v dĺžky presne k?

Príklad použitia: vypisujeme cesty rôznych dĺžok medzi vrcholmi from a to:

        for (int length = 1; length < g.numVertices(); length++) {
            System.out.println("Cesty dlzky " + length + ":");
            FixedLengthPaths p = new FixedLengthPaths(g, 0, 3, length);
        }

Výstup pre graf s V={0,...,4} a E={{0,1},{0,2},{0,3},{1,2},{2,3},{2,4},{3,4}}

Cesty dlzky 1:
 0 3
Cesty dlzky 2:
 0 2 3
Cesty dlzky 3:
 0 1 2 3
 0 2 4 3
Cesty dlzky 4:
 0 1 2 4 3

• Opäť použijeme pomocnú triedu na ukladanie všetkých premenných potrebných v rekurzii
  • Pole path s práve vyrábanou cestou
  • Pole visited, v ktorom máme poznačené, ktoré vrcholy sú použité na ceste
  • Vstupné dáta: graf, 2 vrcholy, požadovaná dĺžka
• V rekurzii skúšame k ceste pridať ďalší vrchol, pričom vyberáme z vrcholov susedných s posledným vrcholom na ceste
• Keď nájdeme cestu požadovanej dĺžky, ktorá končí v cieľovom vrchole, cestu vypíšeme

/** Trieda, ktora umoznuje najst vsetky cesty zadanej
 * dlzky medzi dvoma danymi vrcholmi. */
class FixedLengthPaths {

    /** samotny graf */
    private Graph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** pozadovana dlkza cesty */
    private int length;
    /** tvorena cesta */
    private int[] path;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a pozadovanu dlzku cesty a rovno aj spusti rekurzivne vyhladavanie
     * a vypisuje vysledky. */
    public FixedLengthPaths(Graph g, int from, int to, int length) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        this.length = length;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj polia visited a path
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[length + 1];  // length hran, teda length+1 vrcholov
        search(0, from); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda ako i-ty vrchol cesty ulozi vertex a
     * potom skusa vsetky moznosti ako sa na length-i krokov
     * dostat do cieloveho vrcholu. */
    private void search(int i, int vertex) {
        // ulozime vrchol do cesty a poznacime ho ako pouzity
        path[i] = vertex;
        visited[vertex] = true;
        // ak uz mame cestu dlzky length, pozrieme,
        // ci konci v spravnom vrchole a vypiseme
        if (i == length) {
            if (vertex == to) {
                printPath();
            }
        } else {
            // ak este nemame cestu dlzky length,
            // pozrieme na susedov aktualneho vrcholu vertex
            Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, preskumame ho rekurzivne
                    search(i + 1, neighbor);
                }
            }
        }
        visited[vertex] = false;
    }

    private void printPath() {
        for (int i = 0; i < path.length; i++) {
            System.out.print(" " + path[i]);
        }
        System.out.println();
    }
}

Cvičenia:

• Namiesto vypisovania ciest iba spočítajte, koľko ich je
• Zistite, či cesta dĺžky k existuje, po nájdení prvej cesty je už možné ukončiť ďalšie prehľadávanie
• Navrhnite spôsoby, ako v niektorých prípadoch zistiť, že aktuálne rozrobenú cestu už nie je možné požadovaným spôsobom rozšíriť

Hľadanie najdlhšej cesty

• V grafe chceme nájsť najdlhšiu cestu z u do v
• Malé zmeny v predchádzajúcom programe
  • Pamätáme si najdlhšiu nájdenú cestu
  • Vždy keď prídeme do cieľového vrcholu, porovnáme dĺžku aktuálnej cesty s najdlhšou nájdenou doteraz

/** Trieda, ktora umoznuje najst najdlhsiu cestu medzi dvoma danymi vrcholmi. */
class LongestPath {

    /** samotny graf */
    private Graph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** najvyssia najdena dlzka cesty */
    private int maxLength;
    /** najlepsia najdena cesta */
    private int[] longestPath;
    /** tvorena cesta */
    private int[] path;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a spusti rekurzivne vyhladavanie */
    public LongestPath(Graph g, int from, int to) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj pole visited
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[n];
        maxLength = -1;
        search(0, from); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda ako i-ty vrchol cesty ulozi vertex a
     * potom skusa vsetky moznosti ako v ceste pokracovat dalej. */
    private void search(int i, int vertex) {
        // ulozime vrchol do cesty a poznacime ho ako pouzity
        path[i] = vertex;
        visited[vertex] = true;
        // ak sme v cielovom vrchole, porovname cestu s maximom
        if (vertex == to) {
            if (i > maxLength) {
                // ak sme nasli lepsiu cestu, ulozime si ju
                longestPath = Arrays.copyOf(path, i + 1); // kopiruj prvych i+1 prvkov
                maxLength = i;
            }
        } else {
            // ak este nie sme vo vrchole to,
            // pozrieme na susedov aktualneho vrcholu vertex
            Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, preskumame ho rekurzivne
                    search(i + 1, neighbor);
                }
            }
        }
        visited[vertex] = false;
    }

    int[] longestPath() {
        return Arrays.copyOf(longestPath, maxLength + 1);
    }
}

Použitie triedy:

        LongestPath p = new LongestPath(g, 0, 3);
        System.out.println("Najdlhsia cesta: "
                + Arrays.toString(p.longestPath()));

Príklad výstupu na rovnakom grafe ako vyššie:

Najdlhsia cesta: [0, 1, 2, 4, 3]

Hľadanie najdlhšej cesty v grafe s ohodnotenými hranami

Mierna obmena predchádzajúceho problému

• Každá hrana v grafe má priradené číslo (váha alebo dĺžka hrany)
• Hľadáme cestu z u do v s najväčším súčtom váh hrán

Napr. ak v grafe vyššie majú všetky hrany dĺžku 1, ale hrany {0,2} a {2,3} majú dĺžku 10, dostávame:

Najdlhsia cesta: [0, 2, 3]

Pozor, na hľadanie najkratšej cesty v ohodnotenom grafe sa nedá použiť prehľadávanie do šírky, algoritmy uvidíte v treťom ročníku.

Interface pre graf s ohodnotenými hranami

Potrebujeme v prvom rade takýto graf reprezentovať. V abstraktnom dátovom type potrebujeme aspoň tieto zmeny:

• Možnosť pri vkladaní hrany uložiť aj jej dĺžku
• Možnosť zistiť dĺžku hrany medzi dvoma vrcholmi, ak existuje (nebudeme implementovať)
• Možnosť pri iterovaní cez susedov zistiť dĺžku hrany k susedovi

/** Specialny iterator cez susedov vrchola v ovahovanom grafe,
 * ktory vie vratit okrem cisla vrcholu aj vahu hrany */
interface WeightedEdgeIterator extends Iterator<Integer> {

    /** Vaha hrany k vrcholu, ktory sme naposledy ziskali pomocou next() */
    double weight();
}

/** Interface pre graf s hranami ohodnotenymi
 * desatinnymi cislami. */
interface WeightedGraph extends Graph {

    /** Pridaj hrany s danou vahou */
    boolean addEdge(int from, int to, double weight);

    /** Specialny iterator cez susedov, ktory vie vratit aj vahu hrany */
    WeightedEdgeIterator adjIterator(int vertex);
}

Implementácia ohodnoteného grafu zoznamami susedov

• podobná na neváhovanú verziu
• musí implementovať vlastný iterátor

/** Trieda reprezentujúca neorientovaný graf s hranami ohodnotenymi
 * desatinnymi cislami. Graf je ulozeny pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class WeightedAdjListsGraph implements WeightedGraph {

    /** Zoznam susedov pre každý vrchol (dvojice vrchol, vaha hrany) */
    private ArrayList<ArrayList<Neighbor>> adjLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public WeightedAdjListsGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Neighbor>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Neighbor>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    /** Pridanie hrany s vahou 0 */
    public boolean addEdge(int from, int to) {
        return addEdge(from, to, 0);
    }

    /** Pridanie hrany s danou vahou */
    public boolean addEdge(int from, int to, double weight) {
        adjLists.get(from).add(new Neighbor(to, weight)); // pridaj hranu v oboch smeroch
        adjLists.get(to).add(new Neighbor(from, weight));
        numEdges++;
        return true;

    }

    /** Test na existenciu hrany */
    public boolean existsEdge(int from, int to) {
        // prejdeme cez susedov from iteratorom, testujeme na rovnost s to
        Iterator<Neighbor> it = adjLists.get(from).iterator();
        while (it.hasNext()) {
            if (it.next().vertex == to) {
                return true;
            }
        }
        return false;
    }

    /** iterator cez susedov vrchola */
    public WeightedEdgeIterator adjIterator(int vertex) {
        return new MyIterator(this, vertex);
    }

    /** Pomocna trieda na iterovanie cez susedov vrchola */
    static class MyIterator implements WeightedEdgeIterator {

        /** Iterator pre ArrayList susedov */
        Iterator<Neighbor> it;
        /** Vaha poslednej navstivenej hrany */
        double weight;
        /** Je vaha platna? */
        boolean valid;

        /** Konstruktor dostane graf a vrchol, cez ktoreho susedov chceme iterovat */
        private MyIterator(WeightedAdjListsGraph g, int vertex) {
            it = g.adjLists.get(vertex).iterator(); // uloz iterator
            valid = false;   // vaha nie je platna
        }

        /** Vrati hranu poslednej navstivenej hrany */
        public double weight() {
            if (!valid) {
                throw new NoSuchElementException("Not supported yet.");
            }
            return weight;
        }

        public boolean hasNext() {
            return it.hasNext();
        }

        public Integer next() {
            Neighbor edge = it.next(); // posun iterator
            weight = edge.weight;  // odpamataj vahu
            valid = true;          // vaha je teraz platna
            return edge.vertex;    // vrat vrchol
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    /** Pomocna trieda reprezentujuca dvojicu sused a
     * vaha hrany k tomuto susedovi. */
    static class Neighbor {

        int vertex;    // cislo suseda
        double weight; // vaha hrany k susedovi

        /** Konstruktor dostane vrchol v a vahu w */
        Neighbor(int v, double w) {
            vertex = v;
            weight = w;
        }
    }
}

Samotné prehľadávanie

• Okrem aktuálnej cesty si musíme pamaätať aj jej dĺžku, t.j. súčet váh hrán na ceste
• Rekurzia riešená trochu inak: v cykle cez susedov rovno ukladáme suseda do všetkých potrebných polí (lebo vieme váhu hrany)
  • Rekurzívne prehľadávanie sa väčšinou dá zapísať veľa rôznymi spôsobmi
  • Treba si vždy dobre rozmyslieť, čo robí rekurzívna funkcia a čo by malo platiť o jednotlivýh premenných

/** Trieda, ktora umoznuje najst naldhsiu cestu
 * medzi dvoma danymi vrcholmi v ovahovanom grafe. */
class LongestWeightedPath {

    /** samotny graf */
    private WeightedGraph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** najvyssia najdena dlzka cesty */
    private double maxLength;
    /** najlepsia najdena cesta */
    private int[] longestPath;
    /** tvorena cesta */
    private int[] path;
    /** dlzka tvorenej cesty */
    private double length;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a spusti rekurzivne vyhladavanie */
    public LongestWeightedPath(WeightedGraph g, int from, int to) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj pole visited
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[n];  // vytvor cestu dlzky 0 obsahujucu iba zac. vrchol
        path[0] = from;
        visited[from] = true;
        length = 0;
        maxLength = -1;     // najlespia najdena cesta
        search(1); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda skusa pridat novy vrchol na poziciu i a
     * potom skusa vsetky moznosti ako v ceste pokracovat dalej. */
    private void search(int i) {
        int vertex = path[i - 1];  // predchadzajuci vrchol na ceste
        // ak sme v cielovom vrchole, porovname cestu s maximom
        if (vertex == to) {
            if (length > maxLength) {
                // ak sme nasli lepsiu cestu, ulozime si ju
                longestPath = Arrays.copyOf(path, i); // kopiruj prvych i prvkov
                maxLength = length;
            }
        } else {
            // ak este nie sme v cielovom vrchole,
            // pozrieme na susedov predchadzajuceho vrcholu vertex
            WeightedEdgeIterator it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, ulozime ho do cesty
                    // a zavolame rekurziu
                    path[i] = neighbor;
                    visited[neighbor] = true;
                    double weight = it.weight();
                    length += weight;
                    search(i + 1);
                    length -= weight;
                    visited[neighbor] = false;
                }
            }
        }
    }

    int[] longestPath() {
        return Arrays.copyOf(longestPath, longestPath.length);
    }
}

Programy

Programy z tejto prednášky nájdete tu:

• Prehľadávanie do šírky: #Zdrojový kód programu, grafy
• #Zdrojový kód programu, prehľadávanie s návratom na neohodnotených grafoch
• #Zdrojový kód programu, prehľadávanie s návratom na ohodnotených grafoch

Zdrojový kód programu, prehľadávanie s návratom na neohodnotených grafoch

Program k prednáške: #Prednáška 36

• niekoľko prehľadávaní s návratom v neohodnotenom grafe (cesta zadanej dĺžky, najdlhšia cesta, najväčšia klika)

package prog;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Scanner;

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

/** Trieda reprezentujúca neorientovaný graf pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class AdjListsGraph implements Graph {

    /** Zoznam susedov pre každý vrchol */
    private ArrayList<ArrayList<Integer>> adjLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjListsGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Integer>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Integer>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        adjLists.get(from).add(to); // pridaj hranu v oboch smeroch
        adjLists.get(to).add(from);
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return adjLists.get(from).contains(to); // pozri do zoznamu susedov pre from
    }

    public Iterator<Integer> adjIterator(int vertex) {
        return adjLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }
}

/** Trieda, ktora umoznuje najst vsetky cesty zadanej
 * dlzky medzi dvoma danymi vrcholmi. */
class FixedLengthPaths {

    /** samotny graf */
    private Graph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** pozadovana dlkza cesty */
    private int length;
    /** tvorena cesta */
    private int[] path;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a pozadovanu dlzku cesty a rovno aj spusti rekurzivne vyhladavanie
     * a vypisuje vysledky. */
    public FixedLengthPaths(Graph g, int from, int to, int length) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        this.length = length;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj polia visited a path
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[length + 1];  // length hran, teda length+1 vrcholov
        search(0, from); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda ako i-ty vrchol cesty ulozi vertex a
     * potom skusa vsetky moznosti ako sa na length-i krokov
     * dostat do cieloveho vrcholu. */
    private void search(int i, int vertex) {
        // ulozime vrchol do cesty a poznacime ho ako pouzity
        path[i] = vertex;
        visited[vertex] = true;
        // ak uz mame cestu dlzky length, pozrieme,
        // ci konci v spravnom vrchole a vypiseme
        if (i == length) {
            if (vertex == to) {
                printPath();
            }
        } else {
            // ak este nemame cestu dlzky length,
            // pozrieme na susedov aktualneho vrcholu vertex
            Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, preskumame ho rekurzivne
                    search(i + 1, neighbor);
                }
            }
        }
        visited[vertex] = false;
    }

    private void printPath() {
        for (int i = 0; i < path.length; i++) {
            System.out.print(" " + path[i]);
        }
        System.out.println();
    }
}

/** Trieda, ktora umoznuje najst najdlhsiu cestu medzi dvoma danymi vrcholmi. */
class LongestPath {

    /** samotny graf */
    private Graph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** najvyssia najdena dlzka cesty */
    private int maxLength;
    /** najlepsia najdena cesta */
    private int[] longestPath;
    /** tvorena cesta */
    private int[] path;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a spusti rekurzivne vyhladavanie */
    public LongestPath(Graph g, int from, int to) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj pole visited
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[n];
        maxLength = -1;
        search(0, from); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda ako i-ty vrchol cesty ulozi vertex a
     * potom skusa vsetky moznosti ako v ceste pokracovat dalej. */
    private void search(int i, int vertex) {
        // ulozime vrchol do cesty a poznacime ho ako pouzity
        path[i] = vertex;
        visited[vertex] = true;
        // ak sme v cielovom vrchole, porovname cestu s maximom
        if (vertex == to) {
            if (i > maxLength) {
                // ak sme nasli lepsiu cestu, ulozime si ju
                longestPath = Arrays.copyOf(path, i + 1); // kopiruj prvych i+1 prvkov
                maxLength = i;
            }
        } else {
            // ak este nie sme vo vrchole to,
            // pozrieme na susedov aktualneho vrcholu vertex
            Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, preskumame ho rekurzivne
                    search(i + 1, neighbor);
                }
            }
        }
        visited[vertex] = false;
    }

    int[] longestPath() {
        return Arrays.copyOf(longestPath, maxLength + 1);
    }
}

/** Trieda, ktora umoznuje najst maximalnu kliku v danom grafe. */
class MaximumClique {

    /** samotny graf */
    private Graph g;
    /** zoznam vrcholov v najvacsej doteraz najdenej klike */
    private LinkedList<Integer> maxClique;
    /** zoznam vrcholov v aktualnej klike */
    private LinkedList<Integer> clique;

    /** Konstruktor, ktory dostane graf a spusti rekurzivne vyhladavanie */
    public MaximumClique(Graph g) {
        this.g = g;  // uloz vstupny graf
        // vytvor dve prazdne kliky
        clique = new LinkedList<Integer>();
        maxClique = new LinkedList<Integer>();
        search(0); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda skusi pouzit aj vynechat vrchol vertex
     * potom skusa vsetky moznosti pre vrcholy vertex+1...n-1. */
    private void search(int vertex) {
        // ak aktualna klika je vacsia ako doterajsie maximum, uloz ju
        if (clique.size() > maxClique.size()) {
            // konstruktor LinkedListu moze vytvorit kopiu inej Collection
            maxClique = new LinkedList<Integer>(clique);
        }
        // ak uz sme vycerpali vsetky vrcholy, nie je co skusat dalej
        if (vertex == g.numVertices()) {
            return;
        }
        // otestuj, ci sa vrchol vertex da pidat do kliky
        // a ci ma sancu byt vo vacsej klike ako doteraz najdena
        if (isConnected(g, vertex, clique)
                && degree(g, vertex) + 1 > maxClique.size()) {
            // ak ano, pridaj ho do kliky a zavolaj rekurziu
            clique.addLast(vertex);
            search(vertex + 1);
            // odober vertex x kliky
            clique.removeLast();
        }
        // preskoc vertex a zavolaj rekurziu na ostatne vrcholy
        search(vertex + 1);
    }

    /** pomocna metoda, ktora overi, ci vrchol vertex je v grafe g
     * spojeny s kazdym z vrcholov v mnozine vertexSet. */
    private static boolean isConnected(Graph g, int vertex,
            Collection<Integer> vertexSet) {
        // iterator cez mnozinu vertexSet
        Iterator<Integer> it = vertexSet.iterator();
        while (it.hasNext()) {
            if (!g.existsEdge(vertex, it.next())) { // over hranu
                return false;  // hrana nie je
            }
        }
        return true; // vsetky hrany najdene
    }

    /** pomocna metoda, ktora zisti stupen vrchola vertex v grafe g */
    private static int degree(Graph g, int vertex) {
        // iterujeme cez susedov vrchola, zvysujeme pocitadlo result
        Iterator<Integer> it = g.adjIterator(vertex);
        int result = 0;
        while (it.hasNext()) {
            result++;
            it.next();
        }
        return result;
    }

    /** vrati maximalnu kliku najdenu v grafe g */
    public LinkedList<Integer> maxClique() {
        // vrat kopiu nasej najlepsej kliky
        return new LinkedList<Integer>(maxClique);
    }
}

public class Prog {

    /** Zo scannera s načíta graf vo formáte: počet vrcholov,
     * počet hrán a zoznam hrán zadaných koncami vrcholov.
     * Uloží ho ako AdjMatrixGraph. */
    static Graph readGraph(Scanner s) {
        int n = s.nextInt();
        int m = s.nextInt();
        Graph g = new AdjListsGraph(n);
        for (int i = 0; i < m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            g.addEdge(u, v);
        }
        return g;
    }

    public static void main(String[] args) throws FileNotFoundException {

        Scanner s = new Scanner(new File("graph.txt"));
        Graph g = readGraph(s);
        s.close();

        for (int length = 1; length < g.numVertices(); length++) {
            System.out.println("Cesty dlzky " + length + ":");
            FixedLengthPaths p = new FixedLengthPaths(g, 0, 3, length);
        }

        LongestPath p = new LongestPath(g, 0, 3);

        System.out.println("Najdlhsia cesta: "
                + Arrays.toString(p.longestPath()));

        MaximumClique c = new MaximumClique(g);
        System.out.println(
                "Maximalna klika: "
                + c.maxClique().toString());

    }
}


/* Priklad vstupu (ulozit do graph.txt)

    5 7
    0 1
    0 2
    0 3
    1 2
    2 3
    2 4
    3 4
*/

Cvičenia 22

• Nižšie je verzia prehľadávania do hĺbky, ktorá do poľa whenVisited čísluje vrcholy v poradí, v akom boli navštívené. Odsimulujte algoritmus na grafe nakreslenom vpravo a zistite, v akom poradí budú vrcholy navštívené, ak začneme prehľadávať vo vrchole 0. Predpokladajte, že adjIterator vracia susedov v poradí podľa čísla vrcholu.

• Do reprezentácie grafu pomocou zoznamov susedov z prednášky pridajte metódu addVertex, ktorá pridá do grafu nový vrchol.

• Máme danú šachovnicu n x m, na ktorej sú niektoré políčka obsadené figúrkami. Na políčku (i,j) stojí kôň. Na ktoré políčka šachovnice vie preskákať, pričom môže použiť aj viacero ťahov, ale môže chodiť iba po prázdnych políčkach?
  • Použite prehľadávanie do hĺbky na grafe, v ktorom sú vrcholy jednotlivé políčka a hrany spájajú dvojice voľných políčok, medzi ktorými môže kôň skočiť. Môžete vytvoriť graf v niektorej reprezentácii, alebo to riešiť priamo v matici visited n x m.
  • Šachový kôň môže z pozície (i,j) skočiť na jednu z pozícií (i+2,j+1), (i+2,j-1), (i-2,j+1), (i-2,j-1), (i+1,j+2), (i+1,j-2), (i-1,j+2), (i-1,j-2)

• Reprezentáciu grafu pomocou matice susednosti z prednášky zmeňte tak, aby adjIterator vrátil objekt vašej vlastnej triedy implementujúcej Iterator<Integer>. Tento objekt by si pamätal iba číslo vrchola, cez ktorého susedov iterujeme a pozíciu v príslušnom riadku matice susednosti. Pri každom volaní next hľadá ďalšiu hodnotu true v tomto riadku. Iterátoru tiež správne implementujte metódu remove, aby mazala hranu (obidve jej kópie).

Prehľadávanie s číslovaním pre prvý príklad

/** Trieda obsahujuca prehladavanie do hlbky s cislovanim vrcholov */
class Search {

    /** Pre kazdy vrchol poradove cislo kedy bol navstiveny */
    private int[] whenVisited;
    /** Pocet navstivenych vrcholov */
    private int numVisited;
   /** samotny graf */
    private Graph g;

    /** Konstruktor, ktory dostane graf a prehladava do hlbky 
     * so zaciatkom vo vrchole start */
    public Search(Graph g, int start) {
        this.g = g;      // uloz graf
        numVisited = 0;  // inicializuj pocet navstivenych vrcholov
        int n = g.numVertices();  // pocet vrcholov grafu
        whenVisited = new int[n]; // vytvor a inicializuj pole
        for (int i = 0; i < n; i++) {
            whenVisited[i] = -1;
        }
	search(start); // prehladavaj rekurzive
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore 
     * na rekurzivne prehladavanie. */
    private void search(int vertex) {
        whenVisited[vertex] = numVisited;
        numVisited++;
        Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            if (whenVisited[neighbor] == -1) {
                search(neighbor); // navstivime ho rekurzivne
            }
        }
    }

    @Override    
    public String toString() {
	String res = "";
	for(int i=0; i<g.numVertices(); i++) {
	    res = res + i + ": " + whenVisited[i] + "\n";
	}
	return res;
    }
}

Prednáška 37

Opakovanie backtracky na grafe

• Na minulej prednáške boli príklady na prehľadávanie grafu s návratom. Jednalo sa o hľadania ciest, ktoré zodpovedajú špecifickým požiadavkám.
• Pri riešení sme si postupne vytvárali cestu pridávaním potenciálnych vrcholov do nej a následným kontrolovaním situácie (hotové riešenie, slepá vetva)

Hľadanie maximálnej kliky

• Pozrime sa teraz na iný typ problému, nehľadáme cestu, ale množinu vrcholov
• Klika je taká množina vrcholov, v ktorej sú každé dva spojené hranou
• Maximálna klika je klika s najväčším počtom vrcholov v danom grafe

Graf G=(V,E), kde V={0,...,4} a E={{0,1},{0,2},{0,3},{1,2},{2,3},{2,4},{3,4}} obsahuje niekoľko klík veľkosti 3, ale žiadnu kliku veľkosti 4

Maximalna klika: [0, 1, 2]

Po pridaní hrany {0,4} dostávame kliku veľkosti 4:

Maximalna klika: [0, 2, 3, 4]

Hľadanie maximálnej kliky:

• Rekurzívne skúšame každý vrchol najprv pridať do kliky, potom vynechať
• Vrchol pridávame do kliky iba ak je spojený so všetkými vrcholmi, ktoré sú v klike
• Vrchol v klike veľkosti k má stupeň (počet susedov) aspoň k-1
• Preto do kliky skúšame dať iba vrcholy, ktoré majú dosť veľký stupeň na to, aby mohli patriť do kliky väčšej ako zatiaľ najväčšia nájdená (to neznamená, že do takej kliky aj patria)
• Aktuálnu kliku aj najväčšiu nájdenú si ukladáme do LinkedList-u.

/** Trieda, ktora umoznuje najst maximalnu kliku v danom grafe. */
class MaximumClique {

    /** samotny graf */
    private Graph g;
    /** zoznam vrcholov v najvacsej doteraz najdenej klike */
    private LinkedList<Integer> maxClique;
    /** zoznam vrcholov v aktualnej klike */
    private LinkedList<Integer> clique;

    /** Konstruktor, ktory dostane graf a spusti rekurzivne vyhladavanie */
    public MaximumClique(Graph g) {
        this.g = g;  // uloz vstupny graf
        // vytvor dve prazdne kliky
        clique = new LinkedList<Integer>();
        maxClique = new LinkedList<Integer>();
        search(0); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda skusi pouzit aj vynechat vrchol vertex
     * potom skusa vsetky moznosti pre vrcholy vertex+1...n-1. */
    private void search(int vertex) {
        // ak aktualna klika je vacsia ako doterajsie maximum, uloz ju
        if (clique.size() > maxClique.size()) {
            // konstruktor LinkedListu moze vytvorit kopiu inej Collection
            maxClique = new LinkedList<Integer>(clique);
        }
        // ak uz sme vycerpali vsetky vrcholy, nie je co skusat dalej
        if (vertex == g.numVertices()) {
            return;
        }
        // otestuj, ci sa vrchol vertex da pidat do kliky
        // a ci ma sancu byt vo vacsej klike ako doteraz najdena
        if (isConnected(g, vertex, clique)
                && degree(g, vertex) + 1 > maxClique.size()) {
            // ak ano, pridaj ho do kliky a zavolaj rekurziu
            clique.addLast(vertex);
            search(vertex + 1);
            // odober vertex x kliky
            clique.removeLast();
        }
        // preskoc vertex a zavolaj rekurziu na ostatne vrcholy
        search(vertex + 1);
    }

    /** pomocna metoda, ktora overi, ci vrchol vertex je v grafe g
     * spojeny s kazdym z vrcholov v mnozine vertexSet. */
    private static boolean isConnected(Graph g, int vertex,
            Collection<Integer> vertexSet) {
        // iterator cez mnozinu vertexSet
        Iterator<Integer> it = vertexSet.iterator();
        while (it.hasNext()) {
            if (!g.existsEdge(vertex, it.next())) { // over hranu
                return false;  // hrana nie je
            }
        }
        return true; // vsetky hrany najdene
    }

    /** pomocna metoda, ktora zisti stupen vrchola vertex v grafe g */
    private static int degree(Graph g, int vertex) {
        // iterujeme cez susedov vrchola, zvysujeme pocitadlo result
        Iterator<Integer> it = g.adjIterator(vertex);
        int result = 0;
        while (it.hasNext()) {
            result++;
            it.next();
        }
        return result;
    }

    /** vrati maximalnu kliku najdenu v grafe g */
    public LinkedList<Integer> maxClique() {
        // vrat kopiu nasej najlepsej kliky
        return new LinkedList<Integer>(maxClique);
    }
}

Príklad použitia

        MaximumClique c = new MaximumClique(g);
        System.out.println("Maximalna klika: "
                + c.maxClique().toString());

Cvičenia:

• Čo by program robil, ak by sme vynechali test na stupeň vrcholy z rekurzívnej funkcie?
• Čo by program robil, ak by sme vynechali aj test na isConnected?
• Čo program robí, ak ho spustíme grafe bez hrán?
• Ktorá reprezentácia grafu je vhodnejšia pre tento algoritmus?

Orientované grafy

Pre orientované grafy môžeme využiť existujúci interface Graph ako sme ho mali definovaný pri neorientovaných grafoch.

• Pri implementácii funkcie addEdge však vložíme hranu iba jedným smerom. Napr. pre hranu (0,1) vložíme 1 medzi susedov 0 ale nie 0 medzi susedov 1.
• Funkcia existsEdge nám potom pre parametre (0,1) odpovie true ale pre (1,0) odpovie false.
• Iterator adjIterator bude poskytovať iba vychádzajúce hrany

Prehľadávanie do hĺbky

Pri takto implementovanom grafe, môžeme použiť prehľadávanie do hĺbky z minulých prednášok na zistenie existencie orientovanej cesty medzi dvoma vrcholmi.

• Treba si však uvedomiť, že podobne, ako existencia hrany (0,1) nehovorí nič o hrane (1,0) ani existencia cesty medzi dvomi vrcholmi nie je obojsmerná
• Keďže však máme k dispozícii iterátor cez výstupné hrany, vytvárame práve správne orientované cesty

void search(int vertex, boolean[] visited) {
    visited[vertex] = true;
    Iterator<Integer> it = g.adjIterator(vertex); // prejdi cez susedov
    while (it.hasNext()) {
        int neighbor = it.next();  // sused vrcholu
        if (!visited[neighbor]) {
            search(neighbor, visited); // navstivime ho rekurzivne
        }
    }
}

• Viacnásobným použitím funkcie vieme získať zoznamy vrcholov, ktoré sú dosiahnuteľné z jednotlivých vrcholov.
• Pri prehľadávaní si zároveň môžeme hrany deliť na stromové, ktoré objavujú nový vrchol a nestromové (tieto prípadne ešte podrobnejšie)

Cvičenie:

• Zamyslite sa čo by robil algoritmus na hľadanie komponentov, ktorý bol na minulej prednáške, na orientovanom grafe - funguje? prečo?

Prehľadávanie do šírky a najkratšie cesty v neohodnotenom grafe

Podobne ako prehľadávanie do hĺbky aj prehľadávanie do šírky je na orientovanom (neohodnotenom) grafe rovnako použiteľné.

• Získame najkratšie orientované cesty z vrchola do všetkých ostatných vrcholov
• Môžeme si hrany rozdeliť na stromové (ktoré objavili vrchol) a ostatné

Existencia cyklu, Strom

Čo nás v orientovanom grafe často zaujíma je existencia orientovaného cyklu a s tým súvisiace otázky.

• Orientovaný cyklus existuje, ak vrchol je sám sebe dosiahnuteľný (pritom nerátame dosiahnuteľnosť na 0 krokov)
• Orientovaný cyklus existuje, ak pri prehľadávaní do hĺbky narazíme na svojho predchodcu (potrebujeme si pamätať aktuálnu cestu z vrcholu, ktorým sme začínali

Ďalšia otázka, ktorá nás zaujíma, či je orientovaný graf stromom. Ako by sme mohli postupovať:

• Začneme nejakým vrcholom, ktorý považujeme za koreň / tento vrchol by zjavne nemal mať žiadne hrany čo do neho vedú.
• Ak z koreňa pustíme prehľadávanie dostaneme sa do každého vrchola a nemáme žiadne nestromové hrany (počet hrán si pritom vieme overiť už pred tým).

Topologické triedenie

Motivačná úloha:

• Máme niekoľko vecí, ktoré potrebujeme vybaviť na úrade. Ale číha tam na nás byrokracia. O niekoľkých veciach vieme, že pre tým, ako vybavíme B musíme vybaviť A.
• Úlohou je nájsť poradie (a zistiť, či také vôbec existuje) ako veci na úrade vybavovať.
• Týmto nám zjavne vzniká orientovaný graf, kde vrchol sú povinnosti a hrany prerekvizície medzi nimi.

Pri otázke, či je graf acyklický môžeme buď odpovedať opačne ako pri cykle (alebo upraviť hľadanie cyklu na novú úlohu), alebo skúšať zistiť acyklickosť ináč, kúsok podobne ako pri strome. Na to však potrebujeme mierne rozšíriť grafový interface.

• Už pri strome sme na začiatku položili otázku, že či do vrchola nevstupuje žiadna hrana - túto otázku nevieme rozumne odpovedať, pretože vstupné hrany nikde pri vrchole uložené nemáme
• Rozšírime teda interface, aby si pri vrchole pamätal okrem výstupných aj vstupné hrany a vedel odovzdať ich iterátor.

interface Graph {
..
    Iterator<Integer> adjInIterator(int vertex);
}

class AdjListsGraph implements Graph {

    /** Zoznam susedov pre každý vrchol */
    private ArrayList<ArrayList<Integer>> adjLists;
    /** Zoznam susedov pre každý vrchol */
    private ArrayList<ArrayList<Integer>> adjInLists;

..

    @Override public boolean addEdge(int from, int to) {
        adjLists.get(from).add(to); // pridaj hranu v jednom smere
        adjInLists.get(to).add(from); // pridaj hranu ako vstupnu v opacnom smere
        numEdges++;
        return true;
    }
..
    @Override public Iterator<Integer> adjInIterator(int vertex) {
        return adjInLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }
}

Samotné topologické triedenie bude pracovať nasledovne:

• Bude si vo fronte pamatať vrcholy, ktoré už môže vypísať - týchto môže byť aj viac a pri niektorých je jedno v akom poradí sú vypísané
• V prípade, že vypisujeme vrchol potrebujeme z grafu vymazať všetky hrany, ktoré z neho vchádzali do iného vrchola a spôsobovali mu, vyšší vstupný stupeň
• Každému susedovi vypisovaného vrchola teda umažem vstupnú hranu (z vypisovaného vrchola)
  • V prípade, že to bola jeho posledná vstupná hrana, tak vrchol zaradím na vypísanie

static void printTopological(Graph g) {
    Queue<Integer> s=new LinkedList<Integer>();
    Iterator<Integer> it;
    Iterator<Integer> iter;
    // hladanie vrcholov so stupnom 0
    for (int i=0; i<g.numVertices(); i++){
        it=g.adjInIterator(i);
        if (!it.hasNext()) s.add(i);
    }

    while (!s.isEmpty()){        // vrcholy v zasobniku su uz vypisatelne
        int v=s.remove();
        System.out.print(v+" ");
        // pre susedov vypisaneho vrchola potrebujem vymazat vstupnu hranu od vypisovaneho vrchola
        iter=g.adjIterator(v);
        while (iter.hasNext()){
            // u je sused vypisaovaneho vrchola
            int u=iter.next();
             // len ju musim medzi vstupnymi hranami do u najst
            it=g.adjInIterator(u);
            int count=0;
            while (it.hasNext()){
                count++;
                if (it.next()==v) it.remove();
            }
            // a ak to nahodou bola posledna vstupna hrana, tak je vrchol u uz vypisatelny
            if (count==1) s.add(u);
        }
    }
}

Cvičenie:

• Pomocou topologického triedenia sa dá určiť, či je graf acyklický. Ako? Upravte patrične program.

Ako už som spomínala, úloha ide vyriešiť aj podobnou myšlienkou ako hľadanie cyklov - teda prehľadávaním grafu do hĺbky

Zdrojový kód programu

• Topologické triedenie a detekcia cyklov v orientovanom grafe pomocou spätného prehľadávania do hĺbky

package prog;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

interface DirectedGraph extends Graph {

    /** Vráti iterátor cez hrany vchádzajúce do vrchola vertex.
     * Metóda remove iterátora nemusí byť podporovaná. */
    public Iterator<Integer> adjInIterator(int vertex);
}

/** Trieda reprezentujúca neorientovaný graf pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class AdjListsDiGraph implements DirectedGraph {

    /** Zoznam susedov pre každý vrchol (vychadzajuce hrany) */
    private ArrayList<ArrayList<Integer>> adjLists;
    /** Zoznam susedov pre každý vrchol (vchadzajuce hrany) */
    private ArrayList<ArrayList<Integer>> adjInLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public AdjListsDiGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Integer>>(numVertices);
        adjInLists = new ArrayList<ArrayList<Integer>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Integer>());
            adjInLists.add(new ArrayList<Integer>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    public boolean addEdge(int from, int to) {
        adjLists.get(from).add(to); // pridaj hranu v oboch smeroch
        adjInLists.get(to).add(from);
        numEdges++;
        return true;
    }

    public boolean existsEdge(int from, int to) {
        return adjLists.get(from).contains(to); // pozri do zoznamu susedov pre from
    }

    public Iterator<Integer> adjIterator(int vertex) {
        return adjLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }

    public Iterator<Integer> adjInIterator(int vertex) {
        return adjInLists.get(vertex).iterator(); // vrati iterator pre ArrayList
    }
}

/** Trieda obsahujuca rozdelenie vrcholov grafu do komponentov suvislosti */
class TopologicalSort {

    /** samotny graf */
    private DirectedGraph g;
    /** Zoznam vrcholov v topologickom usporiadani */
    private ArrayList<Integer> order;
    /** Indikator, ci je graf acyklicky  */
    private boolean acyclic;
    /** Pole indikujuce, ci sme uz vrchol v prehladavani navstivili */
    private boolean[] visited;
    /** Pole indikujuce, ci sme uz ukoncili prehladavanie vrchola
     * a vsetkych jeho predchodcov */
    private boolean[] finished;

    /** Konstruktor, ktory dostane graf a prehladavanim do hlbky
     * testuje acyklickost grafu a  hlada topologicke usporiadanie */
    public TopologicalSort(DirectedGraph g) {
        this.g = g;  // uloz graf
        int n = g.numVertices();  // pocet vrcholov grafu
        order = new ArrayList<Integer>();  // inicializuj polia
        visited = new boolean[n];
        finished = new boolean[n];
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        acyclic = true;  // zatial sme nevideli cyklus
        // prechadzaj cez vrchol a ak najdes nevyfarbeny,
        // spusti prehladavanie proti smeru hran
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                search(i);
            }
        }
    }

    /** Pomocna rekurzivna metoda pouzivana v konstruktore 
     * na vyfarbenie vsetkych predchodcov vrchola vertex */
    private void search(int vertex) {
        visited[vertex] = true;  // uz sme ho navstivili
        //prejdi cez vchadzajuce hrany
        Iterator<Integer> it = g.adjInIterator(vertex);
        while (it.hasNext()) {
            int neighbor = it.next();  // sused vrcholu
            // ak uz sme suseda navstivili, ale este nie je
            // ukonceny, mame cyklus
            if (visited[neighbor] && !finished[neighbor]) {
                acyclic = false;
            }
            // ak este sused nebol vobec navstiveny, navstiv do rekurzivne
            if (!visited[neighbor]) {
                search(neighbor); // navstivime ho rekurzivne
            }
        }
        // ukoncili sme prehladavanie aktualneho brcholu
        // poznac ako ukonceny a pridaj ho do zoznamu
        // - jeho predchodcovia tam uz su
        finished[vertex] = true;
        order.add(vertex);
    }

    /** vratil, ci je vstupny graf acyklicky */
    public boolean isAcyclic() {
        return acyclic;
    }

    /** ak je graf acyklicky, vrati topologicke usporiadanie vrcholov */
    public ArrayList<Integer> order() {
        if (!acyclic) {
            return null;
        }
        return new ArrayList<Integer>(order);
    }
}

public class Prog {

    /** Zo scannera s načíta graf vo formáte: počet vrcholov,
     * počet hrán a zoznam hrán zadaných koncami vrcholov.
     * Uloží ho ako AdjMatrixGraph. */
    static DirectedGraph readGraph(Scanner s) {
        int n = s.nextInt();
        int m = s.nextInt();
        DirectedGraph g = new AdjListsDiGraph(n);
        for (int i = 0; i < m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            g.addEdge(u, v);
        }
        return g;
    }

    public static void main(String[] args) throws FileNotFoundException {

        Scanner s = new Scanner(new File("graph.txt"));
        DirectedGraph g = readGraph(s);
        s.close();

        TopologicalSort sort = new TopologicalSort(g);
        if (sort.isAcyclic()) {
            System.out.println("Topologicke usporiadanie: " + sort.order());
        } else {
            System.out.println("Graf ma cyklus");
        }
    }
}
/** Priklad vstupu bez cyklu:

4 4
1 0
2 0
2 1
3 1

 *  s cyklom:
4 4
1 0
0 2
2 1
3 1

 */

Skúškové prostredie

Pozostáva z niekoľkých tried a programov - dokumentácia bude k dispozícii

Graph, Vertex, Edge, MyShape

Sú pomocné triedy reprezentujúce graf a jeho súčasti

• Graph implementuje interface GraphInterface
  • Obsahuje zoznam svojich vrcholov typu Vertex
  • tiež vie, či sú aktuálne indexy vrcholov v intervale 0..N-1 alebo nie

Vrcholy sú typu Vertex

• obsahujú odkaz na graf, ktorému patria
• svoj identifikátor (id), hodnotu (value, všeobecne typu Object) a shape (typu MyShape, teda tvar akým sa vykresľujú - toto je pre vás nepodstatné, nemeňte to)
• vrchol tiež obsahuje hrany s ním incidentné ako ArrayList<Edge>

Hrany sú neorientované (aj keď obsahujú aj pomocnú orientovanú triedu)

• obsahujú odkaz na graf, dva vrcholy (from_ a to_), identifikátor, hodnotu (typu Object) a farbu (ktorá ale v súčasnosti nie je využívaná)

MyFrame, MyPanel

Sú rozšírenia grafických kompomentov SWINGu, upravených pre naše grafové prostredie

• MyFrame je obsiahnutý v GraphGUI.java a je to neverejná trieda reprezentujúca frame pre hlavné grafické okno
• MyPanel je grafický panel pre editovanie samotného grafu
  • Pri kliknutí vzniká nový vrchol alebo je vrchol označený resp. odznčený
  • Pri klinutí so Shiftom pridávame hranu z vyznačeného vrchola na vrchol kliknutý
  • Okrem akcií priamo na ňom vie odovzdať aj práve vybraný vrchol alebo hranu
  • Obsahuje funkciu na vykresľovanie vrcholov a hrán grafu
  • Tiež má v sebe funkcie pre načítanie a výpis grafu

ExamSpecifics

Examspecifics je trieda, ktorá obsahuje niekoľko nastavení, ktoré sa môžu v záavislosti od zadaní skúšky meniť. Patrí sem napríklad

• rozšírené načítanie grafu (načítanie aj hodnôt vrcholov a hrán, ktoré môžu byť rôznych typov - keďže sú všeobecne typu Object)
• podobne aj rozšírené vypísanie týchto hodnôt - ak by napríklad neboli primitívnych typov
• nastavenie vstupného a výstupného súboru

Obsahuje tiež volanie triedy Editor, ktorú budete implementovať ako jednu z úloh - príklad na prácu so SWINGom

GraphInterface

• Interface na grafy je širší oproti interface popísanému na prednáške. Vrcholy aj hrany je možné určovať pomocou samotných objektov typu Vertex resp. Edge, ale aj podľa identifikačných čísel (ako bolo na prednáške).
• Ďalšia zmena je pridanie metód, ktoré vracajú Iterable<>. Tieto metódy nemusíte používať, ich funkčnosť je plne pokrytá adekvátnymi metódami, ktoré vracajú Iterator<>
• Interface obsahuje aj možnosť pridávania a mazania vrcholov a hrán
• Zisťovanie a zadávanie hodnôt vrcholov a hrán je umožnené priamo cez tento interface v metódach setEdgeValue, getEdgeValue, setVertexValue a getVertexValue
• Farbu vrchola a hrany (ktorou sa zobrazujú, keď nie sú vybrané) meníme pomocou setDefaultVertexColor a setDefaultEdgeColor.

public interface GraphInterface {
    public int getNumberOfVertices();

    public Vertex getVertex(int index);
    public int getVertexId(Vertex vertex);
    
    public Iterable<Vertex> getVertices();
    public Iterator<Vertex> verticesIterator();
    public Iterable<Vertex> adjVertices(Vertex vertex);
    public Iterator<Vertex> adjVertexIterator(Vertex vertex);
    public Iterable<Integer> adjVertexIds(Vertex vertex);
    public Iterator<Integer> adjVertexIdIterator(Vertex vertex);
    public Iterable<Edge> adjEdges(Vertex vertex);
    public Iterator<Edge> adjEdgeIterator(Vertex vertex);
    
    public void setEdgeValue(Edge e, Object value);
    public Object getEdgeValue(Edge e);
    public void setVertexValue(Vertex vertex, Object value);
    public Object getVertexValue(Vertex vertex);

    public void setDefaultVertexColor(Vertex vertex, Color color);
    public void setDefaultEdgeColor(Edge e, Color color);    
    
    public Vertex addVertex(int x, int y);
    public Vertex addVertex(int x, int y, Object value);
    public Vertex addVertex(MyShape shape);
    public Vertex addVertex(MyShape shape, Object value);
    
    public void deleteVertex(Vertex vertex);
    public void deleteVertex(int index);
    
    Edge addEdge(Vertex n1, Vertex n2, Object value);
    Edge addEdge(int n1, int n2, Object value);
    Edge addEdge(Vertex n1, Vertex n2);
    Edge addEdge(int n1, int n2);
    
    void deleteEdge(Edge e);
    void deleteEdge(Vertex n1, Vertex n2);
    void deleteEdge(int n1, int n2);
    
    Edge findEdge(Vertex n1, Vertex n2);
    Edge findEdge(int n1, int n2);
}

GraphAlgorithm

Trieda, ktorá má obsahovať implementáciu požadovaného grafového algoritmu z úlohy B. V tejto triede používajte iba metódy GraphInterface.

public class GraphAlgorithm {

   /** Samotný graf, na ktorom spúšťame algoritmus */
   private GraphInterface graph;
   /** Vybraný vrchol, ktorý je parametrom algoritmu, môže byť aj null. */
   private Vertex selected;
   /** Vybraný vrchol, ktorý je parametrom algoritmu, môže byť aj null. */   
   private Edge selectedEdge;

   /** Konštruktor triedy, ktorý dostane graf a vybraný vrchol a hranu (môžu byť aj null). */
   public GraphAlgorithm(GraphInterface graph, Vertex selected, Edge selectedEdge) {
       // uloz vstupne udaje
       this.graph = graph;
       this.selected = selected;
       this.selectedEdge = selectedEdge;
   }

   /** Metóda, ktorá vráti výstup algoritmu v textovom formáte podľa špecifikácie v zadaní ulohy. */
   public String getMessage() {
       // v tomto ukazkovom programe iba vypiseme, ci je graf prazdny
       if (graph.getNumberOfVertices() > 0) {
           return "Neprazdny";
       } else {
           return "Prazdny";
       }
   }
   
   /** Metóda, ktorá vykonáva algoritmus a prípadne upraví graf podľa špecifikácie v zadaní úlohy  */
   public void performAlgorithm() {
       // ukazkove pouzitie grafu: prefarbi vsetky vrcholy na zlto      
       for (Vertex n : graph.getVertices()) {
           graph.setDefaultVertexColor(n, Color.yellow);
       }
       // ak bol nejaky vrchol vybrany, premaluj ho na oranzovo
       if (selected != null) {
           graph.setDefaultVertexColor(selected, Color.orange);
       }       
   }
}

Editor

Trieda, ktorá má obsahovať implementáciu SWINGovej úlohy na skúške.

Obsahuje

• odkaz na volajúci frame (pozor nie typu MyFrame, ale JFrame)
• obsahuje graf (teda jeho metódy prístupné cez interface)

Vašou úlohou bude modifikovať metódy tejto triedy. Metódy triedy sú volané v prípade stlačenia gombíka Edit podľa toho, ako bude špecifikované v ExamSpecifics.java.

• V tomto prípade ak je vybratá hrana, tak vyskočí okno s jej hodnotu. Ak nie je a je vybraný vrchol, vyskočí okno s jeho id. Ak nie je ani to vyskočí okno "Hello world!".

Odporúčam vyhadzovať aj nejaké výnimky, sú odchytávané a vypísané na System.err.

public class Editor {
	
    final JFrame parent_frame;
    final GraphInterface graph;
    Editor(JFrame parent_frame, GraphInterface graph){
	this.parent_frame=parent_frame;
	this.graph=graph;
    }
	
    public void editVertex(Vertex vertex) {
	JOptionPane.showMessageDialog(parent_frame,"vertex "+graph.getVertexId(vertex));
    }
	
    public void editEdge(Edge edge) {
    	JOptionPane.showMessageDialog(parent_frame,"edge "+edge.getValue().toString());
    }

    public void edit() throws Exception{
        JOptionPane.showMessageDialog(parent_frame, "Hello world!");
        throw new Exception("hups, nic nevybrate, co mam editovat");
    }

}

Súbory na stiahnutie

• zip
• dokumentácia - dá sa vytvoriť pomocou JavaDoc z projektu GraphGUI

Zdrojový kód programu, prehľadávanie s návratom na ohodnotených grafoch

• graf s ohodnotenými hranami a hľadanie najdlhšej cesty v ňom

package prog;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Scanner;

/** Interface reprezentujúci graf s n vrcholmi očíslovanými 0..n-1. */
interface Graph {

    /** Vráti počet vrcholov grafu n. */
    int numVertices();

    /** Vráti počet hrán grafu. */
    int numEdges();

    /** Do grafu pridá hranu z vrcholu from do vrcholu to,
     * vráti true ak sa ju podarilo pridať. */
    boolean addEdge(int from, int to);

    /** Vráti true, ak existuje hrana z vrcholu from
     * do vrcholu to. */
    boolean existsEdge(int from, int to);

    /** Vráti iterátor cez susedov vrchola vertex.
     * V prípade orientovaného grafu vracia iba hrany vychádzajúce z vrchola.
     * Metóda remove iterátora nemusí byť podporovaná. */
    Iterator<Integer> adjIterator(int vertex);
}

/** Specialny iterator cez susedov vrchola v ovahovanom grafe,
 * ktory vie vratit okrem cisla vrcholu aj vahu hrany */
interface WeightedEdgeIterator extends Iterator<Integer> {

    /** Vaha hrany k vrcholu, ktory sme naposledy ziskali pomocou next() */
    double weight();
}

/** Interface pre graf s hranami ohodnotenymi
 * desatinnymi cislami. */
interface WeightedGraph extends Graph {

    /** Pridaj hrany s danou vahou */
    boolean addEdge(int from, int to, double weight);

    /** Specialny iterator cez susedov, ktory vie vratit aj vahu hrany */
    WeightedEdgeIterator adjIterator(int vertex);
}

/** Trieda reprezentujúca neorientovaný graf s hranami ohodnotenymi
 * desatinnymi cislami. Graf je ulozeny pomocou
 * zoznamov susedov uložených v poli dynamickej dĺžky (ArrayList). */
class WeightedAdjListsGraph implements WeightedGraph {

    /** Zoznam susedov pre každý vrchol (dvojice vrchol, vaha hrany) */
    private ArrayList<ArrayList<Neighbor>> adjLists;
    /** Počet hrán v grafe */
    private int numEdges;

    /** Konštruktor dostane počet vrcholov grafu */
    public WeightedAdjListsGraph(int numVertices) {
        adjLists = new ArrayList<ArrayList<Neighbor>>(numVertices);
        for (int i = 0; i < numVertices; i++) {
            adjLists.add(new ArrayList<Neighbor>());
        }
        numEdges = 0;
    }

    public int numVertices() {
        return adjLists.size();
    }

    public int numEdges() {
        return numEdges;
    }

    /** Pridanie hrany s vahou 0 */
    public boolean addEdge(int from, int to) {
        return addEdge(from, to, 0);
    }

    /** Pridanie hrany s danou vahou */
    public boolean addEdge(int from, int to, double weight) {
        adjLists.get(from).add(new Neighbor(to, weight)); // pridaj hranu v oboch smeroch
        adjLists.get(to).add(new Neighbor(from, weight));
        numEdges++;
        return true;

    }

    /** Test na existenciu hrany */
    public boolean existsEdge(int from, int to) {
        // prejdeme cez susedov from iteratorom, testujeme na rovnost s to
        Iterator<Neighbor> it = adjLists.get(from).iterator();
        while (it.hasNext()) {
            if (it.next().vertex == to) {
                return true;
            }
        }
        return false;
    }

    /** iterator cez susedov vrchola */
    public WeightedEdgeIterator adjIterator(int vertex) {
        return new MyIterator(this, vertex);
    }

    /** Pomocna trieda na iterovanie cez susedov vrchola */
    static class MyIterator implements WeightedEdgeIterator {

        /** Iterator pre ArrayList susedov */
        Iterator<Neighbor> it;
        /** Vaha poslednej navstivenej hrany */
        double weight;
        /** Je vaha platna? */
        boolean valid;

        /** Konstruktor dostane graf a vrchol, cez ktoreho susedov chceme iterovat */
        private MyIterator(WeightedAdjListsGraph g, int vertex) {
            it = g.adjLists.get(vertex).iterator(); // uloz iterator
            valid = false;   // vaha nie je platna
        }

        /** Vrati hranu poslednej navstivenej hrany */
        public double weight() {
            if (!valid) {
                throw new NoSuchElementException("Not supported yet.");
            }
            return weight;
        }

        public boolean hasNext() {
            return it.hasNext();
        }

        public Integer next() {
            Neighbor edge = it.next(); // posun iterator
            weight = edge.weight;  // odpamataj vahu
            valid = true;          // vaha je teraz platna
            return edge.vertex;    // vrat vrchol
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    /** Pomocna trieda reprezentujuca dvojicu sused a
     * vaha hrany k tomuto susedovi. */
    static class Neighbor {

        int vertex;    // cislo suseda
        double weight; // vaha hrany k susedovi

        /** Konstruktor dostane vrchol v a vahu w */
        Neighbor(int v, double w) {
            vertex = v;
            weight = w;
        }
    }
}

/** Trieda, ktora umoznuje najst naldhsiu cestu
 * medzi dvoma danymi vrcholmi v ovahovanom grafe. */
class LongestWeightedPath {

    /** samotny graf */
    private WeightedGraph g;
    /** pociatocny a koncovy vrchol */
    private int from, to;
    /** najvyssia najdena dlzka cesty */
    private double maxLength;
    /** najlepsia najdena cesta */
    private int[] longestPath;
    /** tvorena cesta */
    private int[] path;
    /** dlzka tvorenej cesty */
    private double length;
    /** vrcholy, ktore su na ceste pouzite */
    private boolean[] visited;

    /** Konstruktor, ktory dostane graf, pociatocny a koncovy vrchol
     * a spusti rekurzivne vyhladavanie */
    public LongestWeightedPath(WeightedGraph g, int from, int to) {
        this.g = g;  // uloz vstupne data
        this.from = from;
        this.to = to;
        int n = g.numVertices();  // pocet vrcholov grafu
        visited = new boolean[n];  // vytvor a inicializuj pole visited
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }
        path = new int[n];  // vytvor cestu dlzky 0 obsahujucu iba zac. vrchol
        path[0] = from;
        visited[from] = true;
        length = 0;
        maxLength = -1;     // najlespia najdena cesta
        search(1); // zavolaj rekurziu
    }

    /** Hlavna rekurzivna metoda volana z konstruktora.
     * Metoda skusa pridat novy vrchol na poziciu i a
     * potom skusa vsetky moznosti ako v ceste pokracovat dalej. */
    private void search(int i) {
        int vertex = path[i - 1];  // predchadzajuci vrchol na ceste
        // ak sme v cielovom vrchole, porovname cestu s maximom
        if (vertex == to) {
            if (length > maxLength) {
                // ak sme nasli lepsiu cestu, ulozime si ju
                longestPath = Arrays.copyOf(path, i); // kopiruj prvych i prvkov
                maxLength = length;
            }
        } else {
            // ak este nie sme v cielovom vrchole,
            // pozrieme na susedov predchadzajuceho vrcholu vertex
            WeightedEdgeIterator it = g.adjIterator(vertex); // prejdi cez susedov
            while (it.hasNext()) {
                int neighbor = it.next();  // sused vrcholu vertex
                if (!visited[neighbor]) {
                    // ak este sused nebol navstiveny, ulozime ho do cesty
                    // a zavolame rekurziu
                    path[i] = neighbor;
                    visited[neighbor] = true;
                    double weight = it.weight();
                    length += weight;
                    search(i + 1);
                    length -= weight;
                    visited[neighbor] = false;
                }
            }
        }
    }

    int[] longestPath() {
        return Arrays.copyOf(longestPath, longestPath.length);
    }
}

public class Prog {

    /** Zo scannera s načíta graf vo formáte: počet vrcholov,
     * počet hrán a zoznam hrán zadaných koncami vrcholov a vahami. */
    static WeightedGraph readGraph(Scanner s) {
        int n = s.nextInt();
        int m = s.nextInt();
        WeightedGraph g = new WeightedAdjListsGraph(n);
        for (int i = 0; i < m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            double weight = s.nextDouble();
            g.addEdge(u, v, weight);
        }
        return g;
    }

    public static void main(String[] args) throws FileNotFoundException {

        Scanner s = new Scanner(new File("weightedGraph.txt"));
        WeightedGraph g = readGraph(s);
        s.close();

        LongestWeightedPath p = new LongestWeightedPath(g, 0, 3);
        System.out.println("Najdlhsia cesta: "
                + Arrays.toString(p.longestPath()));

    }
}

/* Priklad vstupu (ulozit do weightedGraph.txt)

5 7
0 1 1
0 2 10
0 3 1
1 2 1
2 3 10
2 4 1
3 4 1
 
 */

Cvičenia 23

Úloha A: Odsimulujte prácu prehľadávania do šírky na grafe vpravo ak začneme prehľadávať vo vrchole 0. Predpokladajte, že adjIterator vracia susedov v poradí podľa čísla vrcholu. Uveďte, v akom poradí boli vrcholy vložené do queue a vypíšte výsledné polia dist a prev.

Úloha B: Program na hľadanie najdlhšej cesty z u do v v neohodnotenom grafe zmeňte na hľadanie najdlhšieho cyklu, ktorý začína a končí v danom vrchole v

• Cyklus je postupnosť vrcholov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_0,v_1,...,v_k} taká, že každé dva za sebou idúce vrcholy Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_i} a Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_{i+1}} sú spojené hranou, Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle v_0=v_k} a žiaden iný vrchol sa v postupnosti neopakuje.
• Program na hľadanie najdlhšej cesty nájdete v programe pre Prednášku 36, trieda LongestPath

Úloha C: Vráťme sa k príkladu s koňom, ale namiesto prehľadávania do hĺbky použite prehľadávanie do šírky

• Máme danú šachovnicu n x m, na ktorej sú niektoré políčka obsadené figúrkami. Na políčku (i,j) stojí kôň, ktorý sa pohybuje obvyklým spôsobom, ale môže chodiť iba po prázdnych políčkach.
• Pre každé prázdne políčko v šachovnici spočítajte, na aký najmenší počet ťahov na neho vie kôň doskákať. Ak naňho vôbec nevie doskákať, vypíšte -1.
• Použite prehľadávanie do šírky na grafe, v ktorom sú vrcholy jednotlivé políčka a hrany spájajú dvojice voľných políčok, medzi ktorými môže kôň skočiť. Môžete vytvoriť graf v niektorej reprezentácii, alebo to riešiť priamo v matici dist n x m.
• Šachový kôň môže z pozície (i,j) skočiť na jednu z pozícií (i+2,j+1), (i+2,j-1), (i-2,j+1), (i-2,j-1), (i+1,j+2), (i+1,j-2), (i-1,j+2), (i-1,j-2)

Úloha D: Napíšte program, ktorý pomocou prehľadávania s návratom nájde najmenšiu dominujúcu množinu v grafe.

• Dominujúca množina je taká množina vrcholov X, že každý vrchol grafu je buď v X, alebo susedí s nejakým vrcholom v X.
• V každom rekurzívnom volaní vyskúšajte pre jeden vrchol dve možnosti: patrí do dominujúcej množiny alebo nepatrí. Potom rekurzívne zavolajte prehľadávanie pre všetky možnosti ďalších vrcholov.
• Ak ste už spravili rozhodnutie pre každý vrchol, skontrolujte, či je výsledok naozaj dominujúca množina a porovnajte veľkosť s najlepšou zatiaľ nájdenou.
• Viete orezať nejaké neperspektívne vetvy výpočtu? Skúste napríklad niektorú z týchto stratégií:
  • napr. nechceme pridať do X vrchol, ktorý nijako nepomôže, lebo aj on aj všetci jeho susedia už majú suseda v X
  • alebo nechceme vynechať vrchol, ak niektorý z jeho susedov nemá ešte suseda v X a ani nemá suseda s väčším číslom, ktorý ešte môže byť pridaný do X v ďalších rozhodnutiach
  • ak ste už našli dominujúcu množinu určitej veľkosti, nemá zmysel skúmať a rozširovať množiny, ktoré majú zaručene viac prvkov

Úloha E: Program na hľadanie všetkých ciest dĺžky k z u do v v neohodnotenom grafe zmeňte tak, aby si predpočítal najkratšiu cestu z každého vrcholu do cieľového vrcholu (prehľadávaním do šírky z u) a potom nepokračoval ďalej v prehľadávaní z daného vrchola x, ak už nám v ceste zostáva len nejakých q hrán a najkratšia cesta z x do cieľového vrchola má dĺžku viac ako q

• Program na hľadanie najdlhšej cesty nájdete v programe pre prednášku 36, trieda FixedLengthPaths
• Prehľadávanie do šírky nájdete v programe pre prednášku 36, trieda ShortestPaths

Prednáška 38

Oznamy

• Konzultačné hodiny k testu tento piatok 18.5.v čase medzi 9:00 a 11:00 v kancelárii M163 alebo M263 (sledujte oznamy na dverách)
• Do budúceho piatku si skontrolujte body z DÚ a rozcvičiek v Moodli a ohláste nam prípadné reklamácie
  • Ozvite sa aj ak máte ospravedlnenie na viac ako jednu zmeškanú rozcvičku
  • Okrem poslednej rozcvičky a poslednej DÚ by všetky body mali byť v Moodli
  • Posledné body budú do budúcej stredy
• Nepovinný projekt
  • Odovzdajte v Moodli do budúcej stredy
  • Zapíšte sa v AIS na termín predvádzania budúci štvrtok a piatok poobede
  • Známky budú v Moodli

Test

• Termín: 21.5. o 10:00 v B
• Opravný/náhradný termín: 4.6. o 10:00 v M VIII
• 90 minút
• Príklady zhruba ako na cvičeniach alebo rozcvičkách
• Dobre si rozvrhnite čas, niektoré úlohy sú ťažšie, iné ľahšie.
• Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
• Doneste si ISIC, písacie potreby, ťahák 1 list A4
• Zakázané sú ďalšie materiály, elektronické pomôcky, opisovanie

Skúška pri počítači

• Jeden príklad na Swing, jeden na grafy
• Obidva v graphgui, pozrite si vopred pred skúškou
• Zapíšte sa na termín v AIS, prihlasovanie/odhlasovanie do 14:00 deň pred skúškou
• Doneste si ťahák 1 list A4, ISIC, index, písacie potreby, papier
• Príďte na 8:50 pred príslušnú učebňu, kde sa dozviete pokyny a rozsadenie do miestností
• Doobeda: 2 a 3/4 hodiny práca pri počítačoch. Prostredie ako minulý semester, bude dokumentácia k Jave
• Poobede, príp. ďalší deň: vyhodnotenie na rovnakom prostredí u prednášajúcich
• Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
• Hodnotíme správnosť myšlienky, správnosť implementácie, štýl
• Nezáleží na rýchlosti programu

Zhrnutie

Čo by ste mali po dvoch semestroch vedieť

• Základy jazykov C/C++, Java: cykly, podmienky, premenné, funkcie, primitívne typy, polia, alokovanie pamäte, reťazce, súbory
• Základy OOP, triedy, dedenie, polymorfizmus, výnimky, generické programovanie
• Základy tvorby GUI v Swingu
• Dátové štruktúry: spájaný zoznam, zásobník a rad, binárne stromy a ich využitie (vyhľadávacie, lexikografické, aritmetické, rozhodovacie,...), hashovacie tabuľky
• Základné algoritmy: triedenia, binárne vyhľadávanie, prehľadávanie grafov a stromov, prehľadávanie s návratom
• Vymyslieť jednoduchý algoritmus, vedieť ho napísať a odladiť, porozumieť hotovým programom

Nadväzujúce predmety

• Algoritmy a dátové štruktúry (2/Z) a Tvorba efektívnych algoritmov (3/Z): viac algoritmov a dátových štruktúr, časová zložitosť
• Programovanie (3) (2/Z): viac programovania v Jave, návrhové vzory
• Ročníkový projekt (1) a (2): píšete väčší program na tému podľa vlastného výberu

Cvičenia 24

Na dnešnom cvičení máme dve úlohy: stručne si zopakovať topologické triedenie z predchádzajúcej prednášky a vyskúšať si prácu s programom graphgui, ktorý budete používať na skúške.

Úloha A: Nájdite všetky topologické usporiadania orientovaného grafu na obrázku vpravo.

Úloha B: Stiahnite si graphgui.zip a rozzipujte ho. Potom si ho otvorte v Netbeans pomocou New project, ako typ projektu zvoľte Java Project with Existing Sources, na ďalšej obrazovke vyplňte Project Name graphgui a na ďalšej pomocou Add Folder pridajte adresár s rozzipovanými súbormi. Je dobré si tento postup vyskúšať v učebni, aby ste na skúške nemali problémy. Projekt skúste skompilovať, spustiť a pozrite si, čo program robí.

Úloha C: Do súboru Editor.java doprogramujte, aby po stlačení tlačidla Edit sa otvorilo editovacie okienko, v ktorom môže užívateľ zadať tri reálne čísla medzi 0 a 1, ktoré zodpovedajú červenej, zelenej a modrej zložke farby a následne sa práve vybraný vrchol prefarbí na túto farbu. Ak žiaden vrchol nie je vybraný, program vypíše dialogové okienko s upozornením o chybe, podobne aj keď užívateľ zadá neplatné hodnoty, ktoré nie je možné previesť na číslo alebo ktoré nie sú v rozsahu medzi 0 a 1. Pomôcky:

• Trieda Color v balíčku java.awt má konštruktor Color(float r, float g, float b), ktorý vytvorí farbu so zadanými intenzitami červenej (r), zelenej (g) a modrej (b).
• Primitívny typ float sa podobá na double, je však menej presný. Trieda Float reprezentujúca jeho objektový variant má konštruktor Float(String s), ktorý z reťazca načíta číslo a ak v reťazci nie je dané platné číslo, vyhodí výnimku triedy NumberFormatException.

Úloha D: Do súboru GraphAlgorithm.java doprogramujte, aby po stlačení tlačidla Action sa spustil algoritmus hľadania najväčšej kliky a vrcholy v tejto klike aby boli vyfarbené čiernou farbou (statická premenná Color.black). Algoritmus upravte z prednášky (trieda MaximumClique). Po zavolaní getMessage vráti reťazec vo formáte "Pocet vrcholov kliky: 6".

Úloha E: Riešenie úlohy D upravte tak, aby algoritmus nehľadal najväčšiu kliku v celom grafe, ale najväčšiu kliku, ktorá obsahuje vybraný vrchol, ktorý GraphAlgorithm dostane ako parameter. Ak hodnota tohto vrcholu je null, konštruktor vyhodí výnimku typu NoSuchElementException.