[LintCode] Longest Increasing Continuous Subsequence

Give an integer array，find the longest increasing continuous subsequence in this array.

An increasing continuous subsequence:

• Can be from right to left or from left to right.
• Indices of the integers in the subsequence should be continuous.

Example

For [5, 4, 2, 1, 3], the LICS is [5, 4, 2, 1], return 4.

For [5, 1, 2, 3, 4], the LICS is [1, 2, 3, 4], return 4.

Challenge: O(n) time and O(1) extra space

Solution.

Scan input array twice. The first time to find the length of LICS from left to right. The second time to find the length of LICS from right to left.

During scanning, if the next element is strictly bigger than the previous element, increment len by 1, else init len to 1. After checking each element,

update the current max length.

 1 public class Solution {
 2     public int longestIncreasingContinuousSubsequence(int[] A) {
 3         if(A == null || A.length == 0){
 4             return 0;
 5         }
 6         if(A.length == 1){
 7             return 1;
 8         }
 9         int max = 0;
10         int len = 1;
11         for(int i = 1; i < A.length; i++){
12             if(A[i] > A[i - 1]){
13                 len++;
14             }
15             else{
16                 len = 1;
17             }
18             max = Math.max(max, len);
19         }
20         len = 1;
21         for(int i = A.length - 2; i >= 0; i--){
22             if(A[i] > A[i + 1]){
23                 len++;
24             }
25             else{
26                 len = 1;
27             }
28             max = Math.max(max, len);
29         }
30         return max;
31     }
32 }

Follow up question: Reconstruct an optimal solution from dynamic programming

The above solution uses O(1) memory. What about if you need to return the start and end indices of a LICS(pick any if there is multiple answer)?

Q: In this case, we need O(n) memory to store the lenght of an ICS that ends at each element.

leftToRight[i]: from left to right, the length of the ICS that ends at A[i].

rightToLeft[i]: from right to left, the length of the ICS that starts at A[i].

 1 public class Solution {
 2     public ArrayList<Integer> longestIncreasingContinuousSubsequence(int[] A) {
 3         if(A == null || A.length == 0){
 4             return 0;
 5         }
 6         if(A.length == 1){
 7             return 1;
 8         }
 9         int n = A.length;
10         int[] leftToRight = new int[n]; int[] rightToLeft = new int[n];
11         leftToRight[0] = 1; rightToLeft[n - 1] = 1;
12         for(int i = 1; i < A.length; i++){
13             if(A[i] > A[i - 1]){
14                 leftToRight[i] = leftToRight[i - 1] + 1;
15             }
16             else{
17                 leftToRight[i] = 1;
18             }
19         }
20         for(int i = A.length - 2; i >= 0; i--){
21             if(A[i] > A[i + 1]){
22                 rightToLeft[i] = rightToLeft[i + 1] + 1;
23             }
24             else{
25                 rightToLeft[i] = 1;
26             }
27         }
28         int leftToRightEndIdx = 0; int rightToLeftStartIdx = n - 1;
29         int leftToRightMax = 0; int rightToLeftMax = 0;
30         for(int i = 0; i < n; i++){
31             if(leftToRight[i] > leftToRightMax){
32                 leftToRightMax = leftToRight[i];
33                 leftToRightEndIdx = i;
34             }
35         }
36         for(int i = n - 1; i >= 0; i--){
37             if(rightToLeft[i] > rightToLeftMax){
38                 rightToLeftMax = rightToLeft[i];
39                 rightToLeftStartIdx = i;
40             }
41         }
42         ArrayList<Integer> indices = new ArrayList<Integer>();
43         if(leftToRightMax >= rightToLeftMax){
44             indices.add(leftToRightEndIdx - leftToRightMax + 1);
45             indices.add(leftToRightEndIdx);
46         }
47         indices.add(rightToLeftStartIdx);
48         indices.add(rightToLeftStartIdx + rightToLeftMax - 1);
49         return indices;
50     }
51 }

Related Problems

Longest Increasing Continuous subsequence II