Binary Search. Search for x in a sorted array A.
|
|
|
- Joshua Brandon Williamson
- 7 years ago
- Views:
Transcription
1 Divide and Conquer A general paradigm for algorithm design; inspired by emperors and colonizers. Three-step process: 1. Divide the problem into smaller problems. 2. Conquer by solving these problems. 3. Combine these results together. Examples: Binary Search, Merge sort, Quicksort etc. Matrix multiplication, Selection, Convex Hulls.
2 Binary Search Search for x in a sorted array A. Binary-Search (A, p, q, x) 1. if p > q return -1; 2. r = (p + q)/2 3. if x = A[r] return r 4. else if x < A[r] Binary-Search(A, p, r, x) 5. else Binary-Search(A, r + 1, q, x) The initial call is Binary-Search(A, 1, n, x).
3 Binary Search Let T (n) denote the worst-case time to binary search in an array of length n. Recurrence is T (n) = T (n/2) + O(1). T (n) = O(log n).
4 Merge Sort Sort an unordered array of numbers A. Merge-Sort (A, p, q) 1. if p q return A; 2. r = (p + q)/2 3. Merge-Sort (A, p, r) 4. Merge-Sort (A, r + 1, q) 5. MERGE (A, p, q, r) The initial call is Merge-Sort (A, 1, n).
5 Merge Sort Let T (n) denote the worst-case time to merge sort an array of length n. Recurrence is T (n) = 2T (n/2) + O(n). T (n) = O(n log n).
6 Merge Sort: Illustration Divide Merge
7 Multiplying Numbers We want to multiply two n-bit numbers. Cost is number of elementary bit steps. Grade school method has Θ(n 2 ) cost.: xxxxxxxx xxxxxxxx xxxxxxxxx xxxxxxxxx.. xxxxxxxxx xxxxxxxxxxxxxxxx n 2 multiplies, n 2 /2 additions, plus some carries.
8 Why Bother? Doesn t hardware provide multiply? It is fast, optimized, and free. So, why bother? True for numbers that fit in one computer word. But what if numbers are very large. Cryptography (encryption, digital signatures) uses big number keys. Typically 256 to 1024 bits long! n 2 multiplication too slow for such large numbers. Karatsuba s (1962) divide-and-conquer scheme multiplies two n bit numbers in O(n 1.59 ) steps.
9 Karatsuba s Algorithm Let X and Y be two n-bit numbers. Write X = a b Y = c d a, b, c, d are n/2 bit numbers. (Assume n = 2 k.) XY = (a2 n/2 + b)(c2 n/2 + d) = ac2 n + (ad + bc)2 n/2 + bd
10 An Example X = 4729 Y = a = 47; b = 29 c = 13; d = 26. ac = = 611 ad = = 1222 bc = = 377 bd = = 754 XY = XY =
11 Karatsuba s Algorithm This is D&C: Solve 4 problems, each of size n/2; then perform O(n) shifts to multiply the terms by 2 n and 2 n/2. We can write the recurrence as T (n) = 4T (n/2) + O(n) But this solves to T (n) = O(n 2 )!
12 Karatsuba s Algorithm XY = ac2 n + (ad + bc)2 n/2 + bd. Note that (a b)(c d) = (ac + bd) (ad + bc). Solve 3 subproblems: ac, bd, (a b)(c d). We can get all the terms needed for XY by addition and subtraction! The recurrence for this algorithm is T (n) = 3T (n/2) + O(n) = O(n log 2 3 ). The complexity is O(n log 2 3 ) O(n 1.59 ).
13 Recurrence Solving: Review T (n) = 2T (n/2) + cn, with T (1) = 1. By term expansion. T (n) = 2T (n/2) + cn = 2 ( 2T (n/2 2 ) + cn/2 ) + cn = 2 2 T (n/2 2 ) + 2cn = 2 2 ( 2T (n/2 3 ) + cn/2 2) + 2cn = 2 3 T (n/2 3 ) + 3cn. = 2 i T (n/2 i ) + icn Set i = log 2 n. Use T (1) = 1. We get T (n) = n + cn(log n) = O(n log n).
14 The Tree View T (n) = 2T (n/2) + cn, with T (1) = 1. T(n) cn Total Cost cn T(n/2) cn/2 T(n/2) cn/2 2(cn/2) = cn T(n/4) cn/4 T(n/4) cn/4 T(n/4) cn/4 T(n/4) cn/4 4(cn/4) = cn T(n/8) cn/8 cn/8 cn/8 cn/8 cn/8 cn/8 cn/8 cn/8 8(cn/8) = cn # leaves = n; # levels = log n. Work per level is O(n), so total is O(n log n).
15 Solving By Induction Recurrence: T (n) = 2T (n/2) + cn. Base case: T (1) = 1. Claim: T (n) = cn log n + cn. T (n) = 2T (n/2) + cn = 2 (c(n/2) log(n/2) + cn/2) + cn = cn (log n 1 + 1) + cn = cn log n + cn
16 More Examples T (n) = 4T (n/2) + cn, T (1) = 1. n Level 0 Work cn n/2 1 4cn/2 = 2cn n/4 2 16cn/4 = 4cn n/8 3 i i 4 cn / 2 i i = 2 cn
17 More Examples n Level 0 Work cn n/2 1 4cn/2 = 2cn n/4 2 16cn/4 = 4cn n/8 3 i i 4 cn / 2 i = 2 i cn Stops when n/2 i = 1, and i = log n. Recurrence solves to T (n) = O(n 2 ).
18 By Term Expansion T (n) = 4T (n/2) + cn = 4 2 T (n/2 2 ) + 2cn + cn = 4 3 T (n/2 3 ) cn + 2cn + cn. = 4 i T (n/2 i ) + cn ( 2 i i ) = 4 i T (n/2 i ) + 2 i cn Terminates when 2 i = n, or i = log n. 4 i = 2 i 2 i = n n = n 2. T (n) = n 2 + cn 2 = O(n 2 ).
19 More Examples T (n) = 2T (n/4) + n, T (1) = 1. T (n) = 2T (n/4) + n ( = 2 2T (n/4 2 ) + ) n/4 + n = 2 2 T (n/4 2 ) + 2 ( n = 2 2 2T (n/4 3 ) + ) n/ n = 2 3 T (n/4 3 ) + 3 n. = 2 i T (n/4 i ) + i n
20 More Examples Terminates when 4 i = n, or when i = log 4 n = log 2 n log 2 4 = 1 2 log n. T (n) = log n + n log 4 n = n(log 4 n + 1) = O( n log n)
21 Master Method ( n ) T (n) = at + f(n) b Total Cost n f(n) n/b a children af(n/b) n/b 2 a a a 2f(n/b 2 ) a a a a a if(n/b i)
22 Master Method Total Cost n f(n) n/b a children af(n/b) n/b 2 a a a 2f(n/b 2 ) a a a a a if(n/b i) # children multiply by factor a at each level. Number of leaves is a log b n = n log b a. Verify by taking logarithm on both sides.
23 Master Method By recursion tree, we get T (n) = Θ(n log b a ) + log b n 1 i=0 a i f Let f(n) = Θ(n p log k n), where p, k 0. ( n b i ) Important: a 1 and b > 1 are constants. Case I: p < log b a. n log b a grows faster than f(n). T (n) = Θ(n log b a )
24 Master Method By recursion tree, we get T (n) = Θ(n log b a ) + log b n 1 i=0 a i f Let f(n) = Θ(n p log k n), where p, k 0. ( n b i ) Case II: p = log b a. Both terms have same growth rates. T (n) = Θ(n log b a log k+1 n)
25 Master Method By recursion tree, we get T (n) = Θ(n log b a ) + log b n 1 i=0 a i f Let f(n) = Θ(n p log k n), where p, k 0. ( n b i ) Case III: p > log b a. n log b a is slower than f(n). T (n) = Θ (f(n))
26 Applying Master Method Merge Sort: T (n) = 2T (n/2) + Θ(n). a = b = 2, p = 1, and k = 0. So log b a = 1, and p = log b a. Case II applies, giving us T (n) = Θ(n log n) Binary Search: T (n) = T (n/2) + Θ(1). a = 1, b = 2, p = 0, and k = 0. So log b a = 0, and p = log b a. Case II applies, giving us T (n) = Θ(log n)
27 Applying Master Method T (n) = 2T (n/2) + Θ(n log n). a = b = 2, p = 1, and k = 1. p = 1 = log b a, and Case II applies. T (n) = 7T (n/2) + Θ(n 2 ). T (n) = Θ(n log 2 n) a = 7, b = 2, p = 2, and log b 2 = log 7 > 2. Case I applied, and we get T (n) = Θ(n log 7 )
28 Applying Master Method T (n) = 4T (n/2) + Θ(n 2 n). a = 4, b = 2, p = 2.5, and k = 0. So log b a = 2, and p > log b a. Case III applies, giving us ( T (n) = 2T (n/2) + Θ T (n) = Θ(n 2 n) n log n ). a = 2, b = 2, p = 1. But k = 1, and so the Master Method does not apply!
29 Matrix Multiplication Multiply two n n matrices: C = A B. Standard method: C ij = n k=1 A ik B kj. This takes O(n) time per element of C, for the total cost of O(n 3 ) to compute C. This method, known since Gauss s time, seems hard to improve. A very surprising discovery by Strassen (1969) broke the n 3 asymptotic barrier. Method is divide and conquer, with a clever choice of submatrices to multiply.
30 Divide and Conquer Let A, B be two n n matrices. We want to compute the n n matrix C = AB. ( ) ( ) a11 a A = 12 b11 b B = 12 a 21 a 22 b 21 b 22 ( ) c11 c C = 12 c 21 c 22 Entries a 11 are n/2 n/2 submatrices.
31 Divide and Conquer The product matrix can be written as: c 11 = a 11 b 11 + a 12 b 21 c 12 = a 11 b 12 + a 12 b 22 c 21 = a 21 b 11 + a 22 b 21 c 22 = a 21 b 12 + a 22 b 22 Recurrence for this D&C algorithm is T (n) = 8T (n/2) + O(n 2 ). But this solves to T (n) = O(n 3 )!
32 Strassen s Algorithm Strassen chose these submatrices to multiply: P 1 = (a 11 + a 22 )(b 11 + b 22 ) P 2 = (a 21 + a 22 )b 11 P 3 = a 11 (b 12 b 22 ) P 4 = a 22 (b 21 b 11 ) P 5 = (a 11 + a 12 )b 22 P 6 = (a 21 a 11 )(b 11 + b 12 ) P 7 = (a 12 a 22 )(b 21 + b 22 )
33 Strassen s Algorithm Then, c 11 = P 1 + P 4 P 5 + P 7 c 12 = P 3 + P 5 c 21 = P 2 + P 4 c 22 = P 1 + P 3 P 2 + P 6 Recurrence for this algorithm is T (n) = 7T (n/2) + O(n 2 ).
34 Strassen s Algorithm The recurrence T (n) = 7T (n/2) + O(n 2 ). solves to T (n) = O(n log 2 7 ) = O(n 2.81 ). Ever since other researchers have tried other products to beat this bound. E.g. Victor Pan discovered a way to multiply two matrices using 143, 640 multiplications. Using more advanced methods, the current best algorithm for multiplying two n n matrices runs in roughly O(n ) time.
35 Quick Sort Algorithm Simple, fast, widely used in practice. Can be done in place; no extra space. General Form: 1. Partition: Divide into two subarrays, L and R; elements in L are all smaller than those in R. 2. Recurse: Sort L and R recursively. 3. Combine: Append R to the end of L. Partition (A, p, q, i) partitions A with pivot A[i].
36 Partition Partition returns the index of the cell containing the pivot in the reorganized array Example: Partition (A, 0, 10, 3). 4, 3, 2, 6, 7, 11, 9, 10, 13, 21, 8
37 Quick Sort Algorithm QuickSort (A, p, q) sorts the subarray A[p q]. Initial call with p = 0 and q = n 1. QuickSort(A, p, q) if p q then return i random(p, q) r Partition(A, p, q, i) Quicksort (A, p, r 1) Quicksort (A, r + 1, q)
38 Analysis of QuickSort Lucky Case: Each Partition splits array in halves. We get T (n) = 2T (n/2) + Θ(n) = Θ(n log n). Unlucky Case: Each partition gives unbalanced split. We get T (n) = T (n 1) + Θ(n) = Θ(n 2 ). In worst case, Quick Sort as bad as BubbleSort. The worst-case occurs when the list is already sorted, and the last element chosen as pivot. But, while BubbleSort always performs poorly on certain inputs, because of random pivot, QuickSort has a chance of doing much better.
39 Analyzing QuickSort T (n): runtime of randomized QuickSort. Assume all elements are distinct. Recurrence for T (n) depends on two subproblem sizes, which depend on random partition element. If pivot is i smallest element, then exactly (i 1) items in L and (n i) in R. Call it an i-split. What s the probability of i-split? Each element equally likely to be chosen as pivot, so the answer is 1 n.
40 Solving the Recurrence T (n) = = 1 n = 2 n = 2 n n i=1 1 (runtime with i-split) + n + 1 n n (T (i 1) + T (n i)) + n + 1 i=1 n T (i 1) + n + 1 i=1 n 1 i=0 T (i) + n + 1
41 Solving the Recurrence Multiply both sides by n. Subtract the same formula for n 1. nt (n) = 2 (n 1)T (n 1) = 2 n 1 i=0 n 2 i=0 T (i) + n 2 + n T (i) + (n 1) 2 + (n 1)
42 Solving the Recurrence nt (n) = (n + 1)T (n 1) + 2n T (n) n + 1 T (n 1) = n T (n 2) = n 1. = T (2) n + 3 i=3 + 2 n n + 2 n i = Θ(1) + 2 ln n Thus, T (n) 2(n + 1) ln n.
43 Median Finding Median of n items is the item with rank n/2. Rank of an item is its position in the list if the items were sorted in ascending order. Rank i item also called ith statistic. Example: {16, 5, 30, 8, 55}. Popular statistics are quantiles: items of rank n/4, n/2, 3n/4. SAT/GRE: which score value forms 95th percentile? Item of rank 0.95n.
44 Median Finding After spending O(n log n) time on sorting, any rank can be found in O(n) time. Can we find a rank without sorting?
45 Min and Max Finding We can find items of rank 1 or n in O(n) time. minimum (A) min A[0] for i = 1 to n 1 do if min > A[i] then min A[i]; return min The algorithm minimum finds the smallest (rank 1) item in O(n) time. A similar algorithm finds maximum item.
46 Both Min and Max Find both min and max using 3n/2 comparisons. MIN-MAX (A) if A = 1, then return min = max = A[0] Divide A into two equal subsets A 1, A 2 (min 1, max 1 ) := MIN-MAX (A 1 ) (min 2, max 2 ) := MIN-MAX (A 2 ) if min 1 min 2 then return min = min 1 else return min = min 2 if max 1 max 2 then return max = max 1 else return max = max 2
47 Both Min and Max The recurrence for this algorithm is T (n) = 2T (n/2) + 2. Verify this solves to T (n) = 3n/2 2.
48 Finding Item of Rank k Direct extension of min/max finding to rank k item will take Θ(kn) time. In particular, finding the median will take Ω(n 2 ) time, which is worse than sorting. Median can be used as a perfect pivot for (deterministic) quick sort. But only if found faster than sorting itself. We present a linear time algorithm for selecting rank k item [BFPRT 1973].
49 Linear Time Selection SELECT (k) 1. Divide items into n/5 groups of 5 each. 2. Find the median of each group (using sorting). 3. Recursively find median of n/5 group medians. 4. Partition using median-of-median as pivot. 5. Let low side have s, and high side have n s items. 6. If k s, call select(k) on low side; otherwise, call select(k s) on high side.
50 Illustration Divide items into n/5 groups of 5 items each. Find the median of each group (using sorting). Use SELECT to recursively find the median of the n/5 group medians. x medians x = median of medians Group 1 Group 2 Group 3 Group 4 Group 5 Group 6
51 Illustration Partition the input by using this median-of-median as pivot. Suppose low side of the partition has s elements, and high side has n s elements. If k s, recursively call SELECT(k) on low side; otherwise, recursively call SELECT(k s) on high side. x Items => x Group 1 Group 6 Group 3 Group 4 Group 5 Group 2
52 Recurrence For runtime analysis, we bound the number of items x, the median of medians. At least half the medians are x. At least half of the n/5 groups contribute at least 3 items to the high side. (Only the last group can contribute fewer. Thus, items x are at least ( n ) n Similarly, items x is also 3n/10 6.
53 Recurrence Recursive call to select is on size 7n/ Let T (n) = worst-case complexity of select. Group medians, and partition take O(n) time. Step 3 has a recursive call T (n/5), and Step 5 has a recursive call T (7n/10 + 6). Thus, we have the recurrence: T (n) T ( n 5 ) + T (7n ) + O(n). Assume T (n) = O(1) for small n 80.
54 Recurrence T (n) T ( n 5 ) + T (7n ) + O(n) Inductively verify that T (n) cn for some constant c. T (n) c(n/5) + c(7n/10 + 6) + O(n) 9cn/10 + 6c + O(n) cn In above, choose c so that c(n/10 6) beats the function O(n) for all n.
55 Convex Hulls 1. Convex hulls are to CG what sorting is to discrete algorithms. 2. First order shape approximation. Invariant under rotation and translation. p 3. Rubber-band analogy.
56 Convex Hulls Many aplications in robotics, shape analysis, line fitting etc. Example: if CH(P 1 ) CH(P 2 ) =, then objects P 1 and P 2 do not intersect. Convex Hull Problem: Given a finite set of points S, compute its convex hull CH(S). (Ordered vertex list.)
57 Divide and Conquer Upper Tangent CH(A) A B CH(B) Sort points by X-coordinates. Divide points into equal halves A and B. Recursively compute CH(A) and CH(B). Merge CH(A) and CH(B) to obtain CH(S).
58 Merging Convex Hulls Lower Tangent a = rightmost point of CH(A). b = leftmost point of CH(B). while ab not lower tangent of CH(A) and CH(B) do 1. while ab not lower tangent to CH(A) set a = a 1 (move a CW); 2. while ab not lower tangent to CH(B) set b = b + 1 (move b CCW); Return ab
59 Tangent Finding b CH(A) a CH(B)
60 Analysis of D&C Upper Tangent CH(A) A B CH(B) Initial sorting takes O(N log N) time. Recurrence T (N) = 2T (N/2) + O(N) O(N) for merging (computing tangents). Recurrence solves to T (N) = O(N log N).
Closest Pair Problem
Closest Pair Problem Given n points in d-dimensions, find two whose mutual distance is smallest. Fundamental problem in many applications as well as a key step in many algorithms. p q A naive algorithm
CS473 - Algorithms I
CS473 - Algorithms I Lecture 4 The Divide-and-Conquer Design Paradigm View in slide-show mode 1 Reminder: Merge Sort Input array A sort this half sort this half Divide Conquer merge two sorted halves Combine
Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology Professors Erik Demaine and Shafi Goldwasser Quiz 1.
Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Quiz 1 Quiz 1 Do not open this quiz booklet until you are directed
Sorting revisited. Build the binary search tree: O(n^2) Traverse the binary tree: O(n) Total: O(n^2) + O(n) = O(n^2)
Sorting revisited How did we use a binary search tree to sort an array of elements? Tree Sort Algorithm Given: An array of elements to sort 1. Build a binary search tree out of the elements 2. Traverse
Algorithms. Margaret M. Fleck. 18 October 2010
Algorithms Margaret M. Fleck 18 October 2010 These notes cover how to analyze the running time of algorithms (sections 3.1, 3.3, 4.4, and 7.1 of Rosen). 1 Introduction The main reason for studying big-o
Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally
Recurrence Relations Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally modeled by recurrence relations. A recurrence relation is an equation which
CSC148 Lecture 8. Algorithm Analysis Binary Search Sorting
CSC148 Lecture 8 Algorithm Analysis Binary Search Sorting Algorithm Analysis Recall definition of Big Oh: We say a function f(n) is O(g(n)) if there exists positive constants c,b such that f(n)
Algorithm Analysis [2]: if-else statements, recursive algorithms. COSC 2011, Winter 2004, Section N Instructor: N. Vlajic
![Algorithm Analysis [2]: if-else statements, recursive algorithms. COSC 2011, Winter 2004, Section N Instructor: N. Vlajic](/thumbs/40/20847591.jpg "Algorithm Analysis [2]: if-else statements, recursive algorithms. COSC 2011, Winter 2004, Section N Instructor: N. Vlajic")
1 Algorithm Analysis []: if-else statements, recursive algorithms COSC 011, Winter 004, Section N Instructor: N. Vlajic Algorithm Analysis for-loop Running Time The running time of a simple loop for (int
Computational Geometry. Lecture 1: Introduction and Convex Hulls
Lecture 1: Introduction and convex hulls 1 Geometry: points, lines,... Plane (two-dimensional), R 2 Space (three-dimensional), R 3 Space (higher-dimensional), R d A point in the plane, 3-dimensional space,
Analysis of Binary Search algorithm and Selection Sort algorithm
Analysis of Binary Search algorithm and Selection Sort algorithm In this section we shall take up two representative problems in computer science, work out the algorithms based on the best strategy to
Kapitel 1 Multiplication of Long Integers (Faster than Long Multiplication)
Kapitel 1 Multiplication of Long Integers (Faster than Long Multiplication) Arno Eigenwillig und Kurt Mehlhorn An algorithm for multiplication of integers is taught already in primary school: To multiply
Dynamic Programming. Lecture 11. 11.1 Overview. 11.2 Introduction
Lecture 11 Dynamic Programming 11.1 Overview Dynamic Programming is a powerful technique that allows one to solve many different types of problems in time O(n 2 ) or O(n 3 ) for which a naive approach
Randomized algorithms
Randomized algorithms March 10, 2005 1 What are randomized algorithms? Algorithms which use random numbers to make decisions during the executions of the algorithm. Why would we want to do this?? Deterministic
The Tower of Hanoi. Recursion Solution. Recursive Function. Time Complexity. Recursive Thinking. Why Recursion? n! = n* (n-1)!
The Tower of Hanoi Recursion Solution recursion recursion recursion Recursive Thinking: ignore everything but the bottom disk. 1 2 Recursive Function Time Complexity Hanoi (n, src, dest, temp): If (n >
Biostatistics 615/815
Merge Sort Biostatistics 615/815 Lecture 8 Notes on Problem Set 2 Union Find algorithms Dynamic Programming Results were very ypositive! You should be gradually becoming g y g comfortable compiling, debugging
CSE 421 Algorithms: Divide and Conquer
CSE 421 Algorithms: Divide and Conquer Summer 2011 Larry Ruzzo Thanks to Paul Beame, James Lee, Kevin Wayne for some slides hw2 empirical run times e n Plot Time vs n Fit curve to it (e.g., with Excel)
Outline BST Operations Worst case Average case Balancing AVL Red-black B-trees. Binary Search Trees. Lecturer: Georgy Gimel farb
Binary Search Trees Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 27 1 Properties of Binary Search Trees 2 Basic BST operations The worst-case time complexity of BST operations
CSE 326, Data Structures. Sample Final Exam. Problem Max Points Score 1 14 (2x7) 2 18 (3x6) 3 4 4 7 5 9 6 16 7 8 8 4 9 8 10 4 Total 92.
Name: Email ID: CSE 326, Data Structures Section: Sample Final Exam Instructions: The exam is closed book, closed notes. Unless otherwise stated, N denotes the number of elements in the data structure
MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS. + + x 2. x n. a 11 a 12 a 1n b 1 a 21 a 22 a 2n b 2 a 31 a 32 a 3n b 3. a m1 a m2 a mn b m
MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS 1. SYSTEMS OF EQUATIONS AND MATRICES 1.1. Representation of a linear system. The general system of m equations in n unknowns can be written a 11 x 1 + a 12 x 2 +
Converting a Number from Decimal to Binary
Converting a Number from Decimal to Binary Convert nonnegative integer in decimal format (base 10) into equivalent binary number (base 2) Rightmost bit of x Remainder of x after division by two Recursive
Discrete Optimization
Discrete Optimization [Chen, Batson, Dang: Applied integer Programming] Chapter 3 and 4.1-4.3 by Johan Högdahl and Victoria Svedberg Seminar 2, 2015-03-31 Todays presentation Chapter 3 Transforms using
Divide-and-conquer algorithms
Chapter 2 Divide-and-conquer algorithms The divide-and-conquer strategy solves a problem by: 1 Breaking it into subproblems that are themselves smaller instances of the same type of problem 2 Recursively
recursion, O(n), linked lists 6/14
recursion, O(n), linked lists 6/14 recursion reducing the amount of data to process and processing a smaller amount of data example: process one item in a list, recursively process the rest of the list
5.4 Closest Pair of Points
5.4 Closest Pair of Points Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric primitive. Graphics, computer
Chapter 3. if 2 a i then location: = i. Page 40
Chapter 3 1. Describe an algorithm that takes a list of n integers a 1,a 2,,a n and finds the number of integers each greater than five in the list. Ans: procedure greaterthanfive(a 1,,a n : integers)
a 11 x 1 + a 12 x 2 + + a 1n x n = b 1 a 21 x 1 + a 22 x 2 + + a 2n x n = b 2.
Chapter 1 LINEAR EQUATIONS 1.1 Introduction to linear equations A linear equation in n unknowns x 1, x,, x n is an equation of the form a 1 x 1 + a x + + a n x n = b, where a 1, a,..., a n, b are given
A Note on Maximum Independent Sets in Rectangle Intersection Graphs
A Note on Maximum Independent Sets in Rectangle Intersection Graphs Timothy M. Chan School of Computer Science University of Waterloo Waterloo, Ontario N2L 3G1, Canada tmchan@uwaterloo.ca September 12,
28 Closest-Point Problems -------------------------------------------------------------------
28 Closest-Point Problems ------------------------------------------------------------------- Geometric problems involving points on the plane usually involve implicit or explicit treatment of distances
Lecture 1: Course overview, circuits, and formulas
Lecture 1: Course overview, circuits, and formulas Topics in Complexity Theory and Pseudorandomness (Spring 2013) Rutgers University Swastik Kopparty Scribes: John Kim, Ben Lund 1 Course Information Swastik
MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS
MATRIX ALGEBRA AND SYSTEMS OF EQUATIONS Systems of Equations and Matrices Representation of a linear system The general system of m equations in n unknowns can be written a x + a 2 x 2 + + a n x n b a
Data Structures. Algorithm Performance and Big O Analysis
Data Structures Algorithm Performance and Big O Analysis What s an Algorithm? a clearly specified set of instructions to be followed to solve a problem. In essence: A computer program. In detail: Defined
Sorting Algorithms. Nelson Padua-Perez Bill Pugh. Department of Computer Science University of Maryland, College Park
Sorting Algorithms Nelson Padua-Perez Bill Pugh Department of Computer Science University of Maryland, College Park Overview Comparison sort Bubble sort Selection sort Tree sort Heap sort Quick sort Merge
In mathematics, it is often important to get a handle on the error term of an approximation. For instance, people will write
Big O notation (with a capital letter O, not a zero), also called Landau's symbol, is a symbolism used in complexity theory, computer science, and mathematics to describe the asymptotic behavior of functions.
Efficiency of algorithms. Algorithms. Efficiency of algorithms. Binary search and linear search. Best, worst and average case.
Algorithms Efficiency of algorithms Computational resources: time and space Best, worst and average case performance How to compare algorithms: machine-independent measure of efficiency Growth rate Complexity
6. Standard Algorithms
6. Standard Algorithms The algorithms we will examine perform Searching and Sorting. 6.1 Searching Algorithms Two algorithms will be studied. These are: 6.1.1. inear Search The inear Search The Binary
1 Review of Newton Polynomials
cs: introduction to numerical analysis 0/0/0 Lecture 8: Polynomial Interpolation: Using Newton Polynomials and Error Analysis Instructor: Professor Amos Ron Scribes: Giordano Fusco, Mark Cowlishaw, Nathanael
Appendix: Solving Recurrences [Fa 10] Wil Wheaton: Embrace the dark side! Sheldon: That s not even from your franchise!
![Appendix: Solving Recurrences [Fa 10] Wil Wheaton: Embrace the dark side! Sheldon: That s not even from your franchise!](/thumbs/40/21561096.jpg "Appendix: Solving Recurrences [Fa 10] Wil Wheaton: Embrace the dark side! Sheldon: That s not even from your franchise!")
Change is certain. Peace is followed by disturbances; departure of evil men by their return. Such recurrences should not constitute occasions for sadness but realities for awareness, so that one may be
APP INVENTOR. Test Review
APP INVENTOR Test Review Main Concepts App Inventor Lists Creating Random Numbers Variables Searching and Sorting Data Linear Search Binary Search Selection Sort Quick Sort Abstraction Modulus Division
Outline. Introduction Linear Search. Transpose sequential search Interpolation search Binary search Fibonacci search Other search techniques
Searching (Unit 6) Outline Introduction Linear Search Ordered linear search Unordered linear search Transpose sequential search Interpolation search Binary search Fibonacci search Other search techniques
CS473 - Algorithms I
CS473 - Algorithms I Lecture 9 Sorting in Linear Time View in slide-show mode 1 How Fast Can We Sort? The algorithms we have seen so far: Based on comparison of elements We only care about the relative
External Sorting. Chapter 13. Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1
External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing
2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]
![2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]](/thumbs/40/21097758.jpg "2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]")
Code No: R05220502 Set No. 1 1. (a) Describe the performance analysis in detail. (b) Show that f 1 (n)+f 2 (n) = 0(max(g 1 (n), g 2 (n)) where f 1 (n) = 0(g 1 (n)) and f 2 (n) = 0(g 2 (n)). [8+8] 2. (a)
Near Optimal Solutions
Near Optimal Solutions Many important optimization problems are lacking efficient solutions. NP-Complete problems unlikely to have polynomial time solutions. Good heuristics important for such problems.
Analysis of Algorithms I: Binary Search Trees
Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary
Binary search algorithm
Binary search algorithm Definition Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than
Analysis of Computer Algorithms. Algorithm. Algorithm, Data Structure, Program
Analysis of Computer Algorithms Hiroaki Kobayashi Input Algorithm Output 12/13/02 Algorithm Theory 1 Algorithm, Data Structure, Program Algorithm Well-defined, a finite step-by-step computational procedure
Closest Pair of Points. Kleinberg and Tardos Section 5.4
Closest Pair of Points Kleinberg and Tardos Section 5.4 Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric
Lecture 3: Finding integer solutions to systems of linear equations
Lecture 3: Finding integer solutions to systems of linear equations Algorithmic Number Theory (Fall 2014) Rutgers University Swastik Kopparty Scribe: Abhishek Bhrushundi 1 Overview The goal of this lecture
Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction
Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know
To My Parents -Laxmi and Modaiah. To My Family Members. To My Friends. To IIT Bombay. To All Hard Workers
To My Parents -Laxmi and Modaiah To My Family Members To My Friends To IIT Bombay To All Hard Workers Copyright 2010 by CareerMonk.com All rights reserved. Designed by Narasimha Karumanchi Printed in
Computer Science 210: Data Structures. Searching
Computer Science 210: Data Structures Searching Searching Given a sequence of elements, and a target element, find whether the target occurs in the sequence Variations: find first occurence; find all occurences
Lecture 13 - Basic Number Theory.
Lecture 13 - Basic Number Theory. Boaz Barak March 22, 2010 Divisibility and primes Unless mentioned otherwise throughout this lecture all numbers are non-negative integers. We say that A divides B, denoted
CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team
CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we learned about the ADT Priority Queue. A
Binary Heaps * * * * * * * / / \ / \ / \ / \ / \ * * * * * * * * * * * / / \ / \ / / \ / \ * * * * * * * * * *
Binary Heaps A binary heap is another data structure. It implements a priority queue. Priority Queue has the following operations: isempty add (with priority) remove (highest priority) peek (at highest
MATH10212 Linear Algebra. Systems of Linear Equations. Definition. An n-dimensional vector is a row or a column of n numbers (or letters): a 1.
MATH10212 Linear Algebra Textbook: D. Poole, Linear Algebra: A Modern Introduction. Thompson, 2006. ISBN 0-534-40596-7. Systems of Linear Equations Definition. An n-dimensional vector is a row or a column
Matrix-Chain Multiplication
Matrix-Chain Multiplication Let A be an n by m matrix, let B be an m by p matrix, then C = AB is an n by p matrix. C = AB can be computed in O(nmp) time, using traditional matrix multiplication. Suppose
1 Error in Euler s Method
1 Error in Euler s Method Experience with Euler s 1 method raises some interesting questions about numerical approximations for the solutions of differential equations. 1. What determines the amount of
Chapter Objectives. Chapter 9. Sequential Search. Search Algorithms. Search Algorithms. Binary Search
Chapter Objectives Chapter 9 Search Algorithms Data Structures Using C++ 1 Learn the various search algorithms Explore how to implement the sequential and binary search algorithms Discover how the sequential
SIMS 255 Foundations of Software Design. Complexity and NP-completeness
SIMS 255 Foundations of Software Design Complexity and NP-completeness Matt Welsh November 29, 2001 mdw@cs.berkeley.edu 1 Outline Complexity of algorithms Space and time complexity ``Big O'' notation Complexity
Lecture 2 Matrix Operations
Lecture 2 Matrix Operations transpose, sum & difference, scalar multiplication matrix multiplication, matrix-vector product matrix inverse 2 1 Matrix transpose transpose of m n matrix A, denoted A T or
1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++
Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The
Shortest Path Algorithms
Shortest Path Algorithms Jaehyun Park CS 97SI Stanford University June 29, 2015 Outline Cross Product Convex Hull Problem Sweep Line Algorithm Intersecting Half-planes Notes on Binary/Ternary Search Cross
For example, we have seen that a list may be searched more efficiently if it is sorted.
Sorting 1 Many computer applications involve sorting the items in a list into some specified order. For example, we have seen that a list may be searched more efficiently if it is sorted. To sort a group
External Sorting. Why Sort? 2-Way Sort: Requires 3 Buffers. Chapter 13
External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing
5.2 The Master Theorem
170 CHAPTER 5. RECURSION AND RECURRENCES 5.2 The Master Theorem Master Theorem In the last setion, we saw three different kinds of behavior for reurrenes of the form at (n/2) + n These behaviors depended
ECE 842 Report Implementation of Elliptic Curve Cryptography
ECE 842 Report Implementation of Elliptic Curve Cryptography Wei-Yang Lin December 15, 2004 Abstract The aim of this report is to illustrate the issues in implementing a practical elliptic curve cryptographic
Matrix Algebra. Some Basic Matrix Laws. Before reading the text or the following notes glance at the following list of basic matrix algebra laws.
Matrix Algebra A. Doerr Before reading the text or the following notes glance at the following list of basic matrix algebra laws. Some Basic Matrix Laws Assume the orders of the matrices are such that
Chapter 13: Query Processing. Basic Steps in Query Processing
Chapter 13: Query Processing! Overview! Measures of Query Cost! Selection Operation! Sorting! Join Operation! Other Operations! Evaluation of Expressions 13.1 Basic Steps in Query Processing 1. Parsing
Algorithm Design and Analysis Homework #1 Due: 5pm, Friday, October 4, 2013 TA email: ada@csie.ntu.edu.tw. === Homework submission instructions ===
Algorithm Design and Analysis Homework #1 Due: 5pm, Friday, October 4, 2013 TA email: ada@csie.ntu.edu.tw === Homework submission instructions === For Problem 1, commit your source code and a brief documentation
From Last Time: Remove (Delete) Operation
CSE 32 Lecture : More on Search Trees Today s Topics: Lazy Operations Run Time Analysis of Binary Search Tree Operations Balanced Search Trees AVL Trees and Rotations Covered in Chapter of the text From
Analysis of Algorithms I: Optimal Binary Search Trees
Analysis of Algorithms I: Optimal Binary Search Trees Xi Chen Columbia University Given a set of n keys K = {k 1,..., k n } in sorted order: k 1 < k 2 < < k n we wish to build an optimal binary search
Solutions to Homework 6
Solutions to Homework 6 Debasish Das EECS Department, Northwestern University ddas@northwestern.edu 1 Problem 5.24 We want to find light spanning trees with certain special properties. Given is one example
Lecture 3. Linear Programming. 3B1B Optimization Michaelmas 2015 A. Zisserman. Extreme solutions. Simplex method. Interior point method
Lecture 3 3B1B Optimization Michaelmas 2015 A. Zisserman Linear Programming Extreme solutions Simplex method Interior point method Integer programming and relaxation The Optimization Tree Linear Programming
Zabin Visram Room CS115 CS126 Searching. Binary Search
Zabin Visram Room CS115 CS126 Searching Binary Search Binary Search Sequential search is not efficient for large lists as it searches half the list, on average Another search algorithm Binary search Very
DERIVATIVES AS MATRICES; CHAIN RULE
DERIVATIVES AS MATRICES; CHAIN RULE 1. Derivatives of Real-valued Functions Let s first consider functions f : R 2 R. Recall that if the partial derivatives of f exist at the point (x 0, y 0 ), then we
We can express this in decimal notation (in contrast to the underline notation we have been using) as follows: 9081 + 900b + 90c = 9001 + 100c + 10b
In this session, we ll learn how to solve problems related to place value. This is one of the fundamental concepts in arithmetic, something every elementary and middle school mathematics teacher should
CHAPTER 5 Round-off errors
CHAPTER 5 Round-off errors In the two previous chapters we have seen how numbers can be represented in the binary numeral system and how this is the basis for representing numbers in computers. Since any
COMP 250 Fall 2012 lecture 2 binary representations Sept. 11, 2012
Binary numbers The reason humans represent numbers using decimal (the ten digits from 0,1,... 9) is that we have ten fingers. There is no other reason than that. There is nothing special otherwise about
Section IV.1: Recursive Algorithms and Recursion Trees
Section IV.1: Recursive Algorithms and Recursion Trees Definition IV.1.1: A recursive algorithm is an algorithm that solves a problem by (1) reducing it to an instance of the same problem with smaller
Algorithms for Computing Convex Hulls Using Linear Programming
Algorithms for Computing Convex Hulls Using Linear Programming Bo Mortensen, 20073241 Master s Thesis, Computer Science February 2015 Advisor: Peyman Afshani Advisor: Gerth Stølting Brodal AARHUS AU UNIVERSITY
Approximation Algorithms
Approximation Algorithms or: How I Learned to Stop Worrying and Deal with NP-Completeness Ong Jit Sheng, Jonathan (A0073924B) March, 2012 Overview Key Results (I) General techniques: Greedy algorithms
CALCULATIONS & STATISTICS
CALCULATIONS & STATISTICS CALCULATION OF SCORES Conversion of 1-5 scale to 0-100 scores When you look at your report, you will notice that the scores are reported on a 0-100 scale, even though respondents
www.mathsbox.org.uk ab = c a If the coefficients a,b and c are real then either α and β are real or α and β are complex conjugates
Further Pure Summary Notes. Roots of Quadratic Equations For a quadratic equation ax + bx + c = 0 with roots α and β Sum of the roots Product of roots a + b = b a ab = c a If the coefficients a,b and c
Notes on Determinant
ENGG2012B Advanced Engineering Mathematics Notes on Determinant Lecturer: Kenneth Shum Lecture 9-18/02/2013 The determinant of a system of linear equations determines whether the solution is unique, without
Row Echelon Form and Reduced Row Echelon Form
These notes closely follow the presentation of the material given in David C Lay s textbook Linear Algebra and its Applications (3rd edition) These notes are intended primarily for in-class presentation
Binary Search Trees. A Generic Tree. Binary Trees. Nodes in a binary search tree ( B-S-T) are of the form. P parent. Key. Satellite data L R
Binary Search Trees A Generic Tree Nodes in a binary search tree ( B-S-T) are of the form P parent Key A Satellite data L R B C D E F G H I J The B-S-T has a root node which is the only node whose parent
TU e. Advanced Algorithms: experimentation project. The problem: load balancing with bounded look-ahead. Input: integer m 2: number of machines
The problem: load balancing with bounded look-ahead Input: integer m 2: number of machines integer k 0: the look-ahead numbers t 1,..., t n : the job sizes Problem: assign jobs to machines machine to which
FACTORING LARGE NUMBERS, A GREAT WAY TO SPEND A BIRTHDAY
FACTORING LARGE NUMBERS, A GREAT WAY TO SPEND A BIRTHDAY LINDSEY R. BOSKO I would like to acknowledge the assistance of Dr. Michael Singer. His guidance and feedback were instrumental in completing this
Lecture Notes 2: Matrices as Systems of Linear Equations
2: Matrices as Systems of Linear Equations 33A Linear Algebra, Puck Rombach Last updated: April 13, 2016 Systems of Linear Equations Systems of linear equations can represent many things You have probably
Systems of Linear Equations
Systems of Linear Equations Beifang Chen Systems of linear equations Linear systems A linear equation in variables x, x,, x n is an equation of the form a x + a x + + a n x n = b, where a, a,, a n and
Unit 1 Number Sense. In this unit, students will study repeating decimals, percents, fractions, decimals, and proportions.
Unit 1 Number Sense In this unit, students will study repeating decimals, percents, fractions, decimals, and proportions. BLM Three Types of Percent Problems (p L-34) is a summary BLM for the material
I. GROUPS: BASIC DEFINITIONS AND EXAMPLES
I GROUPS: BASIC DEFINITIONS AND EXAMPLES Definition 1: An operation on a set G is a function : G G G Definition 2: A group is a set G which is equipped with an operation and a special element e G, called
Linear Programming. March 14, 2014
Linear Programming March 1, 01 Parts of this introduction to linear programming were adapted from Chapter 9 of Introduction to Algorithms, Second Edition, by Cormen, Leiserson, Rivest and Stein [1]. 1
CSC 180 H1F Algorithm Runtime Analysis Lecture Notes Fall 2015
1 Introduction These notes introduce basic runtime analysis of algorithms. We would like to be able to tell if a given algorithm is time-efficient, and to be able to compare different algorithms. 2 Linear
Chapter 6: Episode discovery process
Chapter 6: Episode discovery process Algorithmic Methods of Data Mining, Fall 2005, Chapter 6: Episode discovery process 1 6. Episode discovery process The knowledge discovery process KDD process of analyzing
Data Structures and Data Manipulation
Data Structures and Data Manipulation What the Specification Says: Explain how static data structures may be used to implement dynamic data structures; Describe algorithms for the insertion, retrieval
Notes from Week 1: Algorithms for sequential prediction
CS 683 Learning, Games, and Electronic Markets Spring 2007 Notes from Week 1: Algorithms for sequential prediction Instructor: Robert Kleinberg 22-26 Jan 2007 1 Introduction In this course we will be looking
Data Structures Fibonacci Heaps, Amortized Analysis
Chapter 4 Data Structures Fibonacci Heaps, Amortized Analysis Algorithm Theory WS 2012/13 Fabian Kuhn Fibonacci Heaps Lacy merge variant of binomial heaps: Do not merge trees as long as possible Structure:
6.207/14.15: Networks Lecture 15: Repeated Games and Cooperation
6.207/14.15: Networks Lecture 15: Repeated Games and Cooperation Daron Acemoglu and Asu Ozdaglar MIT November 2, 2009 1 Introduction Outline The problem of cooperation Finitely-repeated prisoner s dilemma