2022.04.07 力扣300，674，718，1143

学习动态规划——字符串

follow：代码随想录

---

300. 最长递增子序列

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

解析：
一维状态转移数组

• dp数组的含义：
  dp[i]代表前i + 1个字符串中包括i的最长严格递增子序列
• 确定递推公式
  dp[i] = dp[j] + 1，其中j是最大的dp[j]且nums[i] > nums[j]的位置下标
• 初始化
  dp[0] = 1
• 遍历顺序
  从前向后遍历，且在内部需要从后向前找到小于该位置的数，并选择dp最大的。

二维状态转移数组

• dp数组的含义：
  dp[i][0]代表前i + 1个字符串中不包括i的最长严格递增子序列
  dp[i][1]代表前i + 1个字符串中包括i的最长严格递增子序列
• 确定递推公式
  dp[]
• 初始化
  dp[0] = 1
• 遍历顺序
  从前向后遍历，且在内部需要从后向前找到小于该位置的数，并选择dp最大的。

 public int lengthOfLIS(int[] nums) {
        //dp[i]：i之前包括i的最长严格递增子序列
        int[] dp = new int[nums.length];
        int result = 1;
        //初始化
        dp[0] = 1;
        for(int i = 1; i < nums.length; i++){
            for(int j = i - 1; j >= 0; j--){
                if(nums[j] < nums[i]){
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            if(dp[i] == 0) dp[i] = 1;
            result = Math.max(result, dp[i]);
        }
        return result;
    }

674 最长连续递增子序列

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

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

解析：
该题可以不建立dp数组，完成动态规划

• 如果nums[I] > nums[I-1] dp[i] = dp[i - 1] + 1
• 在dp数组中找到最大的

public int findLengthOfLCIS(int[] nums) {
        int result = 1;
        //模拟dp[i - 1]
        int temp = 1;
        for(int i = 1; i < nums.length; i++){
            if(nums[i] > nums[i - 1]) temp++;
            else{
                result = Math.max(result, temp);
                temp = 1;
            }
        }
        return  Math.max(result, temp);
    }

718 最长重复子数组

题目描述：
给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、连续的、长度最长的子数组的长度 。

解析：
该题要求连续，所以与1143题在递推公式上有区别

• 确定dp数组及其含义
  dp[i][j]构建一个二维数组，代表的含义是text1的长度为i，text2的长度为j，这两者的最长公共子序列
• 确定递推公式
  • 如果text1和text2的最后一位相同，则dp[i][j] = dp[i - 1][j - 1] + 1
  • 如果text1和text2最有一位不同，则dp[i][j] = 0
• 初始化
  dp[0][0:j]以及dp[0:i][0]都为0
• 遍历顺序
  从左至右、从上至下

  public int findLength(int[] nums1, int[] nums2) {
        int l1 = nums1.length;
        int l2 = nums2.length;
        // dp[i][j]构建一个二维数组，代表的含义是text1的长度为i，text2的长度为j，这两者的最长公共子序列
        int[][] dp = new int[l1 + 1][l2 + 1];
        //初始化dp[0][0:j]以及dp[0:i][0]都为0
        //递推公式
        //- 如果text1和text2的最后一位相同，则dp[i][j] = dp[i - 1][j  - 1] + 1
 	    //- 如果text1和text2最有一位不同，则dp[i][j] = 0
        int result = 0;
        for(int i = 1; i <= l1; i++){
            for(int j = 1; j <= l2; j++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = Math.max(result, dp[i][j]);
                }
            }
        }
        return result;
    }

1143. 最长公共子序列

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

解析：

• 确定dp数组及其含义
  dp[i][j]构建一个二维数组，代表的含义是text1的长度为i，text2的长度为j，这两者的最长公共子序列
• 确定递推公式
  • 如果text1和text2的最后一位相同，则dp[i][j] = dp[i - 1][j - 1] + 1
  • 如果text1和text2最有一位不同，则dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]
• 初始化
  dp[0][0:j]以及dp[0:i][0]都为0
• 遍历顺序
  从左至右、从上至下

 public int longestCommonSubsequence(String text1, String text2) {
        int l1 = text1.length();
        int l2 = text2.length();
        // dp[i][j]构建一个二维数组，代表的含义是text1的长度为i，text2的长度为j，这两者的最长公共子序列
        int[][] dp = new int[l1 + 1][l2 + 1];
        //初始化dp[0][0:j]以及dp[0:i][0]都为0
        //递推公式
        //- 如果text1和text2的最后一位相同，则dp[i][j] = dp[i - 1][j  - 1] + 1
 	    //- 如果text1和text2最有一位不同，则dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]
        char[] t1 = text1.toCharArray();
        char[] t2 = text2.toCharArray();
        for(int i = 1; i <= l1; i++){
            for(int j = 1; j <= l2; j++){
                if(t1[i - 1] == t2[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[l1][l2];
    }