This preview shows page 1. Sign up to view the full content.
Unformatted text preview: Introduction to Computers and
Programming
Prof. I. K. Lundqvist Recitation 3
April 23 2004
1 BigO
• Given function f(n) and g(n), we say
that f(n) is O(g(n)) if there are positive
constants c and n0 so that
f(n) ≤ cg(n) for n ≥ n0
• Example:2n + 10 is O(n)
–
–
–
– 2n + 10 ≤ cn
10 ≤ n(c – 2)
n ≥ 10/(c2)
Pick c = 3 and n0 = 10
2 BigO
• 4n – 2 is O(n)
– Need a c > 0 and n0 ≥ 1 so that
4n2 ≤ cn for n ≥ n0
true for c = 4 and n0 = 1 • 5n3 + 10n2 + 4n +2 is O(n3)
– Need a c > 0 and n0 ≥ 1 so that
5n3+10n2+4n +2 ≤ cn3 for n ≥ n0
true for c = 21 and n0 = 1 • 2 log2n + 3 is O(log2 n) – Need a c > 0 and n0 ≥ 1 so that
2log2 n + 3 ≤ c log2 n for n ≥ n0
true for c = 5 and n0 = 2
4 BigO
• Given function f(n) and g(n), we say
that f(n) is O(g(n)) if there are
positive constants c and n0 so that
f(n) ≤ cg(n) for n ≥ n0
f(n) is O(g(n))
g(n) grows more
f(n) grows more
g(n) and f(n) has
same growth g(n) is O(f(n)) Yes No No Yes Yes Yes 5 Ex 1
type Int_Array is array (Integer range <>) of Integer;
procedure Measure (A : Int_Array ) is
Sum
: Integer := 0;
begin
for I in A'range loop
for J in A'range loop
Sum := Sum + A(J);
end loop; Inner loop
Outer loop end loop;
end Measure; 6 Statement Runs in
X time Executes
# of times Variable Sum is initialized Constant1 1 Array of size n is created Constant2 1 Variable I is created and initialized Constant3 1 I is tested against A’range (n) Constant4 n+1 Variable J is created and initialized Constant5 n J is tested against A’range (n) Constant6 n(n+1) Sum is incremented by A(J) Constant7 n2 J is incremented by 1 Constant8 n2 Constant9 n I is incremented by 1 7
BigO.adb Ex 2
type Int_Array is array (Integer range <>) of Integer;
procedure Measure (A : Int_Array ) is
Sum
: Integer := 0;
begin
for I in A'range loop
for J in 1 .. I loop – only change to Ex 1
Sum := Sum + A(J);
end loop;
end loop;
end Measure;
8
BigO2.adb CQ – Ex 2 Variable J is created and initialized Constant5 J is tested against I Constant6 Sum is incremented by A(J) Constant7 J is incremented by 1 Constant8 1. N, N*(N+1), N*N, N 2. N, N*(I+1), N*N, N*N 3. N, N*(I+1), N*I, N*I 4. I still don’t get it 9 Ex 3
type Int_Array is array (Integer range <>) of Integer;
procedure Measure (A : Int_Array ) is
Sum
: Integer := 0;
begin
for I in A'range loop
for J in 1 .. 4 loop
Sum := Sum + A(I);
end loop;  only change to Ex 2
 only change to Ex 2 end loop;
end Measure;
10
BigO3.adb CQ – Ex 3 Variable J is created and initialized Constant5 J is tested against I Constant6 Sum is incremented by A(J) Constant7 J is incremented by 1 Constant8 1. N, N*(I+1), N*I, N*I 2. N, N*5, N*4, N*4 3. N, N*5, 4, 4 4. I still don’t get it 11 Ex 4 function Factorial (N : in Natural ) return Positive is
begin
if N = 0 then
return 1;
else
return N * Factorial (N1);
end if;
end Factorial; 12 CQ – Ex 4
How long time does executing the
Factorial algorithm take?
1. O(n)
2. O(n2)
3. log n
4. 42
13 Divide and Conquer
• It is an algorithmic design paradigm
that contains the following steps
– Divide: Break the problem into smaller
subproblems
– Recur: Solve each of the subproblems
recursively
– Conquer: Combine the solutions of each of
the subproblems to form the solution of
the problem Represent the solution using a recurrence equation
14 Merge Sort
• Divide: Split the array into into two
subarrays A(p .. mid) and A(mid+1 .. r),
where mid is (p + r)/2
• Conquer by recursively sorting the two
subarrays A(p .. mid) and A(mid+1 .. r)
• Combine by merging the two sorted
subarrays A(p .. mid) and A(mid+1 .. r) to
produce a single sorted subarray A(p .. r) 15 Merge
• Input: Array A and indices p, mid, r
such that
– p ≤ mid < r
– subarray A(p .. mid) is sorted and
subarray A(mid+1 .. r) is sorted • Output: single sorted array A(p .. r)
• T(n) = O(n),
where n=rp+1 = # of elements being
merged
16 Merge Sort Analysis
• The base case: when n =1, T(n)=O(1)
• When n ≥ 2, time for merge sort steps:
– Divide: Compute mid as the average of p, r
⇒cost = O(1)
– Conquer: Solve 2 subproblems, each of size n/ 2
⇒cost = 2T(n/2)
– Combine: merge to an n element subarray
⇒ cost = O(n) T(n) = O(1)
2T(n/2) + O(n) + O(1) n=1
n>171 Solving Recurrences:
Iteration
c
n =1
⎧
⎪ ⎛ n⎞
T (n) = ⎨aT
⎜ ⎟ + cn n > 1
⎪ ⎝b⎠
⎩ 18 • T(n) =
aT(n/b) + cn
a(aT(n/b/b) + cn/b) + cn
a2T(n/b2) + cna/b + cn
a2T(n/b2) + cn(a/b + 1)
a2(aT(n/b2/b) + cn/b2) + cn(a/b + 1)
a3T(n/b3) + cn(a2/b2) + cn(a/b + 1)
a3T(n/b3) + cn(a2/b2 + a/b + 1)
…
akT(n/bk) + cn(ak1/bk1 + ak2/bk2 + … + a2/b2 + a/b + 1) 19 c
n =1
⎧
⎪
T (n) = ⎨aT ⎛ n ⎞ + cn n > 1
⎜⎟
⎪ ⎝b⎠
⎩ • So we have
– T(n) = akT(n/bk) + cn(ak1/bk1 + ... + a2/b2 + a/b +
1) • For k = logb n
– n = bk
– T(n) = akT(1) + cn(ak1/bk1 + ... + a2/b2 + a/b + 1)
= akc + cn(ak1/bk1 + ... + a2/b2 + a/b + 1)
= cak + cn(ak1/bk1 + ... + a2/b2 + a/b + 1)
= cnak /bk + cn(ak1/bk1 + ... + a2/b2 + a/b + 1)
= cn(ak/bk + ... + a2/b2 + a/b + 1) 20 c
n =1
⎧
⎪ ⎛n⎞
T (n) = ⎨aT
⎜ ⎟ + cn n > 1
⎪ ⎝b⎠
⎩ • So with k = logb n
– T(n) = cn(ak/bk + ... + a2/b2 + a/b + 1) • What if a = b?
– T(n) = cn(k + 1)
= cn(logb n + 1)
= O(n log n) T(n) = O(1)
2T(n/2) + O(n) + O(1) n=1
n>211 The Master Method
• Given: a divide and conquer algorithm
– An algorithm that divides the problem of
size n into a subproblems, each of size n/b
– Let the cost of each stage (i.e., the work to
divide the problem + combine solved
subproblems) be described by the function
f(n)
– The master method provides a simple
“cookbook” solution
22 Simplified Master Method
• T(n) = aT(n/b) + cnk,
where a,c > 0 and b > 1 ()
O(n log n )
O(n ) O n logb a
T(n) = k b k a > bk
a = bk
a < bk
23 The Towers of Hanoi
• Goal: Move stack of rings to another peg
– May only move 1 ring at a time
– May never have larger ring on top of smaller
ring 24 The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C Since we can only move one disk at a time, we move
the top disk from A to B. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from A to C. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from B to C. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from A to B. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from C to A. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from C to B. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C We then move the top disk from A to B. The Towers of Hanoi
For simplicity, suppose there were just 3 disks A B C and we’re done!
The problem gets more difficult as the number of
disks increases... The Towers of Hanoi
•
•
•
• 1
2
3
4 ring
rings
rings
rings Æ
Æ
Æ
Æ 1 operation
3 operations
7 operations
15 operations Cost: 2N1 = O(2N)
• 64 rings Æ 264 operations
33 Towers of Hanoi
• hanoi(from,to,other,number)
 move the top number disks
 from needle from to needle to
if number=1 then
move the top disk from needle from
to needle to
else
hanoi(from,other,to, number1)
hanoi(from,to,other, 1)
hanoi(other,to, from, number1)
end 34 Some math that is good to know
•
•
•
•
•
•
•
•
• logb(xy) = logbx + logby
logb(x/y) = logbx – logby
logbxa = alogbx
logba = logxa/logxb
a(b+c) = abac
abc = (ab)c
ab/ac = a(bc)
b = alogab
bc = aclogab
35 ...
View
Full
Document
This note was uploaded on 01/28/2012 for the course AERO 16.01 taught by Professor Markdrela during the Fall '05 term at MIT.
 Fall '05
 MarkDrela

Click to edit the document details