描述

给定一个整数数组（下标从 0 到 n-1， n 表示整个数组的规模），请找出该数组中的最长上升连续子序列。（最长上升连续子序列可以定义为从右到左或从左到右的序列。）

样例

样例 1：

输入：[5, 4, 2, 1, 3]
输出：4
解释：
给定 [5, 4, 2, 1, 3]，其最长上升连续子序列（LICS）为 [5, 4, 2, 1]，返回 4。

样例 2：

输入：[5, 1, 2, 3, 4]
输出：4
解释：
给定 [5, 1, 2, 3, 4]，其最长上升连续子序列（LICS）为 [1, 2, 3, 4]，返回 4。

挑战

使用 O(n) 时间和 O(1) 额外空间来解决

思路：这题可以用来动态规划练手，但是动态规划并不是最好的思路

动态规划实现

public class Solution {
    /**
     * @param A: An array of Integer
     * @return: an integer
     */
    public int longestIncreasingContinuousSubsequence(int[] A) {
        // write your code here
        if(A.length==0) return 0;
        int[] dp = new int[A.length];
        int[] dp2 = new int[A.length];
        dp[0] = 1;
        dp2[0] = 1;
        int max = 1;
        for(int i=1;i<A.length;i++){
            if(A[i]>A[i-1]){
                dp[i] = dp[i-1]+1;
                dp2[i] = 1;
            } 
            else if(A[i]<A[i-1]){ 
                dp[i] = 1;
                dp2[i] = dp2[i-1]+1;
                }
            else{
                dp[i] =1;
                dp2[i] =1;
            }
            if(Math.max(dp[i], dp2[i])>max) max = Math.max(dp[i], dp2[i]);
        }
        return max;
    }
}

效率非常的低，因为有两种状态，需要定义两个数组

可以用暴力，切换状态的方式直接破解。 

public class Solution {
    /**
     * @param A: An array of Integer
     * @return: an integer
     */
    public int longestIncreasingContinuousSubsequence(int[] A) {
        if(A.length==0) return 0;
        int res=1;
        int len=1;
        boolean up =true;
        for(int i=1;i<A.length;i++){
            if(A[i]>A[i-1]){
                if(up) len++;
                else{
                    up = true;
                    len = 2;
                }
            }
            else if(A[i]<A[i-1]){
                if(!up) len++;
                else{
                    up = false;
                    len = 2;
                }
            }else{
                len = 1;
            }
            if(len>res) res =len;
        }
        return res;
    }
}