动态规划

1143. 最长公共子序列

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

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

 

示例 1:

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，它的长度为 3。
示例 2:

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。
示例 3:

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] memo = new int[m][n];
        for(int[] arr:memo){
            Arrays.fill(arr,-1);
        }
        return dpHelper(text1,0,text2,0,memo);
        
    }
    static int dpHelper(String text1,int i,String text2, int j,int[][] memo){
        if(i==text1.length()||j==text2.length()){
            return 0;
        }
        if(memo[i][j]!=-1){
            return memo[i][j];
        }
        if(text1.charAt(i)==text2.charAt(j)){
            memo[i][j]=1+dpHelper(text1,i+1,text2,j+1,memo);
        }else{
            return memo[i][j]=Math.max(
                dpHelper(text1,i+1,text2,j,memo),
                dpHelper(text1,i,text2,j+1,memo)
            );
        }
        return memo[i][j];
    }
}

583. 两个字符串的删除操作

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

示例：
输入: "sea", "eat"
输出: 2
解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"

class Solution {
    public int minDistance(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] memo = new int[m][n];
        for(int[] arr:memo){
            Arrays.fill(arr,-1);
        }
        int res = dpHelper(text1,0,text2,0,memo);
        return text1.length()-res+text2.length()-res;
    }
    static int dpHelper(String text1,int i,String text2, int j,int[][] memo){
        if(i==text1.length()||j==text2.length()){
            return 0;
        }
        if(memo[i][j]!=-1){
            return memo[i][j];
        }
        if(text1.charAt(i)==text2.charAt(j)){
            memo[i][j]=1+dpHelper(text1,i+1,text2,j+1,memo);
        }else{
            return memo[i][j]=Math.max(
                dpHelper(text1,i+1,text2,j,memo),
                dpHelper(text1,i,text2,j+1,memo)
            );
        }
        return memo[i][j];
    }
    
}

300. 最长递增子序列

给你一个整数数组 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 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

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