剑指 Offer II 095. 最长公共子序列（1143. 最长公共子序列）

题目：

思路：

【0】用例展示

text1 = "ezupkr"     text2 = "ubmrapg"  预期结果   2
//这种共同拥有的字母为 urp 和 upr 。

 

【1】动态规划的方式

代码展示：

当然在动态规划前的时候也尝试了下看看时间复杂度能不能O（n），然后发现貌似最后还是要处理那一堆乱序的字母比较，哈哈，搞不来：

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int res = 0;
        int[] flag = new int[26];
        for (char ch :text1.toCharArray()){
            flag[ch - 'a']++;
        }
        StringBuffer buf2 = new StringBuffer();
        for (char ch :text2.toCharArray()){
            if ((--flag[ch - 'a']) >= 0) buf2.append(ch);
        }
        StringBuffer buf1 = new StringBuffer();
        for (char ch :text1.toCharArray()){
            if ((--flag[ch - 'a']) < 0) buf1.append(ch);
        }
        int index = 0;
        while (index < buf1.length()){
            if (buf1.charAt(index) == buf2.charAt(index)) res++;
            index++;
        }
        return res;
    }
}

 

动态规划的方式：

//时间10 ms击败56.62%
//内存45.2 MB击败51.92%
//时间复杂度：O(mn)，其中 m 和 n 分别是字符串 text1 和 text2 的长度。二维数组 dp 有 m+1 行和 n+1 列，需要对 dp 中的每个元素进行计算。
//空间复杂度：O(mn)，其中 m 和 n 分别是字符串 text1 和 text2 的长度。创建了 m+1 行 n+1 列的二维数组 dp。
//标准动态规划的方式
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int n = text1.length(), m =  text2.length();
        int[][] f = new int[n + 1][m + 1];
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                //简化的写法 f[i][j] = text1.charAt(i - 1) == text2.charAt(j - 1) ? f[i - 1][j - 1] + 1 : Math.max(f[i - 1][j], f[i][j - 1]);
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    f[i][j] = f[i - 1][j - 1] + 1;
                } else {
                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                }
            }
        }

        return f[n][m];
    }
}

//当然还可以优化
//时间3 ms击败100%
//内存39.7 MB击败93.34%
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();

        //保证n比m小
        if (m < n) {
            return longestCommonSubsequence(text2, text1);
        }
        char[] arr1 = text1.toCharArray();
        char[] arr2 = text2.toCharArray();
        short[] dp = new short[n + 1];
        for (int i = 1; i <= m; i++) {
            short temp = 0;
            short old = 0;
            char c = arr1[i - 1];
            for (int j = 1; j <= n; j++) {
                temp = dp[j];
                if (arr2[j - 1] == c) {
                    dp[j] = (short) (old + 1);
                } else {
                    dp[j] = (short) Math.max(dp[j - 1], dp[j]);
                }
                old = temp;
            }
        }
        return dp[n];
    }
}