数组中最长连续序列的分治法

Question

Can anyone help me out with this problem that I have been trying to solve for a while.

Lets say there is an array A[1,2...n] of numbers and we wish to find the longest increasing consecutive sub sequence with Divide an Conquer method. Specifically we wish to find indices i,j such that i<=j and A[i]<=A[i+1]<=.....A[j]. For Example if the array has 4,1,3,5,6,7,5,8,2 then it has to return [1,3,5,6,7].

I have searched a lot about this problem but all I can find is dynamic approach and Longest Increasing Subsequences without consecutive elements.

Answer 1

How about this:

1. Divide array A to A1 and A2.

2. Find the longest consecutive sub sequence of sub array A1 and A2, named as s1, s2 respectively.

3. If the longest consecutive sub sequence cross A1 and A2, the consecutive sub sequence must use the last of A1 and first of A2, named as s3.

4. Compare s1, s2, s3, find the longest one.

5. In step 2, it needs divide sub arrays constantly. And step 3 and 4 are conquer process.

Answer 2

A divide-and-conquer solution can be done by dividing the array into 2, say A ₁ and A ₂ . Then, once having recursively solved the problem for the two sub-arrays, you should consider the scenarios in which the optimal solution to the original array may lie.

Option 1: The longest contiguous increasing subsequence is completely in A ₁ , in which case you already found the maximum length, or the relevant answer, or whatever it is you are planning to return.

Option 2: Similarly, the longest contiguous increasing subsequence is entirely in A ₂ .

Option 3: The longest contiguous increasing subsequence is partially in A ₁ and partially in Array ₂ . In this case, considering A ₁ is the left portion of the array and A ₂ is the right portion, you basically have to go left from the intersection until it is not decreasing or you reach the left end of A ₁ . And then you go to right on A ₂ until it is not increasing or you reach the right end of it.

Among these options you take the one with the greatest length, and you're done.

However, I should note that divide-and-conquer is not the optimal solution to this problem, as it has O(nlogn) time complexity. As mentioned in Jon Bentley's notable book, Programming Pearls , a solution what he calls as the maximum sum contiguous subsequence problem is known to have linear time complexity. That solution may easily be adapted to handle increasing subsequences, instead of the maximum sum.

The algorithm is based on an approach Bentley calls scanning, and it is based on the idea that any subsequence has to end at some point.

The approach is painfully simple, and a Python implementation can be found below.

def maxIncreasing(arr):
    maxLength = 1
    maxStart = 0
    curStart = 0
    curLength = 1
    for i in range(1, len(arr)):
        if arr[i] <= arr[i-1]:
            if curLength > maxLength:
                maxLength = curLength
                maxStart = curStart
            curStart = i
            curLength = 1
        else:
            curLength += 1
    if curLength > maxLength:
        maxLength = curLength
        maxStart = curStart
    return (maxLength, maxStart)