Introduction to Design & Analysis of Algorithmsphg-simulation-laboratory.com/.../uploads/2016/01/M01Introduction2.pdf · Introduction to Design & Analysis of Algorithms Matakuliah

Introduction to Design & Analysis of Algorithms

Matakuliah Desain & Analisis Algoritma(CS 3024)

ZK Abdurahman BaizalSTT Telkom Bandung

ZKA-STT Telkom Bandung 2

Algorithm is a sequence of un ambiguous instructions for solving a problem (Levitin)

Problem

Algorithm

Computerinput output


Isi dari algoritma :AssignmentSubroutine callSequencePencabanganLooping


Fundamentals of Algorithmic Problem Solving

Understand the Problem

Decide on : Computational means, exact vsapproximate solving, data structures,algorithmsdesign techniques

Design algorithm

Prove correctness

Analyze the algorithm

Code the algorithm


Important Problem Types

SortingTo rearrange the items of given list in

ascending/descending orderAda Stable sorting algorithm and ada Not

Stable sorting algorithm


Important Problem Types (Cont)

SearchingDeals with finding a given value, called a

search key, in a given setSequencial search, binary search, dll


Important Problem Types (cont)

String ProcessingString : a sequence of characters (Levitin)Particular problem : searching for a given word

in a text → string matchingGraph Problems

Graph : a collection of point (vertex), some of which are connected by line segments (edge)



Graph bisa sebagai pemodelan daritransportation and communicaton networks, project schedulling, games, dsb



Combinatorial ProblemsProblem ask to find a combinatorial objectCombinatorial objects typically grows

extremely fast with problem’s sizeThere no known algorithms for solving most

such problems in acceptable amount of timeexception : shortest-path problem

(diantaranya)Contoh : graph coloring problem, traveling

salesman problem, knapsack problems, dll



Geometric ProblemsGeometric algorithms deal with geometric

objects such as points, lines and polygons. Applications : computer graphics, robotics, dsbClassic problems of computational geometry:

The closest pair problem and convex hull problem



Numerical ProblemsProblems that involve mathematical objects of

continuous natureExample : solving equations and systems of

equations, computing definite integrals, evaluating functions, dsbMajority can be solved only approximatelyApplication : information storage, information

retrieval, transportation through networks, dsb


Introduction to Software Engineering Concepts


Top Down Programming by Stepwise Refinement

In this chapter, we will concern with small programThe term programming in the small refers to the activities that center on the creation of small program The term programming in the large refers to activities that center on the creation and modification of large software systems


Top Down Programming by Stepwise Refinement

One of the helpful methods for developing small programs is called top down programming by stepwise refinement

We begin at the topmost conceptual level, by imagining a general, and we sketch the rough program strategy in outline form before choosing any particular low level data or algorithmIn stepwise of modifications, we refine the program strategy supplying more detail, until low-level details are completely filled in


Top Down Programming

Consider the following example of a scratch-off lottery ticket


Top Down Programming

We buy ticket with an opaque coating to scratch off. When we remove the coating, six numbers representing dollar amounts become visible, and we can hand in the ticket and receive the largest dollar amount repeated three or more times.If no amount is repeated three or more times, we don’t win anythingWe will write a C program for this case


Process of Top Down Programming

One possible solution follows the theme, “make a table and search it to find the solution”



Refinement stepsMaking program strategy describing top level goals

[ Program Strategy 1]


Process of Top Down ProgrammingRefinement steps of Program Strategy 1: Get six inputs from user

We can use an array that can store six integers

[ Program 1.1 ]



There are two alternatives :We choose the data structure for the table before designing the strategy for the algorithmWe design the algorithm before choosing the details of the data structure → postponing the choice the details of data representations

Let’s we try the second idea !


Process of Top Down ProgrammingRefinement steps of Program Strategy 1: Make a Table of amounts and repetitions

We use abstract table operations

[ Program Strategy 1.2]

unwritten function


The activity of creating program strategies at the top level leads to the creation of function calls, whose lower level function definitions have not yet be written → Top Down Method

We first write the definitions of functions before using calls on them inside other higher level functions → Bottom Up Method



Abstract Program Strategy for function InsertAmount on on Program Strategy 1.2

[ Program Strategy 1.2.1]


Process of Top Down ProgrammingRefinement steps of Program Strategy 1: Print largest amount repeated three or more times

[ Program Strategy 1.3 ]


Choosing Data structure for the table

typedef struct {int Amount;int Repetitions;

} RowStruct;

RowStruct Table[6];


Choosing Data structure for the table

Refinement steps of Program Strategy 1.2

[ Program 1.2.2 ]


Refinement steps of Program Strategy 1.2.1: Details of Program Strategy 1.2.1

[ Program 1.2.1.1 ]


Choosing Data structure for the tableRefinement steps of Program Strategy 1.3

[ Program 1.3.1 ]


Choosing Data structure for the tableRefinement steps of Program Strategy 1


Entire Program for Finding a Lottery Winner


• Another possible solution for Finding a Lottery Winner follows the theme : “Sort the input into descending order and find the first run of three repeated amounts”


Proving Programs Correct


Proving Programs Correct

How to prove that a program does what it is intended to do

Providing assertions:Precondition Initial statePostcondition Final state

{precondition} P{postcondition}


Example: SelectionSort(A,m,n)

By applying the pattern in the case of SelectionSort:

{m ≤ n}SelectionSort(A,m,n){A[m]≥A[m+1] ≥… ≥A[n]}


Proving correctness of SelectionSort

1. Place additional assertions inside the text of the SelectionSort program

2. Construct proofs of correctness of the subroutines used by SelectionSort


First, Proving FindMax

The pre and postcondition are:

{m<n} /*precondition*/

j=FindMax(A,m,n);

{A[j]≥A[m:n]} /*postcondition*/


Finding the position of the largest item


Mathematical Induction

ith tripStatement i++i=m+1j=m

Statement if (A[i]>A[j]) j=iA[j]≥A[m:m+1] A[j] ≥A[m:i]

If (m<n) and (i=m+1), then (i≤n)∴ Loop invariant A[j]≥A[m:i] Λ (i≤n)

true



(i+1)st tripTest the while-condition (i!=n), suppose it is still true, so we have two facts:

(i ≠ n)A[j]≥A[m:i] Λ (i≤n)

→ by combining those two facts, the loop invariant assertionwill yield : A[j]≥A[m:i] Λ (i<n)

after i++ is executed, another assertion:A[j]≥A[m:i-1] Λ (i≤n) must hold.

The statement if (A[i]>A[j]) j=i; is executed, the loop invariant assertion: A[j]≥A[m:i] Λ (i≤n) still holds true



The principle of proving correctness program using induction:

If it’s true on any given trip, it will remain true on the next trip.

Consequently,It’s true on every trip through the loop


Finishing the proof

We are now ready to go back and prove that SelectionSort(A,m,n) sorts A[m:n], using the fact we just establish that j=FindMax(A,m,n)

We can add assertions in SelectionSort(A,m,n) as follows :


Finishing the proof


Outer Subproblem

Assume condition (m<n) is trueFunction FinMax(A,m,n) is called, so we have assertion A[MaxPosition] ≥ A[m:n] (line 14)

Meaning A[MaxPosition] is the largest item in the subarrayA[m:n]

Statement exchange A[m] – A[maxPosition]A[m] = subarray’s first itemA[MaxPosition] = subarray’s largest itemAfter axchange, A[m] is the largest item in A[m:n]

→ so we have assertion A[m] ≥ A[m:n] (line 19)


Smaller subproblems

Recursive call SelectionSort(A,m+1,n)Effect : rearranging the items in A[m+1:n] into decreasing order so we have assertion A[m+1]≥ A[m+2]≥… ≥A[n] (line 21)So we have 2 facts :

A[m] ≥ A[m+1]A[m+1]≥ A[m+2]≥… ≥A[n]

→ yields : A[m] ≥ A[m+1]≥ A[m+2]≥… ≥A[n] (line 27)if condition (m<n) on line 10 was false, combining the falsehood (m<n) with precondition (m≤n) on line 4, implies (m=n) must have been true.A[m:m] only have 1 item, so there are no items to sort.


Finishing the proof

This completes our proof that SelectionSort correctly rearranges the items in A[m:n] into decending order :

A[m] ≥ A[m+1]≥ A[m+2]≥… ≥A[n]


Recursion Induction

We used a second form of induction in constructing the proof of SelectionSort. This sometimes called RECURSION INDUCTIONThis Method is applied by assuming that recursive calls on smaller-sized subproblem within the text of the main outer recursive function, correctly solve the smaller subproblem


A subtle bug

Incomplete assertions !

Is this program a correct sorting algorithm?


Review questions

1. What is an assertion inside a program ?2. What is a precondition ?3. What is a postcondition ?4. What is a correctness proof for a

program?


Transforming & Optimizing Programs



Transformation is applied in order to improve the program efficiency→ maksudnya improve dalam running time (secara real time) dan real memory, bukan improve dari sisikompleksitas

Program Transformations exchange the laws that permit us to replace one form of a program with an equivalent form



Example:If condition (i<n) is simpler than (i <= n && i != n)Polynomial ((x + 3)*x + 5)*x + 2 is simpler than x*x*x + 3*x*x + 5*x + 2


Recursion elimination

Recursion elimination is converting a recursive program to an equivalent iterative program.

Transferring the parametersMaking callReturning from the call



Tail recursion

[Program A]



Tail recursion elimination transformation converts the if-statement into a while loop and replace the tail recursion with assignment statements that assign the actual parameter expressions to be values of the formal parameters of the function


Tail Recursion Elimination

[Program Transformation B]


Tail Recursion EliminationSelection Sorting after Tail Recursion Elimination

[Program C]


Tail Recursion Elimination

Selection Sorting after Useless Assignment Elimination


Iterative vs Recursive running time


Exercises Eliminate the tail recursion from the following program

void RevString(char *S,int m,int n){

char c;

if (m<n){c=S[m];S[m]=S[n];S[n]=c;RevString(S,m+1,n-1);

}}


Algorithm Efficiency


Efisiensi Algoritma

Pertimbangan Memilih algoritma :Kebenaran

Tepat guna (efektif)output sesuai dengan inputnyasesuai dengan permasalahan

Kemudahan/ kesederhanaanUntuk dipahamiUntuk diprogram (proses coding)


Efisiensi Algoritma

Kecepatan AlgoritmaBerkaitan dengan kecepatan eksekusi program

Hemat Biayamengacu pada kebutuhan memory


Efisiensi Algoritma

Keempatnya sulit dicapai bersamaan, dan biasanyayang diutamakan adalah efisiensi (cepat dan hemat)Analisis Algoritma : menganalisis efisiensi algoritma, yang mencakup :

efisiensi waktu (kecepatan) → banyaknya operasiyang dilakukanefisiensi memori → struktur data dan variabels yang digunakan


Efisiensi Algoritma

Algoritma yang bagus adalah algoritmayang efisienAlgoritma yang efisien ialah algoritmayang meminimumkan kebutuhan waktudan ruang/memori. Kebutuhan waktu dan ruang suatualgoritma bergantung pada ukuranmasukan (n), yang menyatakan jumlahdata yang diproses.


Efisiensi Algoritma

Mana yang lebih baik : menggunakanalgoritma yang waktu eksekusinya cepatdengan komputer standard ataumenggunakan algoritma yang waktunyatidak cepat tetapi dengan komputer yang cepat?


Efisiensi Algoritma

Misal dipunyai :Algoritma dengan waktu eksekusi dalam orde2n

Sebuah komputer dengan kecepatan 10-4 x 2n

n=10 → 1/10 detikn=20 → 2 menitn=30 → lebih dari satu harin=38 → 1 tahun


Efisiensi Algoritma

Misal dipunyai :Algoritma dengan waktu eksekusi dalam orde2n

Sebuah komputer dengan kecepatan 10-6 x 2n

n=45 → 1 tahun


Efisiensi Algoritma

Misal dipunyai :Algoritma dengan waktu eksekusi dalam orden3

Sebuah komputer dengan kecepatan 10-4 x n3

n=900 → 1 harin=6800 → 1 tahun


Mengapa kita memerlukan algoritma yang efisien? Lihat grafik di bawah ini.

105 15 20 25 30 35 40

Ukuran masukan

10

102

103

104

105

11 detik

1 menit

1 jam

1 hari

Wak

tu k

ompu

tasi

(dal

am d

etik

)

10-1

10-4 x 2n

10-6 x n3

10-6 x 2n

10-4 x n3


Reference

Munir,Rinaldi. Diktat Strategi Algoritmik . Departemen Teknik Informatika, ITBLevitin, Anany. Introduction to the design and analysis of algorithm. Addison WesleyStandish, Thomas A. Data structures, Algorithms, & Software Principles in C. Addison wesley publishing company. 1995

Documents

Introduction to Design & Analysis of Algorithmsphg-simulation-laboratory.com/.../uploads/2016/01/M01Introduction2.pdf · Introduction to Design & Analysis of Algorithms Matakuliah