Some more example algorithms

• The Maximum subsequence problem.
  • Given a sequence of integers A₁, A₂, ... A_n, find the maximum value of Σ_k=i^jA_k. For convenience, if the sum is less than 0, let the sum be 0.
  • Example 1, Brute Force:
    • Try every possible sum by explicitly computing it.

      MaxSubsequence(A)
      
       maxSum <- 0
       for startPos <- 0 to A.size()-1 do
          for sequenceLength <- 0 to A.size()-1-startPos do
             thisSum <- 0
             for i<- startPos to sequenceLength do
                thisSum <- thisSum + A[i]
             if thisSum > maxSum
                maxSum <- thisSum
       return maxSum
      
          

    • In line two we look at every number as a possible start for a sequence.
    • In line three we look at every possible length for a sequence with this starting position
    • Lines 4 through 6 calculate the sum.
    • Lines 7 and 8 record a new max if one occurs.
    • This is clearly O(n³) where n is the length of the sequence
    • Notice this is a horrid computation, it recomputes many sub-sequence sums over and over again.
  • A recursive algorithm
    • Split the sequence in the middle, the max subsequence must be from the left side, the right side, or contain the middle.

    • MaxSubsequence(A,start, stop)
      
        if start = stop
          if A[start] > 0
             return A[start]
          else
             return 0
        center <- (start+stop) /2
        leftSum <- MaxSubsequence (A, start, center)
        rightSum <- MaxSubsequence(A, center+1, stop)
        leftPartialSum <- 0
        leftMaxSum <- 0
        for i <- center to start do
           leftPartialSum < leftPartialSum + A[i]
           if leftPartialSum > leftMaxSum 
               leftMaxSum = leftPartialSum
        rightPartialSum <- 0
        rightMaxSum <- 0
        for i <- center to stop do
           rightPartialSum < rightPartialSum + A[i]
           if rightPartialSum > rightMaxSum 
               rightMaxSum = rightPartialSum
        middleSum <- rightMaxSum + leftMaxSum 
        return max(middleSum, leftSum, rightSum)
      
      	 

    • To find the performance of this we will need to use a recurence relation.

      • T(n) = 2T(n/2) + cn   
                  ^      ^
                  |      + from lines 11-20
                  + from lines 7 and 8
        
        T(n/2) = 2T(n/2/2) + cn
                 2T(n/22) + cn/2
        T(n) = 2(2T(n/22) + cn/2 ) + cn
             = 22T(n/22) + 2cn
        at step i
        T(n)  = 2iT(n/2i) + icn
        assume n=2k, or k=lg(n)
        T(n) = 2kT(2k/2k) + kcn
        T(n) = 2kT(1)+ cnk 
             = c lg(n)  + c n lg(n) 
             Which is O(n lg(n))
        

  • A better Method Yet:
    • We can notice that if the sum of a subsequence is 0, it is not a prefix (beginning part) for the optimal subsequence.

    • MaxSubsequence(A)
      
       maxSum <- 0
       thisSum <- 0 
       for i <- 0 to size do
          thisSum <- thisSum + A[i]
          if thisSum > maxSum 
              maxSum <- thisSum
          if thisSum < 0 
              thisSum <- 0
       return maxSum
      
      

    • Does this work?
      • Consider -1 -1 -2 -3 4 4 5 6 -4 -4
      • Notice the first and last parts will be ignored.
      • How about 5 -6 1 3 -3 2
      • Again we will begin the sequence at 1 and we will stop at 3
      • 5 6 -1 -1 2 -1 -1 3
      • Lines 7 and 8 essentually skip any negative prefixes.
    • Performance is easy, O(n)