Java 最長子序列和最長子串[算法練習]

• 最長子序列：匹配的字符不需要連續。
• 最長子串： 匹配的字符需要連續，可能有多種結果。

解決思路：將輸入字符串1看作行， 輸入字符串2看作列，構成二位數組，然后將對角線匹配字符的值標記為1，計算滿足條件的匹配字符個數即可。

基本思想： 空間換時間，動態規划。

 

 

圖解與公式（只針對最長子序列，最長子串類似）

狀態轉移方程

 

 

直觀版：

最長子序列

    /**
     * find longest common sequence from two input string
     * @param s1
     * @param s2
     * @return length of longest common sequence
     */
    public static int LCS(String s1, String s2) {
        int[][] c = new int[s1.length()][s2.length()];

        // initialize the elements without top left element
        for(int i=0; i<s1.length();i++){
            if (s1.charAt(i) == s2.charAt(0)) {
                c[i][0] = 1;
            }
        }
        for(int j = 0; j<s2.length();j++){
            if (s1.charAt(0) == s2.charAt(j)) {
                c[0][j] = 1;
            }
        }
        for (int i = 1; i < s1.length(); i++) {
            for (int j = 1; j < s2.length(); j++) {
                if (s1.charAt(i) == s2.charAt(j)) {
                    c[i][j] = c[i - 1][j - 1] + 1;
                } else if (c[i][j - 1] > c[i - 1][j]) {
                    c[i][j] = c[i][j - 1];
                } else {
                    c[i][j] = c[i - 1][j];
                }
            }
        }
        return c[s1.length() - 1][s2.length() - 1];
    }

最長子序列也可以用穩定的排序算法先排序，再匹配。如采用歸並排序算法（注意，快速排序不穩定）。 

 

最長子串

    /**
     * find longest substring from two input string
     *
     * @param s1
     * @param s2
     * @return length of longest substring
     */
    public static int LSS(String s1, String s2) {
        int[][] c = new int[s1.length()][s2.length()];
        int max = 0;

        // initialize the elements without top left element
        for(int i=0; i<s1.length();i++){
            if (s1.charAt(i) == s2.charAt(0)) {
                c[i][0] = 1;
            }
        }
        for(int j = 0; j<s2.length();j++){
            if (s1.charAt(0) == s2.charAt(j)) {
                c[0][j] = 1;
            }
        }

        for (int i = 1; i < s1.length(); i++) {
            for (int j = 1; j < s2.length(); j++) {
                if (s1.charAt(i) == s2.charAt(j)) {
                    c[i][j] = c[i - 1][j - 1] + 1;
                    if (c[i][j] > max) {
                        max = c[i][j];
                    }
                }
            }
        }
        return max;
    }

 

 優化版：

待續..

優化基本思想：

可以采用遞歸方式，盡早舍棄不符合要求的匹配。

對於優化最長子串，

　　可以優先查找最長子串，如果發現一個匹配，就一直找下去，同時將最終的不匹配標記為-1而不是0.

　　如果剩余的可能匹配長度小於已找到的長度，則停止遞歸操作，直接return.

 

其他相關算法

Horspool's Algorithm and Boyer-Moore Algorithm