Leetcode665 (Array) Non-decreasing Array +Leetcode674 Longest Continuous Increasing Subsequence

Given an array with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.

We define an array is non-decreasing if array[i] <= array[i + 1] holds for every i (1 <= i < n).

Example 1:

Input: [4,2,3]
Output: True
Explanation: You could modify the first 4 to 1 to get a non-decreasing array.

Example 2:

Input: [4,2,1]
Output: False
Explanation: You can't get a non-decreasing array by modify at most one element.

Note: The n belongs to [1, 10,000].

这个题不难，但是要考虑完全所有的情况。

两个Example让我觉得判断nums[i]>nums[i+1]，则记录逆序的变量cnt（=0）+1。最后cnt==1 return True  else return False

这种简单粗暴的想法忽略了这种情况：

[3,4,2,3]

cnt==1，因为4>2,想要把4变成1，但是第一个3却大于1，所以还是False。

所以要记录逆序数4发生的角标（位置，index），判断index-1和index+1两个数的相对大小

我的AC Solution:

class Solution(object):
    def checkPossibility(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        cnt=0
        reverse_index=0
        if len(nums)<=2:
            return True
        
        for i in range(0,len(nums)-1):
            if nums[i]>nums[i+1]:            
                cnt=cnt+1
                reverse_index=i
        
        #as for last two
        # if nums[len(nums)-2]>nums[len(nums)-1]:
        #     cnt=cnt+1
        
        if cnt==0:
            return True
        elif cnt==1:
            if reverse_index  == 0 or reverse_index==(len(nums)-2): # [1,2,4,5,3] 数组的倒数第二个数发生逆序
                return True
            elif nums[reverse_index-1]<=nums[reverse_index+1]: #[2,7,2,5]
                return True
            elif nums[reverse_index]<=nums[reverse_index+2]:#[2,3,3,2,4]
                return True
            else: 
                return False
        else:
            return False
           

受leetcode推荐继续刷674，延续上题思路AC出来了。

Given an unsorted array of integers, find the length of longest continuousincreasing subsequence.

Example 1:

Input: [1,3,5,4,7]
Output: 3
Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. 
Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. 

Example 2:

Input: [2,2,2,2,2]
Output: 1
Explanation: The longest continuous increasing subsequence is [2], its length is 1. 

Note: Length of the array will not exceed 10,000.

我原创的解法： 

时间复杂度：O(n)

空间复杂度：O（n） 

如果nums是[2,2,2,2,2]那么要新开辟一个reverse_points数组存储这n个相等的数，所以说是O(n)

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        reverse_points = [0]    
        maximum = 1
        for i in range(0, len(nums) - 1):
            if nums[i] >= nums[i + 1]:
                reverse_points.append(i + 1)
                maximum = max(len(nums[reverse_points[-2]:reverse_points[-1]]), maximum)


        if len(reverse_points) == 1: 
            # 只有初始赋的一个0，证明这是一个纯递增（内不含相等值）序列
            # 也就是说上面的for循环没有添加新的index到reverse_points里
            maximum = len(nums)
        elif (reverse_points[-1] != (len(nums) - 1)):
            # 如果存储陡落位置的index不是倒数第一个数的话，证明最后一段是递增序列
            #并且结尾的index没有添加到reverse_points里
            maximum = max(len(nums[reverse_points[-1]:]), maximum)
        return maximum
        

本题一些值得思考的测试用例：

nums=[1,3,5,4,6,7,8,2,3]
nums=[1,3,5,7]
nums=[1,3,5,4,2,3,4,5]
nums=[1,3,5,4,2,3,4,5]
nums=[2,2,2,2,2,2]
nums=[1,1,2]

本题我绕了好大弯，因为我没有好好看example，[2,2,2,2,2,2]这种情况的最长子序列长度是1，我看到了但我没有思考，可以类比[1,1,2]这种情况的答案应该是2.

因为连续相等的值并不累加在最长子序列长度中。

所以说我一开始把 nums[i] > nums[i+1]与nums[i] ==nums[i+1]分开写，真是绕了好大的圈子

解题思路：

还是找陡落的地方的index,不过这次不是记录i了，为了方便求len()运算，存储的是index+1。

把陡落的地方的index+1放到reverse_points数组里，对于reverse_points数组里的每一段求长度，与最大值比较，留较大者。

注意最后的if -else 很重要，完善了逻辑。

更简单的解法二,比解法一在空间复杂度上进行了优化：

时间复杂度：O(n)

空间复杂度:O(1)

思路：记录当前递增子串的长度，与maximum做比较

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        if len(nums)==0: 
            return 0
       
        maximum=1#为[2,2,2,2,2]这种情况考虑
        temp_length=1

        for i in range(0,len(nums)-1):
            if nums[i+1]>nums[i]:
                temp_length=temp_length+1
                maximum = max(maximum, temp_length)
            else:
                temp_length=1

        return  maximum

解法三 动态规划：

时间复杂度:O（n）

空间复杂度：O(n) ，因为 新开辟一个dp数组

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        if len(nums)==0:
            return 0

        dp=[None]*len(nums)#记录到该位置的Longest Continuous Increasing Subsequence
        maximum=1
        dp[0]=1 #给dp[0]赋初始值，因为后面也没机会赋了
        # temp_length=1

        for i in range(0,len(nums)-1):
            if nums[i+1]>nums[i]:
                #temp_length=temp_length+1
                dp[i+1]=dp[i]+1
                #maximum = max(maximum, temp_length)
                maximum = max(maximum, dp[i+1])
            else:
                #temp_length=1
                dp[i+1]=1
        return  maximum

该解法是根据解法二改编而来，区别在于把解法二的temp_length记录在dp[]数组里