最长公共子序列

1143. 最长公共子序列

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

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 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 {
    private char[] s, t;
    private int[][] memo;

    public int longestCommonSubsequence(String text1, String text2) {
        s = text1.toCharArray();
        t = text2.toCharArray();
        int n = s.length;
        int m = t.length;
        memo = new int[n][m];
        for (int[] row : memo) {
            Arrays.fill(row, -1); // -1 表示没有计算过
        }
        return dfs(n - 1, m - 1);
    }

    private int dfs(int i, int j) {
        if (i < 0 || j < 0) return 0;
        if (memo[i][j] != -1) return memo[i][j]; // 之前计算过
        if (s[i] == t[j]) return memo[i][j] = dfs(i - 1, j - 1) + 1;
        return memo[i][j] = Math.max(dfs(i - 1, j), dfs(i, j - 1));
    }
}

不相交的线

1035. 不相交的线

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：

•  nums1[i] == nums2[j]
• 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

示例 1：

输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如上图所示。 
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。

示例 2：

输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3

示例 3：

输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int m = nums2.length;
        int[] dp = new int[m + 1];
        for (int x : nums1) {
            int pre = 0;
            for (int j = 0; j < m; j++) {
                int temp = dp[j + 1];
                dp[j + 1] = (x == nums2[j] ? pre + 1 : Math.max(dp[j + 1], dp[j]));
                pre = temp;
            }
        }
        return dp[m];
    }
}

让字符串成为回文串的最少插入次数

1312. 让字符串成为回文串的最少插入次数

给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。

请你返回让 s 成为回文串的 最少操作次数 。

「回文串」是正读和反读都相同的字符串。

示例 1：

输入：s = "zzazz"
输出：0
解释：字符串 "zzazz" 已经是回文串了，所以不需要做任何插入操作。

示例 2：

输入：s = "mbadm"
输出：2
解释：字符串可变为 "mbdadbm" 或者 "mdbabdm" 。

示例 3：

输入：s = "leetcode"
输出：5
解释：插入 5 个字符后字符串变为 "leetcodocteel" 。

提示：

• 1 <= s.length <= 500
• s 中所有字符都是小写字母。

class Solution {
    // 定义一个公共方法 minInsertions 接受一个字符串类型的参数 s，并返回一个整型结果
    public int minInsertions(String s) {
        // 获取字符串 s 的长度
        int n = s.length();
        // 初始化一个二维数组 dp，用于存储子问题的解
        int[][] dp = new int[n + 1][n + 1];
        
        // 从字符串末尾向前遍历，填充 dp 数组
        for (int i = n - 1; i >= 0; i--) {
            // 从 i+1 开始，直到字符串结束
            for (int j = i + 1; j < n; j++) {
                // 如果当前字符相等，则不需要插入任何字符，直接跳到下一个匹配
                if (s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = dp[i + 1][j - 1];
                } else {
                    // 如果字符不等，则取两种情况下的最小值加一
                    // 一种是从 i+1 到 j 的子串，另一种是从 i 到 j-1 的子串
                    dp[i][j] = Math.min(dp[i + 1][j], dp[i][j - 1]) + 1;
                }
            }
        }
        
        // 返回 dp 数组的第一个元素，即整个字符串转换为回文所需的最少插入次数
        return dp[0][n - 1];
    }
}