算法進階面試題01——KMP算法詳解、輸出含兩次原子串的最短串、判斷T1是否包含T2子樹、Manacher算法詳解、使字符串成爲最短迴文串

一、KMP算法詳解與應用

 

 

子序列：能夠連續能夠不連續。

子數組/串：要連續

 

暴力方法：逐個位置比對。

 

 

 

KMP：讓前面的，指導後面。

概念建設：

d的最長前綴與最長後綴的匹配長度爲3。（前綴不能到最後一個，後綴也不能到第一個）

 

 

 

先計算出str2的所有匹配信息。

 

 

 

一路相等，直到X與Y不匹配，根據X位置的最長先後綴信息加速。

 

 

例子：

用str1的第一個不一樣的位置（t）從str2最長前綴的下標位置（a）開始比對。

 

（增強）再說說流程，舉例子：

j是推到和後綴等量的位置，若是碰到一個字符最長先後綴爲0（該位置沒得加速），那麼匹配字符就只挪動一位，再繼續逐一比對。

 

 

代碼裏面的實現：匹配到了甲乙位置，甲不動，乙根據Y最長先後綴的值去到前面。和甲繼續比對。因爲有等量的東西，因此就跳過了一部分值的比對。

 

 

實質：

爲何i~j這些位置能夠判斷出，配不出str2？

 

假設能夠從k出發配出所有str2，那麼k~x應該和str2的前段等量相等（Y的前綴），k~x也對應着str2中的另外一部分（Y的後綴），致使和以前找出的最長先後綴不一致，因此在以前的最長先後綴正確的狀況下，是不可能的。

 

 

next數組怎麼求？

數學概括法，例如：a的位置，根據判斷a的前一個b，和b的最長前綴後的一個是否相等來決定。

 

 

若是不等，就拿b最長前綴的下一個c的最長前綴的下一個來比對，同樣就c的+1，不同就繼續拆分來看，一直到拆分不了才設置爲0。

 

 

例子：

 

 

變換一下，把t變爲a的狀況：

 

 

分析代碼....

public class Code_01_KMP {

    public static int getIndexOf(String s, String m) {
        if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
            return -1;
        }
        char[] ss = s.toCharArray();
        char[] ms = m.toCharArray();
        //匹配下標
        int i1 = 0;
        int i2 = 0;
        int[] next = getNextArray(ms);
        while (i1 < ss.length && i2 < ms.length) {
            if (ss[i1] == ms[i2]) {
                i1++;
                i2++;
            } else if (next[i2] == -1) {//-1標誌數組第一個字符
                i1++;//開頭都配不上，就++
            } else {
                i2 = next[i2];//根據next的指引，往前跳，繼續比對
            }
        }
        return i2 == ms.length ? i1 - i2 : -1;
    }

    public static int[] getNextArray(char[] str2) {
        if (str2.length == 1) {
            return new int[] { -1 };
        }
        int[] next = new int[str2.length];
        next[0] = -1;
        next[1] = 0;
        int pos = 2;
        int cn = 0;//跳到的位置
        while (pos < next.length) {
            if (str2[pos - 1] == str2[cn]) {
                next[pos++] = ++cn;
            } else if (cn > 0) {
                cn = next[cn];
            } else {
                next[pos++] = 0;
            }
        }
        return next;
    }

    public static void main(String[] args) {
        String str = "abcabcababaccc";
        String match = "ababa";
        System.out.println(getIndexOf(str, match));

    }

}

 

 

 

KMP應用。

2017秋招京東原題：

輸出包含兩次原子串的最短字符串

例如：

輸入：aba

輸出：ababa

 

計算輸入字符的next數組，計算到最後一個位置，看看前面有多少是已經疊加複用的，不夠再日後添加上字符。

 

public class Code_02_KMP_ShortestHaveTwice {

    public static String answer(String str) {
        if (str == null || str.length() == 0) {
            return "";
        }
        char[] chas = str.toCharArray();
        if (chas.length == 1) {
            return str + str;
        }
        if (chas.length == 2) {
            return chas[0] == chas[1] ? (str + String.valueOf(chas[0])) : (str + str);
        }
        int endNext = endNextLength(chas);
        //該子字符串始於指定索引處的字符，一直到此字符串末尾。
        return str + str.substring(endNext);
    }

    public static int endNextLength(char[] chas) {
        int[] next = new int[chas.length + 1];
        next[0] = -1;
        next[1] = 0;
        int pos = 2;
        int cn = 0;
        while (pos < next.length) {
            if (chas[pos - 1] == chas[cn]) {
                next[pos++] = ++cn;
            } else if (cn > 0) {
                cn = next[cn];
            } else {
                next[pos++] = 0;
            }
        }
        return next[next.length - 1];
    }

    public static void main(String[] args) {
        String test1 = "a";
        System.out.println(answer(test1));

        String test2 = "aa";
        System.out.println(answer(test2));

        String test3 = "ab";
        System.out.println(answer(test3));

        String test4 = "abcdabcd";
        System.out.println(answer(test4));

        String test5 = "abracadabra";
        System.out.println(answer(test5));
    }

}

 

題目二：

在T1中找是否包含T2子樹。

 

 

把T1和T2都序列化爲串，判斷是否爲子串。

 

public class Code_03_KMP_T1SubtreeEqualsT2 {

    public static class Node {
        public int value;
        public Node left;
        public Node right;

        public Node(int data) {
            this.value = data;
        }
    }

    public static boolean isSubtree(Node t1, Node t2) {
        String t1Str = serialByPre(t1);
        String t2Str = serialByPre(t2);
        return getIndexOf(t1Str, t2Str) != -1;
    }

    public static String serialByPre(Node head) {
        if (head == null) {
            return "#!";
        }
        String res = head.value + "!";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }

    // KMP
    public static int getIndexOf(String s, String m) {
        if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
            return -1;
        }
        char[] ss = s.toCharArray();
        char[] ms = m.toCharArray();
        int[] nextArr = getNextArray(ms);
        int index = 0;
        int mi = 0;
        while (index < ss.length && mi < ms.length) {
            if (ss[index] == ms[mi]) {
                index++;
                mi++;
            } else if (nextArr[mi] == -1) {
                index++;
            } else {
                mi = nextArr[mi];
            }
        }
        return mi == ms.length ? index - mi : -1;
    }

    public static int[] getNextArray(char[] ms) {
        if (ms.length == 1) {
            return new int[] { -1 };
        }
        int[] nextArr = new int[ms.length];
        nextArr[0] = -1;
        nextArr[1] = 0;
        int pos = 2;
        int cn = 0;
        while (pos < nextArr.length) {
            if (ms[pos - 1] == ms[cn]) {
                nextArr[pos++] = ++cn;
            } else if (cn > 0) {
                cn = nextArr[cn];
            } else {
                nextArr[pos++] = 0;
            }
        }
        return nextArr;
    }

    public static void main(String[] args) {
        Node t1 = new Node(1);
        t1.left = new Node(2);
        t1.right = new Node(3);
        t1.left.left = new Node(4);
        t1.left.right = new Node(5);
        t1.right.left = new Node(6);
        t1.right.right = new Node(7);
        t1.left.left.right = new Node(8);
        t1.left.right.left = new Node(9);

        Node t2 = new Node(2);
        t2.left = new Node(4);
        t2.left.right = new Node(8);
        t2.right = new Node(5);
        t2.right.left = new Node(9);

        System.out.println(isSubtree(t1, t2));

    }

}

 

題目三：

怎麼判斷一個字符串，不是由一個子字符串獲得的。

12312312312三、aabaabaabaabaab

KMP的應用，最後的結束位的前綴和後綴，會呈整數倍的關係。每次劃分位置都是相等的整數倍。

 

KMP要好好消化。

 

2、Manacher算法詳解與應用

最長迴文子串。

暴力方式：o(n²)

所有加上#後，逐個計算迴文（經過從當前字符每次比對臨近左右兩個數來計算），取出最大的迴文數再除以2即答案。

 

 

 概念建設：

一、迴文半徑數組（存放每一個位置對應的迴文半徑）

二、迴文最右邊界。（實際字符串有虛軸#）

 

三、迴文最右邊界的中心

 

可能性：

一、不在最右邊界裏面，暴力擴充就行。

　   二、三、4是i在右邊界裏面的狀況擴充。

二、i的迴文半徑在右邊界裏面。

 

 

這種狀況i不用計算，直接和i’同樣。

證實：

 

 

三、左邊界沒擴住i’的狀況。i的迴文半徑是i~R

 

 

四、與L壓線

從i~R是不用驗證的，過了R以後仍是要繼續擴充驗證。

 

 

 

複雜度

 

 

 

再畫一下各類狀況

i在R內部。

①在內，直接等於i’的

 

 

②L外，i~R

 

 

③壓線，要繼續向外擴充判斷。

 

public class Code_04_Manacher {

    public static char[] manacherString(String str) {
        char[] charArr = str.toCharArray();
        char[] res = new char[str.length() * 2 + 1];
        int index = 0;
        for (int i = 0; i != res.length; i++) {
            res[i] = (i & 1) == 0 ? '#' : charArr[index++];
        }
        return res;
    }

    public static int maxLcpsLength(String str) {
        if (str == null || str.length() == 0) {
            return 0;
        }
        char[] charArr = manacherString(str);
        //迴文半徑數組
        int[] pArr = new int[charArr.length];
        int C = -1;
        int R = -1;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i != charArr.length; i++) {
            //i'的迴文和i~R的距離，誰更近就是i的瓶頸
            //2 * C - i --> i'的位置
            //pArr[2 * C - i]  i'的迴文半徑
            //R - i --> i到R的距離
            //R > i i在R的邊界裏面
            pArr[i] = R > i ? Math.min(pArr[2 * C - i], R - i) : 1;
            //所有狀況都往外擴，雖然狀況二、3擴充一次後會直接失敗，但統一簡化了代碼
            //檢查是否越界
            while (i + pArr[i] < charArr.length && i - pArr[i] > -1) {
                if (charArr[i + pArr[i]] == charArr[i - pArr[i]])
                    pArr[i]++;
                else {
                    break;
                }
            }
            //若是擴充區域超過了R，作相應的更新
            if (i + pArr[i] > R) {
                R = i + pArr[i];
                C = i;
            }
            //記錄全局最大值
            max = Math.max(max, pArr[i]);
        }
        return max - 1;
    }

    public static void main(String[] args) {
        String str1 = "abc1234321ab";
        System.out.println(maxLcpsLength(str1));
    }

}

 

應用：若是隻能在字符串最後添加字符，怎麼讓字符成爲迴文字符串？要求添加字符最少。

 

思路：就是在求必須包含最後一個字符串的狀況下，最長迴文串是多少，前面不是的部分逆序過來添上去。

 

 

改寫Manacher：

得到第一個達到最後邊界的位置，知道了LR邊界，把L邊界前面的逆序，添加到整體字符串的後面，既是答案。

 

 

例子：

 

 

 

加#解決偶迴文的問題

 

public class Code_05_Manacher_ShortestEnd {

    public static char[] manacherString(String str) {
        char[] charArr = str.toCharArray();
        char[] res = new char[str.length() * 2 + 1];
        int index = 0;
        for (int i = 0; i != res.length; i++) {
            res[i] = (i & 1) == 0 ? '#' : charArr[index++];
        }
        return res;
    }

    public static String shortestEnd(String str) {
        if (str == null || str.length() == 0) {
            return null;
        }
        char[] charArr = manacherString(str);
        int[] pArr = new int[charArr.length];
        int index = -1;
        int pR = -1;
        int maxContainsEnd = -1;
        for (int i = 0; i != charArr.length; i++) {
            pArr[i] = pR > i ? Math.min(pArr[2 * index - i], pR - i) : 1;
            while (i + pArr[i] < charArr.length && i - pArr[i] > -1) {
                if (charArr[i + pArr[i]] == charArr[i - pArr[i]])
                    pArr[i]++;
                else {
                    break;
                }
            }
            if (i + pArr[i] > pR) {
                pR = i + pArr[i];
                index = i;
            }
            if (pR == charArr.length) {
                maxContainsEnd = pArr[i];
                break;
            }
        }
        //原串 - 迴文串 + 1 = 後補的長度
        char[] res = new char[str.length() - maxContainsEnd + 1];
        for (int i = 0; i < res.length; i++) {
            res[res.length - 1 - i] = charArr[i * 2 + 1];
        }
        return String.valueOf(res);
    }

    public static void main(String[] args) {
        String str2 = "abcd123321";
        System.out.println(shortestEnd(str2));

    }

}

 

要多練練，算法相伴隨的衍生題目，提升敏感度。

 

代碼解讀：

取最近距離。

 

 

I’在區域內的狀況：

 

 

I’在區域外的狀況：