0% found this document useful (0 votes)
15 views36 pages

Lecture 13 Algo 1

The document provides an overview of algorithms, defining them as finite sets of instructions for computation or problem-solving. It discusses two algorithms for testing surjectivity, compares their running times, and introduces Big-O notation for analyzing algorithmic complexity. The document emphasizes the importance of understanding running times and provides examples to illustrate these concepts.

Uploaded by

aishaabedin0
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
15 views36 pages

Lecture 13 Algo 1

The document provides an overview of algorithms, defining them as finite sets of instructions for computation or problem-solving. It discusses two algorithms for testing surjectivity, compares their running times, and introduces Big-O notation for analyzing algorithmic complexity. The document emphasizes the importance of understanding running times and provides examples to illustrate these concepts.

Uploaded by

aishaabedin0
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 36

Algorithm

Lecture 13

1
Algorithms

DEF: An algorithm is a finite set of precise


instructions for performing a computation or solving
a problem.

Synonyms for a algorithm are: program, recipe,


procedure, and many others.

2
Pseudo-Java

• Possible alternative to text’s pseudo-Java


Start with “real” Java and simplify:

int f(int[] a){


int x = a[0];
for(int i=1; i<a.length; i++){
if(x > a[i])
x = a[i];
}
return x;
}

3
Pseudo-Java Version 1

integer f(integer_array (a1, a2, …, an) ){


x = a1
for(i =2 to n){
if(x > ai)
x = ai
}
return x
}

4
Pseudo-Java version 2

INPUT: integer_array V = (a1, a2, …, an)


begin
x = a1
for(y  V)
if(x > y)
x = y
end
OUTPUT: x

5
Algorithm for Surjectivity

boolean isOnto( function f: n  m ){


if( m > n ) return false // can’t be onto
soFarIsOnto = true
for( j = 1 to m ){
soFarIsOnto = false;
for(i = 1 to n ){
if ( f(i ) == j )
soFarIsOnto = true;
if( !soFarIsOnto ) return false;
}
}
return true;
}

6
Improved Algorithm for Surjectivity

boolean isOntoB( function f: (1, 2,…, n)  (1, 2,…, m) ){


if( m > n ) return false // can’t be onto
for( j = 1 to m )
beenHit[ j ] = false; // make it false
for(i = 1 to n )
beenHit[ f(i ) ] = true; // assigned on are true
for(j = 1 to m )
if( !beenHit[ j ] )
return false;
return true;
}

7
Algorithmic Complexity

Compare the running time of 2 previous algorithms for


testing surjectivity.

Measure running time by counting the number of


“basic operations”.

8
Running Time

Basic steps—
Assignment Increment
Comparison Negation
Return Random array access
Function output access etc.

In a particular problem, may tell you to consider other


operations (e.g. multiplication) and ignore all others

9
Running time of 1st algorithm
boolean isOnto( function f: (1, 2,…, n)  (1, 2,…, m)
){
if( m > n ) return false 1+1 step OR:
soFarIsOnto = true 1 step (assigment)
for( j = 1 to m ){ m loops: 1 increment plus
soFarIsOnto = false 1 step (assignment)
for(i = 1 to n ){ n loops: 1 increment plus
if ( f(i ) == j ) 1 step possibly leads to:
soFarIsOnto = true 1 step (assignment)
if( !soFarIsOnto ) 1 step possibly leads to:
return false 1 step (return)
}
}
return true; possibly 1 step
}
WORST-CASE
Running time of 1st algorithm
running time:
Number of steps = 1
OR
1+
1 step (m>n) OR: m·
1 step (assigment) (1+ 1 +
m loops: 1 increment plus n·
1 step (assignment) (1
n loops: 1 increment plus +1
1 step possibly leads to: +1
1 step (assignment) +1
+1
1 step possibly leads to:
)
1 step (return)
)
possibly 1 step
1+m(2+5n)+1 +1
= 2+2m+5mn
=5mn+2m+2
= 1 (if m>n) OR
5mn+2m+2
Running time of 2nd algorithm
boolean isOntoB( function f: (1, 2,…, n)  (1, 2,…, m) ){
if( m > n ) return false 1 step OR:
for( j = 1 to m ) m loops: 1 increment plus
beenHit[ j ] = false 1 step (assignment)
for(i = 1 to n )
n loops: 1 increment plus
beenHit[ f(i ) ] = true
1 step (assignment)
for(j = 1 to m )
if( !beenHit[ j ] ) m loops: 1 increment plus
return false 1 step possibly leads to:
return true 1 step
} possibly 1 step
.
Running time of 2nd algorithm

WORST-CASE running time:


1 step (m>n) OR: Number of steps = 1 OR 1+
m loops: 1 increment plus m · (1+
1 step (assignment) 1)
n loops: 1 increment plus + n · (1+
1 step (assignment) 1)
m loops: 1 increment plus + m · (1+ 1+2m+2n+3m+1
1 step possibly leads to: 1 = 2+5m+2n
=5m+2n+2
1 step + 1)
possibly 1 step + 1
. = 1 (if m>n) OR 5m + 2n + 2
Comparing Running Times

1. At most 5mn+2m+2 for first algorithm


2. At most 5m+2n+2 for second algorithm
Worst case when m  n so replace m by n:
5n 2+2n+2 vs. 7n+2
To tell which is better, look at dominant term:
5n2+2n+2 vs. 7n+2

So second algorithm is better.


14
Comparing Running Times: Issues

1. 5n 2+2n+2 , 7n+2 are more than just their biggest


term. Consider n = 1.
2. Number of “basic steps” doesn’t give accurate
running time.
3. Actual running time depends on platform.
4. Overestimated number of steps: under some
conditions, portions of code will not be seen.

15
Running Times Issues Big-O Response

1. Asymptotic notation (Big-O) gives partial resolution to


problems:

2. Different lengths of basic steps, just change 5n2 to


Cn 2 for some constant, so doesn’t change largest
term

16
Running Times Issues Big-O Response

1. Asymptotic notation (Big-O) gives partial resolution to


problems:

2. Basic operations on different (but well-designed)


platforms will differ by a constant factor. Again,
changes 5n2 to Cn2 for some constant.

17
Notational Issues

Big-O notation is a way of comparing functions. Notation


unconventional:
EG: 3x3 + 5x2 – 9 = O (x3)
Doesn’t mean
“3x 3 + 5x 2 – 9 equals the function O(x3)”
Which actually means
“3x3+5x2 –9 is dominated by x3”
Read as: “3x 3+5x 2 –9 is big-Oh of x3”

18
Intuitive Notion of Big-O

Asymptotic notation captures behavior of functions for


large values of x.
EG: Dominant term of 3x3+5x2 –9 is x3.
As x becomes larger and larger, other terms
become insignificant and only x3 remains in the
picture:

19
Intuitive Notion of Big-O domain

y = 3x 3+5x 2 –9

y=x3
y=x2
y=x
Intuitive Notion of Big-O domain

y = 3x 3+5x 2 –9

y=x3

y=x2

y=x
Intuitive Notion of Big-O domain

y = 3x 3+5x 2 –9

y=x3

y=x2
y=x
Intuitive Notion of Big-O domain

y = 3x 3+5x 2 –9

y=x3

y=x2
y=x
23
Intuitive Notion of Big-O
In fact, 3x 3+5x 2 –9 is smaller than 5x 3 for large enough
values of x:

y = 5x 3

y = 3x 3+5x 2 –9

y=x2
y=x
24
Big-O. Formal Definition

f (x ) is asymptotically dominated by g (x ) if there’s a


constant multiple of g (x ) bigger than f (x ) as x
goes to infinity:
DEF: Let f , g be functions with domain R0 or N and
codomain R. If there are constants C and k such
 x > k, |f (x )|  C  |g (x )|
then we write:
f (x ) = O ( g (x ) )

f does not grow faster than g


25
Big-O. Example

EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).


Previous graphs show C = 5 good guess.
Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k

26
EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).

Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k
1. Collect terms: 5x 2 ≤ 2x 3 + 9

27
EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).

Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k
1. Collect terms: 5x 2 ≤ 2x 3 + 9
2. What k will make 5x 2 ≤ x 3 for x > k ?

28
EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).

Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k
1. Collect terms: 5x 2 ≤ 2x 3 + 9
2. What k will make 5x 2 ≤ x 3 for x > k ?
3. k = 5 !!

29
EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).

Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k
1. Collect terms: 5x 2 ≤ 2x 3 + 9
2. What k will make 5x 2 ≤ x 3 for x > k ?
3. k = 5 !!
4. So for x > 5, 5x 2 ≤ x 3 ≤ 2x 3 + 9

30
EG: Show that 3x 3 + 5x 2 – 9 = O (x 3).

Find k so that
3x 3 + 5x 2 – 9  5x 3
for x > k
1. Collect terms: 5x 2 ≤ 2x 3 + 9
2. What k will make 5x 2 ≤ x 3 for x > k ?
3. k = 5 !
4. So for x > 5, 5x 2 ≤ x 3 ≤ 2x 3 + 9
5. Solution: C = 5, k = 5

31
Show that f ( x)  x  2 x  1 is O( x )
2 2

If x>1 then
x<x2 and
1<x2

C=4 and k=1

If x>2 then
2x<=x2 and
1<= x2

C=3 and k=2


2 3
Show that 7 x is O( x )

If x>7 then
7x2 < x3 and

C=1 and k=7


If x>1 then
7x2 < 7x3 and

C=7 and k=1


Big-O and limits

LEMMA: If the limit as x   of the quotient |f (x) / g (x)|


exists then f (x ) = O ( g (x ) ).
EG: 3x 3 + 5x 2 – 9 = O (x 3 ). Compute:
3x 3  5 x 2  9 3  5 / x  9 / x3
lim 3
 lim 3
x  x x  1
…so big-O relationship proved.

34
Big-O. Negative Example

x 4  O (3x 3 + 5x 2 – 9) :
No pair C, k exist for which
x > k implies C (3x 3 + 5x 2 – 9)  x 4
Argue using limits: 4
x x
lim  lim
x   C (3 x  5 x  9)
3 2 x   C (3  5 / x  9 / x 3 )

x 1
 lim   lim x  
x   C (3  0  0) 3C x 
x 4 always catches up regardless of C. •

35
Thank You

36

You might also like