最长连续递增序列-动态规划674-python&c++

没看答案。

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        '''
        state: dp[i]表示以元素nums[i]为结尾的数组的连续递增子序列长度
        basecase: dp数组初始化每个元素都为1
        transfer: dp[i] = dp[i-1]+1 如果nums[i-1] < nums[i]
        result: max(dp)
        '''

        n = len(nums)
        dp = [1] * n
        # dp[0] = 1

        for i in range(1, n):
            if nums[i-1] < nums[i]:
                dp[i] = dp[i-1] + 1

        return max(dp)

用变量代替dp数组，以降低空间复杂度。

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        n = len(nums)
        res = 1
        tmp = 1 # 记录遍历数组期间的连续递增子序列长度，不断更新res，遇到中断时重置为1

        for i in range(1, n):
            if nums[i-1] < nums[i]:
                tmp += 1
            else:
                tmp = 1
                
            res = max(res, tmp)

        return res

#include <vector>

using namespace std;

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // state: dp[i]表示以nums[i]结尾的最长递增子序列
        // base case: dp[0]=1
        // transfer: dp[i] = max(dp[i], dp[j]+1) j为在i之前比nums[i]小的数的索引
        // result: max(dp)
        int res = 1;
        vector<int> dp(nums.size(), 1);
        for (int i = 1; i < nums.size(); i++) {
            for (int j = i-1; j >= 0; j--) {
                if (nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            res = max(res, dp[i]);
        }

        return res;
    }
};