力扣——动态规划之最长上升序列问题

1.最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

题解：经典动态规划题目，定义dp[i]为以nums[i]为结尾的最长连续递增子序列的长度(必须带上nums[i])，dp[i]只能由上一个状态转移而来，如果nums[i]>nums[i-1] dp[i] = dp[i-1]+1；否则为1；

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n]; //定义dp[i]为以num[i]为结尾的最长子序列
        dp[0] = 1;
        int ans = 1;
        for(int i=1;i<n;i++){
            if(nums[i]>nums[i-1]) dp[i] = dp[i-1]+1;
            else dp[i] = 1;
            ans = Math.max(ans,dp[i]);
        }
        return ans;
    }
}

2.最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

题解：本题与上一题的区别是子序列不要求连续，所以不一定从前一个状态转换而来，所以需要遍历枚举上一个状态。定义dp[i] 是以num[i]为结尾的最长递增子序列的长度(必须带上nums[i])。

class Solution {
    public int lengthOfLIS(int[] nums) {
        //定义dp[i] 是以num[i]为结尾的最长递增子序列的长度
        int n = nums.length;
        int[] dp = new int[n];
        for(int i=0;i<n;i++){
            dp[i] = 1;
        }
        int ans = 1;
        for(int i=1;i<n;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;
    }
}

3.最长重复子数组

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

题解：变成了两个数组，还是要求连续，因此定义dp[i][j]是以nums1[i-1]和nums2[j-1]结尾的最长子数组的长度，判断是否可以由前一个状态转移过来，否则dp[i][j]=0

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length,n = nums2.length;
        int ans = 0;
        int[][] dp = new int[m+1][n+1]; //dp[i][j]是以nums1[i-1]和nums2[j-1]结尾的最长子数组的长度
        for(int i= 1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(nums1[i-1]==nums2[j-1]){
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                ans = Math.max(ans,dp[i][j]);
            }
        }
        return ans;
    }
}

4.最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

题解：与上一道题的区别是，子序列可以不连续，所以定义dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]，可以不包含i,j，所以当text1.charAt(i-1)==text2.charAt(j-1)不成立的时候，需要选择丢弃i或者丢弃j的最长公共子序列最大值。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(),n = text2.length();
        int[][] dp = new int[m+1][n+1];
        for(int j=0;j<n;j++)
            dp[0][j] = 0;
        for(int i=0;i<m;i++)
            dp[i][0] = 0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(text1.charAt(i-1)==text2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[m][n];

    }
}