674.最长连续递增序列（简单）- LeetCode

自己的解法

看完题目的初步想法是采用双指针，开一个数组存储片段长度。在数组开头设置指针p和q，当p＜q时，q向后移动，当p≥q时，记录此时片段长度，改变p和q位置，遍历完成时找出数组内片段最大长度即可。时间复杂度为$O(n)$，空间复杂度为$O(n)$。

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 1
        elif not nums:
            return 0
        else:
            i = 0
            j = 1
            ans = []
            while j < len(nums):
                if nums[j-1] < nums[j]:
                    j += 1
                else:
                    ans.append(j-i)
                    i = j
                    j = i+1
            ans.append(j-i)
            return max(ans)

执行结果为，效果不太理想

官方解法：滑动窗口

查看官方解法，使用的思想是滑动窗口：

思路其实跟我的很像，只是更完善更精炼，时间复杂度为$O(n)$，空间复杂度为$O(1)$，Python实现：

class Solution(object):
    def findLengthOfLCIS(self, nums):
        ans = anchor = 0
        for i in range(len(nums)):
            if i and nums[i-1] >= nums[i]:  ##i>0是保证后面下标合法
            	anchor = i
            ans = max(ans, i - anchor + 1)
        return ans

Java实现：

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int ans = 0, anchor = 0;
        for (int i = 0; i < nums.length; ++i) {
            if (i > 0 && nums[i-1] >= nums[i]) anchor = i;
            ans = Math.max(ans, i - anchor + 1);
        }
        return ans;
    }
}

动态规划

查看题解区，有网友给出动态规划解法，比较容易理解，Python代码如下：
dp[i]：表示第i个元素，它的递增元素的个数。比如[1，3，5 ]元素3 从1递增到3 递增元素个数是2,dp[1]=2

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        n=len(nums)
        if not nums or n<0:
            return 0
        dp=[1]*n
        for i in range(1,n):
            if nums[i]>nums[i-1]:
               dp[i]=dp[i-1]+1
        return max(dp)