divide and conquer. 2 algorithmic paradigms greedy. build up a solution incrementally, myopically...
TRANSCRIPT
![Page 1: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/1.jpg)
DIVIDE AND CONQUER
![Page 2: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/2.jpg)
2
Algorithmic Paradigms
Greedy. Build up a solution incrementally, myopically optimizing some local criterion.
Divide-and-conquer. Break up a problem into two sub-problems, solve each sub-problem independently, and combine solution to sub-problems to form solution to original problem.
Dynamic programming. Break up a problem into a series of overlapping sub-problems, and build up solutions to larger and larger sub-problems.
![Page 3: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/3.jpg)
3
Divide and Conquer
Divide and conquer. Break up problem into several parts. Solve each part recursively. Combine solutions to sub-problems into overall solution.
Most common usage. Break up problem of size n into two equal parts of size ½n. Solve two parts recursively. Combine two solutions into overall solution in linear time.
Consequence. Brute force: n2. Divide-and-conquer: n log n. Divide et impera.
Veni, vidi, vici. - Julius Caesar
![Page 4: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/4.jpg)
Mergesort
![Page 5: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/5.jpg)
5
Obvious sorting applications.List files in a directory.Organize an MP3 library.List names in a phone book.Display Google PageRank results.
Problems become easier once sorted.
Find the median. Find the closest pair.Binary search in a database.Identify statistical outliers.Find duplicates in a mailing list.
Non-obvious sorting applications.
Data compression.Computer graphics.Interval scheduling.Computational biology.Minimum spanning tree.Supply chain management.Simulate a system of particles.Book recommendations on Amazon.Load balancing on a parallel computer.. . .
Sorting
Sorting. Given n elements, rearrange in ascending order.
![Page 6: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/6.jpg)
6
Mergesort
Mergesort. Divide array into two halves. Recursively sort each half. Merge two halves to make sorted whole.
merge
sort
divide
A L G O R I T H M S
A L G O R I T H M S
A G L O R H I M S T
A G H I L M O R S T
Jon von Neumann (1945)
O(n)
2T(n/2)
O(1)
![Page 7: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/7.jpg)
7
Merging
Merging. Combine two pre-sorted lists into a sorted whole.
How to merge efficiently? Linear number of comparisons. Use temporary array.
Challenge for the bored. In-place merge. [Kronrud, 1969]
A G L O R H I M S T
A G H I
using only a constant amount of extra storage
![Page 8: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/8.jpg)
8
auxiliary array
smallest smallest
A G L O R H I M S T
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
A
![Page 9: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/9.jpg)
9
auxiliary array
smallest smallest
A G L O R H I M S T
A
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
G
![Page 10: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/10.jpg)
10
auxiliary array
smallest smallest
A G L O R H I M S T
A G
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
H
![Page 11: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/11.jpg)
11
auxiliary array
smallest smallest
A G L O R H I M S T
A G H
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
I
![Page 12: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/12.jpg)
12
auxiliary array
smallest smallest
A G L O R H I M S T
A G H I
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
L
![Page 13: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/13.jpg)
13
auxiliary array
smallest smallest
A G L O R H I M S T
A G H I L
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
M
![Page 14: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/14.jpg)
14
auxiliary array
smallest smallest
A G L O R H I M S T
A G H I L M
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
O
![Page 15: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/15.jpg)
15
auxiliary array
smallest smallest
A G L O R H I M S T
A G H I L M O
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
R
![Page 16: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/16.jpg)
16
auxiliary array
first halfexhausted smallest
A G L O R H I M S T
A G H I L M O R
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
S
![Page 17: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/17.jpg)
17
auxiliary array
first halfexhausted smallest
A G L O R H I M S T
A G H I L M O R S
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
T
![Page 18: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/18.jpg)
18
auxiliary array
first halfexhausted
second halfexhausted
A G L O R H I M S T
A G H I L M O R S T
Merging
Merge. Keep track of smallest element in each sorted half. Insert smallest of two elements into auxiliary array. Repeat until done.
![Page 19: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/19.jpg)
19
A Useful Recurrence Relation
Def. T(n) = number of comparisons to mergesort an input of size n.
Mergesort recurrence.
Solution. T(n) = O(n log2 n).
Assorted proofs. We describe several ways to prove this recurrence. Initially we assume n is a power of 2 and replace with =.
![Page 20: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/20.jpg)
20
Proof by Recursion Tree
T(n)
T(n/2)T(n/2)
T(n/4)T(n/4)T(n/4) T(n/4)
T(2) T(2) T(2) T(2) T(2) T(2) T(2) T(2)
n
T(n / 2k)
2(n/2)
4(n/4)
2k (n / 2k)
n/2 (2)
. . .
. . .log2n
n log2n
![Page 21: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/21.jpg)
21
Proof by Telescoping
Claim. If T(n) satisfies this recurrence, then T(n) = n log2 n.
Pf. For n > 1:
T(n)
n 2T(n /2)
n 1
T(n /2)n /2
1
T(n / 4)n / 4
1 1
T(n /n)
n /n 1 1
log2 n
log2 n
assumes n is a power of 2
![Page 22: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/22.jpg)
22
Proof by Induction
Claim. If T(n) satisfies this recurrence, then T(n) = n log2 n.
Pf. (by induction on n) Base case: n = 1. Inductive hypothesis: T(n) = n log2 n. Goal: show that T(2n) = 2n log2 (2n).
assumes n is a power of 2
![Page 23: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/23.jpg)
23
Analysis of Mergesort Recurrence
Claim. If T(n) satisfies the following recurrence, then T(n) n lg
n.
Pf. (by induction on n) Base case: n = 1. Define n1 = n / 2 , n2 = n / 2. Induction step: assume true for 1, 2, ... , n–1.
log2n
![Page 24: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/24.jpg)
Integer Multiplication
![Page 25: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/25.jpg)
25
Integer Arithmetic
Add. Given two n-digit integers a and b, compute a + b. O(n) bit operations.
Multiply. Given two n-digit integers a and b, compute a × b. Brute force solution: (n2) bit operations.
1
1
0
0
0
1
1
1
0
0
1
1
1
1
0
0
1
1
1
1
0
1
0
1
00000000
01010101
01010101
01010101
01010101
01010101
00000000
0100000000001011
1
0
1
1
1
1
1
0
0
*
1
011 1
110 1+
010 1
111
010 1
011 1
100 0
10111
Add
Multiply
![Page 26: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/26.jpg)
26
To multiply two n-digit integers: Multiply four ½n-digit integers. Add two ½n-digit integers, and shift to obtain result.
Divide-and-Conquer Multiplication: Warmup
assumes n is a power of 2
![Page 27: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/27.jpg)
27
To multiply two n-digit integers: Add two ½n digit integers. Multiply three ½n-digit integers. Add, subtract, and shift ½n-digit integers to obtain result.
Theorem. [Karatsuba-Ofman, 1962] Can multiply two n-digit integers in O(n1.585) bit operations.
Karatsuba Multiplication
A B CA C
![Page 28: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/28.jpg)
28
Karatsuba: Recursion Tree
n
3(n/2)
9(n/4)
3k (n / 2k)
3 lg n (2)
. . .
. . .
T(n)
T(n/2)
T(n/4) T(n/4)
T(2) T(2) T(2) T(2) T(2) T(2) T(2) T(2)
T(n / 2k)
T(n/4)
T(n/2)
T(n/4) T(n/4)T(n/4)
T(n/2)
T(n/4) T(n/4)T(n/4)
. . .
. . .
![Page 29: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/29.jpg)
Matrix Multiplication
![Page 30: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/30.jpg)
30
Matrix multiplication. Given two n-by-n matrices A and B, compute C = AB.
Brute force. (n3) arithmetic operations.
Fundamental question. Can we improve upon brute force?
Matrix Multiplication
![Page 31: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/31.jpg)
31
Matrix Multiplication: Warmup
Divide-and-conquer. Divide: partition A and B into ½n-by-½n blocks. Conquer: multiply 8 ½n-by-½n recursively. Combine: add appropriate products using 4 matrix additions.
![Page 32: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/32.jpg)
32
Matrix Multiplication: Key Idea
Key idea. multiply 2-by-2 block matrices with only 7 multiplications.
7 multiplications. 18 = 10 + 8 additions (or subtractions).
![Page 33: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/33.jpg)
33
Fast Matrix Multiplication
Fast matrix multiplication. (Strassen, 1969) Divide: partition A and B into ½n-by-½n blocks. Compute: 14 ½n-by-½n matrices via 10 matrix additions. Conquer: multiply 7 ½n-by-½n matrices recursively. Combine: 7 products into 4 terms using 8 matrix additions.
Analysis. Assume n is a power of 2. T(n) = # arithmetic operations.
![Page 34: DIVIDE AND CONQUER. 2 Algorithmic Paradigms Greedy. Build up a solution incrementally, myopically optimizing some local criterion. Divide-and-conquer](https://reader037.vdocuments.site/reader037/viewer/2022110321/56649cef5503460f949bdabc/html5/thumbnails/34.jpg)
34
Fast Matrix Multiplication in Practice
Implementation issues. Sparsity. Caching effects. Numerical stability. Odd matrix dimensions. Crossover to classical algorithm around n = 128.
Common misperception: "Strassen is only a theoretical curiosity." Advanced Computation Group at Apple Computer reports 8x
speedup on G4 Velocity Engine when n ~ 2,500. Range of instances where it's useful is a subject of controversy.
Remark. Can "Strassenize" Ax=b, determinant, eigenvalues, and other matrix ops.