Scribd
Upload
49 views3 pages

L02 PDF

1. The document summarizes different algorithms for solving two problems: determining if an array contains a given integer value, and finding the maximum sum subarray in an array. 2. For the contains problem, algorithms discussed include brute force, decrease and conquer, divide and conquer, and greedy (for sorted arrays). 3. For the maximum subarray sum problem, algorithms discussed include brute force, divide and conquer, and dynamic programming. Dynamic programming is identified as the most efficient approach.

Uploaded by

ankurkothari
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
49 views3 pages

L02 PDF

1. The document summarizes different algorithms for solving two problems: determining if an array contains a given integer value, and finding the maximum sum subarray in an array. 2. For the contains problem, algorithms discussed include brute force, decrease and conquer, divide and conquer, and greedy (for sorted arrays). 3. For the maximum subarray sum problem, algorithms discussed include brute force, divide and conquer, and dynamic programming. Dynamic programming is identified as the most efficient approach.

Uploaded by

ankurkothari
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/ 3

Introduction to Algorithms: 6.

006
Massachusetts Institute of Technology Sep. 11, 2018
Instructors: Zachary Abel, Erik Demaine, Jason Ku Lecture 2: Structure of Computation

Lecture 2: Structure of Computation


Review
• Problem, Algorithm, Efficiency, Model of Computation, Data Structure

• How to Solve an Algorithms Problem

– Reduce to a problem you already know (use data structure or algorithm)


– Design your own (recursive) algorithm
Class Graph Visited
Brute Force Star All
Decrease & Conquer Chain All
Divide & Conquer Tree All
Dynamic Programming DAG All
Greedy / Incremental DAG Some

Contains
• Problem: Given an array A of n integers, does it contain integer v?

• Example: Seven element array.

Brute Force O(n) Decrease & Conquer O(n)


1 def contains(A, v): 1 def contains(A, v, i = 0):
2 for i in range(len(A)): 2 if i == len(A): return False
3 if A[i] == v: return True 3 if A[i] == v: return True
4 return False 4 return contains(A, v, i + 1)

Divide & Conquer O(n) Greedy, if sorted A, O(log n)


1 def contains(A, v, i = 0, j = None): 1 def contains(A, v, i = 0, j = None):
2 if j is None: j = len(A) 2 if j is None: j = len(A)
3 if j - i == 0: return False 3 if j - i == 0: return False
4 c = (i + j) // 2 4 c = (i + j) // 2
5 if A[c] == v: return True 5 if A[c] == v: return True
6 left = contains(A, v, i, c) 6 if A[c] > v:
7 right = contains(A, v, c + 1, j) 7 return contains(A, v, i, c)
8 return left or right 8 return contains(A, v, c + 1, j)
2 Lecture 2: Structure of Computation

Max Subarray Sum


• Problem: Given an array A of n integers, what is the largest sum of any nonempty subarray?
(in this class, subarray always means a contiguous sequence of elements)
• Example: A = [-9, 1, -5, 4, 3, -6, 7, 8, -2], largest sum is 16.
• Brute Force:
n n
 
– # subarrays: 2
+ 1
= O(n2 )
– Can compute subarray sum of k elements in O(k) time
– n subarrays have 1 element, n − 1 have 2, ... , 1 has n elements
– Work is c nk=1 (n − k + 1)k = cn(n + 1)(n + 2)/6 = O(n3 )
P

– Graph: single node, or quadratic branching star, each with linear work
1 def MSS(A): 1 def SS(A, i, j):
2 m = A[0] 2 s = 0
3 for j in range(1, len(A) + 1): 3 for k in range(i, j):
4 for i in range(0, j): 4 s += A[k]
5 m = max(m, SS(A, i, j)) 5 return s
6 return m 6 .
• Divide & Conquer
– Max subarray is either:
1. fully in left half,
2. fully in right half,
3. or contains elements from both halves.
– Third case = ( MSS EA, ending at middle ) + ( MSS SA, starting at middle )
– Combine step takes linear time
– Graph is binary tree with linear work at each vertex
– T (n) = 2 T (n/2) + O(n) =⇒ T (n) = O(n log n)
– (Draw tree, Master Theorem will also be discussed in recitation)
1 def MSS(A, i = 0, j = None):
2 if j is None: j = len(A)
3 if j - i == 1: return A[i]
4 c = (i + j) // 2
5 return max(MSS(A, i, c), MSS(A, c, j),
6 MSS_EA(A, i, c) + MSS_SA(A, c, j))

1 def MSS_SA(A, i, j): 1 def MSS_EA(A, i, j):


2 s = m = A[i] 2 s = m = A[j - 1]
3 for k in range(1, j - i): 3 for k in range(1, j - i):
4 s += A[i + k] 4 s += A[j - 1 - k]
5 m = max(s, m) 5 m = max(s, m)
6 return m 6 return m
Lecture 2: Structure of Computation 3

• Dynamic Programming

– MSS EA(A, 0, k) finds largest subarray in A ending at k


– MSS must end somewhere, so check MSS EA(A, 0, k) for all k. (Brute Force)

1 def MSS(A):
2 m = A[0]
3 for k in range(len(A)):
4 s = MSS_EA(A, 0, k + 1)
5 m = max(m, s)
6 return m

Pn
– But takes c k=1 k = cn(n + 1)/2 = O(n2 ) time.
– Computing a lot of subarray sums; can we reuse any work?
– Let’s rewrite MSS EA recursively

1 def MSS_EA(A, i, j):


2 if j - i == 1: return A[i]
3 return A[j - 1] + max(0, MSS_EA(A, i, j - 1))

– Graph of function calls is a tree with O(n2 ) nodes


– Same function called many times!
– Redraw call graph as a DAG of overlapping problems.
– Only O(n) nodes!
– Dynamic programming: remember work done before, or compute from bottom up

1 def MSS(A):
2 m = mss_ea = A[0]
3 for i in range(1, len(A)):
4 mss_ea = A[i] + max(0, mss_ea)
5 m = max(m, mss_ea)
6 return m

You might also like