力扣 最长公共子序列

多维动态规划，字符串比较存状态。

题目

 找公共子序列，典型的dp问题，用两个循环枚举每一个字符然后存下二维dp的值。当然难点还是在状态转移方程上，这题画个表可能好理解点，二维dp分别对应每一行每一列，然后把字符标上，接着当两个字符相等时，即表中所处的行列相等，说明这个字符就可以加进dp，接着行号与列号不同的怎样处理，取上一行与上一列的最大值，这样是为了使得状态转移方程更新时当前元素由上一个相等的元素得来，不相等的已经取大做维护dp状态了。

时间复杂度： O(mn)，空间复杂度： O(mn)。

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 i = 1; i <= m; i++) {
            char c1 = text1.charAt(i - 1);
            for (int j = 1; j <= n; j++) {
                char c2 = text2.charAt(j - 1);
                if (c1 == c2) {
                    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];
    }
}

看到这种来自上一行或上一列的不难想到可以优化成一维数组了。

 时间复杂度： O(mn)，空间复杂度： O(n)。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m=text1.length(),n=text2.length();
        int[] dp=new int[n+1];
        for(int i=1;i<=m;i++){
            int prev=0;
            for(int j=1;j<=n;j++){
                int temp=dp[j];//存一个临时变量是因为使得dp[j]始终是从上一个i得来
                if(text1.charAt(i-1)==text2.charAt(j-1)) dp[j]=prev+1;
                // dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                //dp[i][j]还没有进行更新，因此到了dp[j]时是来自dp[i-1]
                //到了dp[j-1]时，从前往后遍历刚好是内循环的上一步，因此是dp[i]
                else dp[j]=Math.max(dp[j],dp[j-1]);
                prev=temp;
            }
        }
        return dp[n];
    }
}

动态规划是自底向上的，而自顶向下的方法则是记忆化搜索。

时间复杂度： O(mn)，空间复杂度： O(mn)。

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));
    }
}

记忆化搜索通常采用自顶向下的方式，递归地解决问题。每当递归到一个子问题时，先检查该子问题是否已经计算过。如果已经计算过，就直接返回其结果，否则就计算并缓存结果。动态规划通常采用自底向上的方式，通过迭代的方式从最小的子问题开始，逐步构建更大的问题的解。动态规划通常会在表格中保存子问题的解。