1 / 19

CSC 2300 Data Structures & Algorithms

CSC 2300 Data Structures & Algorithms. January 26, 2007 Chapter 2. Algorithm Analysis. Today. Maximum subsequence sum problem. Maximum Subsequence Sum. Given (possibly negative) integers A 1 , A 2 ,…, A N , find the maximum value of ∑ A k (where k goes from i to j inside the summation).

jimmybell
Download Presentation

CSC 2300 Data Structures & Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSC 2300Data Structures & Algorithms January 26, 2007 Chapter 2. Algorithm Analysis

  2. Today • Maximum subsequence sum problem

  3. Maximum Subsequence Sum • Given (possibly negative) integers A1, A2,…, AN, find the maximum value of ∑Ak (where k goes from i to j inside the summation). • For input -2, 11, -4, 13, -5, -2, what is the answer? • 20 (A2 through A4). • Base case: What if all the given integers are negative? • We take the maximum subsequence sum to be 0. • Let us discuss four algorithms to solve this problem.

  4. Running Times of Four Algorithms

  5. Plot of Time versus N

  6. Plot of Time versus N

  7. Algorithm 1 • What is the running time? • O(n3). Why O(n3)?

  8. Improve Algorithm 1? • Which statement requires O(n3) work? • Line 14. • Can we reduce the work?

  9. Algorithm 2 • What is the running time? • O(n2). Why O(n2)?

  10. Algorithm 3 • What is the running time? • O(N logN). Why?

  11. Recursive Procedure • Algorithm 3 is a recursive O(N log N) technique. • It uses a divide-and-conquer strategy. • Divide Part: The idea is to split the problem into two roughly equal subproblems, which are then solved recursively. • Conquer Part: Patch together the two solutions of the subproblems, and possibly do a small amount of additional work to arrive at a solution for the whole problem.

  12. Three Possibilities • The maximum subsequence sum can be in one of three places: entirely in the left half of the input, entirely in the right half, or in both halves by crossing the middle. • The first two cases can be solved recursively. • The third case can be obtained by finding the largest sum in the first half that includes the last element in the first half, and the largest sum in the second half that includes the first element in the second half. The two sums are then added together.

  13. Example • First Half Second Half ---------------------------------- 4 -3 5 -2 -1 2 6 -2 • The maximum subsequence sum for the first half is 6 (elements A1 through A3). • The maximum subsequence sum for the second half is 8 (elements A6 through A7). • The maximum subsequence sum in the first half that includes the last element in the first half is 4 (elements A1 through A4), and the maximum subsequence sum in the second half that includes the first element in the second half is 7 (elements A5 through A7). Thus, the maximum sum that spans both halves and goes through the middle is 11 (elements A1 through A7). • Thus, the third choice provides the solution.

  14. Running Time Analysis • Let T(N) be the time it takes to solve a maximum subsequence sum problem of size N. • If N=1, then the program takes some constant amount of time to execute lines 8 to 12, which we shall call one unit. Thus, T(1) = 1. • Otherwise, the program must perform two recursive calls, the two FOR loops between lines 19 and 32, and some small amount of bookkeeping, such as lines 14 and 34. The time expended in lines 19 to 32 is O(N). The code in lines 8 to 14, 18, 26, and 34 is all a constant amount of work and can be ignored compared with O(N). The remainder of the work is performed in lines 15 and 16. These lines solve two subsequence problems of size N/2 (assuming N is even). • We get the equations: T(1) = 1, T(N) = 2 T(N/2) + O(N).

  15. Finding T(N) • We have T(N) = 2 T(N/2) + O(N), T(1) = 1. • To simplify the calculations, we can replace the O(N) term in the equation by N: T(N) = 2 T(N/2) + N, T(1) = 1. • Since T(N) will be expressed in Big-Oh notation anyway, this will not affect the answer. • We shall learn how to solve the equation rigorously. • For now, we have T(1) = 1 = 1*1, T(2) = 2*1 + 2 = 4 = 2*2, T(4) = 2*4 + 4 = 12 = 4*3, T(8) = 2*12 + 8 = 32 = 8*4, T(16) = 2*32 + 16 = 80 = 16*5. • The pattern that can be derived is that if N = 2k, then T(N) = N*(k+1) = N logN + N = O(N logN).

  16. Algorithm 4 • What is the running time? • O(n). Why O(n)?

  17. Example 1 • Input: 4 -3 5 -2 -1 2 6 -2

  18. Example 2 • Input: 4 -7 5 -2 -8 2 6 -3

  19. Explanation • Like Algorithms 1 and 2, the subsequence goes from i to j. • To find the sum, we do not need i. • If a[i] is negative, it cannot be the start of the optimal subsequence. • Any negative subsequence cannot be the prefix of the optimal subsequence.

More Related