最长上升子序列 && 最长连续递增子序列

dp[i]是可以由dp[j]（j < i）推导而来的，故实验dynamic programming

1. dp[i]的定义：
   dp[i]表示i之前包括i的最长上升子序列的长度。
2. 状态转移方程
   位置i的最长升序子序列等于j从0到i-1各个位置的最长升序自序列 + 1的最大值
   故 if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1)
   这里不是要dp[i]与dp[j] + 1进行比较，而是要取dp[j] + 1的最大值
3. dp[i]的初始化
   每一个i，对应的dp[i]（即最长上升子序列）起始大小至少为1
4. 确定遍历顺序
   dp[i]是由0到i-1各个位置的最长升序子序列推导而来，那么遍历i一定是从前向后遍历。
   即j是从0到i-1，i是从0到nums.size()-1。i在外层，j在里层

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        vector<int> dp(nums.size(), 1);
        int result = 0;
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
            }
            if (dp[i] > result) result = dp[i]; // 取长的子序列
        }
        return result;
    }
};

与1不同，这里要求连续。连续的话就可以考虑使用滑动窗口了。

滑动窗口：

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        //nums = [1,3,5,4,7]
        int l = 0, r = 1;
        int res = 1, maxLen = 1;


        while(r < nums.size()){
            if(nums[r] > nums[r-1]){ 
                res++;
            }
            else{
                l = r;
                res = 1;
                
            }
            r++;

            if(res > maxLen) maxLen = res;
        }

        return maxLen;
    }
};

也可以使用动态规划：

1. dp[i]表示以下标i为结尾的连续递增的子序列的长度为dp[i]
   （以下标i结尾，并不代表以0为开始位置）
2. 若nums[i + 1] > nums[i]，则dp[i + 1] = dp[i] + 1
   因为是要求连续递增子序列，故只用比较nums[i + 1]与nums[i]就行了。 若nums[i + 1] > nums[i]，则dp[i + 1] = dp[i] + 1;
3. 初始化数组值为1
4. 只需一层for循环

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int result = 1;
        vector<int> dp(nums.size() ,1);
        for (int i = 0; i < nums.size() - 1; i++) {
            if (nums[i + 1] > nums[i]) { // 连续记录
                dp[i + 1] = dp[i] + 1;
            }
            if (dp[i + 1] > result) result = dp[i + 1];
        }
        return result;
    }
};