BM65 最长公共子序列(二)

描述

给定两个字符串str1和str2，输出两个字符串的最长公共子序列。如果最长公共子序列为空，则返回"-1"。目前给出的数据，仅仅会存在一个最长的公共子序列

数据范围：Java练习题—动态规划（四）_初始化

要求：空间复杂度 Java练习题—动态规划（四）_字符串_02 ，时间复杂度 Java练习题—动态规划（四）_字符串_02

示例1

输入：

"1A2C3D4B56","B1D23A456A"
  • 1.

返回值：

"123456"
  • 1.

示例2

输入：

"abc","def"
  • 1.

返回值：

"-1"
  • 1.


Java代码：

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * longest common subsequence
     * @param s1 string字符串 the string
     * @param s2 string字符串 the string
     * @return string字符串
     */
    public String LCS (String s1, String s2) {
        // write code here
        if (s1.equals(s2)) {
            return s1;
        }
        if (s1.equals("") || s2.equals("")) {
            return "-1";
        }

        String [][]result = new String[s1.length() + 1][s2.length() + 1];
        for (int i = 0; i < s1.length(); i++) {
            StringBuilder string = new StringBuilder("");
            for (int j = 0; j < s2.length(); j++) {
                if (s1.charAt(i) == s2.charAt(j)) {
                    if (i == 0 || j == 0) {

                        string.append(s1.charAt(i));
                        result[i][j] = string.toString();

                    } else {

                        result[i][j] = result[i - 1][j - 1] + s1.charAt(i);

                    }
                } else {
                    if (i == 0 || j == 0) {

                        if (i == 0 && j == 0) {
                            result[i][j] = "";
                        } else if (i == 0) {
                            result[i][j] = result[i][j - 1];
                        } else if (j == 0) {
                            result[i][j] = result[i - 1][j];
                        }

                    } else {

                        if (result[i - 1][j].length() > result[i][j - 1].length()) {
                            result[i][j] = result[i - 1][j];
                        } else {
                            result[i][j] = result[i][j - 1];
                        }

                    }
                }
            }
        }
        if (result[s1.length() - 1][s2.length() - 1].equals("")) {
            return "-1";
        } else {
            return result[s1.length() - 1][s2.length() - 1];
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
import java.util.*;

public class Solution {
    public String LCS (String s1, String s2) {
        // 字符串1的长度
        int sLen1 = s1.length();
        // 字符串2的长度
        int sLen2 = s2.length();
        // dp数组，初始化高度和宽度分别为两个字符串长度+1
        // 目的是方便初始化，如果高度和宽度分别是两个字符串的长度，初始化会比较麻烦
        // s1[0,i)和s2[0,j)所构成的最长子序列是dp[i][j]
        String[][] dp = new String[sLen1 + 1][sLen2 + 1];
        // dp数组初始化
        for (int i = 0; i <= sLen1; i++) {
            dp[i][0] = "";
        }
        for (int j = 0; j <= sLen2; j++) {
            dp[0][j] = "";
        }
        // 遍历每一种情况
        for (int i = 1; i <= sLen1; i++) {
            for (int j = 1; j <= sLen2; j++) {
                // 因为长度和宽度都是字符串长度+1，所以这里取字符的时候需要减1，保证不越界
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    // 因为要加入的两个字符一样，所以直接取两个字符加入前的最长公共子序列然后加上这个相等的字符
                    dp[i][j] = dp[i - 1][j - 1] + s1.charAt(i - 1);
                } else {
                    // 取s1不加入当前字符和s2不加入当前字符的情况中的最长的那个子序列
                    if (dp[i - 1][j].length() >= dp[i][j - 1].length()) {
                        dp[i][j] = dp[i - 1][j];
                    } else {
                        dp[i][j] = dp[i][j - 1];
                    }
                }
            }
        }
        return "".equals(dp[sLen1][sLen2]) ? "-1" : dp[sLen1][sLen2];
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.