Algorithmen und Datenstrukturen Tafelübung 4. Jens Wetzl 15. November 2011

Transkript

1 Algorithmen und Datenstrukturen Tafelübung 4 Jens Wetzl 15. November 2011

2 Folien Keine Garantie für Vollständigkeit und/oder Richtigkeit Keine offizielle Informationsquelle LS2-Webseite Abrufbar unter: Hinweis zu Aufgabe 4.4: Rekursive Kunst Im CIP-Pool läuft der process checker, der Programme abschießt, die lange mit hoher CPU-Auslastung laufen Große rekursive Kunstwerke auf dem eigenen Rechner! 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 2 / 19

3 Was machen wir heute? Rekursion Theorie Beispiele Rekursionsarten Live-Programmierung: Türme von Hanoi Induktionsbeweise Backtracking Vorgehensweise Live-Programmierung: Monopoly Klausuraufgabe zu Rekursion 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 3 / 19

4 Rekursion Theorie Beispiele Rekursionsarten

5 Theorie Rekursiver Gedanke: Wir wollen ein Problem so in ein oder mehrere (kleinere) Teilprobleme zerlegen, dass 1. bei fortgesetzter Zerlegung die Teilprobleme irgendwann so klein sind, dass sie trivial gelöst werden können 2. aus den Lösungen der kleineren Teilprobleme leicht die Lösung des größeren Problems zusammengestellt werden kann Eine rekursive Methode sieht häufig so aus: static int recursive(int arg1, int arg2,...) { // Basisfall / Basisfaelle: if (arg1 == 0 arg2 == 0) return 1; // Teilprobleme durch Rekursion loesen: int a = recursive(arg1-1, arg2); int b = recursive(arg1, arg2-1); // Zusammensetzen der Loesung aus den Teilloesungen: return a * b; 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 5 / 19

6 Theorie Rekursiver Gedanke: Wir wollen ein Problem so in ein oder mehrere (kleinere) Teilprobleme zerlegen, dass 1. bei fortgesetzter Zerlegung die Teilprobleme irgendwann so klein sind, dass sie trivial gelöst werden können 2. aus den Lösungen der kleineren Teilprobleme leicht die Lösung des größeren Problems zusammengestellt werden kann Eine rekursive Methode sieht häufig so aus: static int recursive(int arg1, int arg2,...) { // Basisfall / Basisfaelle: if (arg1 == 0 arg2 == 0) return 1; // Teilprobleme durch Rekursion loesen: int a = recursive(arg1-1, arg2); int b = recursive(arg1, arg2-1); // Zusammensetzen der Loesung aus den Teilloesungen: return a * b; 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 5 / 19

7 Theorie Rekursiver Gedanke: Wir wollen ein Problem so in ein oder mehrere (kleinere) Teilprobleme zerlegen, dass 1. bei fortgesetzter Zerlegung die Teilprobleme irgendwann so klein sind, dass sie trivial gelöst werden können 2. aus den Lösungen der kleineren Teilprobleme leicht die Lösung des größeren Problems zusammengestellt werden kann Eine rekursive Methode sieht häufig so aus: static int recursive(int arg1, int arg2,...) { // Basisfall / Basisfaelle: if (arg1 == 0 arg2 == 0) return 1; // Teilprobleme durch Rekursion loesen: int a = recursive(arg1-1, arg2); int b = recursive(arg1, arg2-1); // Zusammensetzen der Loesung aus den Teilloesungen: return a * b; 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 5 / 19

8 Theorie Rekursiver Gedanke: Wir wollen ein Problem so in ein oder mehrere (kleinere) Teilprobleme zerlegen, dass 1. bei fortgesetzter Zerlegung die Teilprobleme irgendwann so klein sind, dass sie trivial gelöst werden können 2. aus den Lösungen der kleineren Teilprobleme leicht die Lösung des größeren Problems zusammengestellt werden kann Eine rekursive Methode sieht häufig so aus: static int recursive(int arg1, int arg2,...) { // Basisfall / Basisfaelle: if (arg1 == 0 arg2 == 0) return 1; // Teilprobleme durch Rekursion loesen: int a = recursive(arg1-1, arg2); int b = recursive(arg1, arg2-1); // Zusammensetzen der Loesung aus den Teilloesungen: return a * b; 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 5 / 19

9 Beispiele f (n) = n i=1 i, n > 0 g(n): Abstand der Zahl n von 5 fib(n) = fib(n 1) + fib(n 2): Was muss man hier im Gegensatz zu den Funktionen oben beachten? Pseudocode für Listenlänge: x0, xrest = split(x) spaltet x in 1. Element und Restliste auf, empty(x) prüft, ob Liste x leer ist Stammbaum: void drawfamilytree(person p) { write(p.getname()); if (p.haschildren()) { for (Person child: p.getchildren()) { drawfamilytree(child); drawlink(person, child); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 6 / 19

10 Beispiele f (n) = n i=1 i, n > 0 g(n): Abstand der Zahl n von 5 fib(n) = fib(n 1) + fib(n 2): Was muss man hier im Gegensatz zu den Funktionen oben beachten? Pseudocode für Listenlänge: x0, xrest = split(x) spaltet x in 1. Element und Restliste auf, empty(x) prüft, ob Liste x leer ist Stammbaum: void drawfamilytree(person p) { write(p.getname()); if (p.haschildren()) { for (Person child: p.getchildren()) { drawfamilytree(child); drawlink(person, child); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 6 / 19

11 Beispiele f (n) = n i=1 i, n > 0 g(n): Abstand der Zahl n von 5 fib(n) = fib(n 1) + fib(n 2): Was muss man hier im Gegensatz zu den Funktionen oben beachten? Pseudocode für Listenlänge: x0, xrest = split(x) spaltet x in 1. Element und Restliste auf, empty(x) prüft, ob Liste x leer ist Stammbaum: void drawfamilytree(person p) { write(p.getname()); if (p.haschildren()) { for (Person child: p.getchildren()) { drawfamilytree(child); drawlink(person, child); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 6 / 19

12 Beispiele f (n) = n i=1 i, n > 0 g(n): Abstand der Zahl n von 5 fib(n) = fib(n 1) + fib(n 2): Was muss man hier im Gegensatz zu den Funktionen oben beachten? Pseudocode für Listenlänge: x0, xrest = split(x) spaltet x in 1. Element und Restliste auf, empty(x) prüft, ob Liste x leer ist Stammbaum: void drawfamilytree(person p) { write(p.getname()); if (p.haschildren()) { for (Person child: p.getchildren()) { drawfamilytree(child); drawlink(person, child); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 6 / 19

13 Beispiele f (n) = n i=1 i, n > 0 g(n): Abstand der Zahl n von 5 fib(n) = fib(n 1) + fib(n 2): Was muss man hier im Gegensatz zu den Funktionen oben beachten? Pseudocode für Listenlänge: x0, xrest = split(x) spaltet x in 1. Element und Restliste auf, empty(x) prüft, ob Liste x leer ist Stammbaum: void drawfamilytree(person p) { write(p.getname()); if (p.haschildren()) { for (Person child: p.getchildren()) { drawfamilytree(child); drawlink(person, child); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 6 / 19

14 Rekursionsarten Lineare Rekursion Maximal ein rekursiver Aufruf pro Methodenaufruf (verschieden Aufrufe in verschiedenen Zweigen möglich) Endrekursion Rekursiver Funktionsaufruf ist letzte Aktion zur Berechnung der Methode (was ist der Vorteil? Beispiel?) Kaskadenartige Rekursion Zwei oder mehr rekursive Aufrufe pro Methodenaufruf (was heißt das für die Laufzeit? Beispiel?) Verschränkte Rekursion Zwei Funktionen f und g heißen verschränkt rekursiv, wenn f einen Aufruf von g und g einen von f enthält Verschachtelte Rekursion Z.B. Ackermann-Funktion: static int ackermann(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ackermann(m - 1, 1); else return ackermann(m - 1, ackermann(m, n - 1)); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 7 / 19

15 Rekursionsarten Lineare Rekursion Maximal ein rekursiver Aufruf pro Methodenaufruf (verschieden Aufrufe in verschiedenen Zweigen möglich) Endrekursion Rekursiver Funktionsaufruf ist letzte Aktion zur Berechnung der Methode (was ist der Vorteil? Beispiel?) Kaskadenartige Rekursion Zwei oder mehr rekursive Aufrufe pro Methodenaufruf (was heißt das für die Laufzeit? Beispiel?) Verschränkte Rekursion Zwei Funktionen f und g heißen verschränkt rekursiv, wenn f einen Aufruf von g und g einen von f enthält Verschachtelte Rekursion Z.B. Ackermann-Funktion: static int ackermann(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ackermann(m - 1, 1); else return ackermann(m - 1, ackermann(m, n - 1)); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 7 / 19

16 Rekursionsarten Lineare Rekursion Maximal ein rekursiver Aufruf pro Methodenaufruf (verschieden Aufrufe in verschiedenen Zweigen möglich) Endrekursion Rekursiver Funktionsaufruf ist letzte Aktion zur Berechnung der Methode (was ist der Vorteil? Beispiel?) Kaskadenartige Rekursion Zwei oder mehr rekursive Aufrufe pro Methodenaufruf (was heißt das für die Laufzeit? Beispiel?) Verschränkte Rekursion Zwei Funktionen f und g heißen verschränkt rekursiv, wenn f einen Aufruf von g und g einen von f enthält Verschachtelte Rekursion Z.B. Ackermann-Funktion: static int ackermann(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ackermann(m - 1, 1); else return ackermann(m - 1, ackermann(m, n - 1)); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 7 / 19

17 Rekursionsarten Lineare Rekursion Maximal ein rekursiver Aufruf pro Methodenaufruf (verschieden Aufrufe in verschiedenen Zweigen möglich) Endrekursion Rekursiver Funktionsaufruf ist letzte Aktion zur Berechnung der Methode (was ist der Vorteil? Beispiel?) Kaskadenartige Rekursion Zwei oder mehr rekursive Aufrufe pro Methodenaufruf (was heißt das für die Laufzeit? Beispiel?) Verschränkte Rekursion Zwei Funktionen f und g heißen verschränkt rekursiv, wenn f einen Aufruf von g und g einen von f enthält Verschachtelte Rekursion Z.B. Ackermann-Funktion: static int ackermann(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ackermann(m - 1, 1); else return ackermann(m - 1, ackermann(m, n - 1)); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 7 / 19

18 Rekursionsarten Lineare Rekursion Maximal ein rekursiver Aufruf pro Methodenaufruf (verschieden Aufrufe in verschiedenen Zweigen möglich) Endrekursion Rekursiver Funktionsaufruf ist letzte Aktion zur Berechnung der Methode (was ist der Vorteil? Beispiel?) Kaskadenartige Rekursion Zwei oder mehr rekursive Aufrufe pro Methodenaufruf (was heißt das für die Laufzeit? Beispiel?) Verschränkte Rekursion Zwei Funktionen f und g heißen verschränkt rekursiv, wenn f einen Aufruf von g und g einen von f enthält Verschachtelte Rekursion Z.B. Ackermann-Funktion: static int ackermann(int m, int n) { if (m == 0) return n + 1; if (n == 0) return ackermann(m - 1, 1); else return ackermann(m - 1, ackermann(m, n - 1)); 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 7 / 19

19 Live-Programmierung: Türme von Hanoi

20 Türme von Hanoi Quelle: November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 9 / 19

21 Induktionsbeweise

22 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

23 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

24 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

25 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

26 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

27 Induktionsbeweise Beweismethode, um zum Beispiel die Korrektheit einer rekursiven Formulierung zu zeigen Kann auch in der Klausur drankommen! Einfaches Beispiel: zu zeigen ist n k=1 c = n c Induktionsanfang: Für n = 1 ist 1 k=1 c = c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 1 gilt für n = 1: 2 k=1 c = c + 1 k=1 c = c + 1 c = 2 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 2 gilt für n = 3: 3 k=1 c = c + 2 k=1 c = c + 2 c = 3 c = n c Induktionsschritt: Unter Verwendung der Korrektheit der Formel für n = 3 gilt für n = 4: 4 k=1 c = c + 3 k=1 c = c + 3 c = 4 c = n c Induktionsschritt allgemein: n n + 1 n+1 k=1 c = c + n k=1 c IV = c + n c = (n + 1) c 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 11 / 19

28 Gauß sche Summenformel Zu zeigen: n k = k=1 n (n + 1) November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 12 / 19

29 Gauß sche Summenformel Zu zeigen: n k = k=1 n (n + 1) 2 Induktionsanfang: n = 1: = 1 = k k=1 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 12 / 19

30 Gauß sche Summenformel Zu zeigen: n k = k=1 n (n + 1) 2 Induktionsanfang: n = 1: = 1 = k k=1 Induktionsschritt: n n + 1 n+1 k = k=1 = = n k + (n + 1) IV = k=1 n (n + 1) 2 (n + 1) (n + 2) 2 n (n + 1) + (n + 1) 2 2 (n + 1) + = 2 n (n + 1) + 2 (n + 1) November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 12 / 19

31 Backtracking Vorgehensweise Live-Programmierung: Monopoly

32 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 14 / 19

33 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 14 / 19

34 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 14 / 19

35 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! 15. November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 14 / 19

36 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

37 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

38 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

39 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

40 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! ? November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

41 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

42 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

43 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

44 Backtracking: Vorgehensweise Am Beispiel Sudoku: Per Rekursion wird jede Zelle des Sudoku (mehrfach!) besucht, es werden alle möglichen Zahlen für die Zelle bestimmt Die erste mögliche Zahl wird in das Feld geschrieben, dann wird rekursiv nach Lösungen dieses neuen Sudoku gesucht Wird für die erste mögliche Zahl keine Lösung gefunden, wird nacheinander die zweite, dritte, usw. mögliche Zahl eingesetzt und jedes mal rekursiv nach Lösungen gesucht Wichtig: Wird für keine der möglichen Zahlen eine Lösung gefunden, wird das Feld wieder auf leer zurückgesetzt! November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 14 / 19

45 Live-Programmierung: Monopoly Quelle: November 2011 Jens Wetzl Tafelübung Algorithmen und Datenstrukturen 15 / 19

46 Klausuraufgabe zu Rekursion

47 Klausur 02/2009: Aufgabe 5 Zum deterministischen Testen von Anwendungen lassen sich Pseudo- Zufallszahlen verwenden. Folgende Berechnungsformel erzeugt für n 0 solche Zahlen: f (n) = n + 1 n < (((f (n 1) f (n 2)) f (n 3)) mod 100) sonst Hinweis: Der Modulo-Operator a mod b ergibt den Rest bei ganzzahliger Division und kann in Java durch % ausgedrückt werden. 1. Implementieren Sie die Funktion f rekursiv in Java. public static int f(int n) { 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 17 / 19

48 Klausur 02/2009: Aufgabe 5 Zum deterministischen Testen von Anwendungen lassen sich Pseudo- Zufallszahlen verwenden. Folgende Berechnungsformel erzeugt für n 0 solche Zahlen: f (n) = n + 1 n < (((f (n 1) f (n 2)) f (n 3)) mod 100) sonst Hinweis: Der Modulo-Operator a mod b ergibt den Rest bei ganzzahliger Division und kann in Java durch % ausgedrückt werden. 2. Implementieren Sie die Funktion f nun linear-rekursiv mit Durchreichen von Zwischenergebnissen. Gegeben ist die zugehörige Initialisierungsmethode, die Ihre Methode aufruft. public static int f(int n) { return lin(1, 2, 3, n); public static int lin(int a, int b, int c, int steps) { 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 18 / 19

49 Klausur 02/2009: Aufgabe 5 Zum deterministischen Testen von Anwendungen lassen sich Pseudo- Zufallszahlen verwenden. Folgende Berechnungsformel erzeugt für n 0 solche Zahlen: f (n) = n + 1 n < (((f (n 1) f (n 2)) f (n 3)) mod 100) sonst Hinweis: Der Modulo-Operator a mod b ergibt den Rest bei ganzzahliger Division und kann in Java durch % ausgedrückt werden. 3. Implementieren Sie eine iterative Java-Variante der Funktion f. public static int f(int n) { 15. November 2011 Jens Wetzl (jens.wetzl@cs.fau.de) Tafelübung Algorithmen und Datenstrukturen 19 / 19