100400331

Księgarnia Internetowa PWN: Jacek Tomasiewicz - Zaprzyjaźnij się z algorytmami

Spis treści Wprowadzenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XI Od autora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIII 1. Złożoność czasowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

Porównanie różnych złożoności czasowych . . . . . . . . . . . . . . . . . .

Limit czasu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Złożoność pamięciowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Żabka ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Chodnik ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Taśma ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2 3 4 4 5 5 6 7 8

2. Zliczanie elementów . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Permutacja ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Ropucha ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Przyciski ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10 11 11 12 13 14

3. Sumy prefiksowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

16

Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Długa taśma ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Samochody ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

17 18 18 19 V

Chomiki ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

20 21

4. Sortowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

22

Sposób 1: sortowanie przez wybieranie . . . . . . . . . . . . . . . . . . . .

Sposób 2: sortowanie przez zliczanie . . . . . . . . . . . . . . . . . . . . .

Sposób 3: sortowanie przez scalanie . . . . . . . . . . . . . . . . . . . . .

Funkcje sortujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Iloczyn ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Gwoździe ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Tory kolejowe ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

22 23 24 24 25 25 25 26 27 28

5. Stos i kolejka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

30

Stos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Kolejka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Nawiasy ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Ryby ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Cukiernia ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

30 31 32 32 32 33 34 35

6. Wyszukiwanie lidera . . . . . . . . . . . . . . . . . . . . . . . . . . . .

37

Sprawdzenie kandydata . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązanie o złożoności O(n2 ) . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązanie o złożoności O(n log n) . . . . . . . . . . . . . . . . . . . . .

Rozwiązanie o złożoności O(n) . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Dwie części ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Bajtocka flaga ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . .

Lider prefiksowy ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

37 38 38 39 40 41 41 42 43 44

7. Spójny podciąg o maksymalnej sumie . . . . . . . . . . . . . . . . .

45

Rozwiązanie o złożoności O(n ) . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązanie o złożoności O(n2 ) . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązanie o złożoności O(n) . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Odchudzanie ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Bilet ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

45 46 46 47 49 49 49

3

VI

SPIS TREŚCI

Praca domowa ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

51 51

8. Liczby pierwsze i złożone . . . . . . . . . . . . . . . . . . . . . . . . .

53

Liczenie dzielników . . . . . √ . . . . . . . . . . . . . . . . . . . . . . . . . .

Test pierwszości w czasie O( n) . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Obwód ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Szczyty ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Flagi ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53 54 54 56 56 56 57 58

9. Sito Eratostenesa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

61

Faktoryzacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Tablica liczb ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Liczby półpierwsze ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . .

Liczby doskonałe ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

62 63 64 64 64 65 66

10. Algorytm Euklidesa . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

68

Najmniejsza wspólna wielokrotność . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Mandarynki ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Wesoła małpka ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zbiór pierwszych ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

69 69 69 69 70 71 72

11. Ciąg Fibonacciego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

73

Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zajączek ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Drabina ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Spotkanie ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

74 74 74 75 76 77

12. Wyszukiwanie binarne . . . . . . . . . . . . . . . . . . . . . . . . . . .

79

Intuicja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Implementacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Wyszukiwanie binarne po wyniku . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

79 80 81 81 82

SPIS TREŚCI

VII

Promień ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Deski ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Tort ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

82 82 83 85

13. Gąsienica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

87

Przykład użycia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Smakołyki ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Wycinek ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Temperatura ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

87 88 89 89 90 90 92

14. Programowanie zachłanne . . . . . . . . . . . . . . . . . . . . . . . . .

94

Problem wydawania reszty . . . . . . . . . . . . . . . . . . . . . . . . . .

Dowodzenie poprawności . . . . . . . . . . . . . . . . . . . . . . . . . . . Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Sznurki ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Bracia ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Szklanki ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

94 95 95 96 96 97 98 99

15. Programowanie dynamiczne . . . . . . . . . . . . . . . . . . . . . . . 101 Problem wydawania reszty . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Pionek ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 Wybrzeże ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Ładny ciąg ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

16. Drzewa binarne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 Pełne drzewo binarne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Reprezentacja drzew binarnych . . . . . . . . . . . . . . . . . . . . . . . . 111 Binarne drzewa wyszukiwania (BST) . . . . . . . . . . . . . . . . . . . . 112 Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Drzewko binarne ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Nieskończone drzewko ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . 114 Drzewko ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 VIII

SPIS TREŚCI

17. Kolejka priorytetowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Kopiec binarny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 Wstawienie elementu do kopca O(log n) . . . . . . . . . . . . . . . 120 Usunięcie elementu maksymalnego O(log n) . . . . . . . . . . . . . 121 Tworzenie nowego kopca z listy elementów O(n) . . . . . . . . . . 122 Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Emeryci ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Bilety ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Tamy ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

18. Algorytmy grafowe BFS i DFS . . . . . . . . . . . . . . . . . . . . . . 128 Rodzaje grafów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Reprezentacja grafu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 DFS, czyli przeszukiwanie grafu w głąb . . . . . . . . . . . . . . . . . . . 132 BFS, czyli przeszukiwanie grafu wszerz . . . . . . . . . . . . . . . . . . . 133 Ćwiczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Zadania treningowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Lista kontaktów ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Las ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Wyprawa króla ⋆ ⋆ ⋆ ⋆ . . . . . . . . . . . . . . . . . . . . . . . . 136 Rozwiązania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

A. Kolejne tematy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Algorytm Dijkstry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Średnica drzewa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Zbiory rozłączne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Algorytm Prima i Kruskala . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Sortowanie topologiczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Drzewo licznikowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Szybkie potęgowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Koszt zamortyzowany . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Najdłuższy rosnący podciąg . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Teoria gier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Algorytm Knutha–Morrisa–Pratta . . . . . . . . . . . . . . . . . . . . . . 141 Haszowanie tekstów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Algorytm Karpa–Millera–Rosenberga . . . . . . . . . . . . . . . . . . . . 141 Szukanie palindromów i algorytm Manachera . . . . . . . . . . . . . . . . 141 Najdłuższy wspólny podciąg . . . . . . . . . . . . . . . . . . . . . . . . . 141 Programowanie dynamiczne na drzewach . . . . . . . . . . . . . . . . . . 141 Podstawy geometrii obliczeniowej . . . . . . . . . . . . . . . . . . . . . . 142 Sortowanie kątowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Otoczka wypukła . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Para najmniej i najbardziej oddalonych punktów . . . . . . . . . . . . . . 142 SPIS TREŚCI

IX

Maski bitowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Najniższy wspólny przodek . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Silnie spójne składowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Mosty i punkty artykulacji . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Cykl Eulera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 Przepływy i skojarzenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

B. STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 Para elementów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 Wektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 Kolejka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 Kolejka priorytetowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 Minimum, maksimum i zamiana . . . . . . . . . . . . . . . . . . . . . . . 150 Sortowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Permutacje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Mieszanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 Wskaźniki w C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 Iteratory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Wyszukiwanie binarne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Zbiór i multizbiór . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Mapa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Skorowidz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 Opinie i komentarze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

X

SPIS TREŚCI

Księgarnia Internetowa PWN: Jacek Tomasiewicz - Zaprzyjaźnij się z algorytmami

ROZDZIAŁ 1

Złożoność czasowa Dokładne policzenie czasu działania programu jest bardzo pracochłonne (zależy od kompilatora, rodzaju komputera czy szybkości procesora). Dlatego nie mierzy się czasu dokładnie, lecz do pewnego rzędu wielkości. Złożoność czasowa ułatwia szacowanie czasu działania programów.

Na złożoność możemy patrzeć jak na maksymalną liczbę operacji stałych, które może wykonać program. Operacje stałe to pojedyncze operacje dodawania, mnożenia, przypisania itp. Niektórych operacji możemy nie liczyć, skupiając się na pozostałych, które wykonują się najwięcej razy. Takie operacje nazywamy dominującymi.

Liczba wykonywanych operacji dominujących zależy od konkretnych danych wejściowych. Zwykle chcemy wiedzieć, jak czas wykonania zależy od określonego aspektu danych. Najczęściej jest to wielkość danych, ale może być to również rozmiar kwadratowej macierzy czy wartość wczytywanej zmiennej.

1.1. Która operacja jest dominująca?

1 2 3 4

cin >> n; for (int i = 1; i <= n; i++) wynik++; cout << wynik;

Operacja w wierszu 3 jest dominująca i wykona się n razy. Złożoność zapisujemy w notacji dużego O, w tym przypadku O(n) — złożoność liniowa.

Złożoność oznacza, że program nie wykona więcej operacji niż jest to określone przez rząd wielkości. Dokładniej, w przypadku O(n) program może wykonać c · n operacji, gdzie c jest stałą, ale nie może wykonać już na przykład n2 operacji, gdyż jest to wyższy rząd wielkości. Innymi słowy, obliczając 1

złożoność, pomijamy stałe współczynniki. Jeśli więc pętla wykonywałaby się 20·n lub n5 razy, to wciąż mamy złożoność O(n), choć czas działania programów może być różny. Analizując złożoność, powinniśmy wyszukiwać specjalne, złośliwe przykłady danych, na których dany program będzie działał długo.

Porównanie różnych złożoności czasowych Spróbujmy porównać podstawowe złożoności czasowe.

1.2. Złożoność stała — O(1).

1 2

cin >> n; cout << n * n;

Zawsze mamy stałą liczbę operacji.

1.3. Złożoność logarytmiczna — O(log n).

1 2 3 4 5 6

cin >> n; while (n > 1) { n = n / 2; wynik++; } cout << wynik;

Wartość n jest w każdym obrocie pętli zmniejszana o połowę. Jeśli n = 2x , to log n = x (zakładamy, że domyślną podstawą logarytmu jest 2). Stąd złożoność logarytmiczna.

Zastanówmy się, jak szybko będzie działał poniższy program w zależności od danych wejściowych.

1.4. Złożoność liniowa — O(n).

1 2 3 4 5 6

cin >> n; for (int i = 1; i <= n; i++) { cin >> x; if (x == 0) return 0; }

Zauważmy, że jeśli pierwszą wczytaną wartością x byłoby zero, to program od razu by się zakończył. Pamiętajmy jednak że badając złożoność, szukamy 2

1. ZŁOŻONOŚĆ CZASOWA

złośliwych przypadków. Ten program będzie działał najdłużej, jeśli zero nigdy nie wystąpi.

1.5. Złożoność kwadratowa — O(n2 ).

1 2 3 4 5

cin >> n; for (int i = 1; i <= n; i++) for (int j = i; j <= n; j++) wynik++; cout << wynik;

Wynik będzie równy 12 · (n2 + n) (wyjaśnienie w ćwiczeniach). Obliczając złożoność, szacujemy czas działania, więc jesteśmy zainteresowani wyrażeniem, które rośnie najszybciej. Wobec tego nie tylko pomijamy stałe, ale również inne wyrażenia (w tym przypadku 12 · n), które rosną wolniej. W ten sposób uzyskujemy złożoność kwadratową.

Popatrzmy na przykład, gdy złożoność zależy od kilku zmiennych.

1.6. Złożoność liniowa względem n i m — O(n + m).

1 2 3 4 5

cin >> n >> m; for (int i = 1; i <= n; i++) cout << i << ’ ’; for (int i = 1; i <= m; i++) cout << i << ’ ’;

Złożoności wykładnicze Warto wiedzieć, że istnieją inne złożoności, takie jak O(2n ), O(n!). Są to złożoności wykładnicze. Programy o takich złożonościach rozwiązują problemy tylko dla małych n, gdyż dla dużych działałyby bardzo długo.

Limit czasu Obecnie komputery wykonują około 108 operacji w mniej niż sekundę.

W typowych konkursach programistycznych, na komputerach sprawdzających rozwiązania, limity na wykonanie zadań wynoszą zazwyczaj od 1 do 10 sekund.

Podczas zawodów mamy często podane ograniczenie na wielkość danych, dzięki czemu możemy się domyślać w jakiej złożoności powinno zostać rozwiązane zadanie. Jest to zwykle duże ułatwienie, gdyż możemy szukać LIMIT CZASU

3

rozwiązania działającego w określonej złożoności, zamiast szukać szybszych rozwiązań. Przykładowo, dla: • n ¬ 1 000 000 oczekiwana złożoność czasowa to O(n) lub O(n log n), • n ¬ 10 000 oczekiwana złożoność czasowa to O(n2 ), • n ¬ 500 oczekiwana złożoność czasowa to O(n3 ).

Pamiętajmy, że limity nie są ścisłe, a tylko przybliżone. Często zależą one od konkretnego zadania. Jeśli stwierdzimy, że program wykonuje dużo ponad 108 operacji, to powinniśmy się zastanowić, czy nie istnieje szybsze (o lepszej złożoności czasowej) rozwiązanie problemu.

Złożoność pamięciowa Rozwiązując zadania, należy również zwrócić uwagę na limit dostępnej pamięci. Limit pamięci określa, jak dużo zmiennych możemy zadeklarować.

W przybliżeniu, jeśli mamy stałą liczbę zmiennych, to złożoność pamięciowa wynosi O(1). Jeżeli potrzebujemy zadeklarować tablicę z n elementami, to złożoność pamięciowa wynosi O(n) (analogicznie, jak przy złożoności czasowej). W zadaniach konkursowych limit pamięci określany jest w megabajtach, w skrócie MB. Warto wiedzieć, że każda zmienna typu int zajmuje 4 bajty, a tablica miliona takich zmiennych zajmuje około 4 MB. Warto zauważyć, że nie zawsze wszystkich zmiennych i struktur danych potrzebujemy używać w tym samym czasie. Dzięki temu możemy oszczędzać pamięć, używając jednej zmiennej do różnych celów (poprzez jej nadpisywanie).

Ćwiczenie Problem: Dla danego n mamy obliczyć sumę liczb całkowitych od 1 do n.

Rozwiązanie: Zadanie możemy rozwiązać na kilka różnych sposobów. Osoba niezdająca sobie sprawy ze złożoności czasowej mogłaby zwiększać wynik o jeden.

1.7. Rozwiązanie brutalne — złożoność O(n2 ).

1 2 3

4

for (int i = 1; i <= n; i++) for (int j = 1; j <= i; j++) wynik++;

1. ZŁOŻONOŚĆ CZASOWA

Zastanówmy się, jak przyspieszyć powyższy program. Zamiast pojedynczego zwiększania wyniku, moglibyśmy zwiększać go hurtowo — kolejno o 1, 2, . . . , n.

1.8. Rozwiązanie wolne — złożoność O(n).

1 2

for (int i = 1; i <= n; i++) wynik += i;

Co ciekawe, powyższe rozwiązanie można jeszcze bardziej przyspieszyć.

Wypiszmy ciąg 1, 2, . . . , n, a tuż pod nim ten sam ciąg w odwrotnej kolejności.

Dodajmy liczby z tych samych kolumn.

1

2

3

...

n

n−1

n−2

...

n+1

n+1

n+1

...

n−1

n

2

1

n+1

n+1

Po zsumowaniu, w każdej komórce pojawiła się wartość n + 1, dzięki czemu możemy łatwo obliczyć wzór na całkowitą sumę.

1.9. Rozwiązanie szybkie — złożoność O(1).

1

wynik = n * (n + 1) / 2;

W zależności od limitów w zadaniu powyższe rozwiązania mogą być akceptowane bądź nie. Przykładowo, jeśli mamy zadeklarowane, że: • n ¬ 10 000, to wszystkie programy powinny zostać zaakceptowane, • n ¬ 1 000 000, to rozwiązanie brutalne wykona około 1012 operacji, co zwykle spowoduje przekroczenie limitu czasu. Rozwiązanie wolne i szybkie powinno zostać zaakceptowane, • n ¬ 1010 , to tylko rozwiązanie szybkie powinno zostać zaakceptowane.

Zadania treningowe Zadanie: Żabka Konkurs: VIII Obóz Informatyczny ilocamp Pamięć: 32 MB

⋆ Autor zadania: Jacek Tomasiewicz

Mała żabka chce się przedostać na drugą stronę drogi. Początkowo znajduje się ZADANIA TRENINGOWE

5

w punkcie x, a koniec drogi jest w miejscu y. Żabka skacze zawsze o odległość równą s. s

s

s y

x

Zastanawiamy się, ile co najmniej skoków wykona żabka, nim doskoczy do końca lub przeskoczy koniec drogi.

Wejście Pierwszy wiersz wejścia zawiera 3 liczby całkowite x, y, s (1 ¬ x < y, s ¬ 109 ) oznaczające odpowiednio: pozycję żabki, koniec drogi oraz długość skoku żabki.

Wyjście Pierwszy i jedyny wiersz wyjścia powinien zawierać jedną liczbę całkowitą równą minimalnej liczbie skoków, po których wykonaniu żabka doskoczy do końca drogi lub go przeskoczy.

Przykład Dla danych wejściowych: 10 85 30

Zadanie: Chodnik Konkurs: V Obóz Informatyczny ilocamp Pamięć: 32 MB

Poprawną odpowiedzią jest: 3

⋆⋆ Autor zadania: Jacek Tomasiewicz

Edek napisał kredą na chodniku wszystkie liczby całkowite od 1 do n w losowej kolejności. Następnie poszedł do sklepu. Po powrocie zauważył, że brakuje jednej liczby. Pomóż Edkowi i powiedz, której liczby brakuje!

Wejście Pierwszy wiersz wejścia zawiera jedną liczbę całkowitą n (1 ¬ n ¬ 500 000), która wskazuje, ile liczb wypisał Edek.

Kolejny wiersz zawiera n − 1 liczb całkowitych l0 , l1 , . . . , ln−2 (1 ¬ li ¬ n), gdzie li oznacza i-tą liczbę na chodniku (po powrocie Edka ze sklepu).

6

1. ZŁOŻONOŚĆ CZASOWA

Wyjście Pierwszy i jedyny wiersz wyjścia powinien zawierać jedną liczbę całkowitą — liczbę, której brakuje na chodniku.

Przykład Dla danych wejściowych: 5 2 3 1 5

Poprawną odpowiedzią jest: 4

Zadanie: Taśma Konkurs: III Obóz Informatyczny ilocamp Pamięć: 32 MB

⋆⋆ Autor zadania: Jacek Tomasiewicz

Jaś znalazł w domu długą taśmę. Bez chwili namysłu napisał na taśmie pewien ciąg liczb całkowitych. Teraz chciałby przeciąć taśmę w pewnym miejscu, tak aby różnica między sumą liczb na jednym kawałku, a sumą liczb na drugim kawałku była jak najbliższa zeru. Chcielibyśmy znać wartość bezwzględną z tej różnicy.

Wejście Pierwszy wiersz wejścia zawiera jedną liczbę całkowitą n (2 ¬ n ¬ 1 000 000), oznaczającą liczbę liczb na taśmie. Drugi wiersz wejścia zawiera n liczb całkowitych a0 , a1 , . . . , an−1 (−1 000 ¬ ai ¬ 1 000), gdzie ai oznacza i-tą liczbę napisaną na taśmie.

Wyjście Pierwszy i jedyny wiersz wyjścia powinien zawierać jedną liczbę całkowitą, równą minimalnej wartości bezwzględnej różnicy sum liczb na obu kawałkach.

Przykład Dla danych wejściowych: 5 3 1 2 4 3

ZADANIA TRENINGOWE

Poprawną odpowiedzią jest: 1

7

Rozwiązania Przed czytaniem rozwiązań warto przeczytać punkt Konwencje w rozdziale Od autora.

Żabka • Zadanie można rozwiązać w czasie O(1).

• Różnicę między końcem drogi a punktem startowym należy podzielić przez długość skoku.

1

wynik = 1 + (y - x - 1) / s;

Chodnik • Zadanie można rozwiązać w czasie O(n) oraz w pamięci O(n) lub O(1).

• W pamięci O(n) liczby można włożyć do odpowiadających im komórek w tablicy. Przykładowo, liczbę 5 wkładamy do komórki o indeksie 5. Na koniec wystarczy sprawdzić, której z liczb brakuje.

• W pamięci O(1) można skorzystać ze wzoru na sumę liczb od 1 do n, czyli s = n·(n+1) . Następnie od s wystarczy odjąć sumę wszystkich liczb, które 2 pozostały na chodniku.

• Szkic rozwiązania (zakładamy, że suma to suma wszystkich liczb na chodniku): 1 2

s = (n * (n + 1)) / 2; wynik = s - suma;

Taśma • Zadanie można rozwiązać w czasie O(n).

• Znając sumę wszystkich liczb oraz sumę liczb po lewej stronie, można obliczyć sumę liczb po prawej stronie.

• Szkic rozwiązania (zakładamy, że s to suma wszystkich liczb): 1 2 3 4 5 6 7

8

wynik = 2 * 1000 + 1; for (int i = 0; i < n - 1; i++) { lewa += a[i]; prawa = s - lewa; roznica = abs(lewa - prawa); wynik = min(wynik, roznica); }

1. ZŁOŻONOŚĆ CZASOWA

Księgarnia Internetowa PWN: Jacek Tomasiewicz - Zaprzyjaźnij się z algorytmami

Wprowadzenie Komputer wkroczył niepostrzeżenie w życie każdego z nas. Prawie codziennie poszukujemy informacji w internecie, komunikujemy się ze znajomymi, wysyłając smsy, rozmawiamy przez Skype’a, kupujemy przez komputer bilety na pociąg lub do kina, bawimy się, grając na nim w gry. Z jednej strony stało się to możliwe dzięki rozwojowi technologii, która doprowadziła do miniaturyzacji urządzeń elektronicznych przy jednoczesnym zwiększaniu ich mocy obliczeniowej — procesory są coraz szybsze i są w stanie przechowywać oraz przetwarzać coraz więcej danych. Z drugiej strony komputer jest tylko urządzeniem elektronicznym o potencjalnie nieskończonych możliwościach, które nie znalazłyby tak powszechnego i szerokiego zastosowania, gdyby nie pomysłowość i umiejętności twórców programów komputerowych. Komputer jest w stanie wykonywać jedynie to, co nakaże mu programista za pomocą programu. Program komputerowy jest precyzyjnym zapisem algorytmu w języku, który jest zrozumiały dla komputera — w języku programowania. Algorytm zaś, potocznie, to precyzyjny przepis opisujący działanie, które może być wykonane przez człowieka, komputer lub inne medium, nie koniecznie rozumiejące istotę podjętego działania. Dziedzinę informatyki, która zajmuje się badaniem algorytmów, nazywa się algorytmiką.

Wybitny izraelski informatyk Dawid Harel w swojej znakomitej książce Rzecz o istocie informatyki. Algorytmika napisał: Przepisy określiliśmy mianem algorytmów, obszar zaś ludzkich dociekań, wiedzy i doświadczeń dotyczących algorytmów nazwiemy algorytmiką. I dalej: Algorytmika to więcej niż dział informatyki. Tkwi ona w centrum wszystkich działów informatyki.

W tym miejscu przypomnijmy jeszcze słowa Donalda Knutha (pierwszego badacza, który zajął się systematycznym badaniem algorytmów) z jego trylogii Sztuka programowania: Proces przygotowywania programu dla komputera cyfrowego jest pociągający nie tylko ze względu na potencjalne korzyści ekonoXI

miczne czy naukowe. Wiążą się z nim również przeżycia estetyczne, podobne do tworzenia poezji lub komponowania muzyki.

Książka Jacka Tomasiewicza jest znakomitym wprowadzeniem w świat algorytmów i programowania dla początkujących i średnio zaawansowanych, którzy chcą osiągnąć mistrzostwo w najbardziej podstawowym dziale informatyki, jakim jest algorytmika. Znakomicie dobrane zadania i odpowiednie stopniowanie trudności pozwalają początkującym informatykom zapoznać się z podstawowymi metodami projektowania i analizowania algorytmów ze szczególnym uwzględnieniem ich złożoności obliczeniowej. Autor zebrał zadania, które z powodzeniem wykorzystywał na zajęciach z młodymi adeptami algorytmiki ze szkół ponadgimnazjalnych i gimnazjów. Jako młody człowiek, finalista Olimpiady Informatycznej, doskonale rozumie, co jest najtrudniejsze w poznawaniu algorytmiki na początkowym etapie. Dlatego stara się trudne tematy tłumaczyć bez specjalnego formalizmu, językiem w pełni zrozumiałym nawet dla gimnazjalisty.

Książka Jacka Tomasiewicza jest godna polecenia nie tylko wszystkim zainteresowanym algorytmiką i programowaniem. Będzie także pomocna w powszechnym nauczaniu algorytmiki w gimnazjach i szkołach ponadgimnazjalnych. Zbioru zadań z przystępnymi zadaniami algorytmicznymi bardzo brakowało. Gorąco polecam książkę autorstwa Jacka Tomasiewicza! prof. dr hab. Krzysztof Diks Przewodniczący Komitetu Głównego Olimpiady Informatycznej Instytut Informatyki Uniwersytetu Warszawskiego

XII

WPROWADZENIE

Księgarnia Internetowa PWN: Jacek Tomasiewicz - Zaprzyjaźnij się z algorytmami

Od autora Programowanie w dzisiejszych czasach staje się coraz bardziej popularne.

Jest na tyle ważną umiejętnością, że jego nauczanie zaczyna się od szkół gimnazjalnych lub nawet podstawowych. W programach nauczania jest coraz więcej algorytmiki. Pojawiają się takie tematy, jak rozwiązywanie problemów z zastosowaniem podejścia algorytmicznego. Udział dużej liczby uczestników w Olimpiadzie Informatycznej dedykowanej uczniom szkół ponadgimnazjalnych oraz w Olimpiadzie Informatycznej Gimnazjalistów świadczy o popularności programowania wśród młodych osób.

Początki programowania i pierwsze próby rozwiązywania zadań algorytmicznych mogą być jednak bardzo trudne. Wiele osób poddaje się już po kilku nieudanych podejściach rozwiązania złożonych problemów. Istnieje wiele książek poświęconych analizie zaawansowanych algorytmów, a brakuje materiałów dla początkujących i średnio zaawansowanych oraz książek dla nauczycieli, którzy są bardzo ważni w procesie kształcenia przyszłych programistów.

Książka ta jest swego rodzaju wstępem do algorytmiki oraz podręcznikiem nauczania. Nie zawiera trudnych, zaawansowanych algorytmów, których opis można znaleźć w wielu innych źródłach. Zawiera za to opis i implementację najważniejszych, prostych algorytmów oraz zbiór zadań umożliwiających przećwiczenie ich w praktyce.

Grupą docelową książki są nie tylko uczniowie rozpoczynający swoją przygodę z algorytmiką, ale także nauczyciele informatyki poszerzający swoją wiedzę algorytmiczną. Książka ma szansę wpłynąć pozytywnie na jakość kształcenia uczniów oraz doprowadzić do zwiększenia liczby osób startujących w konkursach informatycznych.

Pomysł na książkę narodził się podczas organizacji konkursów, kół naukowych oraz obozów informatycznych na różnym poziomie zaawansowania.

Największym wyzwaniem było wymyślenie prostych, lecz nietrywialnych XIII

zadań oraz przekazanie wiedzy osobom początkującym. W książce zostały umieszczone najciekawsze i najbardziej odpowiednie zadania zbierane i przygotowywane przez autora od momentu rozpoczęcia studiów. Najważniejsze tematy zostały wybrane na podstawie doświadczenia z ośmiu lat nauczania.

W przypadku jakichkolwiek pytań dotyczących książki prosimy o kontakt do autora na adres mailowy programernia@gmail.com. Autor prowadzi również zajęcia z programowania. Jeśli chciałbyś się dowiedzieć więcej na temat tych zajęć, skontaktuj się, pisząc na podany adres.

Struktura książki Książka składa się z 18 rozdziałów, w których są omawiane algorytmy oraz techniki programowania stosowane w początkach nauczania algorytmiki.

Rozdziały zostały ułożone chronologicznie i poruszają tematy z różnych dziedzin, takich jak struktury danych, teoria liczb i teoria grafów.

Każdy rozdział został podzielony na trzy części. W pierwszej z nich w krótki, przystępny sposób jest opisana wybrana technika programowania lub algorytm wraz z jego implementacją, aby zaznajomić Czytelnika z omawianym tematem. Druga część to ćwiczenie, które porusza problematykę zagadnienia i prezentuje sposób wykorzystania algorytmu w zadaniach. W każdym ćwiczeniu został przedstawiony dokładny opis rozwiązania problemu.

Trzecia część zawiera zestaw trzech zadań treningowych o rosnącym stopniu trudności, dzięki którym Czytelnik może sprawdzić nabyte umiejętności w praktyce. Dodatkowo, do każdego zadania zostały przygotowane wskazówki — po kilka podpowiedzi, które mogą być pomocne podczas rozwiązywania zadania. Elementy implementacji algorytmów oraz rozwiązań zadań zapisane są w popularnym obecnie języku C++.

W dodatku A znajduje się lista 26 bardziej zaawansowanych algorytmów i struktur danych (z krótkim opisem), ułożonych od najprostszych do najtrudniejszych. W dodatku B jest podany opis standardowej biblioteki wzorców (STL), czyli zbioru bibliotek w C++ przydatnych w implementacji algorytmów.

Ćwiczenia i zadania treningowe Poszczególne rozdziały książki zawierają zadania związane z omawianą tematyką (łącznie 18 ćwiczeń i ponad 50 zadań treningowych). Wiedza potrzebna do rozwiązania kolejnych zadań znajduje się w rozdziałach je poprzedzających.

Dzięki temu Czytelnik, po przyswojeniu materiału zawartego w kolejnych XIV

OD AUTORA

rozdziałach, będzie w stanie rozwiązać wszystkie zadania. Większość z nich pochodzi z ogólnopolskich konkursów informatycznych, takich jak Olimpiada Informatyczna lub Potyczki Algorytmiczne, oraz z obozów informatycznych ILOCAMP. Zadania zostały podzielone na cztery kategorie i są oznaczone minimalnie jedną (zadania proste), a maksymalnie czterema gwiazdkami (zadania bardzo trudne).

W zadaniach prostych oraz o średniej trudności do rozwiązania wystarczy podstawowa znajomość pewnego algorytmu oraz umiejętność jego praktycznego zastosowania. Charakteryzują się wysokim odsetkiem poprawnych rozwiązań przez uczestników konkursów, w których zadania zostały użyte, oraz łatwością zrozumienia rozwiązania. Zadania trudne wymagają dodatkowego pomysłu. Co więcej, mogą wymagać zastosowania algorytmów z poprzednich rozdziałów oraz cechują się bardziej złożoną implementacją. Zadania bardzo trudne zawierają złożone problemy, w których wykorzystanie algorytmów nie jest łatwo dostrzegalne. Charakteryzują się małym odsetkiem poprawnych i optymalnych rozwiązań przez uczestników. Przypisanie poziomu trudności bazuje na doświadczeniu autora w pracy z uczniami oraz na statystykach z przeprowadzonych konkursów.

Testowanie rozwiązań Rozwiązania zadań treningowych można przetestować w serwisie na stronie internetowej http://main2.edu.pl. Po wybraniu odpowiedniego kursu http://main2.edu.pl/c/zadania-pwn i zadania wysłany kod zostanie przetestowany pod względem poprawności oraz wydajności.

Wymagania wstępne Książka dotyczy algorytmiki, a nie konkretnego języka programowania.

Wszystkie przedstawione w książce algorytmy są zaimplementowane w języku C++, którego składnię Czytelnik może poznawać, czytając kolejne rozdziały.

Początkowo wystarczy znajomość podstaw jednego języka programowania, takich jak warunki, pętle i tablice.

Konwencje Przedstawione implementacje zakładają, że: • wszystkie zmienne są początkowo wyzerowane, • pomijamy wczytywanie i wypisywanie danych oraz załączanie bibliotek, OD AUTORA

XV

• elementy w tablicach są umieszczone od indeksu 0, chyba że napisano inaczej.

Metody pracy Książka może być wykorzystywana przez uczniów do samodzielnej nauki podstawowych algorytmów oraz przez osoby chcące poszerzyć swoją wiedzę algorytmiczną. Może też być doskonałym podręcznikiem dla nauczycieli uczących w szkołach lub dla wykładowców przeprowadzających dodatkowe zajęcia informatyczne.

Poniżej przedstawiono metody pracy dla osób dokształcających się samodzielnie oraz dla nauczycieli przekazujących swoją wiedzę innym.

Do uczniów Naukę algorytmiki warto rozplanować w czasie. Przykładowo, można się zobowiązać do przerabiania jednego rozdziału tygodniowo. Wszystkie rozdziały mają taką samą formę, warto więc zapoznać się z opisem pracy z pojedynczego rozdziału.

1. Na początku przeczytaj ze zrozumieniem opis algorytmu lub techniki programowania (całość do części z ćwiczeniem). W opisach często znajdziesz implementacje, które warto dokładnie prześledzić.

2. Druga część to ćwiczenie. Zanim przeczytasz rozwiązanie, spróbuj je wymyślić samodzielnie. Wystarczy ogólny pomysł na rozwiązanie, bez implementacji. Następnie opisane rozwiązanie porównaj z wymyślonym przez siebie i ostatecznie je zaimplementuj (abyś był pewien, że zrozumiałeś algorytm).

3. Trzecia część to zadania treningowe ułożone od najprostszych do najtrudniejszych. Po wymyśleniu optymalnego rozwiązania spróbuj je zaimplementować i przetestować pod względem poprawności i wydajności.

W przypadku problemów z pomysłem na algorytm, na końcu rozdziału znajdziesz wskazówki ułatwiające wymyślenie rozwiązania. Po przeczytaniu każdej z nich spróbuj ponownie podejść do zadania. Jeśli po przeczytaniu wszystkich nie będziesz w stanie zrozumieć ani zaimplementować rozwiązania, to odłóż zadanie na później i przejdź do kolejnego rozdziału (ale tylko w przypadku, gdy rozwiążesz co najmniej jedno zadanie). Każdy rozdział zawiera przynajmniej jedno trudne zadanie, dlatego nie przejmuj się w przypadku nieudanych prób jego rozwiązania.

Zawsze warto dokumentować postępy w nauce. Przykładowo, możesz utworzyć tabelę i zaznaczać, które rozdziały już przeczytałeś i jakie zadania XVI

OD AUTORA

udało Ci się rozwiązać. Takie postępowanie motywuje do dalszej pracy oraz pozwala śledzić postępy w nauce.

Po przerobieniu wszystkich rozdziałów możesz przejść do kolejnych, bardziej zaawansowanych tematów. W dodatku B znajdziesz listę 26 najważniejszych algorytmów. Dokładniejszy opis tych zagadnień możesz znaleźć w wielu informatycznych książkach, takich jak Algorytmy i struktury danych [BDR] czy Wprowadzenie do algorytmów [WDA].

Do nauczycieli Poniżej znajduje się opis pracy dla nauczyciela uczącego grupę osób lub przeprowadzającego indywidualne korepetycje. Początkowo warto zaznajomić się ze wszystkimi rozdziałami i rozplanować nauczanie w czasie. W miarę potrzeb można wprowadzić kilka zagadnień, które nie zostały opisane w książce.

Mogą to być tematy poprzedzające (takie jak nauka programowania) lub tematy pomiędzy rozdziałami (takie jak rekurencja, systemy liczbowe lub szyfrowanie).

Pierwsza część to przedstawienie uczniom zagadnień teoretycznych, czyli omówienie algorytmu i pokazanie implementacji. Jest to bardzo ważny fragment. Należy wówczas kontrolować, czy uczniowie nadążają z przyswajaniem materiału.

Druga część to ćwiczenie teoretyczno-praktyczne, w którym pomysł na rozwiązanie będzie szukany wspólnie z nauczycielem. Nauczyciel pokazuje ćwiczenie i daje uczniom trochę czasu na samodzielne zastanowienie się nad problemem. Następnie chętne osoby mogą przedstawić swoje spostrzeżenia, a nauczyciel naprowadza grupę na rozwiązanie. W tej części ważne jest pokazanie procesu wymyślania rozwiązania. Na koniec, celem pełnego zrozumienia, uczniowie powinni zaimplementować rozwiązanie.

Trzecia część to zadania treningowe, które sprawdzają praktyczną wiedzę uczniów. Wybór zadań powinien być dostosowany do poziomu grupy.

W przypadku słabszych grup i ograniczonego czasu należy zadać wyłącznie najprostsze zadanie, natomiast w przypadku mocniejszych grup warto dać wszystkie zadania. Rozwiązywanie i implementowanie może odbywać się w trakcie tak zwanego laboratorium, w którym nauczyciel może rozważnie pomagać uczniom. Zadania mogą być również zadane jako praca domowa.

Zawsze po upływie terminu na rozwiązywanie zadań należy przedstawić całej grupie dokładną metodę rozwiązania (najlepiej w formie podobnej do ćwiczeń) oraz zachęcić uczniów do implementacji rozwiązań.

Po przerobieniu wszystkich rozdziałów nauczyciel może przejść do bardziej zaawansowanych algorytmów. Propozycja listy takich zagadnień znajduje się w dodatku B. OD AUTORA

XVII

Podziękowania Książka ta powstała na podstawie mojej pracy magisterskiej, którą obroniłem w czerwcu 2015 roku na Uniwersytecie Warszawskim. Praca była pisana w latach 2013–2014, jednak materiały do niej powstawały również w latach wcześniejszych. Ogromnie dziękuję opiekunowi pracy, dr. Jakubowi Radoszewskiemu, za cenne uwagi merytoryczne, poświęcony czas oraz wielkie zaangażowanie.

Dziękuję również Grzegorzowi Jakackiemu — szefowi firmy Codility — za wsparcie oraz umożliwienie jednoczesnego pogodzenia pracy zawodowej oraz pisania pracy magisterskiej. Wielkie podziękowania należą się także dr. Marcinowi Kubicy, dr. Tomaszowi Idziaszkowi oraz Przemysławowi Jakubowi Kozłowskiemu za cenne wskazówki oraz uwagi merytoryczne dotyczące pracy.

Jednym z wyzwań podczas gromadzenia materiałów do pracy był proces wybierania odpowiednich zadań. Chciałbym podziękować Joannie Bujnowskiej za udostępnienie swoich zadań Wesoła małpka i Drzewko, dr. Jakubowi Radoszewskiemu za udostępnienie zadań Liczby doskonałe i Spotkanie oraz dr. Marcinowi Kubicy za udostępnienie zadania Obwód.

Podziękowania kieruję również do prof. Krzysztofa Diksa — świetnego wykładowcy oraz przewodniczącego Komitetu Głównego Olimpiady Informatycznej — za merytoryczne wsparcie oraz wszelaką pomoc. Dziękuję też Ireneuszowi Bujnowskiemu — znakomitemu nauczycielowi, który zaszczepił we mnie pasję do informatyki.

XVIII

OD AUTORA