动态规划之递增子序列

        这次分享两道使用动态规划解决递增子序列问题。

最长连续递增子序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：
输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

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

        这道题相对来说比较简单，先明白dp[i]的含义就是以下标i结尾的最长连续递增子序列长度为dp[i]，初始化dp数组为1，即默认下标i结尾的最长连续递增子序列长度为1，仅为下标i对应元素。因为题目要求连续，因此dp[i]仅能通过dp[i - 1]推出，易得dp[i] = dp[i - 1] + 1，以上述示例来看，for循环从下标1开始，即遍历元素3，3大于首元素1，dp[2] = dp[1] + 1，dp[2] = 2，5 > 3，dp[3] = 3，4 < 5，dp[4]保持初始化值为1，7 > 4，dp[5] = 2，显然连续最长递增子序列出现在dp[3]，而不是dp[5]，因此需要使用ans记录最长连续递增子序列的长度。

最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        int ans = 0;
        for(int i = 0;i < nums.length;i++){
            for(int j = 0;j < i;j++){
                if(nums[i] > nums[j]){
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}

        这道题和上一道题的区别在于题目要求可以不连续的子序列，因此dp[i]可以由dp[0]，dp[1] … dp[i - 1]得出，因此外层循环遍历到下标i，内层循环需要遍历[0, i - 1]，选取出dp[0]，dp[1] … dp[i - 1]中的最大值。dp[i]的含义为以下标i结尾的最长递增子序列的长度为dp[i]。和上一题相同，dp数组所有元素初始化为1。外层循环每次遍历下标i结束，即可得到以下标i结尾的最长递增子序列的长度，定义ans，用于记录其中的最大值即为最长递增子序列的长度。
        首先外层循环i等于0，统计以下标0，元素10结尾的最长递增子序列的长度，i = j，因此不进入内层循环，dp[0]保持初始化值为1，以下标0结尾的最长递增子序列长度为1。
        外层循环i等于1，统计以下标1，元素9结尾的最长递增子序列的长度，进入内层循环，j等于0，9 < 10，因此dp[1]保持初始化值为1，以下标1结尾的最长递增子序列长度为1。
        外层循环i等于2，统计以下标2，元素2结尾的最长递增子序列的长度，进入内层循环，j等于0，2 < 10，dp[2]保持初始值，j++，j等于1，2 < 9，dp[2]保持初始值，因此dp[2]保持初始化值为1，以下标2结尾的最长递增子序列长度为1。
        外层循环i等于3，统计以下标3，元素5结尾的最长递增子序列的长度，进入内层循环，j等于0，5 < 10，dp[3]保持初始值，j++，j等于1，5 < 9，dp[3]保持初始值，j++，5 > 2，dp[3] = max(dp[3], dp[2] + 1) = max(1, 2) = 2，因此以下标3结尾的最长递增子序列长度为2。
        外层循环i等于4，统计以下标4，元素3结尾的最长递增子序列的长度，进入内层循环，j等于0，3 < 10，dp[4]保持初始值，j++，j等于1，3 < 9，dp[4]保持初始值，j++，3 > 2，dp[4] = max(dp[4], dp[2] + 1) = max(1, 2) = 2，j++，3 < 5，因此以下标4结尾的最长递增子序列长度为2。
        外层循环i等于5，统计以下标5，元素7结尾的最长递增子序列的长度，进入内层循环，j等于0，7 < 10，dp[5]保持初始值，j++，j等于1，7 < 9，dp[5]保持初始值，j++，7 > 2，dp[5] = max(dp[5], dp[2] + 1) = max(1, 2) = 2，j++，7 > 5，dp[5] = max(dp[5], dp[3] + 1) = max(2, 3) = 3，j++，7 > 3，dp[5] = max(dp[5], dp[4] + 1) = max(3, 3) = 3，因此以下标5结尾的最长递增子序列长度为3。
        外层循环i等于6，统计以下标6，元素101结尾的最长递增子序列的长度，进入内层循环，j等于0，101 > 10，dp[6] = max(dp[6], dp[0] + 1) = 2，j++，j等于1，101 > 9，dp[6] = max(dp[6], dp[1] + 1) = 2，j++，j等于2，101 > 2，dp[6] = max(dp[6], dp[2] + 1) = 2，j++，j等于3，101 > 5，dp[6] = max(dp[6], dp[3] + 1) = 3，j++，j等于4，101 > 3，dp[6] = max(dp[6], dp[4] + 1) = 3，j++，j等于5，101 > 7，dp[6] = max(dp[6], dp[5] + 1) = 4。因此以下标6结尾的最长递增子序列的长度为4。
        外层循环i等于7，统计以下标7，元素18结尾的最长递增子序列的长度，进入内层循环，j等于0，18 > 10，dp[7] = max(dp[7], dp[0] + 1) = 2，j++，j等于1，18 > 9，dp[7] = max(dp[7], dp[1] + 1) = 2，j++，j等于2，18 > 2，dp[7] = max(dp[7], dp[2] + 1) = 2，j++，j等于3，18 > 5，dp[7] = max(dp[7], dp[3] + 1) = 3，j++，j等于4，18 > 3，dp[7] = max(dp[7], dp[4] + 1) = 3，j++，j等于5，18 > 7，dp[7] = max(dp[7], dp[5] + 1) = 4，j++，j等于6，18 < 101，因此以下标7结尾的最长递增子序列的长度为4。
        因此最长递增子序列的长度为以下标6结尾或者下标7结尾的最长递增子序列的长度。