Algorithmische Mathematik I

Vorlesungsskript WS 2009/10

Mario Bebendorf

Inhaltsverzeichnis
1 Maschinenzahlen und -arithmetik 1.1 Zahlensysteme . . . . . . . . . . . . . . . . . . . 1.2 Darstellung ganzer Zahlen im Rechner . . . . . 1.3 Darstellung reeller Zahlen . . . . . . . . . . . . 1.3.1 Festkommazahlen . . . . . . . . . . . . . 1.3.2 Gleitkommazahlen . . . . . . . . . . . . 1.3.3 Genauigkeit der Gleitkommadarstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 3 6 6 7 8 11 11 12 14 17 17 21 25 25 27 30 33 34 39 39 41 45 47 50 52 56 62 69 70 79 82 88 91 95

2 Fehleranalyse 2.1 Rechnerarithmetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Fehlerfortpanzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Kondition und Stabilitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . a 3 Dreitermrekursion 3.1 Theoretische Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Miller-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Sortieralgorithmen 4.1 Bubblesort . . . . . . . . . . 4.2 Mergesort . . . . . . . . . . 4.3 Quicksort . . . . . . . . . . 4.4 Eine untere Schranke fr das u 4.5 Binre Heaps und Heapsort a . . . . . . . . . . . . . . . . . . . . . . . . . . . Sortierproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5 Graphen 5.1 Grundbegrie . . . . . . . . . . . 5.2 Zusammenhang . . . . . . . . . . 5.3 Speicherung von Graphen . . . . 5.4 Graphendurchmusterung . . . . . 5.5 Minimal spannende Bume . . . . a 5.6 Krzeste Wege . . . . . . . . . . u 5.7 Netzwerksse . . . . . . . . . . . u 5.8 Matchings in bipartiten Graphen

6 Lineare Gleichungssysteme 6.1 Vektor- und Matrixnormen . . . . . . . . . . . 6.2 Strungstheorie fr lineare Gleichungssysteme o u 6.3 Gausche Elimination . . . . . . . . . . . . . 6.4 Stabilitt der Gauschen Elimination . . . . . a 6.5 Die Cholesky-Zerlegung . . . . . . . . . . . . . 6.6 Die QR-Zerlegung nach Householder . . . . .

Vorwort
Dieses Skript fasst den Inhalt der von mir im Wintersemester 2009/10 an der Universitt a Bonn gehaltenen Vorlesung Algorithmische Mathematik I zusammen und ist eine Uberarbeitung der Skripte zu den von Helmut Harbrecht und Stefan Hougardy im Wintersemester 2007/08 bzw. 2008/09 gehaltenen gleichnamigen Vorlesungen. Mein Dank gebhrt Herrn u Maximilian Kirchner (mkirchner@uni-bonn.de), der dieses LaTeX-Dokument aus der Vorlesungsmitschrift erstellt hat. Korrekturvorschlge sind willkommen. a Bonn, 29. Mrz 2010 a

iii

Einleitung
Die algorithmische Mathematik vereint die algorithmischen Grundlagen aus verschiedenen Bereichen der Mathematik Diskrete Mathematik Numerische Mathematik Stochastik Die Aufgabe der Algorithmischen Mathematik ist die Konstruktion und Analyse von Algorithmen zur Lsung mathematischer Probleme. Ursprung dieser Probleme knnen Aufgao o benstellungen aus Technik, Naturwissenschaften, Wirtschaft und Sozialwissenschaften sein. Von erheblicher praktische Bedeutung ist deshalb die Umsetzung der Algorithmen in ein Computerprogramm. Literaturangaben: P. Deuhard und A. Hohmann: Numerische Mathematik, de Gruyter Verlag M. Hanke-Bourgeois: Grundlagen d. numerischen Mathematik und des wissenschaftlichen Rechnens, Teubner-Verlag J. Stoer: Numerische Mathematik I, Springer-Verlag N. Blum: Algorithmen und Datenstrukturen, Oldenbourg Verlag B. Korte und J. Vygen: Combinatorial Optimization: Theory and Algorithms, SpringerVerlag

1 Maschinenzahlen und -arithmetik

Bei der mathematischen Analyse von Algorithmen wird das Rechnen mit reellen Zahlen als exakt vorausgesetzt. Tatschlich werden im Rechner jedoch so genannte Maschinenzahlen a verwendet, mit denen ein exaktes Rechnen nicht mglich ist. o

1.1 Zahlensysteme
Die Darstellung einer Zahl basiert auf Zahlensystemen. Es sei N = {1, 2, 3, . . .} die Menge der natrlichen Zahlen und b N, b > 1, beliebig. Dann heit die Menge b := {0, . . . , b 1} u das Alphabet des b-adischen Systems. Ein Wort der Lnge n ist eine Aneinanderreihung a von n Symbolen aus b . b wird als Basis bezeichnet. Beispiel 1.1. Dezimalsystem: b = 10, b = {0, 1, 2, . . . , 9}. Worte aus diesem Alphabet sind zum Beispiel 123, 734, 7806. Eine feste Wortlnge n = 4 erreicht man durch Hinzufgen a u von Nullen: 0123, 0734, 7806. Im Rechner werden ublicherweise Worte fester Lnge a verwendet (8-, 16-, 32-, 64-Bit) (engl. binary digit). 2 = {0, 1} Dual- oder Binralphabet a 8 = {0, . . . , 7} Octalalphabet 16 = {0, . . . , 9, A, B, C, D, E, F } Hexadezimalalphabet Alte Basen sind b = 12 (Dutzend) und b = 60 (Zeitrechnung). Die Basen 2, 8, 16 spielen in der Informatik eine entscheidende Rolle. Satz 1.2. Sei b N \ {1} und z N0 := N {0}. Dann existiert n N mit z < bn , und z ist eindeutig als Wort der Lnge n uber b darstellbar durch a
n1

z=
i=0

zi bi

mit zi b f r alle 0 i < n. u Vereinfacht wir die Ziernschreibweise z = (zn1 , zn2 , . . . , z1 , z0 )b verwendet. Beweis. Der Beweis erfolgt durch vollstndige Induktion nach z. Fr den Induktionsanfang a u beachte man, dass fr alle z < b gilt, dass n = 1 und z = z0 . u Als Induktionsvoraussetzung nehmen wir an, die Behauptung gelte fr alle Zahlen 1, 2, . . . , z u 1. Im Induktionsschluss zeigen wir, dass unter dieser Annahme die Behauptung fr z > b u gilt. Es ist nmlich a z = z b + (z mod b)

1 Maschinenzahlen und -arithmetik u mit z := z . Hier verwenden wir fr x R die Notationen x := max{k Z : k x} und b (x mod b) := x x b. b Wegen z < z besitzt z nach Induktionsvoraussetzung eine Darstellung z = (n1 , . . . , z0 )b . z n1 n n n Dabei ist zn1 = 0, weil aus zn1 b z und z b z < b folgt zn1 b < b . Also ist zn1 < 1 und somit zn1 = 0. Deniere (zn1 , . . . , z0 )b durch zi := zi1 , i = n 1, . . . , 1, und z0 := z mod b. Dann gilt z = z b + (z
n2

mod b) mod b) mod b)

= b =

i=0 n1

zi bi + (z

i=1 n1

zi1 bi + (z zi bi .

=
i=0

Wir mssen noch die Eindeutigkeit zeigen. Angenommen, es existieren zwei verschiedene u Darstellungen z = (zn1 , . . . , z0 )b = (zn1 , . . . , z0 )b . Sei p N der grte Index mit zp = zp . o O.B.d.A. gilt zp > zp . Dann mssen die niederwertigen Stellen zp1 , . . . , z0 die kleinere u (p + 1)-te Stelle zp ausgleichen. Die grte durch diese p Stellen darstellbare Zahl ist aber o
p1

(b 1)b + . . . + (b 1)

p1

= (b 1)

i=0

bi = bp 1.

Von der letzten Identitt uberzeugt man sich schnell durch Ausmultiplizieren. Da aber 1 bp a eine Einheit der niederwertigen (p + 1)-ten Stelle ist, kann diese nicht ausgeglichen werden. Dieser Widerspruch beweist die Eindeutigkeit. Der Beweis ist konstruktiv: man erhlt einen Algorithmus zur Darstellung einer Zahl in a einem b-adischen System. Beispiel 1.3. Darstellung von 1364 im Octalsystem 1364 = 1708 + 4 170 = 21 8 + 2 21 = 2 8 + 5 2 = 0 8 + 2 Hieraus erhlt man z = (1364)10 = (2524)8 . a Algorithmus 1.4 (b-adische Darstellung (xn1 , . . . , x0 )b von z N0 ). Input : z ,b ,n ; Output : x [ n ]; (i =0; i < n; i ++) x[ i ]=0; i =0; (z >0) { x [i ] = z % b; // entspricht (z mod b)

1.2 Darstellung ganzer Zahlen im Rechner

z = z /b ; i ++; }

// entspricht ganzzahliger Division

Die Umwandlung einer Zahl in b-adischer Darstellung in eine Dezimalzahl erfolgt mittels des Horner-Schemas.
n1 n2

z=
i=0

zi b = z0 + b
i=0 n3

zi+1 bi zi+2 bi

= z0 + b z1 + b
i=0

= z0 + b(z1 + b(z2 + b(z3 + . . . (zn2 + bzn1 )))) Algorithmus 1.5 (Umwandlung aus b-adischer Darstellung). Input : x [n ],b , n; Output : z; z =0; (i =n ; i >0; i - -) z = z * b + x [i -1];

Bemerkung. Man beachte, dass die Variante

(i =n -1; i >=0; i - -) z = z * b + x[ i ];
zwar naheliegend ist, aber tatschlich eine Endlosschleife darstellt, falls i vom Typ unsigned a int ist.

1.2 Darstellung ganzer Zahlen im Rechner

Um eine ganze Zahl in Binrdarstellung zu speichern, scheint es natrlich, ein Bit (0 = +, a u 1 = ) fr das Vorzeichen und bei einer Wortlnge von n weitere n 1 Bits fr den u a u Betrag der Zahl zu verwenden. Da die 0 zwei Darstellungen besitzt (0), knnen 2n 1 o Zahlen dargestellt werden. Beispiel 1.6. Im Fall n = 3 ergeben sich folgende Zahlen. Bitmuster 000 001 010 011 100 101 110 111 Dezimaldarstellung +0 +1 +2 +3 0 1 2 3

1 Maschinenzahlen und -arithmetik Die beschriebene Darstellung ist auf Rechnern allerdings unpraktisch, weil auf Rechnern nur Additionswerke vorhanden sind. Daher bentigt man eine Darstellung, bei der die Subo traktion auf die ziernweise Addition zurckgefhrt werden kann. Dies gelingt mit der so u u genannten Komplement-Darstellung. Denition 1.7. Sei z = (zn1 , zn2 , . . . , z0 )b eine n-stellige b-adische Zahl. Das bKomplement Kb (z) ist deniert als Kb (z) = (b 1 zn1 , b 1 zn2 , . . . , b 1 z0 )b + 1. Beispiel 1.8. K10 ((325)10 ) = (674)10 + (1)10 = (675)10 K2 ((10110)2) = (01001)2 + (1)2 = (01010)2 Lemma 1.9. F r jede n-stellige b-adische Zahl gilt u (i) z + Kb (z) = bn , (ii) Kb (Kb (z)) = z.

Beweis. Nach Denition des b-Komplements ist

n1

z + Kb (z) = (b 1, . . . , b 1)b + (1)b = 1 +

n1

i=0

(b 1)bi

= 1 + (b 1) Fr (ii) beachte man, dass aus (i) folgt u

i=0

bi = bn 1 + 1 = bn .

Kb (z) + Kb (Kb (z)) = bn = z + Kb (z) z und hieraus Kb (Kb (z)) = z. Nach (i) von Lemma 1.9 ergibt sich das b-Komplement von z bei n Stellen als Dierenz von bn zu z; siehe Beispiel 1.8 fr n = 3. u Denition 1.10. Sei z Z mit (z)Kb von z ist deniert als (z)Kb =
bn 2

z <

bn 2

. Die b-Komplement-Darstellung

(z)b , falls z 0, (Kb (|z|))b , sonst.

bn 2

Hierbei ist x := min{k Z : k x} f r x R. Das Intervall u darstellbarer Bereich.

bn 2

heit

1.2 Darstellung ganzer Zahlen im Rechner Beispiel 1.11. (a) Im Fall b = 10, n = 2 ist der darstellbare Bereich 50 z < 50. Konkrete Darstellungen sind Zahl 43 13 27 38 Darstellung 43 87 73 38

(b) Im Fall b = 2, n = 3 ist der darstellbare Bereich 4 z < 4. Konkrete Darstellungen sind Zahl 4 3 2 1 0 1 2 3 Bitmuster 100 101 110 111 000 001 010 011

Dies erklrt die Bemerkung vom Ende des Abschnitts 1.1. Die Zahl 1 hat die Darstellung a (111 . . . 1)K2 . Diese Ziern als unsigned int interpretiert ergeben (1, . . . , 1)2 = 2n 1 0. Ein hnliches Problem tritt beim so genannten Unter- bzw. Uberlauf (Verlassen des dara stellbaren Bereiches) beim Typ int auf. Die grte darstellbare Zahl ist (011 . . . 1)K2 = o 2n1 1 =: xmax whrend xmax + 1 = (10 . . . 0)K2 als 2n1 interpretiert wird. a Betrachten wir nun die Addition von Zahlen in dieser Darstellung. Dazu sei mit die zif fernweise Addition der Darstellungen zweier Zahlen bezeichnet, wobei ein eventueller Ubern lauf auf die (n + 1)-te Stelle vernachlssigt wird, d.h. wir rechnen modulo b a Satz 1.12. Seien x, y n-stellige Zahlen und x, y, x + y im darstellbaren Bereich. Dann gilt (x + y)Kb = (x)Kb (y)Kb . Beweis. Fr z 0 gilt per Denition (z)Kb = z. Im Fall z < 0 haben wir nach Lemma 1.9 u (z)Kb = Kb (z) = bn + z. In beiden Fllen gilt daher z = (z)Kb mod bn . Insbesondere ist a n (x)Kb + (y)Kb mod b = x + y = (x + y)Kb mod bn . Beispiel 1.13. Sei b = 10, n = 2. Dann ergibt sich ein darstellbarer Bereich 50 z < 50. Wir erhalten (27)K10 (12)K10 (27)K10 (15)K10 (27)K10 (34)K10 (27)K10 (21)K10 = 27 + 12 = 27 + 85 = 27 + 66 = 73 + 79 mod mod mod mod 100= 39 = (39)K10 , 100= 12 = (12)K10 , 100= 93 = (7)K10 , 100= 52 = (48)K10 .

1 Maschinenzahlen und -arithmetik Die Subtraktion zweier Zahlen x, y lt sich mittels x y = x + (y) auf die Addition a zurckfhren. u u Satz 1.14. Seien x, y n-stellige Zahlen und x, y, x y im darstellbaren Bereich. Dann gilt (x y)Kb = (x)Kb Kb ((y)Kb ). Beweis. Wir zeigen zunchst, dass (y)Kb = Kb ((y)Kb ) gilt. Ist nmlich y > 0, so gilt a a per Denition (y)Kb = Kb (y) = Kb ((y)Kb ). Im Fall y 0 hat man (y)Kb = y = Kb (Kb (y)) = Kb ((y)Kb ). Nach Satz 1.12 gilt dann (x y)Kb = (x)Kb (y)Kb = (x)Kb Kb ((y)Kb ). Beispiel 1.15. Es sei b = 10, n = 2. Hieraus folgt fr den darstellbaren Bereich 50 z < u 50. Wir erhalten (37)K10 K10 ((28)K10 ) = 37 + 72 mod 100 = 9 = (37 28)K10 , (37)K10 K10 ((48)K10 ) = 37 + 52 mod 100= 89 = (37 48)K10 , (12)K10 K10 ((24)K10 ) = 88 + 76 mod 100= 64 = (12 24)K10 .

1.3 Darstellung reeller Zahlen

1.3.1 Festkommazahlen
Denition 1.16. Bei der Festkommadarstellung (engl. xed point presentation) wird bei vorgegebener Stellenzahl n eine feste Anzahl an Nachkommastellen vereinbart, d.h.
k1

z = (zk1 , zk2 , . . . , z0 . z1 , . . . , zkn ) = mit k Vorkomma- und n k Nachkommastellen. Beispiel 1.17. (271.314)10 = 271.314, (101.011)2 = 22 + 20 + 22 + 23 = 5.375.

zi bi
i=kn

Der Hauptnachteil der Festkommazahlen ist, dass der Abstand := 2kn zwischen zwei benachbarten Zahlen immer gleich ist. Liegt beispielsweise ein Rechenergebnis x genau zwischen zwei Festkommazahlen x0 und x0 + , so muss gerundet werden. Die Rundungsgenauigkeit betrgt , d.h. |x x0 | = 2 . Der relative Fehler hngt dann aber von der Gre von x ab: a 2 a o |x x0 | = . |x| 2|x|

a u Beispielsweise ist fr = 103 und x = 0.5 der relative Fehler 10 = 103 , whrend fr u 20.5 2 x = 0.05 der relative Fehler 10 betrgt. Weil man aber an einer relativen Genauigkeit a interessiert ist, die nicht von der Gre der Zahl abhngt, verwendet man anstelle der Festo a kommazahlen die im Folgenden vorgestellten Gleitkommazahlen.

1.3 Darstellung reeller Zahlen

1.3.2 Gleitkommazahlen
Ahnlich wie in Satz 1.2 beweist man Satz 1.18. Sei b N \ {1}. Jedes x R besitzt eine Darstellung x = di b und e Z.
i=0

di bei mit

Beweis. Sei x0 R und o.E. sei x0 > 0. Dann gibt es e Z mit 0 x0 < be+1 . Setzt man d0 = so ist d0 b . Wegen d0
x0 be

x0 , be

< d0 + 1 d0 be x0 < d0 be + be folgt fr u x1 := x0 d0 be

die Abschtzung 0 x1 < be . Genauso wie x1 aus x0 generiert wurde, kann man nun x2 aus a x1 , x3 aus x2 , usw. erzeugen. Nach s Schritten erhlt man somit a
s1

x0 =
i=0

di bei + xs

mit di b , und es gilt 0 xs < be+1s . Wegen be+1s 0 folgt xs 0 und daraus s s die Behauptung. Man beachte, dass die Darstellung aus Satz 1.18 nicht eindeutig ist. Beispielsweise hat man 1.4 103 = 0.14 102 . Die Eindeutigkeit kann aber durch Normierung, d.h. z.B. durch die Forderung d0 = 0, erzwungen werden. Wegen der Endlichkeit des Rechners beschrnken a wir uns auf Zahlen, die folgende Darstellung besitzen. Denition 1.19. Die Menge der normalisierten Gleitkommazahlen sei gegeben durch
t1 p1

F(b, t, p) :=

i=0

di bei : di b , d0 = 0, e =

j=0

ej bj , ej b

{0}.

Dabei bezeichnet b N \ {1} die Lnge der Basis, t N die Mantissenlnge und p die a a Exponentenlnge. a Man speichert also die Informationen (vm , dt1 , . . . d0 , ve , ep1, . . . , e0 ) mit vm , ve {+, } und di , ej b . Der zugeordnete Wert einer solchen Maschinenzahl ist vm m be mit dem Vorzeichen vm , der Mantisse m = t1 di bi und dem Exponenten i=0 e = ve p1 ej bj . j=0 Beispiel 1.20. Die Dezimalzahl x = 3.375 hat die Gleitkommadarstellung (b = 2, t = 5, p = 2) x = (+, 1, 1, 0, 1, 1, +, 0, 1).

1 Maschinenzahlen und -arithmetik Dies sieht man aus

t1

m=
i=0

di bi = 1 20 + 1 21 + 0 22 + 1 23 + 1 24 1 1 1 + + = 1.6875, 2 8 16 e = 1 20 + 0 21 = 1, x = 1.6875 21 = 3.375. =1+

Bemerkung. Weil bei der Basis b = 2 das erste Bit d0 = 1 feststeht, wird es oft nicht dargestellt (sog. hidden bit). In diesem Fall werden t Mantissenbits zur Darstellung von d1 , . . . , dt verwendet. Die Null muss dann gesondert dargestellt werden, z.B. indem man die Bits der Mantisse als Null und den Exponenten als kleinster darstellbarer Exponent 1 2p whlt (IEEE Standard 754). (d1 , . . . , dt ) wird oft auch als Signikant bezeichnet. Beim a hidden bitgelang man somit zu folgendem Zahlenbereich betragsmig grte Zahl: xmax = (1.1 . . . 1)2 (1...1)2 = 2emax mit emax = 2p 1 a o p betragsmig kleinste Zahl ungleich Null: xmin = (1.0 . . . 0)2(1...10)2 = 2emin mit emin = a p 2 2 . Dabei beachte man, dass 1 2p fr die Darstellung der Null reserviert ist. u Bei vorgegebenem Exponenten e liegt die Menge der mit diesem Exponenten darstellbaren Zahlen im Intervall 2e x < 2e+1 , weil (bei positivem Vorzeichen) x = (1.d1 , . . . , dt )2e = (1 + k e )2 2t

fr ein ganzzahliges k mit 0 k < 2t . u Es knnen fr einen Exponenten insgesamt 2t Zahlen dargestellt werden. o u 0
p

2e+1 2t

2e 2t

xmin = 222

2e 2t

2e+1

2t

1.3.3 Genauigkeit der Gleitkommadarstellung

Die Endlichkeit der Menge F der Maschinenzahlen erzwingt bei der Konvertierung oder der Darstellung von Zwischenergebnissen die Rundung auf Maschinenzahlen. Denition 1.21. Die Rundung rd : R F(b, t, p) ist deniert durch |x rd(x)| = min |x a|.
aF

Den maximalen relativen Rundungsfehler F f r xmin |x| xmax nennt man Maschiu nengenauigkeit. Die Stellen der Mantisse heien signikante Stellen. Eine t-stellige Mantisse bezeichnet man auch als t-stellige Arithmetik.

1.3 Darstellung reeller Zahlen Bytes Basis Format 1 + t + p single 4 2 double 8 2 Lnge der a Mantisse 24 53 hidden bit ja ja Bits fr den u Exponenten 8 11

Tabelle 1.1: Zwei Zahlentypen mit ihren Parametern.

Bemerkung. (a) Es gilt rd(x) = x(1 + ) mit || F weil F x x(1 + ) x rd(x) = = || . x x

(b) Liegt x genau in der Mitte zwischen zwei benachbarten Gleitkommazahlen, so wird abgerundet.
1 Satz 1.22. Die Maschinengenauigkeit f r F(b, t, p) ist F = 2 b1t . u

Beweis. Sei x =

i=0

di bei . Dann sind

t1 t1

x :=
i=0

di b

ei

und x := b

et+1

+
i=0

di bei

1 beide in F, und es gilt x x < x . Daher folgt |x rd(x)| 1 |x x | = 2 bet+1 . Wegen 2 d0 = 0 gilt |x| be . Also folgt

1 bet+1 1 |x rd(x)| = b1t . e |x| 2 b 2 Die Maschinengenauigkeit F ist die wichtigste Gre eines Gleitkommasystems. Die Ano zahl signikanter Stellen s im Dezimalsystem berechnet man durch Ausen von o 1 1 F = b1t = 101s 2 2 nach s. Danach ergibt sich s = 1 + (t 1) log10 b.

Beispiel 1.23. Wir betrachten die im IEEE-Standard 754 denierten Zahlentypen single u und double. Aus Tabelle 1.1 ergibt sich fr den Typ double ein minimaler und maximaler p Exponent emin = 2 2 = 1022 bzw. emax = 2p 1 = 1023 und daraus xmax = (2 2t )22
p p 1

xmin = 222 2.225 10308 .

1.797 10308 ,

Auerdem ist F = 1 2153 1.1 1016 , was 16 signikanten Dezimalstellen entspricht. 2

1 Maschinenzahlen und -arithmetik Der Exponent emin 1 = 1023 wird verwendet, um sog. denormalisierte Gleitkommazahlen zu speichern. Dabei reprsentiert die Mantisse (0, 0, . . . , 0) die Zahl 0 und eine a positive Mantisse einen Wert zwischen 0 und xmin als Festkommazahl. Ein Overow ( inf) wird durch den maximalen Exponenten mit Bitmuster (1 . . . 1) und Mantisse 0 reprsentiert. a Die Werte NaN (engl. not a number) werden als Darstellung fr indenite Werte verwendet. u 0 u Diese treten z.B. auf, wenn man Operationen wie 0 ausfhrt. NaN wird ebenfalls durch den maximalen Exponenten aber mit positiver Mantisse kodiert. Der Exponent wird um |emin |+1 verschoben, d.h. statt e wird e + |emin| gespeichert (sog. Biasdarstellung). 0 Vorzeichen + 010. . . 0 Signikant 1.25 10000000010 Exponent 1026 1023 = 3

Beispiel 1.24. Die Dezimalzahl 10.0 wird im IEEE-Standard 754 dargestellt als

Whrend 0, 8 als (gerundetes) Bitmuster a 1 Vorzeichen gespeichert wird. Weil x = 2F die kleinste Zahl ist, fr die rd(1 + x) > 1, kann die Maschinengenauigkeit u auf einem Rechner mit folgendem Algorithmus bestimmt werden. Algorithmus 1.25 (Bestimmung von F ). 1001101. . .10011010 01111111110 Signikant Exponent 1.599 . . . 1022 1023 = 1

eps = 1.0; (1.0+ eps > 1.0) eps = eps /2;

10

2 Fehleranalyse
2.1 Rechnerarithmetik
Wegen der Endlichkeit der Maschinenzahlen entstehen Fehler nicht nur bei der Eingabe von Daten, sondern auch bei den elementaren Rechenoperationen +, , , /. Man hat auf dem Rechner nur eine Pseudoarithmetik, d.h. die Menge F ist nicht abgeschlossen bezglich dieser u Operationen. Beispiel 2.1. Betrachte Gleitkommazahlen F mit Mantissenlnge t = 5 und Basis b = 10. a 3 Mit x = 2.5684 und y = 3.2791 10 gilt, dass x + y = 2.5715791 F rd(x + y) = 2.5714, x y = 0.008422044044 F rd(x y) = 8.4220 103 , x/y = 783.2637004 F, rd(x/y) = 7.8326 102 . Obiges Beispiel verdeutlicht, dass fr x, y F nicht notwendigerweise x y F gilt, u wobei {+, , , /}. Stattdessen wird auf dem Rechner eine Ersatzoperation x y F ausgefhrt. Im Folgenden nehmen wir an, dass u x y = rd(x y) fr alle x, y F. u (2.1)

Dies bedeutet, dass x y denselben Wert hat, als wrde man x y zunchst exakt berechnen u a und das Ergebnis dann runden. a u Annahme (2.1) wird z.B. vom IEEE-Standard 754 gefordert. Hardwaremig wird dafr mit einer lngeren Mantisse gerechnet und das Ergebnis dann gerundet. Unter der Annahme a (2.1) gilt im Fall xmin |x|, |y|, |x y| xmax fr den relativen Fehler u x yxy rd(x y) x y = F . xy xy Das Kommutativgesetz fr Addition und Multiplikation gilt auch in der Rechnerarithmeu tik, Distributivgesetz- und Assoziativgesetz im Allgemeinen jedoch nicht. Beispiel 2.2. Betrachte F mit b = 10, t = 2. Fr x = 4.1, y = 8.2 101 und z = 1, 4 101 u hat man (x y) z = 4.9 0.14 = 5.0, x (y z) = 4.1 0.96 = 3.9, x (y z) = 4.1 0.96 = 5.1, x y x z = 3.4 0.57 = 4.0

Mathematisch quivalente Ausdrcke knnen beim Ausfhren auf dem Rechner zu wesentlich a u o u unterschiedlichen Ergebnissen fhren, selbst dann, wenn die Eingangsdaten Maschinenzahlen u sind.

11

2 Fehleranalyse

2.2 Fehlerfortpanzung
Bei der Fehlerfortpanzung untersucht man, wie sich Fehler in den Eingabedaten im Laufe einer Berechnung verstrken. Man untersucht, welcher Fehler bei exakter Auswertung der a fehlerhaften Eingabedaten auftritt. Lemma 2.3. Es seien x, y die mit relativen Fehlern x := xx , x y := yy y

behafteten Werten f r x bzw. y. Dann gilt f r den relativen Fehler u u := dass = x y x y , xy xy = x + y x y , y (x y ). / = x y + 1 y (x y) ( y ) x , xy {+, , , /},

Beweis. in den Ubungsaufgaben. Aus Lemma 2.3 erkennt man, dass sich die Fehler bei Multiplikation und Division im Wesentlichen addieren bzw. subtrahieren. Bei der Addition und der Subtraktion kann der relative Fehler jedoch sehr verstrkt werden, falls |x y| sehr klein ist im Vergleich zu |x| a und |y|. Diesen Eekt bezeichnet man als Auslschung. Es gilt, ihn soweit wie mglich zu o o vermeiden. Beispiel 2.4. Betrachte die quadratische Gleichung x2 + 2px + q = 0. Die Lsungen dieser o Gleichung sind x1,2 = p p2 q. Diese lassen sich gem a d x1 x2 = sqrt(p*p-q); = -p-d; = -p+d;

berechnen. Fr p = 100 und q = 1 bei dreistelliger dezimaler Rechnerarithmetik ergibt sich u d = p2 d = 10000 1 = 9999 = 100 und somit x1 = p d = 200, x2 = p + d = 0. Richtig wre aber x1 = 200 und x2 = 0.005, wenn das Ergebnis mit drei Stellen angegeben a 1 werden soll. Weil die Maschinengenauigkeit F = 2 1013 = 0.005 betrgt, ist das Ergebnis a x2 = 0 schlicht falsch. Dieser Auslschungseekt bei der Berechnung von x2 kann durch Anderung der Art und o Weise, wie x2 berechnet wird, vermieden werden. Wegen x2 (x1 + x2 )x + x1 x2 = (x x1 )(x x2 ) = x2 + 2px + q fr alle x R u

12

2.2 Fehlerfortpanzung folgt durch Koezientenvergleich x1 + x2 = 2p und x1 x2 = q, was als Wurzelsatz von Vieta bekannt ist. Berechnet man nur die betragsmig grte Nullstelle und die andere mittels x1 x2 = q, so a o erhlt man den folgenden Algorithmus: a d = sqrt (p *p -q ); ( p >= 0) x1 = -p -d; x1 = d - p; x2 = q / x1 ; Hier ergibt sich d = 100, x1 = p d = 200, x2 = 1/ 200 = 0.005. Bei der Fehleranalyse unterscheidet man drei Arten von Fehlern: 1. Datenfehler: Um ein Rechenverfahren zu starten, bentigt man Eingabedaten. Diese o sind im Allgemeinen ungenau (z.B. Messdaten) oder lassen sich nicht exakt im Rechner darstellen. 2. Rundungsfehler: Wegen der begrenzten Rechengenauigkeit sind alle Zwischenergebnisse gerundet. 3. Verfahrensfehler: Viele numerische Verfahren liefern selbst bei einer exakten Arithmetik nach endlich vielen Schritten keine exakte Lsung, sondern nhern sich einer o a solchen nur beliebig genau an. Beispielsweise kann mit Hilfe der Iteration xi+1 := a 1 xi + 2 xi , i = 0, 1, 2, . . . ,

mit Startwert x0 = 1 die Quadratwurzel a > 0 berechnet werden. Kein xi stimmt aus mit a uberein, nur die Dierenz |xi a| wird fr wachsende i beliebig klein. Da u man nur endlich viele Schritte ausfhren kann, entsteht ein Fehler. Dieser wird als u Verfahrensfehler bezeichnet. Denition 2.5. Bei der Vorwrtsanalyse untersucht man, wie sich der relative Fehler a im Verlaufe einer Rechnung akkumuliert. Bei der Ruckwrtsanalyse wird jeder Rechena schritt als exakt bei gestrten Daten interpretiert, und es wird abgeschtzt, wie gro die o a Eingangsdatenstrung ist. o

Beispiel 2.6. Wir untersuchen die Addition zweier Zahlen. Vorwrtsanalyse: x y = rd(x + y) = (x + y)(1 + ) mit || F , a Rckwrtsanalyse: x y = x(1 + ) + y(1 + ) = x + y mit || F . u a Beispiel 2.7. Berechnung
n i=1

s = 0.0; (i =0; i < n; ++ i) s =s +a [i ]* b[ i ];

ai bi fr ai , bi R u

Sei ti := ai bi = ai bi (1 + i ) und si := si1 ti = (si1 + ti )(1 + i ), s0 = 0, mit |i |, |i | F . Hierbei ist zu bercksichtigen, dass wegen s0 = 0 die erste Addition exakt u

13

2 Fehleranalyse durchgefhrt werden kann, d.h. wir haben 1 = 0. Dann gilt u s1 = a1 b1 (1 + 1 ) s2 = [a1 b1 (1 + 1 ) + a2 b2 (1 + 2 )](1 + 2 ) = a1 b1 (1 + 1 )(1 + 2 ) + a2 b2 (1 + 2 )(1 + 2 ) . . .
n n

sn =
i=1

ai bi (1 + i )
j=i i b

(1 + j ) .

Bei der Rckwrtsanalyse werden die Fehler als gestrte Eingabedaten interpretiert: u a o i = bi (1 + i ). Hieraus folgt b
n

1 + i = (1 + i )
j=i

(1 + j )

und somit Mit der Bernoullischen Ungleichung (1 x)n 1 nx, x 1, erhlt man a i (1 F )ni+2 1 (n i + 2)F , (1 2 )ni+2 F i (1 + F )ni+2 1 = 1 (1 F )ni+2 (n i + 2)F 1 1= . 1 (n i + 2)F 1 (n i + 2)F Hieraus folgt |i | und sn =
i=1

(1 F )ni+2 1 + i (1 + F )ni+2 .

(n i + 2)F 1 (n i + 2)F
n

ai bi (1 + i ).

2.3 Kondition und Stabilitt a

Ein zu lsendes Problem ist dadurch gekennzeichnet, dass zu gegebenen Daten x ein Ergebnis o y zu berechnen ist, wobei der Zusammenhang zwischen x und y durch y = f (x) beschrieben wird. Denition 2.8. Ein Problem (2.2) heit wohlgestellt, wenn es zu jedem x genau eine Lsung y gibt und die Zuordnung x y stetig ist. o (2.2)

14

2.3 Kondition und Stabilitt a Gegeben sei eine dierenzierbare Funktion f : R R. Fr fehlerbehaftete Daten x = u x + x gilt f (x + x) f (x) f (x) x Folglich gilt fr den Datenfehler y := f () f (x) u x f (x)x f (x) x x y = = . y f (x) f (x) x Denition 2.9. F r f (x) = 0 deniert man die Konditionszahl von f an der Stelle x als u (f, x) := f (x) x f (x)

Ein Problem heit schlecht konditioniert, falls die Konditionszahl deutlich grer ist als o 1, andernfalls heit es gut konditioniert. Beispiel 2.10.
x f (x) = x + a. Dann ist die Konditionszahl x+a . Das Problem ist schlecht konditioniert, falls |x + a| klein ist im Vergleich zu x (Auslschung). o ax f (x) = x a. Dann ist (f, x) = | xa | = 1. Folglich ist die Multiplikation immer gut konditioniert.

f (x) = x. Dann ist (f, x) = konditioniert.

1 x 2 x1/2 x

= 1 . Somit ist auch das Radizieren stets gut 2

Denition 2.11. Erf llt ein Algorithmus f zur Lsung eines Problems f u o f (x) f (x) cV (f, x) F f (x) mit einer mig groen Konstanten cV > 0, so wird der Algorithmus f als vorwrtsstabil a a (x) = f (x + x) mit bezeichnet. Ergibt die R ckwrtsanalyse f u a x cR F x und ist cR > 0 nicht zu gro, so ist f ruckwrtsstabil. a Bemerkung. Die Kondition ist eine Eigenschaft des Problems, wohingegen die Stabilitt eine Eia genschaft eines Algorithmus ist. Ist ein Problem schlecht konditioniert, so kann kein Algorithmus verhindern, dass sich Eingabefehler vergrern. Ein gut konditioniertes o Problem mit einem stabilen Algorithmus liefert gute numerische Ergebnisse.

15

2 Fehleranalyse Rckwrtsstabile Algorithmen zur Lsung von gut konditionierten Problemen sind u a o auch vorwrtsstabil, denn es gilt a |f (x + x) f (x)| |x| |f (x) f (x)| = cR F . |f (x)| |f (x)| |x| Beispiel 2.12. Wir kommen zurck zu Beispiel 2.4. Fr f (x) = p + u u gilt (f, x) = = = f (x) x x = 2 x(p f (x) 2 p 1 2 x(p + p2 x(p + p2 x)(p p2 x) p2 x mit |x| p

p2 x) p2 x)

1 p + p2 x 1 2 p2 x

Die Nullstellenberechnung ist also gut konditioniert. Folglich ist der erste Algorithmus aus Beispiel 2.4 instabil.

16

3 Dreitermrekursion
3.1 Theoretische Grundlagen
Denition 3.1. Eine Rekursion der Form pk = ak pk1 + bk pk2 + ck , k = 2, 3, . . . (3.1)

mit ak , bk , ck R heit Dreitermrekursion. Gilt ck = 0 f r alle k, so heit die Dreitermu rekursion homogen, sonst inhomogen. Gilt bk = 0 f r alle k, so wird u pk2 = ak 1 ck pk1 + pk bk bk bk (3.2)

als Ruckwrtsrekursion bezeichnet. Geht (3.2) aus (3.1) durch Vertauschen von pk und a pk2 hervor, d.h. gilt bk = 1, so heit die Rekursion symmetrisch. Beispiel 3.2. (a) Sei pk = ak pk1 + bk pk2 , ak = 2 cos(x), bk = 1, k = 2, 3, . . .. Dies liefert mit p0 = 1, p1 (x) = cos(x), dass pk (x) = cos(k x), k = 2, 3, . . . . Dies sieht man mit den trigonometrischen Beziehungen cos(x y) = (cos x)(cos y) (sin x)(sin y). (b) Die Rekursionsformel fr die Tschebyche-Polynome lautet u Tk (x) = 2xTk1 (x) Tk2 (x), k = 2, 3, . . .

mit Startwerten T0 (x) = 1, T1 (x) = x. Diese Rekursionsformel ist vom Typ (a), falls man x = cos einsetzt. Daher gilt Tk (cos ) = cos(k) Tk (x) = cos(k arccos(x)). (c) Die Fibonacci-Zahlen sind rekursiv deniert durch fk = fk1 + fk2 , k = 2, 3 . . . mit Startwerten f0 = 0, f1 = 1. Algorithmus 3.3. (Dreitermrekursion)

n ; a[n -2] , b[n -2] , c [n -2] , p0 , p1 ; // Achtung : Indexshift Output : p [ n ];

p [0] = p0 ; p [1] = p1 ; (k =2; k < n; k ++) p [k ]= a[k -2]* p [k -1]+ b[k -2]* p[k -2]+ c [k -2];

Input :

17

3 Dreitermrekursion Beispiel 3.4. Im Fall der Dreitermrekursion pk = 2pk1 + pk2, k = 2, 3, . . . mit p0 = 1, p1 = 21

liefert Algorithmus 3.3 das folgende Ergebnis.

15

10

-5

-10

-15 0 10 20 k 30 40 50

Wie wir im Folgenden sehen werden, handelt es sich hierbei um eine Instabilitt. Um zu a verstehen, warum diese auftritt, mssen wir Dreitermrekursionen zunchst etwas analysieren. u a Dazu bentigen wir den Begri des Eigenwerts einer Matrix A Rnn . Wir denieren das o charakteristische Polynom () := det(A I), wobei I Rnn die Einheitsmatrix, d.h. die Matrix mit den Eintrgen a Iij = 1, i = j, 0, sonst,

bezeichnet. Jede Nullstelle C von heit Eigenwert von A. Der Name Eigenwert rhrt u aus der Tatsache her, dass die Bedingung det(A I) = 0 quivalent zur Existenz eines a 0 = x Rn mit Ax = x ist. x heit Eigenvektor. Die homogene Dreitermrekursion pk = ak pk1 + bk pk2 , kann umgeschrieben werden gem a pk a b = k k pk1 1 0 Rekursiv folgt somit pk p p = Ak Ak1 . . . A2 1 = Bk 1 pk1 p0 p0 mit Bk = Ak . . . A2 R22 . Oensichtlich gilt fr alle , R u Bk q p1 + 1 q0 p0 = Bk qk pk q p1 . + + Bk 1 = qk1 pk1 q0 p0 pk1 p = Ak k1 , pk2 pk2 k = 2, 3, . . . . k = 2, 3, . . .

18

3.1 Theoretische Grundlagen Die Folge {pk } hngt also linear von den Startwerten a Im Fall konstanter Koezienten ak = a, bk = b folgt Bk = Ak1 , A= a b . 1 0 p1 R2 ab. p0

Beispiel 3.5. Wir bestimmen das charakteristische Polynom von A. Es gilt () = det(A I) = det 1 0 a b 0 1 1 0 = det a b 1

= (a ) b = 2 a b

Satz 3.6. Seien 1 , 2 die Nullstellen des charakteristischen Polynoms von A. Dann ist die Lsung der homogenen Dreitermrekursion o pk = apk1 + bpk2 , gegeben durch pk = k + k , 1 2 k = 0, 1, 2, . . . mit , R Lsungen von + = p0 und 1 + 2 = p1 . o Beweis. Wir fhren den Beweis durch vollstndige Induktion nach k. Fr k = 0, 1 ist die u a u Aussage trivial. Angenommen, die Behauptung gilt fr alle natrlichen Zahlen bis zu einem u u k N. Dann ist pk+1 = apk + bpk1
k1 k1 = a(k + k ) + b(1 + 2 ) 1 2 k1 k1 = 1 (a1 + b) + 2 (a2 + b)

k = 2, 3, . . .

Wegen (1 ) = 0 und (2 ) = 0 folgt die Behauptung. Wenden wir nun den letzten Satz auf Beispiel 3.4 an. Das charakteristische Polynom () = 2 +21 hat die Nullstellen 1,2 = 1 2. Aus + = 1 und 1 +2 = 21 erhlt man = 1, = 0. Nach Satz 3.6 ist die Lsung der Dreitermrekursion also a o pk = k = ( 2 1)k 1. 1 Dies erhlt man auch bei folgendem Algorithmus: a Algorithmus 3.7. (geschlossene Lsung der Dreitermrekursion) o

n; a ,b , p0 , p1 ; Output : p [ n ];
Input : lambda1 = a /2 + sqrt ( a* a /4+ b ); lambda2 = a /2 - sqrt ( a* a /4+ b ); beta = ( p1 - lambda1 * p0 )/( lambda2 - lambda1 );

19

3 Dreitermrekursion

alpha = p0 - beta ; p [0] = p0 ; p [1] = p1 ; l1 = lambda1 ; l2 = lambda2 ; (k =2; k < n; ++ k ) { l1 *= lambda1 ; // l1 = l1 * lambda1 ; l2 *= lambda2 ; p [k ] = alpha * l1 + beta * l2 ; } Im Fall der Werte aus Beispiel 3.4 liefert dieser Algorithmus das folgende Ergebnis.
15

10

-5

-10

-15 0 10 20 k 30 40 50

Wir untersuchen die Kondition des Problems, um diese unterschiedlichen Ergebnisse zu erklren. Dazu betrachten wir f : R R mit f (p0 , p1 ) = pk . Gestrte Daten a o p0 = 1 + 0 , ergeben gestrte Koezienten o = 1 + 0 1 2 1 , 2 1 2 1 1 = (1 0 ) 2 1 k + (1 0 ) 1 1 k . 2 1 2 2 1
k

p1 = 1 (1 + 1 ),

|0 |, |1| F ,

und die gestrte Lsung o o pk = 1 + 0

Folglich ergibt sich der relative Fehler

1 2 1 2 1 2 1

2 1 1 pk pk = 0 1 + (1 0 ) pk 2 1 2 1 2 1 1 = 0 + (1 0 ) 2 1 2 1
k

20

3.2 Miller-Algorithmus Im Fall |2 | > |1 | explodiert der relative Fehler. Genau dies passierte in Beispiel 3.4. Der Term k wchst exponentiell, whrend die exakte Lsung exponentiell abfllt. Wie kann man a a o a 2 dennoch so genannte Minimallsungen berechnen? o Denition 3.8. Die Lsung {pk } der Dreitermrekursion (3.1) zu den Startwerten p0 , p1 o heit Minimallsung, falls f r jede Lsung {qk } zu den von p0 , p1 linear unabhngigen o u o a Daten q0 , q1 gilt pk lim = 0. k qk Die Lsung {qk } wird auch als dominante Lsung bezeichnet. o o o Beispiel 3.9. In Beispiel 3.4 ist {pk } genau dann Minimallsung, wenn = 0.

Es ist klar, dass die Minimallsung nur bis auf einen skalaren Faktor eindeutig bestimmt o ist. Daher fhren wir die Normierung p2 + p2 = 1 ein. u 0 1

3.2 Miller-Algorithmus
Wir suchen die Minimallsung, d.h. diejenige Lsung, die zu dem kleineren Eigenwert koro o respondiert. Betrachte die zu (3.1) gehrende Rckwrtsrekursion o u a 1 a qk2 = qk1 + qk , k = n, n 1, . . . , 1 b b mit Startwerten qn = 0, qn1 = 1. Das charakteristische Polynom von C= ist () = det(C I) = det Daher besitzt C die Eigenwerte 1,2 = a a 1 b b 1 0 a 1 a 1 b b = 2 + . 1 b b a2 + 4b 1 = , 2b 1,2

welche reziprok zu den Eigenwerten von A sind. Daher werden kleine Eigenwerte zu groen, 1 gegen die dann die Rekursion stabil konvergiert. Aus + = 0 und 1 + 2 = 1 ergeben sich die Koezienten 1 2 1 2 , = . = 2 1 2 1 Aufgrund der Lsungsdarstellung o qk = folgt im Fall |1 | < |2 | qk = q0
nk 1 n 1

nk 1

nk 2

+ +

nk 2 n 2

k + k 1 1 2 2

1+

1 n 2

k . 1

Fr n = 100 wird p50 aus Beispiel 3.4 auf 13 Nachkommastellen genau berechnet. u

21

3 Dreitermrekursion

Algorithmus 3.10 (Miller-Algorithmus). (i) whle n gengend gr. a u o (ii) Rckwrtsrekursion: u a 1 a pk2 = pk1 + pk , b b mit den Startwerten pn = 0, pn1 = 1.
(n) (iii) Normierung: setze pk = p2k p0 +2 p1

k = n, n 1, . . . , 2,

, k = 0, 1, 2, . . . , n.

Satz 3.11. Sei {pn } eine Minimallsung der homogenen Dreitermrekursion mit p2 + p2 = 1. o 0 1 Dann gilt f r die Lsung des Miller-Algorithmus u o
n

lim pk = pk ,

(n)

k = 0, 1, 2, . . . , n.

Beweis. Sei {pk } eine normierte dominante Lsung mit zu p1 , p0 o T Startvektoren q1 , q0 . Wegen qk qk1 sind auch qk , qk1
T

linear unabhngigen a

= Ak1
T

q1 q0

und

p pk = Ak1 1 p0 pk1

, pk , pk1

linear unabhngig, weil aus a

0= folgt, dass

q p qk pk + = Ak1 1 + 1 q0 p0 qk1 pk1 p q1 + 1 p0 q0

T

0=

und hieraus = = 0. Also knnen wir den Startvektor pn , pn1 o T T von pn , pn1 und qn , qn1 darstellen: pn pn qn pn qn = + = pn1 pn1 qn1 pn1 qn1 und somit pn qn = pn1 qn1 1 = pn qn1 qn pn1 1 = pn qn1 qn pn1
1

als Linearkombination

pn pn1 qn1 qn pn1 pn 0 1

qn pn

22

3.2 Miller-Algorithmus Wegen der Linearitt folgt a pk = pk + qk = Aus p2 0 + p2 1

2 qn = (qn pn1 pn qn1 )2 2 qn = (pn1 qn qn1 pn )2

qn pk pn qk qn = qn pn1 pn qn1 qn pn1 pn qn1

pk

pn qk . qn

p2 0

2 pn 2 2 pn + 2 (p0 q0 + p1 q1 ) + (q0 + q1 ) 2 qn qn 2 pn p 12 c+ n 2 qn qn

p2 1

mit c := p0 q0 + p1 q1 erhalten wir

(n) pk

pk p2 0 + p2 1

pk

pn q qn k p2 n 2 qn

n 1 2c pn + q

pk

wegen pn /qn 0 fr n . u

23

4 Sortieralgorithmen
Wir betrachten das folgende Sortierproblem: Gegeben seien n Zahlen z1 , . . . , zn R. Gesucht ist eine Permutation , so dass z1 z2 . . . zn . Von Bedeutung ist die Sortierung, wenn z.B. Ausdrcke der Art n zi zu berechnen sind. u i=1 Denition 4.1. Eine bijektive Abbildung : {1, . . . , n} {1, . . . , n} heit Permutation. Wir schreiben (k) = k , k = 1, . . . , n.

Satz 4.2. Es gibt n! = n (n 1) . . . 2 1 Permutationen von {1, . . . , n}. Beweis. Im Fall n = 1 ist die Behauptung klar. Angenommen, die Aussage gilt fr ein n N. u Sei eine Permutation uber {1, . . . , n + 1}. Dann existiert ein k {1, . . . , n + 1}, so dass (k) = n + 1. Die Abbildung (k) : {1, . . . , k 1, k + 1, . . . , n + 1} {1, . . . , n} deniert durch (k) (i) = (i), i = k, ist eine Permutation uber n Zahlen. Umgekehrt ist jede Abbildung dieser zusammengesetzten Form eine Permutation uber {1, . . . , n + 1}. Dies ergibt (n + 1)n! = (n + 1)! Permutationen. Ein naiver Algorithmus besteht darin, alle mglichen Permutationen zu testen, ob sie o die gewnschte Sortierung garantieren. Fr jede Permutation sind n 1 Vergleiche durchu u zufhren. Also ergeben sich im ungnstigsten Fall (engl. worst case) (n 1)n! Operationen. u u

4.1 Bubblesort
Aus der Transitivitt der Ordnungsrelation a x y, y z x z ergibt sich folgende Idee, die eine bessere Ezienz verspricht. Die Zahlenfolge wird in aufsteigender Reihenfolge durchlaufen. Dabei werden immer zwei benachbarte Elemente vertauscht, falls sie in falscher Reihenfolge stehen. Am Ende steht das grte Element am Ende der Folge und muss beim nchsten Durchlauf nicht mehr betrachtet o a werden. Der Name bubblesort rhrt daher, dass die greren Zahlen wie Blasen im Wasser u o aufsteigen. Beispiel 4.3. Wir wollen die Zahlen z1 = 5, z2 = 3, z3 = 2 aufsteigend sortieren. Im 1. Durchlauf haben wir (5, 3, 2) (3, 5, 2) (3, 2, 5). Im 2. Durchlauf ist (3, 2, 5) (2, 3, 5). 25

4 Sortieralgorithmen Die Anzahl der Vergleiche im k = 1, . . . , n 1-ten Schritt ist n k. Also ergeben sich insgesamt n1 n1 n(n 1) k= (n k) = 2 k=1 k=1 Vergleiche, was eine erhebliche Reduktion des Aufwandes gegenber der naiven Vorgehensu weise bedeutet. Algorithmus 4.4 (Bubblesort).

n ; z [n ]; Output : z [n ]; (k =1; k < n; ++ k ) {

Input : swapped = false ; (l =0; l <n - k; ++ l ) { ( z[ l]> z [l +1]) { tmp = z[ l ]; z[ l] = z [l +1]; z[ l +1] = tmp ; swapped = true ; } } ( swapped == false ) }

// in aufsteigender Sortierung

// Folge ist bereits sortiert

Fr die Komplexittsanalyse ist die folgende Funktion ntzlich: u a u Denition 4.5. Seien f, g : R+ R+ zwei Funktionen. Dann schreibt man (i) f = O(g), f ist gro O von g, falls es zwei Konstanten x0 , c > 0 gibt mit f (x) cg(x) f r alle x x0 , u (ii) f = o(g) f ist klein o von g, falls f r alle c > 0 ein x0 R+ existiert mit f (x) cg(x) u f r alle x x0 , u (iii) f = (g), falls f = O(g) und g = O(f ).

Beispiel 4.6. f (x) = 2x + 25, g(x) = x2 10 (a) f = O(g), weil fr c = 1 und x0 = 7 gilt 2x + 25 2x + (x 1)2 11 = x2 10. u (b) f = o(g), weil fr alle c > 0 und alle x x0 = u
1 c

2 10 + 5 c +

1 c2

gilt

1 1 c(x2 10) = c(x )2 + 2x 10c 2x + 25. c c

26

4.2 Mergesort (c) Die Komplexitt von Bubblesort ist O(n2 ). Man beachte: Sie ist nicht (n2 ), weil nur a O(n) Operationen ntig sind, wenn die Folge bereits sortiert ist. o Satz 4.7. Seien f, g : R+ R+ zwei Funktionen. Dann gilt (a) f = o(g) limx
f (x) g(x)

= 0.

(b) Gibt es ein c > 0 mit limx f (x) = c, so gilt f = (g). g(x)

Beweis. zu (a): Es gilt f = o(g) c > 0 x0 R+ mit f (x) c g(x) f (x) x > 0 x0 R+ mit c x x0 g(x) f (x) = 0. lim x g(x) zu (b): Wir haben f (x) f (x) = c > 0 x0 mit | c| < x x0 x g(x) g(x) f (x) < c + x x0 . > 0 x0 mit c < g(x) lim Insbesondere existiert hat man fr die Wahl = u
c 2

3 f (x) 2 c g(x) f = O(g) g(x) 2 f (x) g = O(f ) c

f = (g).

4.2 Mergesort
Mergesort ist ein weiteres Sortierverfahren, das gegenber Bubblesort den Vorteil besitzt, u dass der Aufwand durch O(n log n) beschrnkt ist, um n Zahlen zu sortieren. Die Steigerung a der Ezienz beruht auf folgender Beobachtung. Gegeben seien die sortierten Menge Mx = {x1 , . . . , xm , xi xj , i < j}, My = {y1 , . . . , ym , yi yj , i < j} Dann lsst sich die Menge M := Mx My mit m + n 1 Vergleichen sortieren, indem man a das jeweils kleinste Element der beiden Mengen entfernt und M hinzufgt. u Beispiel 4.8. Es seien Mx = {1, 5, 9} und My = {3, 7, 8}.

27

4 Sortieralgorithmen Mx 1, 5, 9 5, 9 5, 9 9 9 9 My 3, 7, 8 3, 7,8 7, 8 7, 8 8 M 1 1, 1, 1, 1, 1,

3 3, 3, 3, 3,

5 5, 7 5, 7, 8 5, 7, 8, 9

Dieses Zusammenfgen (engl. merge) bildet die Grundlage zu folgendem divide-and-conqueru Algorithmus:

Algorithmus 4.9 (Mergesort). (i) Ist n = 1, so gibt es nichts zu tun. Andernfalls sortiere Mx = {z1 , . . . , zn/2 } und Mx = {zn/2 , . . . , zn } mit Algorithmus 4.9. (ii) Fge die sortierten Mengen zu einer Menge zusammen. u

Bemerkung. (a) Man beachte, dass Mergesort sich selbst aufruft. Man spricht von einer Rekursion bzw. von einem rekursiven Algorithmus. (b) Divide-and-conquer-Algorithmen verfahren immer nach folgendem Prinzip: Teile das Ausgangsproblem in etwa gleich groe Teile, lse diese dann separat und fge die Lsuno u o gen zur Gesamtlsung zusammen. o Beispiel 4.10. 10,6,51,2,11,3,1,47 10,6,51,2 10,6 10 6,10 6 Divide 51 Merge 2,6,10,51 2,51 51,2 2 11 3,11 Divide 11,3 3 Merge 1,3,11,47 11,3,1,47 Divide 1 1,47 1,47 47

Merge 1,2,3,6,10,11,47,51

Eine mgliche Implementierung von Mergesort ist: o

28

4.2 Mergesort

Algorithmus 4.11. merge (z , nbeg , nend , nsep ) // vereinigt z[ nbeg ... nsep ] und z[ nsep +1... nend ] * z; nbeg , nend , nsep ; { tmp [ nend - nbeg +1]; i = nbeg , j = nsep +1 , k = 0; ((i <= nsep ) && (j <= nend )) { ( z[ i ] <= z[ j ]) tmp [k ++] = z[ i ++]; tmp [k ++] = z [j ++]; } (i <= nsep ) tmp [k ++] = z[ i ++]; // Reste anhaengen (j <= nend ) tmp [k ++] = z[ j ++]; (k = nbeg ; k <= nend ; ++ k ) z[ k] = tmp [k - nbeg ]; }

mergesort (z , nbeg , nend )

// sortiert z[ nbeg ... nend ]

( nbeg < nend ) { nsep = ( nbeg + nend )/2; mergesort (z , nbeg , nsep ); // rekursiver Aufruf mergesort (z , nsep +1 , nend ); // rekursiver Aufruf merge (z , nbeg , nend , nsep ); // conquer : merge } }

Der Aufruf erfolgt mittels mergesort(z, 0, n-1); Satz 4.12. Der Aufwand des Mergesort-Algorithmus ist O(n log n). Beweis. Es bezeichne T (n) die Anzahl der Operationen von Mergesort fr n Elemente. Anu genommen, n = 2k fr ein k N. Dann gilt u T (n) 2 T (n/2) + c n (4.1)

mit c N. Wir zeigen induktiv, dass T (2k ) 2k T (1) + c k 2k gilt. u Fr k = 1 ist wegen (4.1) T (2) 2 T (1) + 2 c. Angenommen, die Aussage gilt fr ein u k N. Dann ist T (2k+1) 2 T (2k ) + c 2k+1 2(2k T (1) + c k 2k ) + c 2k+1 = 2k+1 T (1) + c 2k+1 (k + 1). Wegen k = log2 n gilt somit T (n) = O(n log n). Die Behauptung gilt auch fr beliebiges n N. Es existiert k N mit 2k n < 2k+1 . u k+1 k+1 Wegen T (n) T (2 ) = O(2 (k + 1)) = O(2k k) O(n log2 n) folgt die Behauptung.

29

4 Sortieralgorithmen Gegenber Bubblesort haben wir somit einen signikanten Vorteil bzgl. des Aufwandes. u Allgemein gilt fr die Komplexitt von divide-and-conquer-Algorithmen der folgende Satz. u a Satz 4.13 (Master-Theorem). Wir betrachten Funktionen T : N N deniert durch T (n) = aT (n/b) + f (n) mit einer Funktion f : N N und Konstanten a 1, b > 1. Sei f (n) = O(np ) mit p 0. Dann gilt O(np ), falls a < bp , T (n) = O(np log n), falls a = bp , O(nlogb (a) ), falls a > bp .

4.3 Quicksort
Quicksort ist ein weiteres Sortierverfahren. Es basiert ebenfalls auf dem divide-and-conquerPrinzip, spart aber im Vergleich zu Mergesort den Merge-Schritt. Die Idee besteht darin, die Menge Z := {z1 , . . . , zn } bzgl. eines Elementes x Z in Untermengen {z Z : z x} {x} {z Z : x z} zu unterteilen, diese (rekursiv) zu sortieren und die sortierten Mengen zusammenzusetzen. Beispiel 4.14. 7,2,55,19,1,10

2,1

55,19,10

1 1,2

10

19 10,19,55

55

1,2,7,10,19,55

Algorithmus 4.15 (Quicksort).

partition (z , nbeg , nend ) // sortiert z[ nbeg .. nend ] * z; // liefert Position d. letzten Elementes <=x zurueck nbeg , nend ;
{

30

4.3 Quicksort

x = z [ nend ]; // x wird als letztes Element gewaehlt i = nbeg ; // kein Element vor i ist groesser als x j = nend -1; // kein Element nach j ist kleiner als x { ((i < nend ) && (z [i ] <= x )) ++ i ; ((j > nbeg ) && (z [j ] >= x )) --j ;
(i < j) { tmp = z[ i ]; z[ i] = z [j ]; z[ j] = tmp ;

// vertausche z[i] und z[j]

} (i <j ); z[ nend ] = z[ i ]; z [i ] = x; i ; }

// vertausche x an Endposition

quicksort (z , nbeg , nend ) * z; nbeg , nend ;

{ ( nbeg < nend ) p = quicksort (z , quicksort (z , } } { partition (z , nbeg , nend ); nbeg , p -1); p +1 , nend );

Der Aufruf erfolgt mittels quicksort(z, 0, n-1). Man beachte, dass Quicksort im Vergleich zu Mergesort keinen zustzlichen Speicher bentigt, der so gro ist wie das Feld z. a o Man sagt, der Algorithmus luft in place. a Satz 4.16. Der Quicksort-Algorithmus hat eine Worst-Case-Komplexitt von O(n2 ). a Beweis. Sei T (n) die Anzahl der Operationen fr n Elemente. Dann gilt u T (n) c n + max [T (k) + T (n k)].
1k<n

Wir zeigen, dass T (n) c n2 . Fr n = 1 ist die Behauptung trivial. Angenommen, die Beu hauptung gilt fr alle natrlichen Zahlen kleiner als n N. Dann folgt wegen max1k<n (k 2 + u u (n k)2 ) = 1 + (n 1)2 T (n) c n + max [T (k) + T (n k)] c n + max [c k 2 + c (n k)2 ]
1k<n 1k<n

c n + c + c (n 1) = c n c n + 2c c n2 .

31

4 Sortieralgorithmen Bemerkung. Die Worst-Case-Komplexitt wird angenommen, falls die Menge bereits sora tiert ist. Satz 4.17. Der Aufwand von Quicksort ist im Durchschnitt O(n log n). Beweis. Sei Pn die Menge aller Permutationen uber {1, . . . , n}. Dann ist der mittlere Auf wand durch 1 T (n) = T () n! P
n

gegeben, wobei T () den Aufwand von Quicksort fr die Sortierung einer Permutation Pn u (k) (k) bezeichnet. Wir teilen Pn in Mengen Pn , k = 1, . . . , n, mit Pn = { Pn : n = k}, n 2. (k) (k) Weil das letzte Element aus Pn fest ist, gilt |Pn | = (n 1)!, k = 1, 2, . . . , n. (k) Fr alle Pn ergibt der Teilungsschritt zwei Permutationen (1) und (2) uber {1, . . . , k u (1) (2) 1} bzw. {k + 1, . . . , n}. Somit folgt T () = n 1 + T ( ) + T ( ) und somit
Pn
(k)

(k) T () = |Pn | (n 1) +

[T ( (1) ) + T ( (2) )].

Pn
(k)

Wenn alle Permutationen aus Pn {1, . . . , k 1} und zwar jede genau T ( (1) ) =
Pn
(k)

(k)

(n1)! (k1)!

durchluft, entstehen fr (1) alle Permutationen von a u (k) -mal, weil |Pn | = (n 1)!. Also gilt T ( (1) ) = (n 1)! T (k 1)

(n 1)! (k 1)!

(1) Pk1

und analog
Pn
(k)

T ( (2) ) = (n 1)! T (k 1).

Als Folgerung erhlt man die rekursive Abschtzung a a T (n) = 1 1 T () = n! P n!

n

T ()
k=1 P (k) n

1 n!

k=1

(n 1)! n 1 + T (k 1) + T (n k)
n

1 =n1+ n =n1+ Hieraus folgt insbesondere, dass T (n) = n 1 2 n

k=1 n1

[T (k 1) + T (n k)] T (k).

k=0

n1 n1 2 (n 2) + T (n 1) + T (n 1) n n n n+1 2 T (n 1) = (n 1) + n n

32

4.4 Eine untere Schranke f r das Sortierproblem u mit T (0) = 1, T (1) = 1. Wir zeigen induktiv, dass T (n) 2(n + 1)

n 1 i=1 i .

Fr n = 2 gilt u
n

1 T (2) = 3 6(1 + ) = 2(n + 1) 2 Angenommen, die Aussage gilt fr ein n N. Dann folgt u T (n + 1) =

i=1

1 . i

n+2 2 2 n+ n + 2(n + 2) T (n) n+1 n+1 n+1 n+2 + 2(n + 2) n+1

n

i=1

1 i

i=1

1 = 2(n + 2) i

n+1

i=1

1 . i

Die Partialsumme n 1 der harmonischen Reihe lt sich durch ein Integral abschtzen. a a i=1 i Die Rechtecke mit den Ecken (i 1, 0) und (i, 1/i), i = 2, 3, . . . , sind Teil der Flche, die der a Graph der Funktion 1/x, x 1, mit der x-Achse einschliesst. Daher gilt
n

i=1

1 =1+ i

i=2

1 1+ i

n 1

1 dx = 1 + log n, x

woraus T (n) 2(n + 1)(1 + log n) = O(n log n) folgt.

4.4 Eine untere Schranke fr das Sortierproblem u

In diesem Abschnitt wollen wir untersuchen, welche Laufzeit ein Verfahren zur Sortierung von n unterschiedlichen Elementen mindestens haben muss. Satz 4.18. Jeder Algorithmus zur Sortierung von n Elementen, der die Information uber die Elemente ausschlielich durch paarweise Vergleiche erhlt, bentigt mindestens log n! viele a o Vergleiche. Fr den Beweis betrachten wir den Entscheidungsbaum, der jedem Sortierverfahren mit u paarweisen Vergleichen fr festes n zugeordnet werden kann. Allgemein knnen wir den u o Entscheidungsbaum wie folgt beschreiben: Innere Knoten sind Vergleiche im Algorithmus Ein Weg von der Wurzel des Baumes zu einem Blatt entspricht der zeitlichen Abfolge der Vergleiche. Ein Weitergehen nach rechts entspricht einem richtigen Vergleich, nach links einem falschen. Die n! Bltter des Baumes stellen die Permutationen der Eingabefolge dar, die jeweils a zur Abfolge der Vergleiche gehrt. o Beispiel 4.19. Der Entscheidungsbaum fr {z1 , z2 , z3 } ist wie folgt gegeben: u

33

4 Sortieralgorithmen z1 < z2 nein z1 < z3 nein z2 < z3 nein z3 z2 z1 ja z2 z3 z1 ja z2 z1 z3 nein z3 z1 z2 nein z1 < z3 ja z1 z3 z2 ja z2 < z3 ja z1 z2 z3

u u o Beweis zu Satz 4.18. Wir mssen eine untere Schranke fr die Hhe des Entscheidungsbaumes nden. Bestenfalls ist der Baum balanciert, d.h. alle Bltter liegen in der gleichen Ebene. a Ein balancierter Baum hat also pro Ebene 1, 2, 4, 8, . . . , 2m Knoten. Da wir n! Bltter haben, a m folgt 2 = n! bzw. m = log2 n! n n n log2 ... 2 2 2 n 2 n 2
n 2

log2 =

n (log2 n 1). 2

Bemerkung. Die Funktion f (n) = log n! verhlt sich im Wesentlichen wie n log n, denn es a gilt auch die Abschtzung a log n! log nn = n log n. Also folgt log n! = (n log n). Daher ist Mergesort asymptotisch optimal. Allerdings bentigt o Mergesort im Allgemeinen mehr als log n! viele Vergleiche.

4.5 Binre Heaps und Heapsort a

Fr viele Zwecke ist es sinnvoll, Elemente einer Folge hinzuzufgen und Elemente aus einer u u Folge zu entfernen. Das Einfgen von Elementen in ein Array kann mit O(1) Aufwand durchu gefhrt werden, whrend das Entfernen des kleinsten Elementes O(n) Aufwand bentigt. Ist u a o das Array sortiert, so bentigt man fr das Einfgen O(n) und fr das Lschen O(1). o u u u o Mit Hilfe von sog. binren Heaps knnen Einfgen und Entfernen mit jeweils O(log n) a o u Aufwand durchgefhrt werden. u Denition 4.20. Eine Zahlenfolge z1 , . . . , zn besitzt die Heapeigenschaft, falls gilt: (i) zi z2i , i = 1, . . . , n/2, (ii) zi z2i+1 , i = 1, . . . , (n 1)/2.

34

4.5 Binre Heaps und Heapsort a Beispiel 4.21. Die folgende Zahlenfolge besitzt die Heapeigenschaft. i zi 1 3 2 3 4 7 4 5 6 5 8 10 7 8 9 11 6 9 10 11 12 10 13 15

Indem man jeweils die Elemente z2i und z2i+1 in einem Baum unter zi anordnet, lsst sich a die Heapeigenschaft leicht ablesen, da zu jedem Element die darunter liegenden mindestens genauso gro sein mssen. u 3 4 5 6 9 10 8 13 10 15 7 11

Natrlich kann man Heaps auch als Bume (d.h. mit Hilfe von Pointern) abspeichern. u a Dies kann allerdings die Datenlokalitt beeintrchtigen, was sich negativ auf Cache-Eekte a a im Rechner auswirkt. Daher sollte die Speicherung in dem obigen Array mit Hilfe der sog. Kekul-Anordnung bevorzugt werden. e

Lemma 4.22. Falls die Folge z1 , . . . , zn die Heapeigenschaft besitzt, so gilt z1 zi , i = 1, . . . , n. Beweis. Sei j der kleinste Index mit der Eigenschaft zj zi , i = 1, . . . , n. Ist j = 1, so ist nichts zu zeigen. Im anderen Fall ist j > 1. Dann gilt wegen der Heapeigenschaft, dass zj/2 zj . Dies fhrt zum Widerspruch, weil j als kleinster Index deniert wurde. u Ein kleinstes Element lsst sich daher bei einer Folge mit Heapeigenschaft in O(1) nden. a Im Folgenden zeigen wir, wie Elemente eingefgt bzw. entfernt werden knnen und man u o dabei die Heapeigenschaft erhlt. a Zum Einfgen eines Elementes fge man dieses am Ende der Zahlenfolge als zn+1 an. u u Besitzt die neue Folge die Heapeigenschaft, so ist nichts zu tun. Andernfalls tauscht man das eingefgte Element sukzessive jeweils mit dem darberstehenden Element. u u Beispiel 4.23. Wir wollen die Zahl 6 in die Folge aus Beispiel 4.21 unter Erhaltung der Heapeigenschaft einfgen. Dann ergibt die beschriebene Vorgehensweise die folgende Folge u von Bumen. a 3 4 5 6 9 10 8 13 15 10 6 7 11

35

4 Sortieralgorithmen 3 4 5 6 9 10 8 13 3 4 5 6 9 10 8 13 15 7 10 6 11 15 6 10 7 11

Damit ist die Heapeigenschaft wiederhergestellt. Algorithmus 4.24 (Einfgen in Heap). u

Insert (x , z , heapsize ) x , * z; heapsize ;

{

i = heapsize ; (i >0 && z [( i -1)/2)] > x ) {

z[ i] = z [(i -1)/2]; i = (i -1)/2; } z[ i] = x ;

Die beiden folgenden Lemmata behandeln die Korrektheit des Algorithmus 4.24 (also die Frage, ob die Heapeigenschaft erhalten wird) und die Komplexitt des Algorithmus. a Lemma 4.25. Sei z1 , . . . , zn eine Zahlenfolge, die die Heapeigenschaft besitzt, falls zj durch zj/2 > zj ersetzt wird. Durch Vertauschen von zj mit zj/2 erhlt man entweder eine a Folge mit Heapeigenschaft oder es gilt zj/2/2 > zj/2 und man erhlt eine Folge mit a Heapeigenschaft, falls man zj/2 durch zj/2/2 ersetzt.
Beweis. Es bezeichne {zi } die Folge, die durch Vertauschen von zj mit zj/2 entsteht. Be sitzt die Folge {zi } die Heapeigenschaft, so ist nichts weiter zu tun. Andernfalls gilt nach Vorraussetzung, dass

(i) zj/2/2 min{zj/2 , zj1 }, j1 :=

j/2 + 1, falls j/2 gerade, j/2 1, falls j/2 ungerade,

36

4.5 Binre Heaps und Heapsort a j + 1, j gerade, j 1, j ungerade,

(ii) zj/2 zj2 , j2 :=

(iii) zj/2 min{z2j , z2j+1 }. Hieraus folgt, dass

zj = zj/2 min{z2j , z2j+1 } = min{z2j , z2j+1 }, zj/2 < zj = zj/2 zj2 = zj2 . (ii) (iii)

Da die Vernderung an den Positionen j und j/2 nur die Relationen zwischen den Posia tionen j/2 /2, j/2, j2 , j, 2j und 2j + 1 eventuell ndern, muss zj/2/2 > zj/2 sein, a weil die anderen Relationen gerade nachgewiesen wurden. Ersetzt man zj/2 durch zj/2/2 , so gilt
zj/2/2 = zj/2/2 zj1 = zj1 , (i)

zj/2 = zj/2/2 = zj/2/2 zj/2 zj2 = zj2 .

(i)

(ii)

In diesem Fall ist also die Heapeigenschaft erfllt. u

Satz 4.26. Der Algorithmus 4.24 f gt ein Element zn+1 in die Folge z1 , . . . , zn , zn+1 mit u Aufwand O(log n) so ein, dass die Heapeigenschaft erhalten bleibt. Beweis. Die Erhaltung der Heapeigenschaft folgt durch sukzessive Anwendung des Lemmas 4.25 auf die Folge z1 , . . . , zn+1 . Der Aufwand betrgt O(log n), weil die Folge n + a 1, (n + 1)/2 , (n + 1)/2 /2 , . . . nach sptestens O(log n) Schritten den Wert 1 erreicht. a Ein Element kann unter Erhaltung der Heapeigenschaft dadurch entfernt werden, dass die entstehende Lcke jeweils durch das kleinere der beiden Elemente z2i bzw. z2i+1 ersetzt wird, u bis keine darunter liegenden Elemente mehr existieren. Man beachte, dass der Index des zu lschenden Elements bekannt sein muss, weil eine Suche im Heap nicht ezient durchgefhrt o u werden kann. Beispiel 4.27. Wir wollen die 4 aus der Folge von Beispiel 4.21 entfernen: 3 7 5 6 9 10 8 13 10 15 11

37

4 Sortieralgorithmen 3 5 8 6 9 10 13 3 5 6 9 10 8 13 10 15 7 11 10 15 7 11

Satz 4.28. Falls z1 , . . . , zn die Heapeigenschaft besitzt, so kann durch obige Vorgehensweise ein Element mit Aufwand O(log n) so entfernt werden, dass die resultierende Folge die Heapeigenschaft besitzt. Beweis. analog zum Beweis von Satz 4.26. Bemerkung. Anstelle der obigen Vorgehensweise kann auch das letzte Element an die freiwerdende Position kopiert werden. In diesem Fall entsteht keine Lcke, nachdem die Heapeiu genschaft wiederhergestellt wurde. Dazu muss aber das eingefgte Element zunchst wie bei u a Beispiel 4.23 aufwrts und anschlieend wie bei Beispiel 4.27 abwrts den Heap durchlaufen. a a Wird das erste Element gelscht, so gengt natrlich der Durchlauf nach unten. o u u Mit Hilfe binrer Heaps lassen sich nun n Zahlen mit Aufwand O(n log n) sortieren. a Zunchst werden die Zahlen sukzessive mit Gesamtaufwand O(n log n) in den Heap eingefgt. a u Danach wird der Heap sukzessive abgebaut, indem jeweils das oben stehende Element (nach Lemma4.25 ist dies das jeweils kleinste Element) vom Heap wie oben beschrieben entfernt wird. Der resultierende Algorithmus wird entsprechend Heapsort genannt.

38

5 Graphen
5.1 Grundbegrie
Denition 5.1. Ein Graph ist ein Paar G = (V, E) bestehend aus endlichen Mengen V von Knoten (engl. vertices) und E Kanten (engl. edges). Die Kanten stehen f r Verbindungen u zwischen den verschiedenen Knoten und knnen gerichtet oder ungerichtet sein. o F r gerichtete Graphen (sog. Digraphen) ist E {(v, w) V V : v = w}. Ist u e = (v, w) E, dann heit v der Anfangsknoten und w der Endknoten der Kante e. f r ungerichtete Graphen ist E die Menge von ungeordneten Paaren (v, w) mit u v, w V und v = w. Eine Kante e = (v, w) heit zu den Knoten v, w V inzident. Beachte: Es gilt (v, w) = (w, v), falls (v, w) eine Kante in einem ungerichteten Graphen ist. Dies gilt jedoch nicht in einem gerichteten Graphen. Den zugrundeliegenden ungerichteten Graphen G eines gerichteten Graphen G erhlt man, indem man bei gleicher a Knotenmenge die Kanten in G als ungeordnete Paare in G interpretiert. Beispiel 5.2. Gerichteter Graph G = {(v, w), (w, x), (v, x), (x, y), (y, x)}: v w x y Ungerichteter Graph G = {(v, w), (w, x), (v, x), (x, y)}: v w x y Bemerkung. In gerichteten Graphen werden manchmal auch Kanten der Form (v, v) zugelassen. Man spricht von Schleifen.

39

5 Graphen

v Denition 5.3. Sei G = (V, E) ein Graph. Ein Weg oder Pfad in G ist eine Knotenfolge = v0 , v1 , . . . , vr mit r 1 und (vi , vi+1 ) E, i = 0, . . . , r 1. Wir sprechen von einem Weg, der von v nach w f hrt, wenn der Anfangsknoten v0 = v und der Endknoten vr = w ist. Ein u Weg heit einfach, falls gilt, dass v0 , v1 , . . . , vr1 paarweise verschieden sind. Der Weg heit geschlossen, falls v0 = vr . Die Anzahl der Knoten r, die in durchlaufen werden, wird als Lnge || von bezeichnet. Ein kurzester Weg von v nach w ist ein Weg von v nach a w minimaler Lnge. Ein Knoten w heit von einem Knoten v erreichbar, falls ein Weg a = v0 , . . . , vr in G existiert, so dass v0 = v und vr = w. Beispiel 5.4. Beispiele fr Wege in den beiden Graphen aus Beispiel 5.2 sind u (a) 1 = v, w (Lnge 1), a (b) 2 = v, w, x (Lnge 2), a (c) 3 = v, w, x, y, x, y (Lnge 5). a Im ungerichteten Fall ist auch 4 = v, w, x, v (Lnge 3) ein Weg. a Denition 5.5. Sei G = (V, E) ein Graph und v V . Wir denieren die Menge der (direkten) Nachfolger von v als suc(v) = {w V : (v, w) E}, die Menge der (direkten) Vorgnger von v als pre(v) = {w V : (w, v) E}, a ein Knoten w suc(v) pre(v) ist ein Nachbar von v, und v, w heien benachbart oder adjazent, die Menge aller von v erreichbaren Knoten als suc (v) w ist von v erreichbar}, = {w V :

die Menge der Knoten, die v erreichen knnen pre (v) = {w V : v suc (w)}. o F r ungerichtete Graphen gilt oenbar pre(v) = suc(v) und auch pre (v) = suc (v) f r alle u u v V. Beispiel 5.6. Fr den gerichteten Graphen aus Beispiel 5.2 ist u suc(v) = {w, x}, und Im ungerichteten Fall ist suc(x) = {v, w, y} und suc (x) = {v, w, x, y}. suc(y) = {x}, suc (y) = {x, y}. suc (v) = {w, x, y}, pre(v) = pre (v) =

40

5.2 Zusammenhang

Denition 5.7. Sei G = (V, E) ein Graph. Wir denieren den Grad eines Knoten v V als deg v := |{(x, y) E : x = v oder y = v}| unter Ber cksichtigung der Eigenschaft (x, y) = (y, x) bei ungerichteten Graphen. Im geu richteten Fall heit deg+ (v) = |suc(v)| Ausgangsknotengrad und deg (v) := |pre(v)| Eingangsknotengrad von v. Knoten mit Grad 0 heien isoliert.

Satz 5.8. F r jeden Graphen G = (V, E) gilt u deg v = 2|E|.

vV

Beweis. Zu jeder Kante e E gehren genau zwei Knoten. Auf der linken Seite der Gleichung o zhlt man daher jede Kante genau zweimal. a Satz 5.9. F r jeden Digraphen G = (V, E) gilt u deg+ (v) =
vV vV

deg (v) = |E|

Beweis. Zu jeder Kante e = (v, w) E ist v pre(w) und w suc(v). Daher zhlt man bei a beiden Summen jede Kante genau einmal.

5.2 Zusammenhang
Denition 5.10. Sei G = (V, E) ein ungerichteter Graph und C V . C heit zusammenhngend, falls je zwei Knoten v, w C, v = w, voneinander erreichbar sind, d.h. falls a gilt w suc (v) und v suc (w). Ist der Graph gerichtet, so heit C zusammenhngend, a falls C im zugrundeliegenden ungerichteten Graphen zusammenhngend ist. C heit Zua sammenhangskomponente von G, falls C eine nicht-leere maximale zusammenhngende a Knotenmenge ist. Maximalitt bedeutet hier, dass C in keiner anderen zusammenhngenden a a Menge C V echt enthalten ist (also C = C ). Der Graph G heit zusammenhngend, a falls V zusammenhngend ist. a Beispiel 5.11. Ein nicht zusammenhngender Graph mit drei Zusammenhangskomponena ten ist

41

5 Graphen Ein zusammenhngender Graph ist a

Bemerkung. Oenbar sind die Zusammenhangskomponenten eines ungerichteten Graphen die Aquivalenzklassen der Knotenmenge V unter der Aquivalenzrelation , wobei vw v suc (v) = w suc (w).

Insbesondere zerfllt G in paarweise disjunkte Zusammenhangskomponenten C1 , C2 , . . . , Cr a mit r r V =

i=1

Ci ,

E=
i=1

Ei ,

wobei Ei := E (Ci Ci ), i = 1, . . . , r. Satz 5.12. Ein ungerichteter Graph G = (V, E) ist genau dann zusammenhngend, wenn a {(v, w) E : v X, w V \ X} = f r alle = X u V.

Beweis. Sei = X V und v X, w V \ X. Weil G zusammenhngend ist, gibt es a einen Weg von v nach w. Da v X, aber w X, muss der Weg eine Kante (x, y) enthalten, sodass x X, y X. Umgekehrt sei angenommen, dass G nicht zusammenhngend ist. Dann existieren zwei a Knoten v, w V , zwischen denen kein Weg existiert. Setze X := {v} suc (v). Dann gilt v X und w X und somit = X V . Aus der Denition der Menge X folgt aber {(v, w) E : v X, w V \ X} = . Dies liefert den Widerspruch, die Annahme ist somit falsch. Satz 5.13. Ist G = (V, E) ein ungerichteter Graph mit n = |V | 1 Knoten und mit m = |E| Kanten, so gilt: Ist G zusammenhngend, so gilt m n 1 a Beweis. Wir beweisen den Satz per vollstndiger Induktion nach n. Fr n = 1 folgt m = 0 = a u n 1; fr n = 2 ist G zusammenhngend genau dann, wenn m = 1 = n 1. Wir betrachten u a nun den Fall n 3. Whle v V , so dass a k := deg v = min deg w.
wV

Es gilt k > 0, denn sonst wre v ein isolierter Knoten. Im Fall k 2 folgt a 2m = 2|E| =
wV

deg w n k 2n
k

42

5.2 Zusammenhang und folglich m n n 1. Fr k = 1 ergibt sich die Aussage wie folgt: Es sei G = (V , E ) u derjenige Graph, der durch Entfernen des Knoten v und der inzidenten Kante entsteht. Mit G ist auch G zusammenhngend und nach Induktionsvorraussetzung folgt wegen |V | = n1 a und |E | = m 1 m 1 = |E | (n 1) 1 = n 2 und daraus die Behauptung m n 1.

Denition 5.14. Ein einfacher Zyklus oder einfacher Kreis in einem Graphen G = (V, E) ist ein einfacher, geschlossener Weg = v0 , . . . , vr mit r 2 (gerichteter Graph) bzw. r 3 (ungerichteter Graph). Beispiel 5.15. Der gerichtete Graph v w x y besitzt die einfachen Zyklen 1 = x, y, x und 2 = v, w, x, v. Der ungerichtete Graph v w x y besitzt den einfachen Zyklus 1 = v, w, x, v. Der Weg 2 = x, y, x ist hingegen kein Zyklus. Denition 5.16. Ein Graph heit azyklisch oder zyklenfrei, falls es keine Zyklen in G gibt. Ein ungerichteter, azyklischer und zusammenhngender Graph ist ein Baum. Ein a Knoten v V eines Baumes mit deg v = 1 heit Blatt. Ist v V kein Blatt, so wird v als innerer Knoten bezeichnet. Beispiel 5.17. Azyklischer gerichteter Graph:

43

5 Graphen Azyklischer ungerichteter Graph:

Satz 5.18. Sei G = (V, E) ein ungerichteter Graph mit n Knoten. Dann sind folgende Aussagen quivalent: a (i) G ist ein Baum (ii) G hat n 1 Kanten und ist zusammenhngend. a (iii) G hat n 1 Kanten und ist azyklisch. (iv) G ist azyklisch und das Hinzuf gen einer beliebigen Kante erzeugt einen Zyklus. u (v) G ist zusammenhngend und das Entfernen einer Kante erzeugt einen unzusammena hngenden Graphen. a (vi) Jedes Paar von verschiedenen Knoten in G ist durch genau einen einfachen Weg miteinander verbunden.

o Fr den Beweis von Satz 5.18 bentigen wir das folgende u Lemma 5.19. F r einen azyklischen und ungerichteten Graphen gilt |V | = |E| + p, wobei u p die Anzahl der Zusammenhangskomponenten bezeichnet. Beweis. Die Behauptung ist klar fr m := |E| = 0. Angenommen, die Aussage gilt fr ein u u m. Fgen wir eine zustzliche Kante hinzu, d.h. |E| = m + 1, so muss sich die Anzahl der u a Zusammenhangskomponenten p um Eins reduzieren, weil sonst ein Zyklus entsteht. Beweis von Satz 5.18. (i) (vi): Dies folgt aus der Tatsache, dass die Vereinigung zweier disjunkter einfacher Wege mit gleichem Anfangs- und Endknoten ein Zyklus ist. (vi) (v): G ist zusammenhngend nach Denition und das Entfernen der Kante (v, w) a macht w unerreichbar von v. (v) (iv): G ist azyklisch, weil sonst eine Kante entfernt werden kann, so dass G weiterhin zusammenhngend ist. Da es in G stets einen Weg von v nach w gibt, liefert das Hinzufgen a u einer Kante einen Zyklus. (iv) (iii): Weil das Hinzufgen einer beliebigen Kante einen Zyklus erzeugt, muss G u zusammenhngend sein. Nach Lemma 5.19 gilt dann n = m + 1. a (iii) (ii): Weil G azyklisch ist mit n 1 Kanten folgt nach Lemma 5.19, dass p = 1. Also

44

5.3 Speicherung von Graphen ist G zusammenhngend. a (ii) (i) Wir zerstren Zyklen in G durch Entfernen von Kanten. Haben wir k Kanten so o entfernt, dass der resultierende Graph azyklisch ist, so folgt aus Lemma 5.19 n1k+ p = n
Kanten =1

und hieraus k = 0. G ist also bereits azyklisch. Weil G nach Voraussetzung ausserdem zusammenhngend ist, ist G ein Baum. a Das folgende Lemma ist ntzlich, um die Anzahl der Knoten in einem Baum ausgehend u von einer bekannten Anzahl von Blttern abzuschtzen. a a Lemma 5.20. Sei L die Menge der Bltter in einem Baum mit V \ L = . Weiter sei a v V \ L ein innerer Knoten, die sog. Wurzel. Wir denieren pv := min{deg w : w V \ (L {v})}. Gilt qv := min{deg v, pv 1} 2, so folgt |V | qv |L| 1 2|L| 1. qv 1

Beweis. Wir entfernen sukzessive die Bltter ausgehend vom Baum V0 := V , indem wir in a jedem Schritt alle Nachbarn vom Grad 1 eines inneren Knoten entfernen. Es bezeichne k die Anzahl der Schritte bis nur noch v ubrig ist, und es sei V der Baum nach Schritten. Dann gilt bis zum (k 1)-ten Schritt, dass |V | = |V1 | (p 1) und |L(V )| = |L(V1 )| (p 2), = 1, . . . , k 1, wobei p den Grad des -ten Knoten bezeichnet. Im letzten Schritt gilt 1 = |Vk | = |Vk1| deg v und 1 = |L(Vk )| = |L(Vk1 )| (deg v 1). Also haben wir
k1 k1

|V0 | = |Vk | + deg v +

=1

(p 1) = 1 + deg v +
k1

=1

(p 1),
k1

|L(V0 )| = |L(Vk )| + deg v 1 +

=1

(p 2) = 1 k + deg v +

=1

(p 1).

Hieraus folgt k = |V0 | |L(V0 )| und mit min{deg v, p 1} qv 2, dass |L(V0 )| 1 + k(qv 1) 1 + (qv 1)(|V0| |L(V0 )|) |V0 | qv |L(V0 )| 1 . qv 1

5.3 Speicherung von Graphen

Eine Mglichkeit, Graphen auf einem Rechner zu speichern, sind sog. Adjazenzmatrizen. o

45

5 Graphen

Denition 5.21. Sei G = (V, E) ein Graph mit Knoten vi , i = 1, . . . , n := |V |. Die Matrix A Rnn heit Adjazenzmatrix von G, falls aij = 1, falls (vi , vj ) E, 0, sonst.

Beispiel 5.22. Der gerichtete Graph v4 v1 v2 v3 v5 besitzt die Adiazenzmatrix 0 0 A = 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0 ist 1 0 0 0 0 0 0 1 0 0 0 0 1 . 0 0

Die Adjazenzmatrix ungerichteter Graphen ist immer symmetrisch, d.h. es gilt aij = aji , i, j, = 1, . . . , n, weil (vi , vj ) = (vj , vi ) fr ungerichtete Graphen. Speichert man jeden Eintrag u der Adjazenzmatrix, so werden unabhngng von der Anzahl der Kanten |V |2 Speichereina heiten bentigt. Ezienter ist es, Graphen durch sog. Adjazenzlisten darzustellen. Dabei o speichert man zu jedem Knoten v V eine Liste aller Knoten w V mit der Eigenschaft, dass (v, w) E. Beispiel 5.23. Die Adjazenzlisten zum gerichteten Graphen aus Beispiel 5.22 sind v1 : v2 , v3 , v4 v2 : v3 v3 : v5 v4 : v5 : v3 Adjazenzlisten knnen als einfach verkettete Listen mit Elementen der Form o

Beim zugrundeliegendend ungerichteten Graphen 0 1 1 1 0 1 A = 1 1 0 1 0 0 0 0 1

list_item { idx ;
list_item * next ; };

// Nummer des Knotens // Pointer auf naechstes Element

46

5.4 Graphendurchmusterung a Sind a und b vom Typ list item, so enthlt a.idx die Nummer des Knoten und a.next =&b; deniert b als Nachfolger von a. Das Ende der Liste wird durch b.next=NULL markiert. Merken muss man sich jeweils den Anfang der Liste, wofr ein Array der Lnge |V | bentigt u a o wird. Fr gerichtete Graphen haben Adjazenzlisten den Speicherbedarf |V | + |E|; fr ungeu u richtete Graphen werden |V | + 2|E| Speichereinheiten bentigt, da jede Kante in zwei Listen o vorkommt. In der folgenden Tabelle sind Aufwand und Speicherbedarf von Adjazenzmatrizen bzw. -listen gegenbergestellt. u Speicher Knoten einfgen u Knoten entfernen Kante einfgen u Kante entfernen Testen, ob (v, w) E Adjazenzmatrix O(n2) O(n) O(n) O(1) O(1) O(1) Adjazenzliste O(n + m) O(1) O(n + m) O(1) O(1) O(m)

Bemerkung. Kann man auf die Mglichkeit, Adjazenzlisten zu verndern, verzichten, so o a gengt es, die Position der von Null verschiedenen Eintrge der schwachbesetzten Matrix u a zu speichern. Die Adjazenzmatrix zum gerichteten Graphen aus Beispiel 5.22 wird dann gespeichert als die Arrays cols := (2, 3, 4, 3, 5, 3) und rptr := (1, 4, 5, 6, 6, 7). Dabei enthlt cols die Spaltenindizes der nicht verschwindenden Eintrge und rptr legt a a fest, welches Element im Array cols das erste der jeweiligen Zeile ist. Genauer sind die Eintrge mit den Positionen rptr[i] bis rptr[i+1]-1 die Eintrge der i-ten Zeile. Im letzten a a Eintrag von rptr wird daher die um Eins erhhte Anzahl der nicht verschwindenden Eintrge o a gespeichert. Bei dieser Datenstruktur handelt es sich um eine Spezialisierung des CRSFormats (engl. compressed row storage), bei dem zustzlich die Werte der Matrixeintrge a a in einem weiteren Feld der Lnge des Feldes cols gespeichert werden. Bei ungerichteten a Graphen ist die Adjazenzmatrix symmetrisch. Daher gengt es, den oberen Dreiecksanteil u im CRS-Format zu speichern. Man erhlt fr den ungerichteten Graphen aus Beispiel 5.22 a u die Arrays cols = (2, 3, 4, 3, 5) und rptr = (1, 4, 5, 6, 6, 6).

5.4 Graphendurchmusterung
Hug muss ein Graph entlang seiner Kanten von einem Startknoten s V durchgegangen a werden (sog. Durchmusterung), um z.B. einen Knoten mit maximalem Abstand zu s zu nden. Die Hauptproblematik hierbei ist, dass die Durchmusterung wegen mglicher Zyklen o im Graphen in eine Endlosschleife laufen kann. Populre Graphendurchmusterungsmethoden a sind die Tiefensuche und die Breitensuche. Beiden liegt folgender Algorithmus zugrunde: Algorithmus 5.24. Input: Graph G = (V, E) und Startknoten s V Output: azyklischer Graph G = (R, T ) mit R = {s} suc (s) und T E

R := {s}; Q := {s}; T := ; while (Q = ) { whle v Q beliebig; a

// R Resultat, Q Queue, T Tree

47

5 Graphen

if (w V \ R mit e := (v, w) E) { R := R {w}; Q := Q {w}; T := T {e}; } else Q := Q \ {v};

Satz 5.25. Algorithmus 5.24 liefert einen azyklischen zusammenhngenden Graphen G = a (R, T ) mit R = {s} suc (s) und T E. Beweis. Zu jedem Zeitpunkt des Algorithmus ist (R, T ) zusammenhngend, weil mit einem a Knoten auch die verbindende Kante zu R bzw. T hinzugefgt wird. Ausserdem ist (R, T ) u azyklisch, denn eine neue Kante e verbindet stets Knoten v Q R, w V \ R. Angenommen, am Ende des Algorithmus existiert ein von s erreichbarer Knoten w, der nicht in R ist. Sei ein einfacher Weg, der s mit w in G verbindet und (x, y) E eine Kante mit x R und y R. Weil x R, muss x zu einem gewissen Zeitpunkt in Q gewesen sein. Der Algorithmus terminiert nicht, bevor x aus Q entfernt wurde. Dies geschieht jedoch nur, falls (x, y) E. Dies liefert den Widerspruch. Satz 5.26. Wir nehmen an, die Ausf hrung von whle v Q beliebig und w V \ R u a mit (v, w) E ist mit O(1) Aufwand mglich. Dann besitzt Algorithmus 5.24 die Gesamto komplexitt O(|V | + |E|). a Beweis. Jeder Knoten wird hchstens (deg v + 1)-mal und jede Kante e E wird hchstens o o zweimal betrachtet. Damit ergibt sich eine Gesamtkomplexitt von O(|V | + |E|). a Algorithmus 5.24 kann beispielsweise verwendet werden, um die Zusammenhangskomponenten eines ungerichteten Graphen zu bestimmen, indem man ihn auf einen beliebigen Knoten s V anwendet. Falls R = V , so ist G zusammenhngend. Andernfalls ist (R, T ) a eine Zusammenhangskomponente von G, und man fhrt mit der Anwendung von Algoritha mus 5.24 auf einen Knoten aus dem Rest V \ R fort. Damit ergibt sich Satz 5.27. Die Zusammenhangskomponenten eines ungerichteten Graphen knnen mit o O(|V | + |E|) Aufwand bestimmt werden. Je nachdem, wie der Knoten v Q in Algorithmus 5.24 ausgewhlt wird, ergibt sich eine a andere Reihenfolge, in der der Graph durchmustert wird. Bei der Tiefensuche oder DFSSuche (engl. Depth-First-Search) wird derjenige Knoten v Q ausgewhlt, der zuletzt zu Q a hinzugefgt wurde, whrend bei der Breitensuche oder BFS-Suche (engl. Breadth-Firstu a Search) der zuerst zu Q hinzugefgte Knoten ausgewhlt wird. u a Beispiel 5.28. Wir betrachten den Graphen G gegeben durch seine Adjazenzlisten

48

5.4 Graphendurchmusterung v1 v2 v3 v4 v5 : : : : : v2 , v3 v4 , v5 , v3 , v1 v1 , v2 , v5 v2 , v5 v2 , v3 , v4 v1 v2 v4 v5 v3

Bei der Tiefensuche mit s = v1 ergibt sich die Besuchsreihenfolge: v1 , v2 , v4 , v5 , v3 . v3 v5 v4 v2 v1 Die Breitensuche liefert die Reihenfolge v1 , v2 , v3 , v4 , v5 und somit den Baum v1 v2 v4 v5 v3

Auf dem Graph G lt sich eine Metrik denieren. Fr v, w V deniere a u distG (v, w) := min{||, verbindet v mit w in G} als Abstand von v und w, falls ein solcher Weg existiert. Andernfalls setze distG (V, W ) = . Indem wir in Algorithmus 5.24 eine Variable einfhren, die die Entfernung eines Knoten u von s speichert, knnen wir mit Hilfe einer Breitensuche einen krzesten Weg von s zu allen o u erreichbaren Knoten bestimmen. Algorithmus 5.29. Input: Graph G = (V, E) und Startknoten s V Output: azyklischer Graph G = (R, T ) mit R = {s} suc (s) und T E, (v), v R

R := {s}; Q := {s}; T := ; (s) := 0; // Initialisierung while (Q = ) { v := erster Knoten in Q; Q := Q \ {v}; // Breitensuche for (w suc(v) \ R) { R := R {w}; Q := Q {w}; T := T {(v, w)}; (w) := (v) + 1; } }

49

5 Graphen

Satz 5.30. Sei G = (V, E) ein ungerichteter Graph. Dann enthlt der BFS-Graph G = a (R, T ) von Algorithmus 5.29 zum Startknoten s V einen k rzesten Weg zu jedem v u suc (s), und es gilt, dass distG (s, v) = (v) f r alle v R u a Beweis. Wir beobachten zunchst, dass fr das in Algorithmus 5.29 gewhlte v gilt a u (w) (v) + 1 und falls x nach y in Q aufgenommen wird. Wir zeigen nun, dass zu jedem Zeitpunkt des Algorihtmus gilt: (v) = dist(R,T ) (s, v) = distG (s, v) fr alle v R. Die Aussage (v) = dist(R,T ) (s, v) ist klar, weil G = (R, T ) azyklisch ist. u Angenommen, es gibt einen Knoten w mit dist(R,T ) (s, w) = distG (s, w), also dist(R,T ) (s, w) > distG (s, w). Existieren mehrere solcher Knoten, so whle w als denjenigen Knoten, der den a geringsten Abstand zu s hat. Sei ein krzester Weg von s nach w in G, und es bezeichne u e = (v, w) die letzte Kante auf . Dann gilt nach Konstruktion von w, dass distG (s, v) = dist(R,T ) (s, v) und distG (s, v) + 1 = distG (s, w) < dist(R,T ) (s, w). Also gilt (v) + 1 = dist(R,T ) (s, v) + 1 = distG (s, v) + 1 < dist(R,T ) (s, w) = (w). (5.3) (x) (y), (5.2) fr alle w Q u (5.1)

Aus (5.1) folgt, dass w Q. Wre w bereits in Q aufgenommen gewesen, so htte dies vor v a a sein mssen. Dann wre aber nach (5.2) (v) (w) ein Widerspruch zu (5.3). Also war w u a noch nicht in Q und kann somit nicht in R sein. Es gilt also w suc(v) \ R und somit nach Algorithmus 5.29, dass (w) = (v) + 1 im Widerspruch zu (5.3).

5.5 Minimal spannende Bume a

Sei G = (V, E) ein ungerichteter Graph. Es sei eine Gewichts- bzw. Kostenfunktion c : E R fr die Kanten des Graphen gegeben. Das Tripel (V, E, C) wird auch als gewichteter Graph u bezeichnet. Fr Teilmengen F E der Kantenmenge E denieren wir u c(F ) =
eF

c(e).

Denition 5.31. Ein Graph H = (V (H), E(H)) heit Teilgraph des Graphen G = (V (G), E(G)), falls V (H) V (G) und E(H) E(G). Gilt V (H) = V (G), so wird H als (auf )spannender Teilgraph bezeichnet. F r einen Teilgraphen H sei c(H) := c(E(H)) u die Kosten bzw. das Gewicht von H. Beim Minimum-Spanning-Tree-Problem ist ein spannender Teilgraph T G mit minimalen Kosten c(T ) gesucht. Anwendungen sind kostengnstige zusammenhngende Netzwerke u a wie beispielsweise Telefonnetze.

50

5.5 Minimal spannende Bume a

Algorithmus 5.32 (Kruskals Algorithmus). Input: Ein zusammenhngender ungerichteter Graph G = (V, E) a Gewichte c : E R Output: Ein minimal spannender Baum Sortiere E(G), so dass c(e1 ) . . . c(em ); Setze T := (V (G), ); for (i = 1, i ; + + i) if (T {ei } azyklisch) T := T {ei }; Beispiel 5.33. Wir betrachten den folgenden Graphen. Die Kostenfunktion c : E R ist durch Zahlen entlang der Kanten dargestellt. 2 1 1 3 4 1 4 2 1 1 5 3 1 1 5 2 1 3 5 1 2 3 3 1 1: 2: 3: 4: 5: 2(1), 1(1), 2(3), 1(3), 1(4), 4(3), 3(3), 4(1), 3(1), 2(1), 5(4) 5(1) 5(2) 5(1) 3(2), 4(1)

2 1 1 1 4 5 1 3 1 1 1

2 1 5 1 4 3

Bemerkung. Der Test, ob T {ei } azyklisch ist, lst sich mit O(1) Aufwand durchfhren, a u wenn man sich fr jeden Knoten die ZusammenhangsKomponente merkt, in der er aktuell u

51

5 Graphen liegt. Zu Beginn liegen alle Knoten in unterschiedlichen Komponenten. Wird eine Kante ei zu T hinzugefgt, so werden zwei Komponenten vereinigt und die entsprechenden Weru te der Knoten der einen Komponente auf die der anderen gesetzt. Daher muss lediglich geprft werden, ob die Anfangs- und Endknoten der einzufgenden Kante in unterschiedliu u chen Komponenten liegen. Bei der Aktualisierung der Komponenteninformation sollte der Komponentenwert der Komponente mit der kleineren auf den Wert der Komponente mit der greren Mchtigkeit gesetzt werden. Dies stellt sicher, dass jeder Knoten hchstens o a o O(log n)-mal eine neue Komponentennummer erhlt. a Satz 5.34. Der Algorithmus von Kruskal bestimmt einen minimal spannenden Baum und kann mit O(m log n) Aufwand durchgef hrt werden. u Beweis. Der vom Algorithmus von Kruskal zurckgelieferte Graph ist oensichtlich azyu klisch. Angenommen, T ist nicht zusammenhngend. Dann gibt es eine Partition V = A B, a A B = mit |A|, |B| 1, sodass keine Kante von T zwischen A und B verluft. Da G a zusammenhngend ist, muss aber in G eine Kante zwischen A und B existieren. Diese wre a a in der letzten Zeile des Algorithmus von Kruskal zu T hinzugefgt worden, was einen Wiu derspruch liefert. Wir zeigen nun, dass T ein minimal spannender Baum ist. Sei T ein minimal spannender Baum, so dass der kleinste Index i, fr den ei T aber ei T grtmglich ist. Falls u o o dieser Index nicht existiert, so gilt T = T und wir sind fertig. Ansonsten betrachte den Graphen T {ei }. Dieser enthhlt einen Zyklus. Weil T azyklisch ist, muss dieser Kreis a eine Kante ej T enthalten. Die Kanten, die vor ei in T eingefgt wurden, sind gem der u a Denition von i auch alle in T enthalten. Zu dem Zeitpunkt, zu dem Kruskals Algorithmus die Kante ei hinzufgt, htte daher auch ej zu T hinzugefgt werden knnen, ohne einen u a u o Kreis zu erzeugen. Da aber ej T , muss j > i und somit c(ej ) c(ei ) gelten. Dann ist aber T := (T {ei })\{ej } ein minimalspannender Baum, der der Denition von T widerspricht, o weil e T , i, und somit der minimale Index i , fr den ei T aber ei T , grer als u i sein muss. Zum Aufwand des Algorithmus: Das Sortieren der m Kanten bentigt O(m log m) Operao tionen. Nach Satz 5.13 gilt n (n 1) n1 m 2 und somit O(m log m) = O(m log n). Nach der letzten Bemerkung bentigt der Test, ob o T {ei } azyklisch ist, in jedem der m Durchlufe der for-Schleife O(1) Operationen. Inklusive a der Aktualisierung der Komponentenummern werden daher O(m + n log n) Operationen fr u die for-Schleife bentigt. o

5.6 Krzeste Wege u

Gegeben sei ein Graph G = (V, E) und eine Gewichtsfunktion c : E R. Wir verallgemeinern die Denition des Abstands distG (v, w) zweier Knoten v, w V , indem wir die Kosten c entlang der Kanten bercksichtigen u dist(G,c) (v, w) := min{c() : ist ein Weg von v nach w}, falls w von v erreichbar, , sonst.

52

5.6 K rzeste Wege u Entsprechend verallgemeinern wir den Begri des krzesten Weges, indem wir diesen Abu standsbegri zu Grunde legen. Beispiel 5.35. Gegeben sei der folgende gewichtete Graph (V, E, c) x 2 w Der krzeste Weg von v nach w ist 1 = v, x, w. Seine Weglnge ist c(1 ) = 1 + 2 = 3, u a whrend der direkte Weg 2 = v, w die Weglnge c(2 ) = 4 hat. a a Beim krzesten Wege-Problem besteht die Aufgabe darin, fr ein Paar s, t V einen u u krzesten Weg von s nach t zu nden, bzw. die Angabe, dass ein solcher Weg nicht existiert. u Eine oensichtliche Anwendung ist die Planung von Verkehrsrouten. Es zeigt sich, dass das Problem schwierig ist, falls negative Kantengewichte vorkommen. Beispiel 5.36. Wir betrachten den folgenden Graphen w 2 v 4 2 x 1 v 4

Der Weg 1 = v, w, x, v hat die Lnge c(1 ) = 1, der Weg 2 = v, w, x, v, w, x, v die Lnge a a c(2 ) = 2. Daher existiert kein krzester Weg. u Wir setzen daher voraus, dass alle Gewichte positiv sind.

Algorithmus 5.37 (Dijkstras Algorithmus). Input: Ein Digraph G = (V, E), v : E R+ , s V Output: (x) = dist(G,c) (s, x) fr alle x V , u p(x) enthlt den vorletzten Knoten auf dem minimalen Weg von s nach x, a falls ein solcher existiert. (s) := 0; (x) = fr alle x V \ {s}; Q := V ; u while (Q = 0) { x := Knoten in Q mit (x) minimal; Q := Q \ {x}; for (y Q mit e := (x, y) E) { if ((x) + c(e) < (y)) { (y) := (x) + c(e); p(y) := x; } } }

53

5 Graphen Beispiel 5.38. Wir betrachten den folgenden gewichteten Graphen und suchen den krzesu ten Weg ausgehend von a. a Iteration x p(x) a b c d e 4 0 0 1 1 a 1 4 c 2 b a 4 2 b 3 d b 3 5 1 1 3 4 c d 4 5 e c 1 e d Bemerkung. u (a) Der Algorithmus von Dijkstra berechnet einen krzesten Weg von s zu allen erreichbaren Knoten t suc (s) {s}. Es ist kein Algorithmus mit geringerer Komplexitt bekannt, a der den krzesten Weg zu genau einem Knoten t suc (s) {s} bestimmt. u (b) (t) gibt uber die Erreichbarkeit bzw. die Lnge eines krzesten Weges Auskunft. Der a u Weg kann rekonstruiert werden, indem mit dem Feld p der Weg rckwrts gegangen u a wird. In Beispiel 5.38 kann man einen krzesten Weg von a nach e als p(e) = c, p(c) = d, u p(d) = b, p(b) = a rekonstruieren. Ist man nur an der Weglnge interessiert, so kann p a aus Algorithmus 5.37 entfernt werden. Satz 5.39. Dijkstras Algorithmus arbeitet korrekt. Der Aufwand ist von der Ordnung |V |2 . Beweis. Angenommen, die Aussage ist falsch. Sei x der erste Knoten, der aus Q entfernt wird mit (x) = dist(G,c) (s, x). Dann gilt x = s und (x) > dist(G,c) (s, x), weil die 7-te Zeile die Existenz eines Weges von s nach x der Lnge hchstens (x) sichert. Wir betrachten a o den Zeitpunkt, bevor x aus Q entfernt wird. Sei s = v1 , . . . , vk = x ein krzester Weg von s u nach x in G und i der grte Index eines Knoten, der bereits aus Q entfernt wurde. Dieser o Index existiert, weil s Q, und es gilt i < k, weil x noch in Q. Wegen vi+1 Q gilt (vi+1 ) (vi ) + c(vi , vi+1 ) nach Zeile 6 und 7. Wegen Zeile 3 gilt (x) (vi+1 ) (vi ) + c(vi , vi+1 ) dist(G,c) (s, x). Hierbei gilt die letzte Ungleichung, weil v1 , . . . , vk ein krzester Weg von s nach x ist. u Dies ergibt einen Widerspruch zur Annahme; die Aussage ist also richtig. Wegen (x) = dist(G,c) (s, x) ist p(x) der vorletzte Knoten auf einem krzesten Weg von s nach x. u Zur Laufzeit: Die while-Schleife wird |V |-mal durchlaufen, wobei jeder Durchlauf O(|V |) Aufwand bentigt (bereits in Zeile 3). o Bemerkung. Im Fall von Gewichten c 1 kann Algorithmus 5.29 mit Aufwand O(|V |+|E|) verwendet werden, um einen krzesten Weg zu bestimmen. u Durch die Verwendung von Heaps lt sich Dijkstras Algorithmus ezienter implementiea ren.

54

5.6 K rzeste Wege u

Satz 5.40. Dijkstras Algorithmus kann so implementiert werden, dass der Aufwand von der Ordnung |V | log |V | ist. Beweis. Ist die Menge Q als binrer Heap implementiert, dann bentigen die Zeilen 3 und a o 4 O(log |V |) Operationen. Ebenso werden fr die Zeilen 6 und 7 O(log |V |) Operationen u bentigt. Die while-Schleife wird |V |-mal durchlaufen. o Wir hatten bereits angemerkt, dass Dijkstras Algorithmus bei negativen Gewichten Schwierigkeiten hat. Im Fall von konservativen Gewichten, d.h. es gibt keinen Zyklus in G mit negativem Gewicht, gilt ein Prinzip, das wir bereits mehrfach verwendet haben. Lemma 5.41. Sei G = (V, E) ein gerichteter Graph und c : E R konservativ. Sei : s = v1 , . . . , vk+1 = w ein Weg zwischen s, w V mit hchstens k N Kanten. Dann ist o : s = v1 , . . . , vk ein k rzester Weg zwischen s und vk unter allen Wegen zwischen s und vk u mit hchstens k 1 Kanten. o Beweis. Angenommen, ist ein krzester Weg zwischen s und vk mit hchstens k 1 u o Kanten und c( ) < c( \ {(vk , w)}) = c() c(vk , w). Falls w V ( ), so ist {(vk , w)} ein krzerer Weg von s nach w als mit hchstens k Kanten. Im anderen Fall (w V ( )) u o gilt
c([s,w]) = c( ) + c(vk , w) c([w,vk ] {(vk , w)}) < c() c([w,vk ] {(vk , w)}) c(), weil c konservativ und [w,vk ] {(vk , w)} ein Zyklus ist. Dies widerspricht der Wahl von .

(s) = 0; (x) = fr x V \ {s}; u for (i = 1; i |V |; + + i) { for ((x, y) E) { if ((y) > (x) + c(x, y)) { (y) := (x) + c(x, y); p(y) := x; } } }

Algorithmus 5.42 (Moore-Bellman-Ford). Input: Ein gerichteter Graph G, konservatives c : E R, s V Output: (x) = dist(G,c) (s, x) fr alle x V , Vorgngerinformation p. u a

Satz 5.43. Der Moore-Bellman-Ford Algorithmus arbeitet korrekt und kann in O(|V | |E|) Operationen ausgef hrt werden. u Beweis. Wir zeigen induktiv uber die Anzahl der k Kanten eines krzesten Weges zwischen u s und y, dass (y) = dist(G,c) (s, y) nach sptestens k Iterationen der for-Schleife in der 2. a Zeile terminiert. Der Fall k = 1 ist klar. Fr den Induktionsschritt sei y ein Konten, so dass ein krzester u u

55

5 Graphen Weg zwischen s und y mit k Kanten existiert. Es bezeichne x den vorletzten Knoten dieses Weges. Dann ist [s,x] nach Lemma 5.41 ein krzester Weg zwischen s und x der Lnge k 1. u a Hieraus folgt per Induktionsannahme (x) = dist(G,c) (s, x) nach k 1 Iterationen und somit (y) (x) + c(x, y) = dist(G,c) (s, x) + c(x, y) = dist(G,c) (s, y). Die Abschtzung (y) dist(G,c) (s, y) ist wieder klar. a Bemerkung. Um die Abstnde zwischen allen Paaren von Knoten zu berechnen, kann a man |V |-mal den Moore-Bellman-Ford Algorithmus aufrufen. Dies erfordert O(|V |2 |E|) Operationen. Der aus der Literatur bekannte Algorithmus von Floyd-Warshall bentigt dafr o u 3 O(|V | ) Operationen.

5.7 Netzwerksse u
Zur Motivation von Netzwerkussproblemen betrachten wir das folgende aktuelle Beispiel 5.44. In den Depots A1 , . . . , Ap des Weihnachtsmannes liegen r1 , . . . , rp Geschenke zum Transport bereit. In den Stdten B1 , . . . , Bq warten d1 , . . . , dq Kinder auf ihr Geschenk. a Dabei nehmen wir an, dass jedes Kind das gleiche Geschenk bekommt. Von Depot Ai knnen o an Heiligabend vom Knecht Ruprecht und seinen Kollegen hchstens c(Ai , Bj ) Geschenke o zur Stadt Bj transportiert werden. Es ergeben sich folgende Fragen: 1. Ist es mglich, jedem Kind ein Geschenk zu bringen? o 2. Falls nein, wieviele Geschenke knnen maximal zu den Kindern gebracht werden? o 3. Wieviele Geschenke sollen von Depot Ai in die Stadt Bj transportiert werden? Den Kanten (Ai , Bj ) ordnen wir die Kapazitt c(Ai , Bj ) zu. Um die Menge der vorhandenen a bzw. der bentigten Geschenke zu erfassen, fhren wir zwei weitere Knoten s, t und Kanten o u (s, Ai ) bzw. (Bj , t) mit Kapazitten vi bzw. dj ein. a A1 r1 s r2 r3 A3 A2 c(A1 , B1 ) c( A 1, B 2) B 2) c(A 2, c(A2 , B 3) B1 d1 B2 B3 d4 B4 d2 d3 t

c( A

2, B 4)

c(A3 , B4 )

Zur Beantwortung dieser drei Fragen lsen wir folgendes Problem: Was ist der maximale o Fluss von s nach t und wie sieht dieser aus? Dabei ist der Fluss auf einer Kante durch ihre Kapazitt beschrnkt und der gesamte Fluss, der einen Knoten betritt, muss diesen auch a a wieder verlassen.

56

5.7 Netzwerk sse u

Denition 5.45. Ein Netzwerk ist ein Tupel N = (V, E, c, s, t) bestehend aus (i) einem Digraphen G(V, E), (ii) einer Kapazittsfunktion c : E R+ , a (iii) einer Quelle s V mit pre(s) = , (iv) einer Senke t V mit suc(t) = . Ein Fluss f : E R+ ist eine Funktion, die folgende Bedingungen erf llt: u 0 (i) Kapazittsbedingung: f (v, w) c(v, w) f r alle (v, w) E, a u (ii) Flusserhaltung f (u, v) =
upre(v) wsuc(v)

f (v, w)

f r alle v V \ {t, s}. u Der Wert eines Flusses f ist deniert als |f | := f (s, v).
vsuc(s)

Der maximale Fluss eines Netzwerkes N ist der maximale Wert aller Fl sse f r N. u u Beispiel 5.46. Wir betrachten das folgende Netzwerk 3 s 4 Der maximale Fluss ist 3. Denition 5.47. Ein Schnitt f r N = (V, E, c, s, t) ist eine Knotenmenge S V mit u s S, t S. Die Kapazitt eines Schnittes ist gegeben durch a cap(S) :=
vS wsuc(v)\S

x 9 y 1

2 t

c(v, w).

Die minimale Schnittkapazitt von N ist die minimale Kapazitt aller Schnitte f r N. a a u

Lemma 5.48. Sei S ein Schnitt f r N = (V, E, c, s, t). Dann gilt f r jeden Fluss f u u (i) |f | =

vS

wsuc(v)\S

f (v, w)

upre(v)\S

f (u, v) ,

57

5 Graphen

(ii) |f | cap(S). Beweis. Aussage (i) folgt aus der Flusserhaltung |f | = f (s, v) =
vsuc(s)

=
vS

vS

wsuc(v)

f (v, w)

upre(v)

+
vS

wsuc(v)\S

f (v, w)

upre(v)\S

f (u, v)

f (u, v)

wsuc(v)S

f (v, w)
=0

upre(v)S

f (u, v) .

Die beiden letzten Summen stimmen uberein, weil {(v, w) : v S, w suc(v) S} = {(v, w) : w S, v pre(w) S}. Weil 0 f (e) c(e) fr alle e E, folgt (ii) aus u |f |
(i) vS wsuc(v)\S

f (v, w)

c(v, w) = cap(S).
vS wsuc(v)\S

Denition 5.49. Sei G = (V, E) ein Digraph. F r e = (v, w) E bezeichne e1 := (w, v) u als gegenluge Kante. Ist c : E R+ eine Kapazittenfunktion und f : E R+ ein a a 0 Fluss, dann sind die Restkapazitten cf deniert durch a cf (e) := c(e) f (e) und cf (e1 ) := f (e). Der Restgraph Gf besteht aus den Knoten V und den Kanten E(Gf ) := {e E : cf (e) > 0} {e1 : e E und cf (e1 ) > 0}. Ein augmentierender Weg ist ein Weg von s nach t im Restgraphen Gf . Beispiel 5.50. Wir betrachten folgendes Netzwerk mit Fluss/Kapazitt. a 2/2 s 0/1 Der Restgraph ist y 0/4 x 2/3 t

58

5.7 Netzwerk sse u x 2 1 y 4 1 t

2 s

Dabei sind gegenluge Kanten gepunktet dargestellt. a Sei ein augmentierender Weg und 0 < mineE() cf (e). Unter der Augmentierung des Flusses f entlang um versteht man das Folgende. Fr jedes e E() erhhe f (e) um u o 1 1 , falls e E(G) und verringere f (e ) um , falls e E(G). Durch diese Augmentierung erhlt man einen neuen Fluss f entlang mit |f | = |f | + . a Algorithmus 5.51 (Ford-Fulkerson). Input: Netzwerk N = (V, E, c, s, t) Output: Fluss f maximalen Wertes Setze f (e) = 0 fr alle e E; u while ( augmentierender Weg ) { := min cf (e);
eE()

augmentiere den Fluss f entlang um ; } Satz 5.52. Ein Fluss von s nach t hat genau dann maximalen Wert, wenn es keinen augmentierenden Weg gibt. Beweis. Falls es einen augmentierenden Weg gibt, so kann f entlang zu einem Fluss mit grerem Wert augmentiert werden. o Falls es keinen augmentierenden Weg gibt, so ist t von s aus in Gf nicht erreichbar. Sei R die Menge der von s aus in Gf erreichbaren Knoten. Dann gilt f (e) = c(e) fr alle e = (v, w), u v R, w suc(v) \ R und f (e) = 0 fr alle e = (v, w), w R, v pre(w) \ R, weil sonst u nach Denition von Gf eine Kante aus R herausluft in Gf . Nach Lemma 5.48 (i) gilt a |f | = f (v, w) f (u, v) =
vR upre(v)\R vR wsuc(v)\R

c(v, w) = cap(R).

vR wsuc(v)\R

Nach Lemma 5.48 (ii) hat f maximalen Wert. Satz 5.53 (Max-Flow-Min-Cut Theorem). In einem Netzwerk (V, E, c, s, t) stimmt der maximalen Fluss von s nach t und die minimale Schnittkapazitt uberein. a Beweis. Nach Lemma 5.48 (ii) ist der Wert eines Flusses von s nach t hchstens so gro wie o die Kapazitt eines Schnittes. Im Beweis von Satz 5.52 wurde ein Schnitt R deniert mit a |f | = cap(R).

59

5 Graphen

Satz 5.54. Der Algorithmus von Ford-Fulkerson ist korrekt und bentigt bei ganzzahligen o Kapazitten O |E| eE c(e) Aufwand. a Beweis. Die Korrektheit ergibt sich aus Satz 5.52. Fr die Aufwandsabschtzung bercku a u sichtige man, dass sich der Fluss bei jedem Durchlauf der while-Schleife um mindestens 1 erhht. Ein Schleifendurchlauf bentigt O(|E|) Aufwand. o o Beispiel 5.55. Wir betrachten folgendes Netzwerk. v 1 M w M

M s

M t

Oensichtlich ist der maximale Fluss 2M. Augmentieren wir abwechselnd entlang der Wege s, v, w, t und s, w, v, t, so erhht sich der Wert von f um = 1. Folglich werden 2M Schritte o bentigt. o Bemerkung. Ford und Fulkerson haben anhand eines Beispiels gezeigt, dass bei irrationalen Kapazitten der Algorithmus mglicherweise nicht terminiert. Ferner kann der Algorithmus a o exponentiellen Aufwand verursachen. Beispiel 5.55 zeigt, dass bei ungeschickter Wahl des augmentierenden Weges die Anzahl der Augmentierungsschritte sehr gro sein kann. Polynomielle Laufzeiten knnen im Fordo Fulkerson-Algorithmus durch die Wahl eines krzesten Weges erreicht werden. Hierbei beu zieht sich die Lnge auf die Anzahl der Kanten. a

Algorithmus 5.56 (Edmonds-Karp). Input: Netzwerk N = (V, E, c, s, t) Output: Fluss f maximalen Wertes Setze f (e) = 0 fr alle e E; u while ( augmentierender Weg) { whle krzesten augmentierenden Weg von s nach t; a u := min cf (e);
eE()

augmentiere den Fluss f entlang um ; } Bemerkung. Die Wahl eines krzesten Weges kann durch eine Breitensuche im Restgrau phen realisiert werden; vgl. Algorithmus 5.29.

60

5.7 Netzwerk sse u Beispiel 5.57. Wir illustrieren den Edmonds-Karp-Algorithmus anhand des folgenden Netzwerks. Restgraph und krzester u Netzwerk mit aktuellem Fluss augmentierender Weg 0/2 y y 0/5 t 0/8 t s 0/4 s 0/12 0/2 x z x z 0/7 2/5 s 0/2 x y 0/4 2/2 x y 0/4 2/2 x y 0/4 2/2 0/8 z 2/2 0/8 z 2/2 3/8 z t 5/12 s x z t 2/12 s x y t z t 0/12 s x y t z y t

0/7

2/5 s

2/7

5/5 s

2/7

Fr die Laufzeitabschtzung des Algorithmus bentigen wir u a o Lemma 5.58. Der Abstand distGf (s, x), x V , wchst monoton mit jedem Schleifendurcha lauf des Edmonds-Karp-Algorithmus. Beweis. Fr x = s ist dies sicher richtig. Sei also x = s. Angenommen, es gibt einen Knoten u x V , sodass distGf (s, x) in einer Iteration des Algorithmus kleiner wird. Sei f der Fluss, bevor distGf (s, x) fr ein x V zum ersten Mal kleiner wird und sei f der Fluss eine u Iteration spter. Ferner sei x so gewhlt, dass distGf (s, x) < distGf (s, x) und distGf (s, x) a a unter allen mglichen Wahlen von x minimal ist. Sei ein krzester Weg von s nach x in o u Gf und y der Vorgnger von x in . Dann gilt a distGf (s, x) = distGf (s, y) + 1 und nach Wahl von x Wir zeigen, dass (y, x) E(Gf ). Falls doch, so glte a distGf (s, y) distGf (s, y).

distGf (s, x) distGf (s, y) + 1 distGf (s, y) + 1 distGf (s, x)

61

5 Graphen im Widerspruch zu unserer Annahme fr x. Es gilt also (y, x) E(Gf ) und (y, x) E(Gf ). u Daher muss der Edmonds-Karp-Algorithmus den Fluss entlang der Kante (x, y) erhht hao ben, um von f zu f zu kommen. Weil der Edmonds-Karp-Algorithmus immer einen krzesten u augmentierenden Weg auswhlt, muss die Kante (x, y) in dem krzesten Weg von s nach y a u enthalten sein. Es folgt distGf (s, x) = distGf (s, y) 1 distGf (s, y) 1 = distGf (s, x) 2, was distGf (s, x) < distGf (s, x) widerspricht. Unsere Annahme ist falsch. Satz 5.59. Algorithmus 5.56 terminiert unabhngig von den Kapazitten nach hchstens a a o 1 2 |V | |E| Schritten und bentigt daher O(|V | |E| ) Aufwand. o 2 Beweis. Sei (x, y) eine kritische Kante auf einem krzesten ausgewhlten augmentierenden u a Weg , d.h. cf (x, y) = . Es gilt distGf (s, y) = distGf (s, x) + 1. Die Kante (x, y) wird aus Gf entfernt. Sie kann zu einem spteren Zeitpunkt nur dann wieder hinzugefgt werden, a u falls (y, x) in einem augmentierenden (krzesten) Weg auftritt. Sei f der Fluss zu diesem u Zeitpunkt. Dann gilt distGf (s, x) = distGf (s, y) + 1. Da distGf (s, y) distGf (s, y) nach Lemma 5.58, folgt distGf (s, x) = distGf (s, y) + 1 distGf (s, y) + 1 = distGf (s, x) + 2. Falls eine Kante mehrfach kritisch ist, so erhht sich der Abstand von s nach x jedesmal. o 1 Weil der Abstand hchstens |V | 1 ist, kann die Kante hchstens 2 |V |-mal kritisch sein. o o 1 Es gibt |E| Kanten, die kritisch werden knnen. Also gibt es hchstens 2 |V | |E| Schritte. o o Bei Terminierung von Algorithmus 5.56 existiert kein augmentierender Weg von s nach t im Restgraphen Gf . Nach Satz 5.52 ist der Fluss dann maximal. Die Aufwandsabschtzung a ergibt sich, weil die Breitensuche den Aufwand O(|E|) hat. Weil G zusammenhngend ist, a gilt nmlich |V | 1 |E|. a

5.8 Matchings in bipartiten Graphen

Denition 5.60. Sei G = (V, E) ein ungerichteter Graph. Ein Matching von G ist eine Kantenmenge M E, sodass f r alle (v, w), (x, y) M gilt u (v, w) = (x, y) {v, w} {x, y} = , d.h. jeder Knoten von G liegt auf hchstens einer Kante von M. Ein Matching M heit o maximal, falls M {e} kein Matching ist f r alle e E \ M. M ist grtes Matching, u o falls |M| |M | f r alle Matchings M von G. u Algorithmus 5.61 (Maximales Matching). Input: ungerichteter Graph G = (V, E) Output: maximales Matching M M := ; while (e E \ M mit M {e} ist Matching) M := M {e};

62

5.8 Matchings in bipartiten Graphen

Satz 5.62. Algorithmus 5.61 ist korrekt und bentigt O(|E|) Aufwand. o Beweis. klar Ein maximales Matching ist im Allgemeinen kein grtes Matching. Der folgende Satz o besagt aber, dass sich die Kardinalitt eines maximalen Matchings hchstens bis auf eine a o Konstante von der eines grten Matchings unterscheidet. o

Satz 5.63. Sei M ein maximales und M ein grtes Matching. Dann gilt |M| 1 |M |. o 2 Beweis. Sei S = {x V : e M mit x e}. Dann ist |S| = 2|M|. Fr (x, y) M gilt u {x, y} S = , sonst wre M {(x, y)} ein Matching. Weil M selbst ein Matching ist, gibt a es keine weitere Kante, die x oder y enthlt. Hieraus folgt |M | |S| = 2|M|. a Beispiel 5.64. Die Schranke aus Satz 5.63 ist bestmglich, wie folgender Graph zeigt. o

|M | = 4 |M| = 2

Im Folgenden wollen wir uns darauf beschrnken, grte Matchings in sog. bipartiten a o Graphen zu suchen.

Denition 5.65. Ein ungerichteter Graph G = (V, E) heit bipartit oder zweigeteilt, falls nicht-leere Knotenmengen V1 , V2 existeren, sodass (i) V = V1 V2 , V1 V2 = , (ii) f r jede Kante (v, w) E ist {v, w} V1 = und {v, w} V2 = , d.h. alle Kanten u verlaufen zwischen einem Knoten aus V1 und einem Knoten aus V2 ; es gibt also keine Kanten jeweils innerhalb von V1 und V2 . Die Mengen V1 , V2 heien Bipartition. Ein Matching M heit perfekt, falls |M| = |V1 |. Beispiel 5.66 (Arbeitsvermittlungsproblem). Drei Personen V1 := {x, y, z} besitzen unterschiedliche Fhigkeiten, die sie fr drei ausgeschriebene Stellen V2 := {a, b, c} qualizieren. a u Ziel ist es, mglichst vielen Personen eine Stelle zu vermitteln. Wir erhalten beispielsweise o den folgenden Graphen, in dem jede Kante die Eignung einer Person fr eine Stelle symbou lisiert.

63

5 Graphen x y z a b c

Die Bestimmung eines grten Matchings kann auf ein Flussproblem zurckgefhrt wero u u den. Die Lsung dieses Flussproblems mittels des Ford-Fulkerson-Algorithmus bentigt O(|V | o o |E|) Aufwand. Mit dem folgenden Algorithmus von Hopcroft und Karp kann ein grtes o Matching mit Aufwand O( |V | |E|) bestimmt werden. Um den Algorithmus vorstellen zu knnen, bentigen wir einige Begriserklrungen. o o a

Ein grtes Matching ist M := {(x, c), (y, b), (z, a)}. o

Denition 5.67. Sei G = (V, E) ein ungerichteter Graph und M E ein Matching. Ein Pfad in G, bei dem sich Kanten e M und Kanten e M abwechseln, heit M alternierend. Ein Knoten v V heit frei, falls v e f r alle e M. Ein einfacher u M-alternierender Pfand = (v1 , . . . , vk ) mit freien Knoten v1 , vk heit M -augmentierend. Beispiel 5.68. Wir betrachten das Matching M = {(v2 , v3 ), (v4 , v5 )} im folgenden Graphen. v2 v3 v5

v1

v4

v6

Der Weg := (v1 , v2 , v3 , v4 , v5 , v6 ) ist M-augmentierend. Betrachte das Matching N := (M \ ) ( \ M), in dem im Vergleich zu M die Kanten e M entfernt und e mit e M hinzugefgt u werden. Dann gilt N = {(v1 , v2 ), (v3 , v4 ), (v5 , v6 )} und somit |N| = |M| + 1. v2 v3 v5

v1

v4

v6

Mit Hilfe eines M-augmentierenden Weges kann oenbar die Kardinalitt des Matchings a vergrert werden. o

Satz 5.69. Sei G = (V, E) ein ungerichteter Graph und M E ein Matching. M ist genau dann ein grtes Matching, falls es keinen M-augmentierendend Pfad gibt. o

64

5.8 Matchings in bipartiten Graphen Beweis. Wir zeigen die Negierung der Aussage. Sei = (v1 , . . . , vk ) ein M-augmentierender Pfad. Die Menge N := (M \ ) ( \ M) ist ein Matching, weil M ein Matching ist und v1 , vk frei sind. Ferner gilt |N| = |M| + 1, weil die Anzahl der Kanten in ungerade ist und (v1 , v2 ), (vk1 , vk ) M. Also ist M kein grtes Matching. o Fr die Gegenrichtung sei M ein Matching mit |M | > |M|. Sei N := (M \ M) (M \ M ) u und betrachte den durch N induzierten Subgraphen G . Dazu entferne alle Kanten, die nicht in N sind und danach alle isolierten Knoten. Die Knoten in G haben Grad 1 oder 2, weil fr u einen greren Grad mindestens zwei M-Kanten oder mindestens zwei M -Kanten anliegen o mssten, was der Matchingeigenschaft von M und M widerspricht. Daher besteht G aus u disjunkten einfachen Pfaden oder Zyklen. Die Zyklen in G enthalten die gleiche Anzahl von M- und M -Kanten, weil weder zwei M-Kanten noch zwei M -Kanten aneinander stoen knnen. Weil aber |M | > |M| gilt, muss es in G mehr M -Kanten als M-Kanten geben. o Also muss es mindestens einen einfachen Weg geben, der abwechselnd aus M- und M -Kanten besteht und mit M -Kante beginnt und endet. Die Anfangs- und Endknoten sind frei, weil in G keine weitere M -Kante anliegen kann. Wrde eine M-Kante anliegen, so wre sie dann u a auch in G enthalten. Dieser Pfad ist oenbar M-augmentierend. Aus dem letzten Satz ergibt sich ein einfacher Matching-Algorithmus. Um nur M-alternierende Wege zu beschreiten, denieren wir den gerichteten Graphen GM = (V1 V2 , EM ) mit EM = {(u, v) : u V1 , v V2 , (u, v) M} {(v, u) : u V1 , v V2 , (u, v) E \ M}. Beispiel 5.70. Wir betrachten den bipartiten Graphen G = (V1 V2 , E). V1 V1

V2 Pfade in GM sind oenbar M-alternierend.

V2

Algorithmus 5.71 (Einfacher Matching-Algorithmus). Input: Bipartiter Graph G = (V, E) Output: grtes Matching M o 1: 2: 3: 4: 5: 6: 7: M := ; konstruiere GM ; suche mittels Breitensuche einen gerichteten Pfad in GM zwischen zwei freien Knoten; if ( existiert) { M := (M \ ) ( \ M); goto 2; }

Satz 5.72. Algorithmus 5.71 berechnet ein grtes Matching f r einen bipartiten Graphen o u G = (V, E) mit Aufwand O(|V | |E|).

65

5 Graphen Beweis. Gerichtete Pfade in GM zwischen freien Knoten sind oenbar M-augmentierend und umgekehrt. Wenn es einen solchen Pfad gibt, wird er auch per Breitensuche gefunden. Dies bentigt O(|E|) Operationen. Die Kardinalitt von M wird in jedem Schleifendurchlauf um 1 o a a erhht. Die Kardinalitt eines grten Matchings ist durch 1 |V | nach oben beschrnkt. o a o 2 Dieser einfache Algorithmus soll nun verbessert werden, so dass ein Aufwand von der Ordnung |V ||E| entsteht. Dazu wird das Matching in jedem Schritt durch die Augmentierung von mehreren knotendisjunkten Pfaden vergrert. Wir verwenden im Folgenden die Notao tion M1 M2 := (M1 \ M2 ) (M2 \ M1 ). Die Bedeutung der beiden folgenden Lemmata wird erst bei der Komplexittsanalyse des Hopcroft-Karp-Algorithmus klar werden. a Lemma 5.73. Sei G = (V, E) ein ungerichteter Graph und M E ein Matching. Sei ein k rzester M-augmentierender Pfad N := M . Ist ein N-augmentierender Pfad, so gilt u | | || + | | Beweis. Betrachte N := N . Dann gilt |N | = |N| + 1 = |M| + 2. Wegen N := M N = M ((M ) ) = enthlt N zwei M-augmentierende Pfade 1 , 2 . Folglich ist |N | |1 | + |2 |. Weil a ein krzester M-augmentierender Weg ist, gilt || min{|1 |, |2 |}. Somit ist |N | 2||. u Andererseits gilt | | = || + | | | |. Hieraus folgt || + | | | | 2||. Das folgende Lemma verwendet die im letzen Lemma gemachte Beobachtung fr eine Folge u augmentierender Wege. Lemma 5.74. Sei G = (V, E) ein ungerichteter Graph. Sei M0 := und Mi+1 := Mi i , i > 0, wobei i ein k rzester Mi -augmentierender Weg ist. Dann gilt u (i) |i | |i+1 |, (ii) |i | = |j |, i = j = i und j sind knotendisjunkt. u a Beweis. Der erste Teil folgt aus Lemma 5.73. Fr den zweiten Teil nehmen wir an, es gbe zwei nicht-knotendisjunkte Pfade , j , i = j mit |i | = |j |. Dann haben nach (i) auch alle Pfade , i j, diese Lnge. Wir whlen zwei Indizes k, l mit i k < j, so dass a a k und nicht knotendisjunkt aber alle , k < < , knotendisjunkt zu k und sind. Die Existenz solcher Indizes ist gesichert, weil im Zweifel fr k = 1 die Bedingung fr u u trivial wird. Die Wahl von k und stellt sicher, dass ein Mk+1 -augmentierender Pfad ist. Sei v V (k ) V (l ). Die zu v inzidente Kante aus Mk+1 ist in und in k enthalten, weil sonst nicht Mk+1 -augmentierend sein kann. Also ist k = . Nach Lemma 5.73 folgt der Widerspruch | | |k | + |k | > |k |. Im letzten Beweis haben wir bereits verwendet, dass knotendisjunkte M-augmentierende Pfade gleichzeitig zu M addiert werden knnen, ohne dass diese sich gegenseitig beieinuso sen. Wir knnen also gefahrlos |M| um mehr als 1 in jedem Schleifendurchlauf vergrern. o o

66

5.8 Matchings in bipartiten Graphen

Algorithmus 5.75 (Hopcroft-Karp-Algorithmus). Input: Bipartiter Graph G = (V, E) Output: grtes Matching M o 1: 2: 3: 4: 5: 6: 7: M := ; konstruiere GM ; Berechne eine maximale Menge 1 , . . . , k knotendisjunkter krzester Wege u in GM zwischen zwei freien Knoten; if (k 1) { M := M 1 2 . . . k ; goto 2; }

Bemerkung. Um jeden Schleifendurchlauf ezient durchfhren zu knnen, fgen wir GM u o u zwei Knoten s und t und alle Kanten (s, v), (w, t) mit freien v V1 bzw. freien w V2 hinzu. Ausgehend von s wird eine Breitensuche durchgefhrt, und alle Kanten, die nicht u auf einem krzesten Weg nach t liegen, werden entfernt. Oenbar sind dann alle krzesten u u M-augmentierenden Pfade in diesem Graphen enthalten. Um sicher zu stellen, dass wir knotendisjunkte M-augmentierende Pfade erhalten, entfernen wir alle Kanten und Knoten eines bereits bestimmten krzesten Weges. Dies garantiert einen Aufwand von der Ordnung u |E| fr Zeile 3 von Algorithmus 5.75. u Satz 5.76. Der Algorithmus von Hopcraft und Karp berechnet ein grtes Matching f r o u einen bipartiten Graphen mit Aufwand O( |V | |E|). Beweis. Die Korrektheit haben wir schon in Satz 5.69 behandelt. Wir zeigen, dass O( |V |) Schleifendurchlufe ntig sind. Dann ergibt sich die Komplexittsabschtzung aus der letzten a o a a Bemerkung. Betrachte nochmals den Graphen G aus dem Beweis zu Satz 5.69. G entsteht aus M und M , wobei M unser aktuelles Matching und M ein grtes Matching bezeichnen. Seien o Ci := (Vi , Ei ) die Zusammenhangskomponenten von G , die wir als einfache Wege oder Zyklen identiziert hatten. Wir hatten auch gesehen, dass i := |Ei M | |Ei M| {1, 0, 1}. Ci ist genau dann M-augmentierend, wenn i = 1. Weil aber i = |M | |M|,

muss es mindestens |M ||M| knotendisjunkte M-augmentierende Pfade geben. Diese Pfade enthalten zusammen hchstens |M| Kanten aus M. Daher muss ein M-augmentierender o Weg existieren, der hchstens := |M |M | | Kanten aus M enthlt. Weil M- und M o a ||M Kanten alternieren, ist die Lnge dieses Pfades durch 2 + 1 nach oben beschrnkt. Wir a a unterscheiden nun zwei Phasen des Hopcroft-Karp-Algorithmus. In der ersten Phase gelte

67

5 Graphen |M| |M | |M | . Dann ist |M | |M | |M | +1 = 2 |M | 1. |M | +1 | |M

2 + 1 2

Fr eine Abschtzung der Anzahl der Schritte ist eine obere Schranke fr die Lnge krzester u a u a u M-augmentierender Pfade ausreichend, weil nach Lemma 5.74 die Lnge der Pfade bei jedem a |) Schleifendurchlufen die erste Phase beendet. In Schritt wchst. Daher ist nach O( |M a a | von der Kardinalitt eines grten der zweiten Phase ist |M| nur noch um hchstens |M o a o Matchings entfernt. Weil jeder Schleifendurchlauf |M| um mindestens 1 erhht, kann auch o die zweite Phase nicht mehr als O( |M |) Schleifendurchlufe bentigen. Wegen |M | n a o 2 folgt die Behauptung. Bemerkung. Wir haben uns beim Matching-Problem auf bipartite Graphen konzentriert. Will man die Inhalte dieses Abschnitts auf allgemeine Graphen anwenden, so stellt man fest, dass sowohl Satz 5.69 als auch Lemma 5.74 auch weiterhin gelten. Ein Problem tritt ausschlielich bei der ezienten Implementierung der Zeile 3 von Algorithmus 5.75 auf. Der Algorithmus von Micali und Vazirani verallgemeinert den Hopcroft-Karp-Algorithmus auf allgemeine Graphen und besitzt die gleiche asymptotischen Komplexitt. a

|M | |M | |M | |M | =2 1 + 1 2 |M |

68

6 Lineare Gleichungssysteme
Im Folgenden bezeichne Kmn , K {R, C}, den Raum der m n-Matrizen a11 . . . a1n . . , a K. . A= . ij . . am1 . . . amn

Dabei verwenden wir die komponentenweise Addition und Multiplikation mit Skalaren. Fr u k = 1 ergibt sich der Raum der Vektoren Km .

Beispiel 6.1. Eine Matrix A Kmn heit Diagonalmatrix, falls aij = 0 fr i = j. Die u nn Matrix I K mit 1, i = j, Iij = 0, sonst, wird als Identitt oder Einheitsmatrix bezeichnet. Die Vektoren ei Kn mit a (ei )j = heien kanonische Einheitsvektoren. Zwischen Matrizen kann ein Produkt : Kmp Kpn Kmn durch
p

1, i = j, 0, sonst,

(A B)ij =

ai bi ,
=1

i = 1, . . . , m, j = 1, . . . , n,

fr A Kmp , B Kpn deniert werden. Es gilt Assoziativitt (A B) C = A (B C). u a Den Multiplikationspunkt lassen wir auch weg. Die Matrix AT Knm mit den Eintrgen (AT )ij = aji wird als die zu A Kmn transa H ponierte Matrix bezeichnet. A mit (AH )ij = aji wird die zu A adjungierte Matrix genannt. Gilt AT = A bzw. AH = A, so heit A symmetrisch bzw. hermitesch. Ferner gelten die Rechenregeln (AB)T = B T AT , (AB)H = B H AH , (A + B)T = AT + B T , (A + B)H = AH + B H fr K sowie (AT )T = A = (AH )H . u Lineare algebraische Gleichungssysteme Ax = b (6.1)

mit gegebener Systemmatrix A Kmn und rechter Seite b Km tauchen sehr oft als o Endproblem in vielen Anwendungen auf. (6.1) ist oenbar genau dann lsbar, wenn b Im A. Sei x Kn eine Lsung, dann ist die Lsungsmenge von (6.1) gegeben durch x + ker A := o o {x + y, y ker A}. Insbesondere ist, falls rank A = dim Im A = n, x die eindeutige Lsung o nn nn von (6.1). Quadratische Matrizen A K heien invertierbar, falls B K existiert mit AB = BA = I. Daher wird B = A1 als Inverse von A bezeichnet. A ist genau dann invertierbar, wenn rank A = n ist.

69

6 Lineare Gleichungssysteme Eine weitere Charakterisierung der Lsbarkeit von (6.1) ergibt sich aus dem folgendem o Lemma, in dem der Orthogonalraum X = {y Kn : xH y = 0 fr alle x X} u von X Kn verwendet wird. Man beachte, dass (X ) = X. Lemma 6.2. Sei A Kmn . Dann gilt (Im A) = ker AH . Beweis. Sei x ker AH , d.h. AH x = 0 und sei z Im A. Dann existiert y Kn mit z = Ay. Dann ist z H x = (Ay)H x = y H (AH x) = 0 und somit x (Im A) . Mit der Umkehrung des Arguments erhlt man die verbleibende Inklusion. a Theorem 6.3. Das Gleichungssystem (6.1) ist genau dann lsbar, falls bH y = 0 fr alle o u m H y K mit A y = 0. Beweis. Nach dem letzten Lemma gilt Im A = ((Im A) ) = (ker AH ) .

6.1 Vektor- und Matrixnormen

Denition 6.4. Eine Abbildung (i) x > 0 f r alle x Kn \ {0}, u (ii) x = || x f r alle x Kn , K, u (iii) x + y x + y f r alle x, y Kn . u : Kn R heit Vektornorm, falls (Positivitt) a (Homogenitt) a (Dreiecksungleichung)

Bemerkung. Der Ausdruck d(x, y) := x y ist ein Ma fr den Abstand von x und y. u Auerdem gilt die umgekehrte Dreiecksungleichung | x y | xy , Beispiel 6.5. die aus x = x y + y x y + y und y = y x + x x y + x folgt.

(a) Betragssummennorm
n

x und euklidische Norm x

2

:=
i=1

|xi |
n

:=

xH x

=
i=1

|xi |2

70

6.1 Vektor- und Matrixnormen sind Spezialflle der p-Normen a

n 1/p

x auf Kn . (b) Der punktweise Grenzwert von

=
i=1

|xi |

p N,

fr p ergibt die Maximumnorm u

:= max |xi |.
i=1,...,n p

Die folgende Abbildung zeigt die Einheitssphre Sp := {x R2 : x a

1

= 1} der p-Norm.

(c) Ist eine Vektornorm, so ist auch x Vektornorm.

:= T x mit T Knn , rank A = n, eine

Satz 6.6. Alle Normen auf Kn sind quivalent, d.h. f r jeweils zwei Normen und a u n auf K existieren positive Konstanten c, C > 0 mit c x x C x f r alle x Kn . u Beweis. Es gengt, die Behauptung fr u u Dazu seien x, y Kn . Wegen xy =

=
n

und eine beliebige Norm zu zeigen.

i=1

(xi yi )ei

folgt aus der umgekehrten Dreiecksungleichung

n n

| x y | xy

i=1

|xi yi | ei x y

ei .
i=1

Folglich ist : (Kn , ) R eine Lipschitz-stetige1 Funktion mit Lipschitz-Konstante n n L = a : x = 1} i=1 ei . Diese nimmt auf der kompakten Einheitssphre {x K
1

Eine Funktion f : (Kn , ) R heit Lipschitz-stetig, falls L > 0 existiert mit |f (x) f (y)| L x y .

71

6 Lineare Gleichungssysteme sowohl ihr Maximum C wie auch ihr Minimum c an. Wegen der Positivitt der Norm ist a C c > 0. Also gilt fr alle z Kn u c z C c z z

z C z

Beispiel 6.7. Es sei p q. Dann gilt fr x Kn u x Speziell gilt x

q

x
1

n p q x q. n x
2

n x

x Kn .

Denition 6.8. Eine Abbildung

: Kmn R heit Matrixnorm, falls

(i) A > 0 f r alle A Kmn \ {0}, u (ii) A = || A f r alle A Kmn , K, u (iii) A + B A + B f r alle A, B Kmn , u (iv) AB A B f r alle A Kmp , B Kpn . u Beispiel 6.9. (a) Auf Kmn deniere analog zur Maximumnorm die Abbildung A
M

(Submultiplikativitt) a

:= max |aij |.
i=1,...,m j=1,...,n

Diese ist eine Vektornorm auf Kmn aber keine Matrixnorm. Denn fr u A=B= gilt AB = und somit AB
M

1 1 1 1 2 2 2 2

=2>1= A

(b) Spaltensummenorm
m

A Zeilensummenorm A

:= max

j=1,...,n

i=1 n

|aij |,

:= max

i=1,...,m

j=1

|aij |

72

6.1 Vektor- und Matrixnormen und Frobeniusnorm

m n

1/2

:=
i=1 j=1

|aij |2
1

sind Matrixnormen auf Kmn . Man beachte AH

= A

Wir zeigen die Submultiplikativitt der Frobeniusnorm. Sei dazu A Kmp , B Kpn . a Dann gilt unter Verwendung der Cauchy-Schwarzschen-Ungleichung
n n 1/2 n 1/2

i=1

xi yi

i=1

|xi |

2 i=1

|yi |

x, y Kn ,

dass
m n m n p 2

AB

2 F

=
i=1 j=1 m n

|(AB)ij | =
p

ai bj
i=1 j=1 p =1

(6.2a) (6.2b) (6.2c)

i=1 j=1 A 2 F

=1 B 2. F

|ai |

2 =1

|bj |2

Denition 6.10. Sind Vektornormen und auf Km bzw. Kn gegeben, so deniert man die zugeordnete Norm (oder induzierte Norm) auf Kmn durch |||A||| := sup
x=0

Ax = max Ax . x =1 x und , falls

Eine Abbildung f : Kmn R heit vertrglich mit a Ax f (A) x Beispiel 6.11. (i)

f r alle A Kmn , x Kn . u

M aus Beispiel 6.9 (a) ist auf Kmn den Vektornormen bzw. Kn zugeordnet. Es gilt nmlich a
n n

und

auf Km

Ax

= max |
i=1,...,m

j=1

aij xj | max
n

i=1,...,m

j=1

|aij | |xj |
1

i=1,...,m |aij | max

j=1,...,n

j=1

|xj | = A

fr alle x Kn . u

Sei (i0 , j0 ) so gewhlt, dass |ai0 j0 | = A M . Dann wird das Maximum fr x := ej0 a u angenommen Aej0 = max |aij0 | = |ai0 j0 | = A M ej0 1 .
i=1,...,m .

Hieraus folgt A

= max Ax
x
1 =1

73

6 Lineare Gleichungssysteme (ii) Die Frobeniusnorm ist mit der euklidischen Vektornorm vertrglich. Dies folgt aus der a Submultiplikativitt (6.2) fr den Fall B = x Kn . Sie ist aber keine einer Vektornorm a u zugeordnete Norm, weil fr einer Vektornorm zugeordnete Norm gilt |||I||| = 1 mit u nn I K . Fr die Frobeniusnorm gilt aber I F = n. u Lemma 6.12. Sei ||| ||| die = zugeordnete Norm. Dann ist ||| ||| eine mit vertrgliche Matrixnorm. Ist f : Kmn R eine mit vertrgliche Abbildung, so gilt a a mn |||A||| f (A) f r alle A K u . Beweis. Die Aussage gilt oenbar fr 0 = B Kpn . Daher sei A Kmp und B = 0. Dann u gilt |||AB||| = sup ABx ABx ABx Bx = sup = sup x x Bx x x=0 Bx=0 Bx=0 Bx Ay Bx ABx sup sup sup sup Bx x y x Bx=0 y=0 Bx=0 Bx=0 Ay Bx sup sup = |||A||| |||B|||. y x y=0 x=0

Die ubrigen Eigenschaften einer Matrixnorm sind oensichtlich. Die Vertrglichkeit mit erhlt man aus a a |||A||| = sup
x=0

Ax Ax x x

for all x Kn \ {0}.

Hieraus folgt Ax |||Ax||| x fr alle x Kn , weil die letzte Abschtzung fr x = 0 u a u trivialerweise gilt. Der letzte Teil der Aussage ergibt sich aus |||A||| = sup
x=0

Ax f (A) x sup = f (A). x x x=0

Bemerkung. Die Annahme = im letzten Lemma ist wichtig, weil M zwar durch und 1 induziert (siehe Beispiel 6.11) aber nach Beispiel 6.9 (a) keine Matrixnorm ist. In den Ubungsaufgaben werden wir sehen, dass die Spaltensummen- und die Zeilensummennorm jeweils den Vektornormen 1 bzw. zugeordnet sind. Da die Frobeniusnorm keine zugeordnete Norm ist und somit der euklidischen Norm nicht zugeordnet sein kann, stellt sich die Frage, welche Matrixnorm der euklidischen Vektornorm zugeordnet ist. Im Folgenden bentigen wir fr die Charakterisierung der der euklidischen Vektornorm zugeo u ordneten Matrixnorm 2 einige Aussagen aus der linearen Algebra. Sei Pn die Menge der Permutationen (siehe Denition 4.1) uber {1, . . . , n}. Ist Pn , so wird ein Paar (i, j) {1, . . . , n} {1, . . . , n} mit i < j und (i) > (j) als Fehlstand bezeichnet. Man deniert das Signum einer Permutation Pn durch sign = +1, falls die Anzahl der Fehlstnde von gerade ist, a 1, falls die Anzahl der Fehlstnde von ungerade ist. a

74

6.1 Vektor- und Matrixnormen Die Determinante einer Matrix A Knn ist deniert durch
n

det A =
Pn

(sign )
i=1

ai(i) .

Eine regulre Matrix erfllt det A = 0. Im anderen Fall wird A als singulr bezeichnet. a u a A Knn ist genau dann regulr, wenn A invertierbar ist. a Aus der Denition der Determinanten folgt, dass det AT = det A und det AH = det A. Ferner kann gezeigt werden, dass fr A, B Knn gilt det AB = det A det B und det A1 = u (det A)1 , falls A regulr ist. a Wir denieren (vgl. auch Kapitel 3) A () := det(A I) als charakteristisches Polynom. Jede Zahl C heit Eigenwert von A Knn , falls A () = 0. Eine n n-Matrix besitzt n Eigenwerte. Bemerkung. Weil fr einen Eigenwert gilt det(A I) = 0, ist ker A I nicht trivial. u Daher existiert ein sog. Eigenvektor 0 = x Knn mit Ax = x. Wegen Ak x = Ak1 x = . . . = k x ist insbesondere k Eigenwert von Ak . Im folgenden Lemma verwenden wir auch die Spur einer Matrix A Knn deniert durch
n

trace A =
i=1

aii .

Man rechnet leicht nach, dass A

2 F

= trace AH A gilt.

Lemma 6.13. Seien 1 , . . . , n die Eigenwerte von A Knn . Dann gilt

n n

trace A =
i=1

und

det A =
i=1

i .

Beweis. Es gilt A (0) = det A. Daher stimmt der absolute Term der Polynoms A mit det A uberein. Man sieht ferner leicht, dass der Koezient vor n1 mit der Spur trace A ubereinstimmt. Auf der anderen Seite gilt A () = ( 1 ) . . . ( n ). Durch Koezientenvergleich ergibt sich die Behauptung. Denition 6.14. Eine Matrix A Knn heit normal, falls AH A = AAH , unitr (im Fall K = R orthogonal), falls AAH = AH A = I, a

75

6 Lineare Gleichungssysteme

hnlich zu B Knn , falls T Knn regulr existiert, so dass A = T BT 1 , a a diagonalisierbar, falls A hnlich zu einer Diagonalmatrix ist, a unitr diagonalisierbar, falls A diagonalisierbar mit unitrer Matrix T ist. a a Bemerkung. (a) Ist A unitr, so ist A insbesondere invertierbar, denn B := AH erfllt AB = BA = I. a u (b) Seien A und B hnlich. Dann gilt A = T BT 1. Unter Verwendung der Rechenregeln der a Determinanten folgt A () = det(A I) = det(T BT 1 I) = det(T (B I)T 1 ) = (det T )(det T 1 ) det(B I) = B (). Daher besitzen A und B dieselben Eigenwerte. (c) Hermitesche Matrizen sind normal. Wir geben ohne Beweis an: Satz 6.15. A Knn ist genau dann normal, falls A unitr diagonalisierbar ist. a Denition 6.16. Eine Matrixnorm auf Kmn heit unitr invariant, falls a A = P AQ f r alle A Kmn und alle unitren Matrizen P Kmm , Q Knn . u a Satz 6.17. Die Frobeniusnorm und die der euklidischen Vektornorm zugeordnete Matrixnorm 2 sind unitr invariant. a Beweis. Seien P Kmn und Q Knn unitr. Wegen P x 2 = xH P H P x = xH x = x a 2 folgt P AQ 2 = max P AQx 2 = max AQx 2 .
x
2 =1

2 2

2 =1

Weil Q unitr ist, gilt nach der Bemerkung zu Denition 6.14, dass rank Q = n und somit a Im Q = Kn . Daher knnen wir das Maximum fr y = Qx bilden. Dann folgt aus y 2 = x 2 o u P AQ
2

= max Ay
y
2 =1

= A 2.

Fr die unitre Invarianz der Frobeniusnorm verwenden wir A 2 = trace AH A. Daher u a F gilt P AQ 2 = trace QH AH P H P AQ = trace QH AH AQ. F Nach Lemma 6.13 stimmt trace A mit der Summe der Eigenwerte von A uberein. Weil QH AH AQ hnlich zu AH A ist, besitzen entsprechend der Bemerkung nach Denition 6.14 a QH AH AQ und AH A dieselben Eigenwerte. Daher folgt trace QH AH AQ = trace AH A.

76

6.1 Vektor- und Matrixnormen Der folgende Satz erklrt die Bezeichnung Spektralnorm fr die der euklidischen Veka u tornorm zugeordnete Matrixnorm 2 . Satz 6.18. F r A Knn gilt u A = 1/2 (AH A),

wobei (A) := max{|| : ist Eigenwert von A} den Spektralradius von A bezeichnet. Ist A Knn normal, so gilt A 2 = (A). Beweis. Fr A Kmn gilt u A
2 2

= max Ax
x
2 =1

2 2

= max xH AH Ax.
x
2 =1

Die Matrix AH A ist oenbar hermitesch und damit normal. Nach Satz 6.15 ist sie unitr a nn nn diagonalisierbar, d.h. es existiert Q K unitr und K a diagonal mit AH A = QQH . Daher folgt mit y = QH x
n

x A Ax = x QQ x = y y =
i=1

ii |yi |2 .

Die Diagonalmatrix enthlt nach der Bemerkung zu Denition 6.14 die Eigenwerte von a H A A. Also gilt
n

Ax

2 2

(A A)

i=1

|yi |2 = (AH A) y

2 2

= (AH A) x 2 . 2
2

Sei i0 N ein Index mit |i0 i0 | = (AH A). Dann gilt mit x = Qei0 , x Positivitt der Vektornorm a Ax Insgesamt folgt also A
2 2 2 2

= 1, und der

= |eH QH QQH Qei0 | = |eH ei0 | = |i0 i0 | = (AH A). i0 i0 = max Ax

x
2 =1

2 2

= (AH A).

Ist A normal, so folgt A = QQH und mit der unitren Invarianz der Spektralnorm und a der Ahnlichkeit von A und A
2

= QQH

= 1/2 (2 ) = () = (A).

Lemma 6.19. F r jede zugeordnete Norm ||| ||| auf Knn gilt (A) |||A||| f r alle A Knn . u u Beweis. Sei Eigenwert von A und x ein zugehriger Eigenvektor mit x = 1. Dann gilt o || = || x = x = Ax |||A||| x = |||A|||. Das folgende Lemma wird fr sptere Zwecke bentigt. Da der Beweis sehr technisch ist, u a o wird er ausgelassen.

77

6 Lineare Gleichungssysteme

Lemma 6.20. Zu jedem > 0 und jedem A Knn existiert eine zugeordnete Norm ||| ||| , sodass |||A||| (A) + . Satz 6.21. Sei A Kmn . Dann gilt (i) A
2 2

AH

= A
2

(ii) ist A normal, so gilt A

|||A||| f r jede zugeordnete Norm ||| |||, u

(iii) besitzt A nur Eintrge pro Zeile und pro Spalte, die nicht verschwinden, so gilt a A 2 A M, (iv) A
M

A 2.

Beweis. Zu (ii): folgt aus Satz 6.18 und Lemma 6.19. Zu (i): Aus (ii) folgt, weil AH A normal ist, dass A
2 2

= (AH A) AH A

AH

= A

Zu (iii): Folgt aus (i), weil A 1 = maxj=1,...,n Zu (iv): Sei (i0 , j0 ) so gewhlt, dass |ai0 j0 | = A a nenten xj = ai0 j , j = 1, . . . , n. Dann gilt
m n 2 n

A M. n M . Sei x K der Vektor mit den Kompo2 n 2

m i=1 |aij |

Ax

2 2

=
i=1 j=1

aij xj
n 2 j=1

ai0 j xj
j=1

=
j=1

|ai0 j |

|ai0 j | Wir erhalten A

2

|ai0 j |2

= A

2 M

x 2. 2

= sup
y=0

Ay 2 Ax 2 A y 2 x 2

M.

Satz 6.6 lt sich natrlich auf Matrixnormen ubertragen. Wir geben einige Aquivalenza u relationen an. Beispiel 6.22. Sei A Kmn . Dann gilt A
2

1 A A n 1 A 1 A n 1 A A n

F 2

m A 2, m A , m A 1,
.

78

6.2 Strungstheorie f r lineare Gleichungssysteme o u

6.2 Strungstheorie fr lineare Gleichungssysteme o u

Wir wollen die Strungsanflligkeit der Lsung x des linearen Gleichungssystems Ax = b bei o a o invertierbarer Matrix A Knn und b Kn untersuchen. Dazu nehmen wir zunchst an, dass a b um b gestrt ist und A exakt gegeben ist. Sei x die Lsung des linearen Gleichungssystems o o mit gestrter rechter Seite, d.h. A = b + b. Dann gilt fr x := x x o x u x = x x = A1 (b + b) A1 b = A1 b Fr ein vertrgliches Vektor-/Matrixnormpaar erhlt man u a a x A1 b A1 b b = = A1 x x x b Denition 6.23. Sei Ausdruck b b Ax A1 x A b . b

eine Matrixnorm und A Knn invertierbar. Dann wird der cond

(A) := A bezeichnet.

A1

als Kondition der Matrix A bzgl.

Bemerkung. Verallgemeinert man Denition 2.9 auf vektorwertige Probleme f : Kn Kn , so sieht man, dass die Kondition einer Matrix mit dem Maximum der Konditionszahlen maxxKn (f, x) der Abbildung f (b) := A1 b im Fall zugeordneter Normen ubereinstimmt. Im Folgenden wollen wir untersuchen, wie die Lsung x von Strungen der Koezienteno o matrix A abhngt. Das folgende Strungslemma bentigt die sog. Neumannsche Reihe a o o Ak einer Matrix A Knn . Man rechnet leicht nach, dass k=0
m

(I A) Ist I A invertierbar, so folgt

k=0

Ak = I Am+1

fr alle m N u

k=0

Ak = (I A)1 (I Am+1 )

(6.3)

Wir zeigen im folgenden Satz, dass unter der Vorraussetzung (A) < 1, I A invertierbar ist und Am+1 0 fr m . u Lemma 6.24. Sei eine Matrixnorm. Dann gilt f r A Knn u
1 k

(i) (A) = limk Ak

A ,

(ii) (Ak )kN ist genau dann eine Nullfolge, wenn (A) < 1.

Beweis.

79

6 Lineare Gleichungssysteme (i) Sei > 0. Nach Lemma 6.20 existiert zu A eine zugeordnete Norm (A) + . Auerdem folgt aus der Aquivalenz der Normen c A

mit A

A C A
1 k

fr alle A Knn . u C c
1 k 1 k

u Dann gilt nach Lemma 6.19 und der Bemerkung vor Lemma 6.13 fr alle k N (A) = (A ) A = C c
1 k

1 k

1 c k
1 k

1 k

C c

1 k

( A k) k

C c

((A) + ).

Im Grenzwert k erhlt man a

(A) lim Ak
k

1 k

(A) + .

Weil beliebig ist, folgt die Behauptung. (ii) Ist (A) < 1, so folgt mit (i) aus dem Wurzelkriterium
k=0

k=0

Ak < .

Daher konvergiert Ak und (Ak )kN muss eine Nullfolge sein. Ist (A) 1, so sei k=0 x Kn , x = 1, ein Eigenvektor zum betragsmaximalen Eigenwert . Dann gilt Daher kann (Ak )kN keine Nullfolge sein. Ak Ak x = ||k x = k (A) 1.

Satz 6.25. Genau f r (A) < 1 konvergiert die Neumannsche Reihe. In diesem Fall ist u
k=0

Ak = (I A)1 .
1 1 A

Ist A < 1, so gilt sogar (I A)1

Beweis. Im Fall (A) < 1 ist 1 kein Eigenwert von A. Weil I A die Eigenwerte 1 i (A), wobei i (A) den i-ten Eigenwert von A bezeichnet, ist 0 kein Eigenwert von I A. Da nach Lemma 6.13 die Determinante das Produkt der Eigenwerte ist, folgt det(I A) = 0, was zur Invertierbarkeit von I A quivalent ist. Wegen Lemma 6.24 kann in (6.3) der Grenzwert a m gebildet werden, und man erhlt die gewnschte Darstellung. a u Im Fall (A) 1 ist (Ak )kN nach Lemma 6.24 keine Nullfolge. Daher kann die Neumannsche Reihe nicht konvergieren. Ist A < 1, so folgt nach Lemma 6.24, dass (A) A < 1. Daher konvergiert die Neumannsche Reihe, und es gilt (I A)
1

k=0

k=0

1 . 1 A

80

6.2 Strungstheorie f r lineare Gleichungssysteme o u

Lemma 6.26 (Strungslemma). Sei A Knn invertierbar und eine Matrixnorm. o Ist A Knn mit A1 A < 1, so ist auch A + A invertierbar und (A + A)1 A1 . 1 A1 A

Beweis. Wegen A1 A A1 es gilt

A < 1 existiert nach Satz 6.25 (I + A1 A)1 und 1 1 1 A1 A 1 A1 A .

(1 + A1 A)1

Weil A + A = A(I + A1 A), ist auch A + A invertierbar. Die Behauptung folgt wegen (A + A)1 = (I + A1 A)1 A1 aus (A + A)1 (I + A1 A)1 A1 . Satz 6.27. Sei ein vertrgliches Vektor-/Matrixnormpaar gegeben. Seien A Knn a invertierbar und A Knn mit A1 A < 1. Mit vorgegebenen b Kn \ {0}, b Kn seien x und x deniert durch Ax = b, Dann gilt f r x := x x u cond (A) x x 1 cond (A) A A b A + A b . (A + A) = b + b. x (6.4)

Beweis. Wegen A1

A < 1 ist A + A nach dem Strungslemma 6.26 invertierbar und o (A + A)1 A1 . 1 A1 A

Aus (6.4) erhlt man a (A + A)(x + x) = b + b Ax + A x + (A + A)x = b + b (A + A)x = b A x x = (A + A)1 (b A x). Hieraus folgt x A1 ( A x + b ) 1 A1 A cond (A) b A x + } = A A A 1 cond (A)
A

Division durch x und Verwendung von b = Ax A

x liefert die Behauptung.

81

6 Lineare Gleichungssysteme Beispiel 6.28. (a) Sei A= Dann ist A1 = und somit A Sei

3 1.001 , 6 1.997

b=

1.999 . 4.003

= 7.997, A1

= 600. Hieraus erhlt man cond a = 2.002 b 4.003 b = 0.003 0

1 1.997 1.001 3 0.015 6

(A) = 4798.2.

3 1 A= , 6 1.997 A = 0 0.001 , 0 0

Dann ist

und somit A = 0.001, b = 0.003. Man uberprft leicht, dass x = [1, 1]T die u x b. Lsung von Ax = b ist. Auerdem ist x = [0.229, 4/3]T die Lsung von A = o o Der relative Fehler betrgt a x 7 = = 2.3. x 3 (b) Die Hilbert-Matrix Hn = mit n wchst. a
1 i+j1 i,j=1,...,n

weist eine Kondition auf, die exponentiell

6.3 Gausche Elimination

Sei A Knn eine untere Dreiecksmatrix, d.h. aij = 0 fr i < j mit nicht verschwindenden u Diagonaleintrgen. Die Lsung x von Ax = b erhlt man wegen a o a
i i1

bi =
j=1

aij xj = aii xi +
j=1 i1

aij xj , i = 1, . . . , n.

1 xi = aii

bi

aij xj
j=1

Man beachte, dass auf der rechten Seite der letzten Gleichung ausschlielich bekannte Komponenten des Lsungsvektors auftreten. o Algorithmus 6.29. Input: untere Dreiecksmatrix A, rechte Seite b Output: Lsung von Ax = b o

(i =0; i < n; ++ i ) {
x [i ] = b[ i ]; ( j =0; j <i ; ++ j) x[ i] = x [i ] - A[ i+ n* j ]* x [ j ]; x [i ] = x[ i ]/ A [( n +1)* i ]; }

82

6.3 Gausche Elimination Der folgende Algorithmus liefert dieselbe Lsung, ist aber deutlich ezienter, weil er wegen o der besseren Datenlokalitt beim Zugri auf die Matrix A den Cache des Prozessors nutzen a kann.

Algorithmus 6.30. Input: untere Dreiecksmatrix A, rechte Seite b Output: Lsung von Ax = b o

(j =0; j < n; ++ j) {
x [j ] = b[ j ]/ A [ j *( n +1)]; ( i= j +1; i < n; ++ i ) b[ i] = b [i ] - A[ i +n *j ]* x[ j ]; }

u Ist nun A Knn eine obere Dreiecksmatrix, d.h. gilt aij = 0 fr i > j, mit nicht verschwindenden Diagonaleintrgen, so erhlt man a a
n n

bi =
j=i

aij xj = aii xi +
j=i+1

aij xj

und somit 1 xi = aii bi

aij xj
j=i+1

i = 1, . . . , n.

Hier muss der Vektor x beginnend beim grten Index, d.h. rckwrts, bestimmt werden. o u a

Algorithmus 6.31. Input: obere Dreiecksmatrix A, rechte Seite b Output: Lsung von Ax = b o

(j =n ; j >0;) {
--j; x[ j] = b [j ]/ A[ j *( n +1)]; (i =j ; i >0;) { --i; b[ i] = b [i ] - A [i +n *j ]* x[ j ]; } }

Mit obigen Algorithmen kann Ax = b mit Aufwand O(n2 ) gelst werden, falls A eine o untere oder eine obere Dreiecksmatrix ist. Ublicherweise ist A aber eine allgemeine Matrix. Wenn wir A in das Produkt einer unteren und einer oberen Dreiecksmatrix L bzw. R zerlegen knnen, d.h. A = LR, so kann die Lsung von Ax = b in zwei Schritten geschehen: o o Ax = b LRx = b Ly = b, Rx = y.

83

6 Lineare Gleichungssysteme Das Lsen des Gleichungssystems Ly = b nach y kann mit Algorithmus 6.30 geschehen und o wird als Vorwrtssubstitution bezeichnet. Die anschlieende Lsung von Rx = y (siehe a o a Algorithmus 6.31) wird als Ruckwrtssubstitution bezeichnet. Im Folgenden wird gezeigt, wie man eine LR-Zerlegung einer regulren Matrix A Knn a konstruiert.

Denition 6.32. Jede Matrix der Form Lk = I (k) eT Knn mit k (k) = 0, . . . , 0, (k) , . . . , (k) n k+1 heit Gau-Matrix. Die Gau-Matrix Lk besitzt die Eintrge a 1 .. . 1 . Lk = (k) k+1 1 . .. . . . (k) n 1
T

Kn

Daher gilt det Lk = 1 und Lk ist invertierbar. Ihre Inverse ist L1 = I + (k) eT , weil mit k k eT (i) = 0, i k, folgt k L1 Lk = (I + (k) eT )(I (k) eT ) = I (k) eT + (k) eT (k) eT (k) eT = I. k k k k k k k Insbesondere ist L1 ebenfalls eine Gau-Matrix. Die Multiplikation von Lk mit x Kn k ergibt x1 . . . xk Lk x = xk+1 (k) xk . k+1 . . . xn n xk
(k)

Dabei bleiben die ersten k Komponenten von x unverndert. Gilt xk = 0, so kann durch die a Wahl xi (k) (6.5) i := , i = k + 1, . . . , n, xk

erreicht werden, dass Lk x in den letzten n k Komponenten verschwindet. Durch sukzessive Anwendung von Gau-Matrizen wird nun eine gegebene regulre Matrix a nn AK auf obere Dreiecksform gebracht. Die Bedingung xk = 0 in (6.5) werden wir durch Vertauschung der Zeilen von A garantieren. Dazu multiplizieren wir A mit Permutationsmatrizen.

84

6.3 Gausche Elimination

Denition 6.33. Eine Matrix P Rnn heit Permutationsmatrix, falls eine Permutation Pn existiert, sodass 1, (i) = j, Pij = 0, sonst.

Permutationsmatrizen sind wegen

n

(P T P )ij =
=1

(ei )() (ej )() =

1, i = j, 0, sonst,

In den unteren n1 Eintrgen der zweiten Spalte von L1 A(0) bendet sich wegen | det L1 A(0) | = a | det A| wiederum ein nicht verschwindender Eintrag. Die Permutation, die die entsprechende Zeile mit der zweiten Zeile von L1 A(0) vertauscht, bezeichnen wir mit P2 . Man ndet wieder eine Gau-Matrix L2 , indem wir fr x in (6.5) die zweite Spalte von A(1) := P2 L1 A(0) u einsetzen. Wir erhalten (0) (0) a11 a1n 0 a(1) a(1) 22 2n (1) 0 . L2 A = 0 . . . . . . . . . . . . 0 0 Durch sukzessive Multiplikation mit Permutationsmatrizen P1 , . . . , Pn1 und Gau-Matrizen L1 , . . . , Ln1 erhlt man auf diese Weise die gewnschte obere Dreiecksstruktur a u a11 0 0 R := Ln1 Pn1 Ln2 Pn2 . . . L1 P1 A = . . . . . . 0
(0)

und analog P P T = I orthogonal. Die Multiplikation einer Permutationsmatrix an eine Matrix A von links entspricht der Vertauschung der Zeilen und die Multiplikation von rechts bedeutet die Vertauschung der Spalten von A. Sei A Knn regulr. Die erste Spalte von A enthlt einen nicht verschwindenden Eintrag, a a weil A sonst singulr wre. Mit P1 bezeichnen wir die Permutationsmatrix, die die zugehrige a a o Zeile in A mit der ersten Zeile vertauscht. Whlt man fr x in (6.5) die erste Spalte von a u (0) A := P1 A, so lt sich eine Matrix L1 denieren, sodass die erste Zeile von L1 A(0) und A(0) a ubereinstimmen und die letzten n 1 Eintrge der ersten Spalte von L1 A(0) verschwinden: a (0) (0) a11 a1n 0 (0) L1 A = . . . . . . . . . . 0

(1) a22 (2) 0 a33 . . . 0 . . . . . . 0 0

(0) a1n (1) a2n (2) a3n . . .. . . . . .. .. . . . . (n1) 0 ann

85

6 Lineare Gleichungssysteme Die letzte Gleichung kann wegen der Orthogonalitt der Matrizen P1 , . . . , Pn1 auch in der a Form Ln1 . . . L1 Pn1 . . . P1 A = R dargestellt werden. Dabei denieren wir
T T Lk = Pn1 . . . Pk+1 Lk Pk+1 . . . Pn1

T T = Pn1 . . . Pk+1 (I (k) eT )Pk+1 . . . Pn1 k T T = I Pn1 . . . Pk+1(k) eT Pk+1 . . . Pn1 k = I (k) eT k

mit (k) := Pn1 . . . Pk+1 (k) . Dabei haben wir die Identitt ek = Pn1 . . . Pk+1 ek benutzt. a (k) verschwinden, ist Lk ebenfalls eine Gau-Matrix. Mit Weil die ersten k Eintrge von a P := Pn1 . . . P1 ist daher
n1

P A = L1 . . . L1 R = 1 n1

I+
k=1

(k) eT k

R.

Die letzte Gleichung folgt aus eT (i) = 0, i k. Die Matrix k

n1

L := I +
k=1

(k) eT k

liefert P A = LR. Aus der Struktur der Vektoren (k) erkennt man, dass L eine untere Dreiecksmatrix mit Eintrgen 1 auf der Diagonalen ist. Wegen | det A| = | det R| ist ferner a R regulr und die Diagonaleintrge von R sind nicht Null. a a Denition 6.34. Eine spaltenpivotisierte LR-Zerlegung einer Matrix A Knn ist eine Faktorisierung P A = LR mit einer Permutationsmatrix P Rnn , einer unteren Dreiecksmatrix L mit 1 auf der Diagonalen und einer oberen Dreiecksmatrix R mit nicht verschwindenden Diagonaleintrgen. a

Algorithmus 6.35 (Spaltenpivotisierte Gausche Elimination). Input: Regulre Matrix A Knn a Output: Spaltenpivotisierte LR-Zerlegung von A 1: 2: 3: 4: 5: 6: 7: 8: 9: R := A; L := I; P := I; for (k = 1; k < n; ++k) { whle i k, sodass rik = 0; a vertausche die i-te mit der k-ten Zeile in P, R und L; for (j = k + 1; j n; ++j) { rjk jk = rkk ; rj,k:n = rj,k:n jk rk,k:n; } }

86

6.3 Gausche Elimination Bemerkung. (a) Wir verwenden die MATLAB-Notation ai,k: fr den Vektor [aik , . . . , ai ] bestehend aus u den Eintrgen von Position k bis der i-ten Zeile von A. a (b) Die im k-ten Schritt berechneten Eintrgen der Gau-Matrix Lk nnen in den frei gewora o denen Positionen der k-ten Spalte von A unterhalb der Diagonalen gespeichert werden. Auf diese Weise steht nach Abschluss des Verfahrens in der unteren Hlfte von A die a untere Hlfte von L (ohne Diagonale), und in der oberen Hlfte von A (einschlielich der a a Diagonalen) bendet sich die obere Dreiecksmatrix R. Die Permutation muss in einem Feld der Lnge n gesondert gespeichert werden. a (c) Durch das obige Gausche Eliminationsverfahren wird es mglich, mit o
n1 n n1 n1

k=1 j=k+1

2(n k + 1) = 2

k=1

(n k)(n k + 1)

k =nk

2 k 2 + k = n3 + O(n2 ) 3 k=1

Operationen eine spaltenpivotisierte LR-Zerlegung von A zu berechnen. Beispiel 6.36. 1 A= 3 2 Wir erhalten folgende LR-Zerlegung 3 1 1 0 0 1 3 1 1 0 0 1 3 1 8 4 = 3 1 0 0 1 1 = 3 1 0 0 1 1 . 2 4 2 0 1 0 4 2 2 4 1 0 0 2
T

Die Lsung von Ax = b := 2 3 6 o

ergibt sich aus Ly = b 2 y= 3 2 3 2 . x= 1

und Rx = y

1 0 0 y1 2 3 1 0 y2 = 3 2 4 1 y3 6

Der folgende Satz fasst unsere Konstruktion der LR-Zerlegung zusammen. Satz 6.37. Ist A Knn regulr, so ist Algorithmus 6.35 durchf hrbar und produziert eine a u spaltenpivotisierte LR-Zerlegung P A = LR. In Beispiel 6.36 haben wir keine Permutation bentigt. Der folgende Satz klrt, unter o a welchen Umstnden dies der Fall ist. a Satz 6.38. Algorithmus 6.35 ist genau dann ohne Pivotisierung durchf hrbar, wenn die u ersten n 1 Hauptabschnittsmatrizen Ak := a1:k,1:k , k = 1, . . . , n 1, von A regulr sind. a Die Zerlegung A = LR ist dann eindeutig.

1 3 1 x1 2 0 1 1 x2 = 3 0 0 2 x3 2

87

6 Lineare Gleichungssysteme Beweis. Wir zeigen per Induktion, dass im k-ten Schritt akk = 0 genau dann gilt, wenn det Ak = 0. Fr k = 1 ist die Aussage trivial. Wir nehmen an, dass die Aussage fr k 1 u u gilt. Wegen (0) (1) (2) (k2) (k1) det Ak = a11 a22 a33 . . . ak1k1 akk (6.6)
det Ak1 =0 (k1)

ist akk

(k1)

= 0 genau dann, wenn det Ak = 0. In diesem Fall bestimmt die Darstellung

i1

aij =
k=1

ik rkj + rij

i, j = 1, . . . , n,

die Koezienten auf eindeutige Weise. 0 1 ist regulr, aber die Hauptabschnittsmatrix A1 = a11 ist sina 1 0 gulr. Hier bentigt man die Pivotisierung. a o Beispiel 6.39. A = Bemerkung. Wegen (6.6) kann die Determinante einer Matrix aus einer LR-Zerlegung mit O(n3 ) Operationen berechnet werden.

6.4 Stabilitt der Gauschen Elimination a

Im Folgenden wollen wir den Einuss von Rundungsfehlern auf das Produkt LR betrachten. Die Genauigkeit der Faktoren L und R wird im Allgemeinen schlechter sein, was fr die u Numerik von untergeordnetem Interesse ist, weil L und R immer als Produkt auftreten. Wir bentigen den Betrag |A| Rmn einer Matrix A Kmn deniert durch o |A|ij = |aij |, i = 1, . . . , m, j = 1, . . . , n.

Abschtzungen der Form |A| |B| sind eintrgeweise zu verstehen. a a Satz 6.40. Sei A Knn . Wenn die LR-Zerlegung in endlicher Arithmetik durchf hrbar u ist, dann gilt f r die berechneten Matrizen L und R, dass u LR = A + A mit |A| 2(n 1)F (|A| + |L| |R|) + O(2 ). F Beweis. Der Beweis erfolgt induktiv uber n. Fr n = 1 ist die Aussage klar. Angenommen, u sie gilt fr n 1. Wir verwenden die Zerlegung u A= wT v B mit K \ {0}.

Im Algorithmus wird im ersten Schritt z = rd v und S = rd(B z w T )

88

6.4 Stabilitt der Gauschen Elimination a bestimmt. Nach (2.1) und der Bemerkung nach Satz refsen:1.22 gilt z= und v + f, |f | F |v| , || (6.7)

S = B z w T + F,

|F | 2F (|B| + || |w|T ) + O(2 ). z F

Nach Induktionsannahme gilt fr die in den nchsten n 1 Schritten berechneten Faktoren u a 1 , R1 L L1 R1 = S + E, |E| 2(n 2)F (|S| + |L1 | |R1|) + O(2 ). (6.8) F Daher erhlt man a 1 0 LR = z L1 wT 0 0 1 = A + f E + F =: A + A. 0 R

Es bleibt, |A| abzuschtzen. Zunchst erhlt man aus (6.7), dass a a a |S| (1 + 2F )(|B| + || |w|T ) + O(2 ). z F Ferner haben wir mit (6.8) |E + F | 2(n 1)F (|B| + || |w|T + |L1 | |R1 |) + O(2 ). z F Aus |f | F |v| folgt |A| 2(n 1)F 1 0 || |w|T + 1| |v| |B| || |L z = 2(n 1)F (|A| + |L| |R|) + O(2 ).
F

|| |w|T 0 |R1 |

+ O(2 ) F

Bemerkung. (a) Satz 6.40 gilt natrlich auch fr P A, wobei P eine Permutationsmatrix bezeichnet, mit u u der die LR-Zerlegung durchfhrbar ist. u u a a (b) Man beachte, dass Satz 6.40 nicht die Rckwrtsstabilitt der Gauschen Elimination bedeutet. Dies gilt nur, falls |L| |R| |A|. Beispiel 6.41. Wendet man Algorithmus 6.35 auf die Matrix A= an, so erhlt man a 1 0 1 = 1/ 1 1 1 1 . 0 1 1/ 1 , 1 1 > 0,

Dabei sei > 0 so klein gewhlt, dass bei endlicher Arithmetik 1 1/ = 1/ gilt. Anstelle a von R wrde mit u 1 R= 0 1/ 89

6 Lineare Gleichungssysteme gerechnet. Das bedeutet LR =

T

1 1 0
T

und bei rechter Seite b = 1 0 wrde man statt der exakten Lsung x = 1 1 die u o T Lsung x = 0 1 erhalten. Fehler der Grenordnung knnen somit Fehler der Ordnung o o o 1 hervorrufen. Eine solche Instabilitt tritt immer dann auf, wenn im Vergleich zu den a Eintrgen von A groe Eintrge in L oder R vorkommen. Vertauscht man die Zeilen von A, a a so erhlt man a 1 1 1 0 1 1 = . 1 1 0 1 Hier tritt die Instabilitt nicht auf. a Daher sollte im k-ten Schritt der Gauschen Elimimation das betragsmig grte Element a o der letzten n k + 1 Eintrge der k-ten Spalte pivotisiert werden. Diese Strategie wird a als partielle Pivotisierung bezeichnet. Sie hat zur Folge, dass |ij | 1, i, j = 1, . . . , n. Die Wahl des betragsmig grten Eintrags im Schnitt der unteren n k + 1 Zeilen und a o hinteren n k + 1 Spalten bezeichnet man als vollstndige Pivotisierung. In diesem Fall a werden auch Spaltenvertauschungen ntig. Man erhlt daher eine Zerlegung P AQ = LR mit o a Permuationsmatrizen P, Q. Diese Strategie ist aber aufwndig und der Zusatzaufwand hilft a im Hinblick auf die Stabilitt in der Regel nur wenig. a Weil im Fall der partiellen Pivotisierung |ij | 1, i, j = 1, . . . , n, gilt, hngt die Rckwrtsa u a stabilitt nach Satz 6.40 nur von der Gre von |R| ab. Wir denieren daher den Wachsa o tumsfaktor R . n := A Aus Satz 6.40 erhalten wir das folgende Resultat.

Satz 6.42. Sei A Knn regulr. Das Gausche Eliminationsverfahren mit Spaltenpivotia sierung berechne Matrizen L, R und P . Dann ist LR = P A + A f r ein A Knn mit A u

cn F A

Bemerkung. Der Wachstumsfaktor n entscheidet uber die Rckwrtsstabilitt der Gauu a a u a u schen Elimination. Diese ist nach Denition 2.11 rckwrtsstabil, falls n fr alle Matrizen A Knn gleichmig nach oben beschrnkt ist. a a Lemma 6.43. Sei P A = LR eine spaltenpivotisierte LR-Zerlegung von A Knn . Dann gilt n 2n1 . Beweis. Wegen R = L1 P A haben wir n := R A

L1

= L1

90

6.5 Die Cholesky-Zerlegung Weil L1 = Ln1 . . . L1 (siehe die Darstellung vor Denition 6.34) und Li L1

2, folgt

Ln1

. . . L1

2n1 .

Beispiel 6.44. Wir betrachten die Wilkinson-Matrix 1 1 . . . . 1 . . nn Wn = . . .. . R . .. . . . . . 1 1 1

Man uberzeugt sich leicht davon, dass Spaltenpivotisierung P = I liefert und dass 1 1 1 . ... 2 1 . . Wn = . . . . .. ... . . . . 1 n1 2 1 1 1

Zusammenfassend ist die Gausche Elimination rckwrtsstabil. Die Konstanten hngen u a a jedoch exponentiell von der Dimension ab, sodass die Stabilittsabschtzung in der Praxis a a unbrauchbar ist. Die tatschliche Gre von n und damit die Stabilitt kann aber im Verlauf a o a des Algorithmus auf einfache Weise inspiziert werden. Die Gausche Elimination kann auch in Blockform angewendet werden. Wir betrachten die Blockpartitionierung von A Knn A= A11 A12 , A21 A22 A11 Kpp , A22 K(np)(np) . (6.9)

Ist A11 regulr, so kann A wie folgt zerlegt werden: a A= I A21 A1 11 0 I A11 A12 0 S (6.10)

mit dem Schur-Komplement S := A22 A21 A1 A12 von A bzgl. A11 . Mann beachte, dass 11 (6.10) eine Block-LR-Zerlegung ist.

6.5 Die Cholesky-Zerlegung

In diesem Abschnitt werden wir eine Spezialform der LR-Zerlegung fr positiv denite Mau trizen vorstellen. Denition 6.45. Eine hermitesche Matrix A Knn heit positiv semidenit, falls xH Ax 0 f r alle x Kn . Gilt xH Ax > 0 f r alle x Kn \ {0}, so heit A positiv denit. u u Bemerkung. Ist A positiv denit, so ist A insbesondere regulr. Wegen xH Ax > 0 fr alle a u x = 0 ist nmlich ker A = {0}. Daher sind die Spalten von A sind linear unabhngig, und es a a folgt det A = 0. Ferner sind die Diagnaleintrge positiv: aii = eH Aei > 0, i = 1, . . . , n. a i

91

6 Lineare Gleichungssysteme Das folgende Lemma wird von zentraler Bedeutung fr die Durchfhrbarkeit der Choleskyu u Zerlegung sein. Lemma 6.46. Sei A Knn positiv denit. Dann ist das Schur-Komplement S wohldeniert und sowohl A11 als auch S sind positiv denit. Beweis. Sei x = [x1 , x2 ]T mit x1 Kp partitioniert wie in (6.9). Aus A11 A12 A11 A12 = A21 A22 A21 A22
H

AH AH 11 21 AH AH 12 22

sieht man A11 = AH , A22 = AH und A12 = AH . Also ist A11 hermitesch, und es gilt 11 22 21 0 x1 0
H

A11 A12 A21 A22

x1 x = 1 0 0

A11 x1 = xH A11 x1 . 1 A21 x1

Gleichheit gilt genau fr x1 = 0. Daher ist A11 positiv denit und nach der letzten Bemerkung u invertierbar. Dies beweist die Wohldeniertheit von S, und wir haben S H = AH AH AH AH = A22 A21 A1 A12 = S. 22 12 11 21 11 Betrachte nun x = [x1 , x2 ]T mit x1 = A1 A12 x2 . Dann gilt 11 x 0 x Ax = 1 x2
H H

x A11 x1 + A12 x2 = 1 x2 A21 x1 + A22 x2 0 = xH Sx2 . 2 Sx2

0 A21 A1 A12 x2 11 + A22 x2

x1 x2

Weil Gleichheit nur im Fall x2 = 0 gilt, ist S ebenfalls positiv denit. Denition 6.47. Eine Zerlegung A = LLH mit unterer Dreiecksmatrix L, die positive Diagonaleintrge besitzt, heit Cholesky-Zerlegung von A. a Die Cholesky-Zerlegung ist also eine spezielle LR-Zerlegung. Im folgenden Satz sehen wir, dass eine Cholesky-Zerlegung einer positiv deniten Matrix ohne Pivotisierung berechnet werden kann. Satz 6.48 (Existenz der Cholesky-Zerlegung). Genau dann existiert die CholeskyZerlegung von A, wenn A positiv denit ist. Beweis. Sei A = LLH . Dann gilt AH = (LH )H LH = LLH = A. Wegen xH Ax = xH LLH x = LH x
2 2

und weil LH regulr ist, gilt xH Ax > 0 fr alle x Kn \ {0}. a u

92

6.5 Die Cholesky-Zerlegung Sei umgekehrt A positiv denit. Wir zeigen per Induktion, dass die Cholesky-Zerlegung existiert. Sei n = 1. Wegen a11 > 0 gilt mit 11 = a11 , dass [a11 ] = [11 ][11 ] = LLH . Angenommen, die Aussage gilt fr n 1. Betrachte u A= a11 A12 A21 A22

mit A21 = AH und das Schur-Komplement S = A22 a1 A21 A12 von A bzgl. a11 . Nach 12 11 Lemma 6.46 sind a11 > 0 und S positiv denit. Also ist 11 := a11 > 0 und nach Indukti onsannahme besitzt S eine Cholesky-Zerlegung S = LLH . Deniere L= Dann gilt LLH = 11 0 1 A L 11 21 11 0
1 A 11 12 H

11 0 . A L 11 21
1

a11 A21

A12 1 A A + a11 21 12

a11 A12 LH = A21 A22 = A. L

Eine Berechnungsformel fr die Eintrge von L ergibt sich aus u a

j j1

aij =
k=1

ik jk =
k=1

ik jk + ij jj ,

i j,

zu
j1

jj =

ajj

k=1

|jk |2 , ik jk , i = j + 1, . . . , n,

(6.11a)

1 ij = jj

j1

aij

(6.11b)

k=1

fr j = 1, . . . , n. Man beachte, dass auf der rechten Seite der Formeln nur Eintrge der u a Spalten 1, . . . , j 1 von L erscheinen. Die Durchfhrbarkeit ist durch das Existenzresultat u Satz 6.48 gesichert. Insbesondere folgt aus (6.11) die Eindeutigkeit der Cholesky-Zerlegung. Algorithmus 6.49. Input: positiv denite Matrix A Knn Output: untere Dreiecksmatrix L mit A = LLH

(j =0; j < n; ++ j) {
l [j *( n +1)] = a [j *( n +1)]; ( k =0; k +1 < j; ++ k ) l[ j *( n +1)] = l[ j *( n +1)] - abs (l [j +k *n ])* abs ( l[ j+ k* n ]); l [j *( n +1)] = sqrt ( l[ j *( n +1)]); ( i= j +1; i < n; ++ i ) { l[ i+ j* n] = a[ i+ j* n ]; (k =0; k +1 < j ; ++ k)

93

6 Lineare Gleichungssysteme

l [i +j *n ] = l[ i +j *n ]- l[ i+ k* n ])* conj (l [j + k* n ]); l[ i+ j* n] = l [i +j * n] / l [j *( n +1)]; } }

Zur Berechnung von ij , i j, sind 2(j 1) Multiplikationen und Additionen ntig. Somit o werden insgesamt
n n

j=1 i=j+1

2(j 1) = 2

1 (n j)(j 1) = n3 + O(n2 ) 3 j=1

Multiplikationen und Additionen sowie n Wurzeln bentigt. Der Aufwand ist deshalb etwa o halb so gro wir der der LR-Zerlegung. Beispiel 6.50. Die Cholesky-Zerlegung von 1 3 2 10 10 A= 3 2 10 21 ergibt sich wegen 11 = 21 = 31 zu 1 = 1, 22 = 32 = a22 2 = 1, 21 33 = a33 2 2 = 1 31 32

3 = 3, 1 2 = 2, = 1

a32 31 21 = 4, 22

Die Stabilittsprobleme der LR-Zerlegung nden man nicht bei der Cholesky-Zerlegung. a Diese ist immer stabil. Die fr die Instabilitt der LR-Zerlegung verantwortlichen groen u a Eintrge in den Faktoren L und R treten wegen des folgenden Lemmas bei der Choleskya Zerlegung nicht auf. Lemma 6.51. Sei A = LLH die Cholesky-Zerlegung von A Knn . Dann gilt |ij | aii f r i j. u

1 1 3 2 1 4 . 1 A= 3 2 4 1 1

Beweis. Vergleicht man die i-ten Diagonaleintrge von A und von LLH , so erhlt man a a
i

0 < aii =
j=1

|ij |2 .

Hieraus folgt |ij |2 aii , j i.

94

6.6 Die QR-Zerlegung nach Householder Wir erhalten als Folgerung von Satz 6.37 und Lemma 6.51 den folgenden Satz, der die Rckwrtsstabilitt der Cholesky-Zerlegung belegt. u a a Satz 6.52. Sei A Knn positiv denit. Die berechnete untere Dreiecksmatrix L erf llt u LLH = A + A f r eine Matrix A Knn mit A u

cF A

6.6 Die QR-Zerlegung nach Householder

Wir haben in den letzten Abschnitten gesehen, dass lineare Gleichungssysteme mit Hilfe einer LR-Zerlegung gelst werden knnen. Anstelle der LR-Zerlegung kann aber auch eine o o QR-Zerlegung verwendet werden. Denition 6.53. Sei A Kmn . Eine Zerlegung der Form A = QR mit unitrem Q Kmm a mn und einer oberen Dreiecksmatrix R K heit QR-Zerlegung von A. Ist Ax = b zu lsen, so kann bei bekannter Faktorisierung A = QR die Lsung x aus dem o o System Ax = b QRx = b Rx = QH b (6.12) mittels Rckwrtssubstitution berechnet werden. Diese Vorgehensweise ist numerisch stabil u a im Vergleich zur Verwendung der LR-Zerlegung, weil unitre Matrizen die Lnge erhalten a a und somit Rundungsfehler nicht ubermig verstrkt werden. a a Denition 6.54. Jede Matrix Q Knn der Form Q=I uuH uH u

mit einem u Kn \{0} und einem K\{0}, ||2 = 2 Re , wird als Householder-Matrix bezeichnet.

Lemma 6.55. Sei Q eine Householder-Matrix. Dann gilt (i) Q ist unitr. Im Fall K = R ist Q symmetrisch. a (ii) Ist K = R, so gilt x Qx span {u} und 1 (x + Qx) (span {u}) . Also spiegelt Q 2 den Vektor x = 0 an der Hyperebene senkrecht zu u. (iii) Sei x Kn \ {0}. F r u = x e1 , || = x 2 , und = 1 + u Beweis.
xH u uH x

gilt Qx = e1 .

95

6 Lineare Gleichungssysteme (i) Dass Q unitr ist, sieht man wegen a Q Q=

H

uuH I H u u

uuH uH u

= I

uuH u(uH u)uH uuH H + ||2 =I uH u u u (uH u)2 uT x =2 T u u u

(ii) Ist K = R, so gilt 2 = 2 = 2. Dann gilt

u(uT x) x Qx = x x 2 T u u

und uT (x + Qx) = uT x + uT x 2 (iii) Wegen uH x = (x e1 )H x = x folgt

2 2

(uT u)uT x = 0. uT u
2 2

uH u = (x e1 )H (x e1 ) = x Qx = x

x1 und
2 2

x1 x1 + ||2 = 2( x

Re (x1 ))

uH x uH x xH u Re uH x u=x H u H u= x2 H u uH u u u u u u u Re ( x 2 x1 ) 2 u = x u = e1 . = x x 2 Re (x1 ) 2

Bemerkung. Um Auslschungseekte zu vermeiden, sollte in (iii) das entgegengesetzte o Vorzeichen der ersten Komponente x1 von x bekommen. Es sollte also x1 = x 2 |x1 | gewhlt werden. a Beispiel 6.56. Der Punkt x = [3, 4]T R2 soll durch Anwendung einer Householder-Matrix auf die x-Achse transformiert werden. Nach Lemma 6.55 (iii) wird dies durch Q=I erreicht. Tatschlich gilt a 1 8 3 Qx = 4 40 4 8 4
T

1 8 40 4

8 4

5 8 3 3 . = = 0 4 4 4 5 4 3 x

1 (x 2

+ Qx) 2 1

Qx 5 4 3 2 1 1 1 2 3 4 5

96

6.6 Die QR-Zerlegung nach Householder Sei nun A Kmn , m n, mit linear unabhngigen Spalten. Wie in Lemma 6.55 (iii) a kann die erste Spalte von A durch Multiplikation mit einer Householder-Matrix Q1 Kmm von links in ein Vielfaches des ersten kanonischen Einheitsvektors e1 transformiert werden: A(1) := Q1 A, A(1) e1 = e1 . Sei nun angenommen, dass die Matrix A durch k 1 sukzessive Anwendungen von einer Householder-Matrix in folgende partielle obere Dreiecksform gebracht wurde: (1) (1) a11 a1n . .. . . . (k1) (k1) (k1) A = Qk1 . . . Q1 A = akk akn . . . . . 0 . . (k1) (k1) amk amn

Im k-ten Schritt soll A(k1) so transformiert werden, dass Qk A(k1) bis zur k-ten Spalte eine obere Dreiecksmatrix ist. Um die ersten k 1 Zeilen und Spalten unverndert zu lassen, a whlen wir a Ik1 0 Qk = , 0 Qk wobei Qk K(mk+1)(mk+1) eine Householder-Matrix ist, die den Vektor (k1) akk . . =0 . amk
(k1)

auf ein Vielfaches von e1 Kmk+1 transformiert. Weil Qk unitr ist, trit dies auch auf Qk a zu. Nach n Schritten erhlt man also die obere Dreiecksmatrix a (1) (1) a11 a1n . .. . . (n) . =: R. A = Qn . . . Q1 A = (n) ann Bemerkung. u Setzen wir also Q = QH . . . QH , so erhalten wir die gewnschte Zerlegung A = QR. n 1

2 (a) Fr die QR-Zerlegung von A Kmn mittels Householder-Spiegelung werden 2mn2 3 n3 u arithmetische Operationen bentigt. o

(b) Die Eintrge von Q sollten niemals berechnet werden. Ezienter ist es, die Vektoren a u zu speichern. Diese knnen in gerade frei gewordene Spalten der Matrix A abgelegt o werden. (c) Auch fr die Berechnung der Matrix-Vektor-Multiplikation wie bei der rechten Seite in u a (6.12) kann auf die explizite Darstellung der Matrix verzichtet werden. Es gilt nmlich Qx = x uH x u, uH u

97

6 Lineare Gleichungssysteme d.h. Qx entsteht als Linearkombination der Vektoren x und u, was mit O(m) Operationen im Vergleich zu O(m n) Operationen bei eintrgeweiser Multiplikation durchgefhrt a u werden kann.

98

Index
b-Komplement, 4 b-Komplement-Darstellung, 4 Adjazenzliste, 47 Adjazenzmatrix, 46 Algorithmus Bubblesort, 26 Heapsort, 38 Mergesort, 28 Quicksort, 30 rckwrtsstabiler, 15 u a von Dijkstra, 54 von Edmonds und Karp, 61 von Ford und Fulkerson, 59 von Hopcroft und Karp, 67 von Kruskal, 51 von Miller, 22 von Moore, Bellman und Ford, 56 vorwrtsstabiler, 15 a Alphabet, 1 Anfangsknoten, 39 Ausgangsknotengrad, 41 Auslschung, 12 o Basis, 1 Baum, 44 Betrag, 88 Biasdarstellung, 10 Bipartition, 64 Blatt, 44 Breitensuche, 49 Cauchy-Schwarzsche-Ungleichung, 73 Cholesky-Zerlegung, 92 CRS-Format, 48 darstellbarer Bereich, 4 Determinante, 75 Diagonalmatrix, 69 dominante Lsung, 21 o Dreitermrekursion, 17 homogene, 17 inhomogene, 17 symmetrische, 17 Eigenvektor, 18, 75 Eigenwert, 18, 75 Eingangsknotengrad, 41 Einheitsmatrix, 18, 69 Endknoten, 39 Exponent, 7 Festkommadarstellung, 6 Fibonacci-Zahlen, 17 Fluss, 57 maximaler, 57 Wert eines, 57 Gau-Matrix, 84 Gleitkommazahl denormalisierte, 10 normalisierte, 7 Graph azyklischer, 44 bipartiter, 64 gerichteter, 39 gewichteter, 51 ungerichteter, 39 zugrundeliegender ungerichteter, 39 zusammenhngender, 42 a Heap -eigenschaft, 34 binrer, 34 a hidden bit, 8 Hilbert-Matrix, 82 Horner-Schema, 3 Householder-Matrix, 95 Identitt, 69 a kanonischer Einheitsvektor, 69

99

Index Kante gegenluge, 59 a inzidente, 39 Kekul-Anordnung, 35 e Knoten Abstand zweier, 50 adjazente, 40 benachbarte, 40 erreichbarer, 40 freier, 64 Grad eines, 41 innerer, 44 isolierter, 41 Nachbar eines, 40 Komplement-Darstellung, 4 Kondition, 79 konservative Gewichte, 55 LR-Zerlegung spaltenpivotisierte, 86 Mantisse, 7 Maschinengenauigkeit, 8 Maschinenzahlen, 1 Matching, 63 grtes, 63 o maximales, 63 perfektes, 64 Matrix ahnliche, 76 adjungierte, 69 diagonalisierbare, 76 hermitesch, 69 Inverse einer, 69 invertierbare, 69 normale, 75 regulre, 75 a singulre, 75 a symmetrische, 69 transponierte, 69 unitr diagonalisierbare, 76 a unitre, 75 a Matrixnorm, 72 unitar invariante, 76 Minimallsung, 21 o Nachfolger, 40 Netzwerk, 57 Neumannsche Reihe, 79 Norm p-, 71 Betragssummen-, 70 euklidische, 70 Frobenius-, 73 Maximum-, 71 Spaltensummen-, 72 Zeilensummen-, 72 zugeordnete, 73 obere Dreiecksmatrix, 83 Orthogonalraum, 70 Partition, 52 Permutation, 25 Fehlstand einer, 74 Signum einer, 74 Permutationsmatrix, 85 Pfad, 40 M-alternierender, 64 M-augmentierender, 64 Pivotisierung partielle, 90 vollstndige, 90 a Polynom charakteristisches, 18, 75 positiv denit, 91 positiv semidenit, 91 Problem gut konditioniertes, 15 Konditionszahl eines, 15 schlecht konditioniertes, 15 wohlgestelltes, 14 QR-Zerlegung, 95 Rckwrtsanalyse, 13 u a Rckwrtsrekursion, 17 u a Rckwrtssubstitution, 84 u a Rekursion, 28 Restgraph, 59 Restkapazitten, 59 a Rundung, 8 Rundungsfehler, 8 Schleife, 40 Schnitt, 58 Kapazitt eines, 58 a minimale Kapazitt, 58 a Schur-Komplement, 91

100

Index Signikant, 8 signikante Stellen, 8 Spektralnorm, 77 Spur, 75 Teilgraph, 51 aufspannender, 51 Gewicht eines, 51 Kosten eines, 51 Tiefensuche, 49 Tschebyche-Polynome, 17 umgekehrte Dreiecksungleichung, 70 untere Dreiecksmatrix, 82 Vektornorm, 70 vertrglich, 73 a Vorgnger, 40 a Vorwrtsanalyse, 13 a Vorwrtssubstitution, 84 a Wachstumsfaktor, 90 Weg, 40 augmentierender, 59 einfacher, 40 geschlossener, 40 krzester, 40 u Lnge eines, 40 a Wilkinson-Matrix, 91 Wurzelsatz von Vieta, 13 Zahlensystem, 1 Zusammenhangskomponente, 42 Zyklus einfacher, 43

101