Übungen zu Algorithmen - Universität Osnabrück

Institut für Informatik Universität Osnabrück, 26.11.2013
Prof. Dr. Oliver Vornberger
http://www-lehre.inf.uos.de/~ainf
Nils Haldenwang, M.Sc.
Testat bis 04.12.2013, 14:00 Uhr
Nicolas Neubauer, M.Sc.
Übungen zu Algorithmen
Wintersemester 2013/2014
Blatt 6: Komplexität und Backtracking
Aufgabe 6.1: Fragen (30 Punkte)
Beantworten Sie Ihrer Tutorin bzw. Ihrem Tutor Fragen zur Vorlesung.
Aufgabe 6.2: Laufzeiten (15 Punkte)
Betrachten Sie die im Anhang befindliche Java-Klasse Laufzeiten.java
a) Was berechnen die einzelnen Methoden in Abhängigkeit von n (n ≥ 1) ?
b) Welche asymptotische Laufzeit haben die einzelnen Methoden, ausgedrückt in der O-Notation,
in Abhängigkeit von n? Begründen Sie Ihre Antworten!
Musterlösung:
/************************ LaufzeitenLoes.java *************************/
import AlgoTools.IO;
/**
* Komplexitaet von Methoden in der O-Notation
*/
public class LaufzeitenLoes {
/** Berechnet den ganzzahligen Logarithmus dualis von n. O(log_2(n)) */
public static int a(int n) {
int z = 0;
}
while (n > 1) {
n /= 2;
z++;
}
return z;
/** Berechnet das Quadrat von n. Laufzeit O(n) */

public static int b(int n) {
int i = 0;
int b = 1;
}
while (++i < n) {
b = b + 2 * i + 1;
}
return b;
/** Berechnet die ganzzahlige Quadratwurzel von n. O(Wurzel(n)) */
public static int c(int n) {
int t = 1, z = 0;
}
while (n > 0) {
n -= t;
t += 2;
z++;
}
return z;
/** Berechnet Wurzel vom Logarithmus von n. O(log2(n))
* zunaechst Logarithmus, dann daraus die Wurzel
* log2(n)+Wurzel(log2(n)) O(log2(n))
*/
public static int d(int n) {
return c(a(n));
}
/** berechnet Quadrat von Wurzel n.
* zunaechst Wurzel, dann davon das Quadrat
* Wurzel(n)+Wurzel(n)=2*Wurzel(n) --> O(Wurzel(n))
*/
public static int e(int n) {
return b(c(n));
}
/** berechnet Wurzel vom Quadrat von n. O(n)
* zunaechst Quadrat, dann daraus die Wurzel
* n+Wurzel(n^2)=n+n --> O(n)
*/
public static int f(int n) {
return c(b(n));
}
/** berechnet Wurzel n mal Wurzel n. O(n)
2

* Wurzel(n)*Wurzel(n)*2=2*n --> O(n)
*/
public static int g(int n) {
int z = 0;
for (int i = 1; i

}
}
IO.print("a(" + n + ") =");
IO.println(a(n), 8);
IO.print("c(" + n + ") =");
IO.println(c(n), 8);
IO.print("b(" + n + ") =");
IO.println(b(n), 8);
IO.print("d(" + n + ") =");
IO.println(d(n), 8);
IO.print("e(" + n + ") =");
IO.println(e(n), 8);
IO.print("f(" + n + ") =");
IO.println(f(n), 8);
IO.print("g(" + n + ") =");
IO.println(g(n), 8);
IO.print("h(" + n + ") =");
IO.println(h(n), 8);
IO.print("i(" + n + ") =");
IO.println(i(n), 8);
IO.print("j(" + n + ") =");
IO.println(j(n), 8);
Aufgabe 6.3: Zusicherung (15 Punkte)
Betrachten Sie die im Anhang befindliche Java-Klasse Zusicherung.java
a) Welches Problem löst die Methode main dieser Klasse?
b) Zeigen Sie die partielle Korrektheit mit Hilfe von Zusicherungen, die Sie als Kommentare in
den Programmtext einfügen (siehe Programmtext).
c) Zeigen Sie die totale Korrektheit durch den Nachweis der Terminierung.
d) Geben Sie die asymptotische Laufzeit in O-Notation an.
Musterlösung:
4

************************** ZusicherungLoes.java ***************************/
import AlgoTools.IO;
/**
* Beweis der Korrektheit mit Hilfe der Zusicherungsmethode
*
* a) Berechnet das Quadrat der Eingabezahl n.
* b) Zeigen Sie die partielle Korrektheit mit Hilfe von Zusicherungen im
* Programmtext.
* c) Zeigen Sie die totale Korrektheit durch den Nachweis der Terminierung.
* d) Geben Sie die asymptotische Laufzeit in O-Notation an.
*
*/
public class ZusicherungLoes {
public static void main(String[] args) {
int i = 0, h = 1, z = 0, n;
/* i = 0 und h = 1 und z = 0 */
do {
n = IO.readInt("n= ");
} while (n < 0);
/* n >= 0 und i = 0 und h = 1 und z = 0 */
/* z = i * i und h = 2 * i + 1 und i

}
}
/* z = i * i und h = 2 * i + 1 und i = 0 unveraendert bleibt und i zu Beginn
*

Sei f (m) ≤ m · log(m) + 1 für m ≤ n bewiesen.
Schritt:
Zu zeigen: f (n + 1) ≤ (n + 1) · log(n + 1) + 1
( ) (n + 1)
f (n + 1) = 3 · f
3
( ( ) )
(n + 1) (n + 1)
≤ 3 · · log + 1
3
3
= (n + 1) · log(n + 1) − (n + 1) · log(3) + 3
≤ (n + 1) · log(n + 1)
Schluss:
Damit gilt die Behauptung für alle n ∈ N.
Aufgabe 6.5: Sudoku (30 Punkte)
Sudoku ist ein Zahlenpuzzle. Es besteht aus einem Quadrat, das in 3 × 3 Unterquadrate bzw. Blöcke
eingeteilt ist. Jedes Unterquadrat ist wieder in 3 × 3 Felder eingeteilt, sodass das Gesamtquadrat also
81 Felder (= 9 · 9 Felder) bzw. 9 Reihen und 9 Spalten mit je 9 Feldern besitzt.
In einige dieser Felder sind schon zu Beginn Ziffern (1 bis 9) eingetragen. Das Puzzle muss nun so
vervollständigt werden, dass
• in jeder Zeile,
• in jeder Spalte und
• in jedem der neun Blöcke jede Ziffer von 1 bis 9 genau einmal auftritt.
Betrachten Sie die im Anhang befindliche Java-Klasse Sudoku.java. Vervollständigen Sie diese
Klasse zu einem Javaprogramm, welches ein eingelesenes Sudoku löst. Implementieren Sie dazu die
rekursive Methode fuelleFeld, die zunächst ein freies Feld sucht und nacheinander die Zahlen von
1 bis 9 einsetzt und auf Korrektheit prüft. Lagern Sie die Prüfung in die Methode gueltigeZahl
aus. Ist eine korrekte Zahl gefunden wird diese eingetragen und es erfolgt ein rekursiver Aufruf, um
das nächste freie Feld zu bearbeiten.
Kann in einem freien Feld keine korrekte Zahl positioniert werden, ist der eingeschlagene Lösungsweg
falsch. In diesem Fall wird dieses Feld als frei markiert (Wert 0 eintragen), der aktuelle Rekursionsaufruf
beendet und es wird beim vorherigen Schritt weiter getestet.
Verwenden Sie die bereits vorgegebene Strukturierung des Programmes in Methoden.
Ein korrektes Sudoku besitzt immer genau eine Lösung. Wenn alle Felder korrekt belegt sind ist das
Sudoku also gelöst.
7

Hinweis: Die beschriebene Vorgehensweise wird Backtracking genannt. Backtracking ist eine Programmierstrategie,
die nach dem Prinzip Trial and Error (Versuch und Irrtum) vorgeht. Man wählt
einen von mehreren Lösungswegen aus und verfolgt ihn über weitere Entscheidungen so lange, bis
die Lösung gefunden worden ist oder der Weg sich als definitiv falsch herausgestellt hat. Ist dies
der Fall, kehrt man zur letzten Entscheidung zurück und wählt einen anderen Weg. Auf diese Weise
werden von Entscheidung zu Entscheidung so viele Wege ausprobiert, bis einer ans Ziel führt.
Im Anhang finden Sie zwei Beispielsudokus, die Sie mit dem Pipe-Operator Ihrem Programm wie
folgt übergeben können:
java Sudoku < test_sudoku_1.txt
Musterlösung:
import AlgoTools.IO;
/**
* SudokuSolver, der die Loesung eines Sudokus mittels Backtracking ermittelt.
*/
public class SudokuSolver {
/**
* rekursive Methode, die das naechste freie Kaestchen im Sudoku-Feld sucht
* und dort alle erlaubten Zahlen einsetzt und sich dann selbst aufruft.
*
* @param sudoku
* Feld, welches gefuellt werden soll
* @param spalte
* Spaltennumer im Array
* @param zeile
* Zeilennummer im Array
* @return ob Loesung gefunden oder nicht
*/
private static boolean fuelleFeld(int[][] sudoku, int spalte, int zeile) {
/*
* freies Feld suchen
*/
while (zeile < 9 && sudoku[zeile][spalte] != 0) {
spalte++;
if (spalte > 8) {
zeile++;
spalte = 0;
}
}
/*
* Rekursionsverankerung: Am Ende angekommen, fertig!
8

}
*/
if (zeile > 8) {
return true;
} else {
/*
* Fuer das aktuelle Feld alle Zahlen einmal durchtesten
*/
for (int number = 1; number

if (sudoku[zeile][x] == zahl) {
return false;
}
}
/*
* teste Spalte
*/
for (int y = 0; y < 9; y++) {
if (sudoku[y][spalte] == zahl) {
return false;
}
}
/*
* Teste Kaestchen. Dazu obere linke Ecke des aktuellen Kaestchens
* berechnen
*/
for (int y = (zeile / 3) * 3; y < (zeile / 3) * 3 + 3; y++) {
for (int x = (spalte / 3) * 3; x < (spalte / 3) * 3 + 3; x++) {
if (sudoku[y][x] == zahl) {
return false;
}
}
}
}
return true;
/**
* Gibt das Sudoku-Feld ordentlich formatiert aus
*
* @param field
* Feld das ausgegeben werden soll
*/
private static void druckeSudoku(int[][] field) {
for (int yPos = 0; yPos < 9; yPos++) {
if (yPos != 0 && yPos % 3 == 0)
IO.println("------+-------+------ ");
for (int xPos = 0; xPos < 9; xPos++) {
if (xPos != 0 && xPos % 3 == 0)
IO.print("| ");
IO.print(field[yPos][xPos] + " ");
}
IO.println();
}
}
public static void main(String[] argv) {
10

}
}
// Sudoku-Feld als
// zweidimensionales Array
int[][] sudoku;
sudoku = new int[9][];
IO.println("Bitte geben Sie die Zeilen des zu loesenden Sudokus ein");
int[] eingabe;
// Einlesen des Sudokus
for (int i = 1; i < 10; i++) {
do {
eingabe = IO.readInts("Zeile " + i + ": ");
} while (eingabe.length != 9);
sudoku[i - 1] = eingabe;
}
// Feld einmal ausgeben
druckeSudoku(sudoku);
//Loesung ermitteln, oben links anfangen
if(fuelleFeld(sudoku, 0, 0)){
IO.println("Die Loesung: ");
druckeSudoku(sudoku);
}
11