Übungsblatt 5. Thema: Algorithmen: Rekursion vs Iteration, O-Notation, Korrektheit

Transkript

1 Informatik I WS 05/06 Prof. Dr. W. May Dipl.-Inform. Oliver Fritzen Dipl.-Inform. Christian Kubczak Übungsblatt 5 Ausgegeben am: Abgabe bis: (Theorie) (Praktisch) Thema: Algorithmen: Rekursion vs Iteration, O-Notation, Korrektheit Die Theorieaufgaben auf diesem Blatt sind bis zum Dienstag, Dezember um Uhr - pünktlich! - in die Info-I-Briefkästen im Erdgeschoss der NAM einzuwerfen. Die Kästen sind nach Übungsgruppen geordnet. Achten Sie bitte darauf dass Sie Ihren Zettel in den richtigen Kasten werfen, und dass Name und Gruppe auf jedem Blatt stehen! Falls Ihre mehrere Blätter umfasst, heften Sie diese bitte zusammen! Die Praxis-Aufgaben auf diesem Zettel bearbeiten Sie bitte am Rechner und führen Sie in der Abgabewoche in der Gruppenübung ihrem Tutor am Rechner vor (bzw. dem Dienst habenden Tutor in der Freiübung). Eine Bearbeitung in Zweier-Teams innerhalb Ihrer Übungsgruppe ist möglich. Aufgabe 1 (Theorie: 20 Punkte): Korrektheit von iterativen Algorithmen Gegeben sei folgendes Programmstück: z0; btrue; do { zz+1; b!b; while(z! x) wobei x und z int-variablen sind, x>0. Beweisen Sie folgende Behauptung: Nach Beendigung des Programms ist btrue genau dann wenn x gerade ist. Erklären Sie außerdem, warum die Schleife terminiert. Korrektheit:

2 Vorbedingung: Nachbedingung: Abbruchbedingung: z0 UND btrue (x ist gerade UND btrue) ODER (x ist ungerade und bfalse) xz Invariante(noch zu bew.): (z ist gerade UND btrue) ODER (z ist ungerade und bfalse) Für den Korrektheitsnachweis müssen folgende Regeln erfüllt sein: 1. Vorbedingung Invariante 2. Abbruchbedingung + Invariante Nachbedingung 3. Die Invariante ist tatsächlich eine, d.h. falls die Invariante vor dem Schleifendurchlauf gilt, gilt sie auch nach dem Schleifendurchlauf. Dass 1. und 2. gelten, sieht man direkt. Invariante: Vor dem Schleifendurchlauf gilt nach Vor.: (z ist gerade UND btrue) ODER (z ist ungerade und bfalse). Nach dem Schleifendurchlauf wurden b und z verändert. Einsetzen liefert: ((z+1) ist gerade UND (not b)true) ODER ((z+1) ist ungerade und (not b)false). Umformen liefert: (z ist ungerade UND bfalse) ODER (z ist gerade und btrue), was genau die Ausgangsbedingung ist. Die Bedingung ist also invariant, wird also von einem Schleifendurchlauf nicht verändert. Und damit ist man fertig. Aufgabe 2 (Theorie: 30 Punkte): Mystery Gegeben sei folgendes Programme: public class Mystery { public static int compute(int n) { return computeinternal(n,1,1); private static int computeinternal(int n, int i, int res) { if(i n) return res; return computeinternal(n, i+1, res+i+i+1); 1. Betrachten Sie den Aufruf Mystery.compute(5);. Vollziehen Sie die Berechnung von Hand nach und geben Sie die Variablenwerte im Aufruf von computeinternal(n, i+1, res+i+i+1) an. 2. Was berechnet Mystery (als Funktion von n)? Beweisen Sie Ihre Aussage. 3. Re-formulieren Sie Mystery iterativ (auf Papier) und beweisen Sie die Korrektheit mit Hilfe der Schleifeninvariante. 1. Aufruf von Hand:

3 compute(5) computeinternal(5,1,1) computeinternal(5,1+1, ) computeinternal(5,2,4) computeinternal(5,2+1, ) computeinternal(5,3,9) computeinternal(5,3+1, ) computeinternal(5,4,16) computeinternal(5,4+1, ) computeinternal(5,5,25) n5,i1,res1 n5,i2,res4 n5,i3,res9 n5,i4,res16 n5,i5,res25 (Abbruchbedingung ni ist erfüllt!) Was berechnet compute(n)? Anscheinend gilt: compute(n) n 2. Beweis durch Induktion über n: n1: compute(1) computeinternal(1,1,1) n n+1 : Leider nicht ganz so einfach. Probieren wir es anders. Beobachtung aus Teilaufgabe 1: Anscheinend hat "res" im i-ten Aufruf von computeinternal(n,i,res) stets den Wert i 2. Beweis (Induktion über die Aufruftiefe i): i1: compute(n) computeinternal(n,1,1) (1. Aufruf). n?, i1, res i 2. i i+1: Zu zeigen ist: falls im i-ten Aufruf von computeinternal (also computeinternal(n,i,res) ) gilt dass res i 2 (Induktionsvoraussetzung oder IV), dann gilt auch im (i+1)-ten Aufruf (also computeinternal(n,i+1,res neu ) ) dass res neu (i+1) 2. Beweis: Es gilt laut IV im i-ten Aufruf: computeinternal(n, i, res) computeinternal(n,i,i 2 ). Dadurch sieht der (i+1)-te Aufruf so aus: computeinternal(n, i, i 2 ) computeinternal(n, i+1, i 2 + i + i + 1) computeinternal(n, i+1, i 2 + 2*i + 1) (1. Binomische Formel) computeinternal(n, i+1, (i+1) 2 ). Es gilt also: res (i+1) 2 im (i+1)-ten Aufruf. Wir wissen nun: im i-ten Aufruf von computeinternal(n,i,res) gilt stets: res i 2. compute(n) startet die Berechnung von computeinternal(n,1,1). computeinternal ruft sich jedesmal selbst auf, i wird jedesmal um 1 vergrößert, solange bis in. computeinternal wird also n-mal aufgerufen (einmal von compute, (n-1)-mal von sich selbst). Und im n-ten Durchgang (wo, wie wir wissen, res den Wert n 2 hat), brechen wir ab und liefern res n 2 zurück. Also gilt: compute(n) n Mystery iterativ:

4 public class Mystery { public static int compute(int n) { int i1; int res1; while(i!n) { resres+i+i+1; ii+1; return res; Korrektheit: Vorbedingung: i1 und res1 Nachbedingung: res n 2 Abbruchbedingung: in Invariante(noch zu bew.): res i 2 Für den Korrektheitsnachweis müssen folgende Regeln erfüllt sein: 1. Vorbedingung Invariante 2. Abbruchbedingung + Invariante Nachbedingung 3. Die Invariante ist tatsächlich eine, d.h. falls die Invariante vor dem Schleifendurchlauf gilt, gilt sie auch nach dem Schleifendurchlauf. 1. VB INV: i1, res1 res i AB + INV NB: in, resi 2 resn 2 3. INV ist Invariante: Vorher: resi 2. Schleifendurchgang: i neu i+1; res neu res+i+i+1; Nachher: (i neu ) 2 (i+1) 2 i 2 + 2*i + 1 (siehe "vorher") res + i + i + 1. Aufgabe 3 (Theorie: 20 Punkte): O-Notation Gegeben sei folgendes Programm(stück), wobei n beliebig ist: int summe 0; for (int i1; i< n; i++) { for (int j1; j<n; j++) { summe summe + j; if(summe % 2 0) { summe summe +17; else { for (int i1; i<n; i++) { summe summe-1;

5 Bestimmen Sie den Gesamtaufwand in Abhängigkeit von n mit Hilfe dero-notation. Jedes Programm / jeder Algorithmus ist zusammengesetzt aus den Primitiven Anweisung/Zuweisung, Sequenz, Alternative und Schleife: Zuweisung Prog Zuweisung Sequenz Prog Prog 1 ;Prog 2 ;Prog 3 ;... Prog n ; Auswahl einer Alternative Prog if(bedingung) Prog 1 ; else Prog 2 Schleife Prog for(i0;i<k;i++) Prog 1 ; Wir nehmen hier ein einfaches Kostenmaß an, das für eine einfache Anweisung 1 Schritt berechnet, für eine Sequenz von Programmen die Summe ihrer Schritte, für eine Alternative das Maximum der möglichen Schritte und für eine Schleife die Anzahl der Schleifendurchläufe multipliziert mit der Anzahl der Schritte im Schleifen-Inneren: T(Prog)? Zuweisung Prog Zuweisung 1 Sequenz Prog Prog 1 ;Prog 2 ;Prog 3 ;... Prog n ; T(Prog 1 ) T(Prog n ) Auswahl einer Alternative Prog if(bedingung) Prog 1 ; else Prog 2 max( T(Prog 1 ), T(Prog 2 ) ) Schleife Prog for(i0;i<k;i++) Prog 1 ; k * T(Prog 1 ) Für die einfachen Anweisungen int summe 0, summe summe + j, summe summe +17 und summe summe-1 ergibt sich jeweils 1 Schritt. Jede for-schleife wird n-mal durchlaufen, die Schachtelung der oberen beiden Schleifen führt für diese zu einem n * n * T(Schleifeninhalt). Die untere Schleife bekommt ein n * T(Schleifeninhalt). Die Auswahl if(summe % 2 0) {.. else {... liefert das Maximum von Alternative 1 und Alternative 2: max( T(Alt1), T(Alt2) ). Das ergibt eine Gesamtlaufzeit von 1 + ( n * ( n * 1 ) ) + max ( 1, ( n * 1 ) ) 1 + n 2 + max ( 1, n ) n 2 + n + 1 O(n 2 ). Aufgabe 4 (Praktisch: 30 Punkte): Permutationen Schreiben Sie eine Java-Klasse Permutation mit einer Methode permute, die ein char-array der Länge n als Eingabe hat und alle Permutationen der Zeichen im Array ausgibt. Als Permutationen einer Menge bezeichnet man Vertauschungen der einzelnen Elemente. Beispiel:

6 public class PermutationTest { public static void main(string[] args) { char[] k { a, b, c ; Permutation.permute(k); Die main-methode soll alle Kombinationen von Vertauschungen der Zeichen a, b und c auf den Bildschirm ausgeben: a b c a c b b a c b c a c b a c a b Sie können davon ausgehen, dass die einzelnen Zeichen paarweise verschieden sind (d.h. sie brauchen sich nicht um Duplikate zu kümmern). Testen Sie Ihr Programm mit den Werten { a, b, c und { a, b, c, d. Hinweis: Für ein Array x enthält x.length die Länge des Arrays x. Anmerkung: Sie sollten in der Lage sein, ihr Programm beim Testieren erklären zu können, wie sie auf die Idee gekommen sind, welche Eigenschaft der Permutation sie ausgenutzt haben, etc. Wem es nur um die Punkte geht, der sollte sich besser auf die Aufgaben 1-3 konzentrieren, wo die Punkte deutlich einfacher zu holen sind als hier. svariante 1 mit quadratischen Arrays: public class Permutation1 { public static char[][] permute(char[] array) { if (array.length 0) return new char[0][0]; char[][] perms new char[fakultaetrek.berechnen(array.length)][array.length]; int currentpermindex 0; for (int i 0; i < array.length; i++) { perms[currentpermindex][0] array[i]; char[] copy new char[array.length-1]; int arrayindex 0; int copyindex 0; // kopiere array ohne pos i nach copy while(arrayindex<array.length) { if(arrayindexi) arrayindex++; else copy[copyindex++] array[arrayindex++]; char[][] subperms permute(copy); for(int j0; j<subperms.length;j++) { perms[currentpermindex][0] array[i]; for(int k0; k<subperms[j].length;k++) { perms[currentpermindex][k+1] subperms[j][k]; currentpermindex++; return perms; svariante 2 mit direkter Ausgabe:

7 public class Permutation2 { public static void permute(char[] number) { permute(number, 0); public static void permute(char[] number, int from) { char[] new_number new char[number.length]; for (int i from; i < number.length; i++) { /* * kopiere das number nach new_number (noetig, da die alte ordnung * VOR dem vertauschen noch fuer den rek. aufruf benoetigt wird) */ for (int j 0; j < number.length; j++) new_number[j] number[j]; // tausche new_number[i] und new_number[from] char temp new_number[i]; new_number[i] new_number[from]; new_number[from] temp; // rekursiver aufruf permute(new_number, from + 1); // ausgabe des arrays nur dann wenn die rekursion am zeilenende angekommen ist if (from number.length) output(number); // Ausgaberoutine static void output(char[] number) { for (int i 0; i < number.length; i++) System.out.print(number[i] + " "); System.out.println(); Testmethode für beide Alternativen: public class PermutationTest { private static void printmatrix(char[][] array) { for (int i 0; i < array.length; i++) { for (int j 0; j < array[i].length; j++) System.out.print(array[i][j]); System.out.println(); public static void main(string[] args) { char[] k1 { a, b, c ; char[] k2 { a, b, c, d ; char[][] perms1 Permutation1.permute(k1); char[][] perms2 Permutation1.permute(k2); printmatrix(perms1); System.out.println("---"); printmatrix(perms2); Permutation2.permute(k1); Permutation2.permute(k2);