3.5 Aufwandsabschätzung - WINFOR

3.5 Aufwandsabschätzung 

Bei der Auswahl eines Algorithmus für eine 

Lösung wird stets 

ein korrekter Algorithmus ausgewählt. Stehen 

mehrere korrekte Algorithmen zur Auswahl wird 

hieraus 

ein effizienter Algorithmus ausgewählt, d.h. ein 

Algorithmus der hinsichtlich der betrachteten 

Kapazitätsbeanspruchung einen Aufwand verursacht, 

der nicht durch einen anderen Algorithmus in allen 

Kategorien nicht übertroffen wird und in mindestens 

einer Kategorie unterboten wird 

Als Kategorien werden die Betriebsmittel 

Rechenzeit und 

Speicherplatz 

betrachtet 

Wirtschaftsinformatik und Operations Research 

473

Beachte 

Die Kategorien Speicherplatz und Rechenzeit sind 

konfliktär, d.h. unter Umständen gegenläufig 

Konkret bedeutet dies zum Beispiel, dass durch die Bereitstellung 

umfangreicher Datenstrukturen Rechenoperationen vermieden 

werden können und somit Rechenzeiten gesenkt werden können 

Andersherum, lässt sich auch der Speicherplatzbedarf durch 

Neuberechnungen reduzieren. Hierbei wächst dann der 

Zeitaufwand der Algorithmen entsprechend 

Hieraus ergibt sich eine mehrdimensionale Zielsetzung 

bei der Algorithmenentwicklung 

Ein Algorithmus heißt somit effizient für ein 

spezifiziertes Problem, falls es keinen anderen 

Algorithmus für dieses Problem gibt, der 

weniger Speicherbedarf bei höchstens gleichem Zeitaufwand oder 

weniger Zeitaufwand bei höchstens gleichem Speicherbedarf 

verursacht 


474

Größenordungen 

Aufwand wird in der Regel nur asymptotisch, d.h. 

in seiner Größenordnung erfasst 

Dabei werden Abschätzungen vorgenommen, die 

durch empirische Analysen zu spezifizieren sind 

Größenordnung wird durch eine mathematische 

Analyse ermittelt 

Konstanten werden anschließend durch Experimente 

genauer ausgewertet 

Mögliches Beispiel 

Ein Algorithmus hat die asymptotische Laufzeit c . n 4 

Anschließend ist die Konstante c näher durch 

Experimente zu untersuchen 


475

Abschätzungsarten 

Schlimmster Fall (worst case) 

Maximaler Aufwand der bei allen möglichen Eingaben auftreten 

kann 

D.h. es wird die ungünstigste Konstellation ermittelt und dann 

näher analysiert 

Häufigster Untersuchungsgegenstand 

Bester Fall (best case) 

Minimaler Aufwand der bei allen möglichen Eingaben auftreten 

kann 

D.h. es wird die günstigste Konstellation ermittelt und dann näher 

analysiert 

Von geringer Relevanz 

Mittlerer Fall (average case) 

Es wird über alle möglichen Eingaben der durchschnittliche 

Aufwand bestimmt 

Von höchster Relevanz 

Leider häufig schwer analysierbar (unendlich viele 

Eingabekonstellationen) 


476

3.5.1 Der exakte Aufwand 

Kann nur für einzelne Eingaben berechnet 

werden 

Ist von vielen Faktoren abhängig, die unabhängig 

vom gewählten Algorithmus sind und deshalb zu 

einer Verzerrung der Bewertung führen können. 

Dies sind z.B. 

Programmierstil 

Gewählte Programmiersprache 

Gewählter Übersetzer 

Gewählte Maschine 

Deshalb: Systematische Vereinheitlichung der 

Analyse durch Abstraktionen 


477

Von Neumann Rechnermodell 

Anstelle eines realen Rechners führt ein abstraktes 

Maschinenmodell unsere Algorithmen aus 

Dies ist die Random Access Machine (RAM) 

Modell des von Neumann Rechners (Programm ist ein 

Datum) 

Rechenzeit für Elementaroperationen und 

Speicherzugriffe sind durch eine vorgegebene Konstante 

beschränkt (Einheitskostenmaß) 

Eingabeumfang (Anzahl von Variablen, Parametern) wird 

durch n gemessen, wodurch sich der Aufwand in 

Abhängigkeit von n ergibt 

Die Aufwandsfunktionen werden jeweils auf die 

bestimmende Größenordnung vergröbert 


478

Eingesetzte Notationen 

Im Einzelnen sind wir an der Ermittlung der folgenden 

Größen interessiert: 

T min (n): Rechenzeit im besten Fall bei Eingabegröße n 

T max (n): Rechenzeit im schlechtesten Fall bei 

Eingabegröße n 

T avg (n): Rechenzeit im durchschnittlichen Fall bei 


S min (n): Speicherplatzbedarf im besten Fall bei 


S max (n): Speicherplatzbedarf im schlechtesten Fall bei 


S avg (n): Speicherplatzbedarf im durchschnittlichen Fall 

bei Eingabegröße n 


479

Beispiel – Sequentielle Suche 

Wir wollen nun den Aufwand der einfachen Suche 

analysieren 

Funktion Suche (A, a, l, r) 

if (l>r) 

then p:=0 

else 

end if 

p:=r /* Wir suchen von rechts nach links */ 

if (A p ≠a) 

end if 

– then p:=Suche(A, a, l, p-1) /* Abstieg in die Rekursion */ 


480

Best case 

Zunächst überlegen wir was die optimale, d.h. 

beste Problemkonstellation für unsere 

sequentielle Suche wäre, d.h. genau die 

Konstellation, bei der das Suchverfahren die 

wenigsten Rechenschritte ausführen muss 

Wir sehen unmittelbar 

T min (0)=2 (Vergleich l und r & Zuweisung) 

n>0: T min (n)=3 (Vergleich l und r, Zuweisung & 

Vergleich) 

Damit konstanter Aufwand im best case 

Damit wenden wir uns nun dem ungünstigsten 

Fall, dem worst case zu 


481

Worst case 

Offensichtlich entsteht der größte 

Rechenaufwand, d.h. der Algorithmus führt dann 

die meisten Schritte aus, wenn das gesuchte 

Element nicht in der Folge vorkommt 

In diesem Fall sind alle Folgeglieder 

nacheinander zu überprüfen 

Damit erhalten wir unmittelbar 

T max (0)=2 (Vergleich l und r & Zuweisung) 

n>0: T min (n)=4+T min (n-1) (Vergleich l und r, Zuweisung, 

Vergleich & Zuweisung) 

Damit erhalten wir insgesamt 

T min (n)=4 . n+2 


482

Worst case – Beweis der Rekursion 

Induktionsanfang (n=0) 

Induktionsschritt 

( ) 

T 0 = 4⋅ n+ 2= 2 

max 

Es gelte die Behauptung für n≥0 

( ) ( ) ( ) 

T n = 4+ T n− 1 = 4+ 4⋅ n− 1 + 2 

max max 

= 4+ 4⋅n− 4+ 2= 4⋅ n+ 2 

Damit ist die Behauptung bewiesen 


483

Average case 

Hierfür müssen wir gewisse Annahmen 

hinsichtlich der Verteilung der betrachteten Folge 

machen 

So gehen wir davon aus, dass jedes Element der 

Folge mit gleicher Wahrscheinlichkeit (=(n+1) -1 ) 

gesucht wird 

Zudem unterstellen wir vereinfachend, dass mit 

gleicher Wahrscheinlichkeit (=(n+1) -1 ) ein 

Element gesucht wird, das nicht in der Folge 

vorhanden ist 


484

Wir definieren 

( ) 

T n,j 

Notation 

als Aufwand falls bei einer Folge von n Elementen der gesuchte Eintrag 

an der j-ten Stelle von hinten vorkommt 

j=0 bedeutet dabei, dass das Element nicht in der Folge vorkommt 

Mit Hilfe dieser Notation gilt offensichtlich 

Zur Berechnung des Aufwandes sind die einzelnen Elemente zu 

bestimmen 

Offensichtlich gilt T( n,0) = Tmax ( n) 

und 

j> 0:T n,j = T j− 1 + 

1 

( ) ( ) 

max 

Warum? 

Wenn es das j-te Element von hinten ist, dann entspricht dies dem worst 

case für j-1 Elemente ohne die letzten beiden Befehle und 

drei weitere Operationen 

Damit also insgesamt eine zusätzliche Operation 

( ) 

T n 


avg 

= 

n 

∑ 

j= 0 

( ) 

T n,j 

n+ 1 

485

Durchschnittlicher Aufwand 

Aufgrund dieser Berechnungen erhalten wir insgesamt 

avg 

( ) 

T n 

n n 

∑T( n,j) Tmax ( n) + ∑( 

1+ Tmax ( j−1) ) 

j= 0 j= 1 

= = 

n+ 1 n+ 1 

n n 

( ( ) ) ( ) 

∑ ∑ 

4⋅ n+ 2+ 1+ 4⋅ j− 1 + 2 4⋅ n+ 2+ 4⋅j−1 = 

j1 = 

n+ 1 

= 

j1 = 

n+ 1 

n n 

∑ ∑ 

4⋅ n+ 2− n+ 4⋅j 3⋅ n+ 2+ 4⋅ j 

j1 = j1 = 3n ⋅ + 2+ 2n ⋅ ⋅ n+ 1 

= = = 

n+ 1 n+ 1 n+ 1 

3⋅ ( n+ 1) + 2⋅n⋅ ( n+ 1) + 1 1 

= = 2⋅ n+ 3+ ≈2⋅ n+ 3 

n+ 1 n+ 1 


( ) 

486

Exakter Aufwand 

Häufig ist es nicht so einfach möglich den 

durchschnittlichen Aufwand oder den maximalen Aufwand 

zu bestimmen 

Dann sind wir schon mit einer Näherung zufrieden 

Diese Näherung sollte dann lediglich das asymptotische 

Verhalten des Rechenaufwandes wiedergeben 

Für den asymptotischen Aufwand ist lediglich der Term 

relevant, der mehr und mehr das Verhalten der Funktion 

für große Eingabewerte von n bestimmt 

In unserem Fall also für 

den worst case: 4 . n 

und im average case: 2 . n 

oder einfach allgemein n, d.h. linearer Aufwand 


487

3.5.2 Asymptotischer Aufwand – O Kalkül 

Das O-Kalkül gestattet es, komplizierte 

Aufwandsfunktionen durch ihre wesentlichen Anteile zu 

klassifizieren, die für große Werte des 

Aufwandsparameters n allein die Art des Wachstums der 

Aufwandsfunktion bestimmen 

t 

( ) 6 4 2 

n = 17⋅ 

n + 6⋅ 

n + 3⋅ 

n + 5 

Unterdrückung konstanter Anteile 

( n) 

t = 

⋅ 

6 4 2 

17⋅ n + 6⋅ 

n + 3 n 

Unterdrückung von Summanden kleinerer Ordnung 

( n) 

t = 17⋅ n 

Unterdrückung von konstanten Faktoren 

6 ( n) 

n 

t = 


6 

488

Asymptotischer Aufwand – O Kalkül 

Man sagt: 

Gesprochen: 

Und man meint: 

t 

( n) 

steigt 

stärker 

als 

( ) ( 6 

n O n ) 

t ∈ 

ab 

t 

die 

( ) ( 6 

n hat die Ordnung O n ) 

einer 

bestimmten 

Funktion 

n 

6 

Eingabegröße 


nicht 

489

Seien 

∃c 

t,g:IN 

Funktionen, 

> 0 : ∃n 

Definition des O-Kalküls 

0 

IR 

> 0 : ∀n 

( t,g:IR → IR ) 

→ + 

+ 

dann 

gilt 

> 

t 

( n) 

∈O( 

g( 

n) 

) 

n 

( n) 

≤ c ⋅ g( 

n) 

Asymptotisch wächst t nicht stärker als g 

Auch 

gilt 

0 

somit 

: t 

: 

limn→∞ 

positive 

t 

g 

wenn 

( n) 

( n) 

≤ 


reellwertige 

gilt 

c 

: 

490

Klasse 

O(1) 

O(log(n)) 

O(n) 

O(n . log(n)) 

O(n 2 ) 

O(n!) 

O(2 n ) 

Typische Aufwandsklassen 

Vertreter 

Polynomiell lösbare Probleme 

Minimum aus geordneter Folge 

Binäre Suche 

Sequentielle Suche 

Schnelles Sortieren 

Elementares Sortieren 

Exponentiell lösbare Probleme 

Rucksack Problem 

Travelling Salesman Problem 


491

Aufwandsanalyse rekursiver Algorithmen 

Rekursive Algorithmen der einfachen Form 

Typ 1: f(n): … f(n-1) … 

Typ 2: f(n): … f(n/c) … f(n/c) … 

führen zu folgenden allgemeinen 

Rekurrenzgleichungen für den Aufwand 

Typ 1: 

Typ 2: 

( ) 

t n 

⎧b 

für n=1 

= ⎨ 

⎩t( 

n− 1) + d⋅( n−1 

) für n>1 

⎧b 

für n=1 

⎪ ⎛n⎞ = ⎨ ⎜ ⎟ 

⎪ 

⎝c⎠ ⎪Anzahl 

der Aufrufe 

⎩ von Teilproblemen 

für n>1 

Nebenaufwand zur 

Verarbeitung 

der Teilergebnisse 

( ) a⋅ t + b⋅n t n 


492

Lösung der rekursiven Formel vom Typ 1 

Wir erhalten als Aufwand für den Typ 1 

n 

Typ 1: t n b d n 1 O n 

2 

( ) ( ) ( 2 

= + ⋅ ⋅ − ∈ ) 

Dies lässt sich sehr einfach zeigen 

1 

Induktionsanfang: t() 1 = b+ d⋅ ⋅( 1− 1) = b+ 0 = b⇒korrekt 

2 

n −1 

Induktionsschritt: t n t n 1 d n 1 b d n 1 1 d n 1 

2 

2 

n−1 n −3⋅ n+ 2+ 2⋅n−2 = b+ d⋅ ⋅( n− 2) + d⋅( n− 1) 

= b+ d⋅ 

2 2 

2 

n − n n⋅( n−1) 

n 

= b+ d⋅ = b+ d⋅ = b+ d⋅ ⋅( n−1) 

⇒korrekt 

2 2 2 

( ) = ( − ) + ⋅( − ) = + ⋅ ⋅( − − ) + ⋅( − ) 


493


Wir erhalten als Aufwand für den Typ 2 

Typ 2: 

( ) 

( ) 

( ) 

logc 

( a 

⎛ ) 

logc ( a) 

a ⎞ 

= 

( ) 

logc n 

⎛a⎞ t( n) = b⋅n⋅ ∑ ⎜ ⎟ 

i= 

0 ⎝c⎠ logc n 

⎛a⎞ ⇒ 1 .a< c: b⋅n⋅ ∑ ⎜ ⎟ ∈On 

i= 

0 ⎝c⎠ ( ) 

logc n 

⎛a⎞ ⇒ 2 .a= c: b⋅n⋅ ∑ ⎜ ⎟ ∈On⋅logn i= 

0 ⎝c⎠ i 

i 

i 

( ( ) ) 

c ⎛ ( ) ⎞ ⎛ ( ) 

logc ( a) 

⎞ 

⎜ ⎟ ⎜ log ( a) 

⎟ 

i log a 

logc n logc a 

⎛a⎞ ⎛a⎞ a 

⇒ 3 .a> c: b⋅n⋅ ∑ ⎜ ⎟ ∈On⋅ ⎜ ⎟ = O n ⋅ 

c 

i= 

0 ⎝c⎠ ⎜ ⎝c⎠ ⎟ 

⎝ ⎠ ⎝ c ⎠ 

= O⎜n ⋅ ⎟ 

⎝ a ⎠ 

( log ( ) ) c a 

O n 


494


Die allgemeine Formel lässt sich sehr einfach 

zeigen 

0 

⎛a⎞ ⎛a⎞ Induktionsanfang: t() 1 = b⋅1⋅ ∑⎜ 

⎟ = b⋅1⋅ ⎜ ⎟ = b⋅ 1 = b⇒korrekt 

i= 

0 ⎝ c⎠ ⎝c⎠ logc ( n) 

−1 

i 

⎛ ⎞ 

⎛n⎞ ⎛n⎞ Induktionsschritt: t( n) = a⋅ t⎜ ⎟+ b⋅ n = a⋅⎜b⋅⎜ ⎟⋅ ⎝c⎠ ⎜ 

⎝ ⎝c⎠ ∑ 

i= 

0 

⎛a⎞ ⎜ ⎟ ⎟+ 

b⋅n ⎝ c⎠ 

⎟ 

⎠ 

logc( n) i logc( n) 

i 

logc ( n) 

i 

⎛a⎞ ⎛ ⎛a⎞ ⎞ ⎛a⎞ = bn ⋅ ⋅ ∑ ⎜ ⎟ + bn ⋅ = bn ⋅ ⋅⎜ 

⎜ ⎟ + 1 = bn ⋅ ⋅ ⇒korrekt 

i= 1 ⎝c⎠ ⎜ ∑ ⎟ 

i= 

1 ⎝ c⎠ 

⎟ ∑ 

⎜ ⎟ 

⎝ ⎠ 

i= 

0 ⎝c⎠ Die hergeleiteten Formeln lassen sich auf viele 

Beispiele direkt anwenden 

i 


0 

495

3.5.3 Binäre Suche 

Im Folgenden betrachten wir die so genannte 

binäre Suche auf einer Folge 

Bisher haben wir lediglich sequentiell gesucht 

D.h., in Unkenntnis zusätzlicher Informationen 

über die einzelnen Folgeglieder sind wir die Folge 

von vorne nach hinten oder von hinten nach 

vorne durchgegangen 

Damit entsteht sowohl im schlechtesten wie auch 

im durchschnittlichen Fall ein linearer Aufwand, 

d.h., wir führen asymptotisch zur Folgenlänge 

viele Schritte aus 


496

Sortierte Folge 

Wenn wir aber – im Gegensatz dazu – eine 

sortierte Folge vorliegen haben, lassen sich 

durch jeden einzelnen Vergleich wichtige 

zusätzliche Informationen ableiten 

So ist sofort klar, dass bei einer ansteigend 

sortierten Folge für ein gesuchtes Element a f t

while l≤r do 

p:=(l+r) DIV 2 

if a≤A p 

then r:=p-1 

end if 

if a≥A p 

then l:=p+1 

end if 

end while 

if r≠l-2 

then p:=0 

end if 

Binäre Suche 

Man sieht: Wird a gefunden, gilt r=p-1 und l=p+1 


498

Falls n=0 

Aufwandsabschätzung 

Nun gilt l>r (Vergleich) 

Zweiter Vergleich (if r≠l-2) 

Zuweisung (p:=0) 

Gesamtaufwand: 3 Anweisungen 

Falls n>0 

Für eine Lösung des Problems der Größe n wird ein 

rekursiver Aufruf der Größe n/2 getätigt 

Daneben maximal 5 Befehle 

Zuweisung (p:=(l+r) DIV 2) 

2 Vergleiche 

2 Zuweisungen 


499

Damit ergibt sich 


A 

max 

( ) 

0 = 3 

⎛⎢n+ 1⎥ 

⎞ 

Amax ( n+ 1) = 5+ 

Amax 

⎜⎢2⎥⎟ ⎝⎣⎦⎠ Wirtschaftsinformatik und Operations Research 

500

n 

0 

1 

2 

3 

4 

5 

6 

7 

8 

Aufwandabschätzung 

floor(log 2 (n)) 

- 

0 

1 

1 

2 

2 

2 

2 

3 

A max (n) 

5+ A max (0)=8 

5+ A max (1)=13 

5+ A max (1)=13 

5+ A max (2)=18 

5+ A max (2)=18 

5+ A max (3)=18 

5+ Amax (3)=18 

5+ Amax (4)=23 


3 

501


Damit ergibt sich als Gesamtaufwand 

( ) ( ) 

( ) 

( ⎢ ) 2 ⎥ 

2( 

) 

Amax n = 5⋅ ⎣log n ⎦+ 

1 + 3∈O 

log n 

Damit haben wir eine signifikante Reduktion des 

Rechenaufwandes erreicht 

Beachte 

Das Prinzip „Teile und Herrsche“ (Englisch: „Divide and 

Conquer“) wurde bei der binären Suche angewendet 

Das heißt, das Gesamtproblem wurde in der Weise gelöst, dass 

es aufgeteilt (verkleinert) wurde und die Einzellösungen mit Hilfe 

einer gefundenen Gesetzmäßigkeit zur Gesamtlösung 

zusammengesetzt wurden 

Dieses wichtige Prinzip findet seine Anwendung für eine Reihe 

von Problemstellungen 


502

3.6 Ausgewählte Algorithmentechniken 

Dynamische Programmierung 

Erweiterung des „Divide and Conquer” in der Weise, dass das 

Gesamtproblem mit Hilfe einer gefunden rekursiven Gleichung in kleinere 

Probleme zerlegt wird und aus den Teillösungen die Lösung des 

Gesamtproblems erzeugt wird 

Dieses Prinzip wird innerhalb der Dynamischen Programmierung in der 

Weise vollständig durchgeführt, dass alle möglichen Teilprobleme des 

betrachteten Gesamtproblems gelöst werden 

Auf diese Weise werden rückwärts ausgehend von den elementaren 

Problemen alle größeren Probleme gelöst 

Branch & Bound 

Bei dieser Technik wird das Gesamtproblem ebenfalls schrittweise 

verkleinert 

Diesmal allerdings in der Weise, dass in jedem Verzweigungsschritt für 

ausgewählte Teile der Lösung alle möglichen Belegungen getestet 

werden (Branching) 

Hierdurch verkleinert sich das Problem und es werden untere und obere 

Schranken für eine gegebene Konstellation bestimmt, um zu 

entscheiden, ob diese Teillösung noch einer neuen optimalen Lösung 

ergänzt werden kann (Bounding) 


503

3.6.1 Dynamische Programmierung 

Wir erläutern diese Technik anhand eines einfachen und 

sehr bekannten Beispiels 

Betrachtetes Problem: All pair shortest path 

Gegeben: 

Gewichteter Graph G=(V,E) 

V ist die Knotenmenge des Graphen 

E ist die Kantenmenge des Graphen 

∀(v,w)∈VxV: c(v,w) Kantengewicht 

Gesucht: 

– mit c(v,w)>0: Gewicht der Kante zwischen v und w 

– mit c(v,w)=0 für v=w 

– Mit c(v,w)=∞sonst Matrix A (a(v,w)) mit 

a(v,w) als Länge des kürzesten Pfades p von v nach w (Summe der 

Kantengewichte der Kanten entlang des Pfades) 


504

Lösung des Problems 

Wir definieren eine neue Matrix A i , die 

schrittweise in die Ergebnismatrix überführt wird 

Dazu definieren wir konkret 

i 

{ } ( ) 

∀∈ i 0, 1 ,...,n : ∀v,w∈ V × V: a v,w bezeichnet die Länge 

des längsten Pfades von v nach w unter ausschließlicher 

{ } 

Nutzung von Knoten j ∈ 1 ,...,i als Zwischenstationen 

Wir können direkt festhalten 

( ) ( ) 

∀ ∈ × = 

0 

v,w V V: a v,w c v,w 


505

Die rekursive Berechnungsformel 

Wird der kürzeste Pfad von v nach w über alle 

Knoten kleiner gleich p gesucht und sind alle 

kürzesten Pfade unter Verwendung der Knoten 

mit Index kleiner gleich p-1 bekannt so gilt 

Entweder geht dieser Pfad über Knoten p 

Dann aber als kürzester Weg von v nach p über alle Knoten 

kleiner gleich p 

Und anschließend von p nach w über alle Knoten kleiner 

gleich p 

Oder dieser Pfad geht nicht über Knoten p; dann 

entspricht er dem bereits bekannten Pfad über alle 

Knoten kleiner gleich p 

Aus diesen Überlegungen folgt bereits die 

folgende rekursive Berechnungsformel 


506

Rekursive Berechnungsformel 

Wir erhalten somit 

{ 1 } 

( ) = 

−1( ) −1( ) + 

−1( 

) 

( ) = 

( ) 

∀p ∈ ,...,n : ∀v,w∈ V × V : 

0 

a v,w c v,w 

Offensichtlich gilt 

{ } 

p p p p 

a v,w min a v,w ,a v, p a p,w 

A p kann direkt aus A p-1 bestimmt werden 

A n ist die gesuchte Matrix mit allen kürzesten Wegen 

A 0 ist direkt aus der Kantengewichtematrix c 

ermittelbar 


507

for v:=1 to n do 

for w:=1 to n do 

a(v,w):=c(v,w) 

for v:=1 to n do 

for w:=1 to n do 

Lösungsverfahren 

for p:=1 to n do 

/* Nun sind alle Einträge a(v,p) und a(p,w) bereits für p-1 

aktualisiert */ 

– a(v,w):=min{ a(v,w), a(v,p)+a(p,w) } 

end do 

end do 

end do 


508

Komplexität 

Ansätze der Dynamischen Programmierung lassen sich 

sehr leicht hinsichtlich ihres zeitlichen Rechenaufwandes 

analysieren 

So besitzen sie häufig ein sehr stabiles Verhalten, d.h. 

worst und best case fallen in der Regel zusammen 

Offensichtlich ergibt sich im konkreten Fall unabhängig 

von konkreten Werten der Zeitaufwand O(n 3 ) 

Am konkreten Beispiel zeigte sich die Mächtigkeit des 

Instrumentes 

Es gibt eine Reihe von wichtigen Problemen, für die erste 

polynomiell zeitbeschränkte Lösungsverfahren lediglich 

auf der Basis der dynamischen Programmierung bekannt 

sind 


509

3.5 Aufwandsabschätzung - WINFOR

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?