Divide and Conquer algorithm for Longest Increasing Consecutive sequence in an array

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.

Is there any particular reason you'd like to use divide-and-conquer here? — templatetypedef, Mar 14 '16 at 01:21
There is no particular reason for that, I have been trying to solve some practice problems that my professor has suggested. — ArCh3r, Mar 14 '16 at 01:23
probably more useful for you to understand the LIS w/o consecutive elements algorithm... dynamic approach is arguably bottom-up divide and conquer too — softwarenewbie7331, Mar 14 '16 at 02:19

score 1 · Answer 1 · answered Mar 14 '16 at 03:34

How about this:

Divide array A to A1 and A2.
Find the longest consecutive sub sequence of sub array A1 and A2, named as s1, s2 respectively.
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.
Compare s1, s2, s3, find the longest one.
In step 2, it needs divide sub arrays constantly. And step 3 and 4 are conquer process.

ilim · Answer 2 · 2016-03-14T09:14:26.547

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)

please help me in understanding. how this solution is nlong? — shivankgtm, Apr 02 '20 at 09:03
@shivank98 Consider dividing the array into 2 equal parts. You start with length `N`, and after you recursively divide it into 2 for `logN` times, you end up with `N` arrays of length 1 and you can't divide any further. So, after dividing a subsequence `S` into 2 and solving the problem for them recursively, if you can form the solution for sequence `S` from the solutions for its halves in `O(K)` time, where `K` is the length of subsequence `S`, then you end up with `O(NlogN)` complexity. Because there are `logN` levels of recursion and sum of lengths of subsequences at every level is `N`. — ilim, Apr 02 '20 at 09:24

Divide and Conquer algorithm for Longest Increasing Consecutive sequence in an array

2 Answers2