Leetcode:Scramble String 解題報告

Scramble String

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

    great
   /    \
  gr    eat
 / \    /  \
g   r  e   at
           / \
          a   t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

    rgeat
   /    \
  rg    eat
 / \    /  \
r   g  e   at
           / \
          a   t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

    rgtae
   /    \
  rg    tae
 / \    /  \
r   g  ta  e
       / \
      t   a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

解答：
1. Brute Force 遞歸。
基本的思想就是：在S1上找到一個切割點，左邊長度為i, 右邊長為len - i。 有2種情況表明它們是IsScramble
(1). S1的左邊和S2的左邊是IsScramble， S1的右邊和S2的右邊是IsScramble
(2). S1的左邊和S2的右邊是IsScramble， S1的右邊和S2的左邊是IsScramble （實際上是交換了S1的左右子樹）

而i的取值可以是1  ~  len-1。 基於這個思想，我們可以寫出以下的遞歸Brute Force 解：

引自stellari對復雜度的解釋：

stellari

2014 年 5 月 12 日 at 14:22

看了你的不少文章，感覺收獲良多！只是有點小問題想請教：按照我的理解，那個遞歸算法在最差情況下應該是O(3^n)，而非O(n^2)。理由是：假設函數運行時間為f(n)，那么由於在每次函數調用中都要考慮1~n之間的所有長度，並且正反都要檢查，所以有
f(n) = 2[f(1) + f(n-1)] +2[f(2) + f(n-2)] … + 2[f(n/2) + f(n/2+1)]. 易推得f(n+1) = 3(fn), 故f(n) = O(3^n)。當然這是最差情況下的時間復雜度。那么你提到的O(n^2)，是否是通過其他數學方法得到的更tight的上限？歡迎探討！

這一個解是不能通過LeetCode的檢查的，復雜度是 3^N

public static boolean isScramble1(String s1, String s2) {
        if (s1 == null || s2 == null) {
            return false;
        }

        int len1 = s1.length();
        int len2 = s2.length();

        // the two strings should be the same length.
        if (len1 != len2) {
            return false;
        }

        return rec(s1, s2);
    }

    // Solution 1: The recursion version.
    public static boolean rec1(String s1, String s2) {
        int len = s1.length();

        // the base case.
        if (len == 1) {
            return s1.equals(s2);
        }

        // 鍒掑垎2涓瓧絎︿覆
        for (int i = 1; i < len; i++) {
            // we have two situation;
            // the left-left right-right & left-right right-left
            if (rec1(s1.substring(0, i), s2.substring(0, i))
                    && rec1(s1.substring(i, len), s2.substring(i, len))) {
                return true;
            }

            if (rec1(s1.substring(0, i), s2.substring(len - i, len))
                    && rec1(s1.substring(i, len), s2.substring(0, len - i))) {
                return true;
            }
        }

        return false;
    }

2. 遞歸加剪枝
感謝unieagle的提示，我們可以在遞歸中加適當的剪枝，也就是說在進入遞歸前，先把2個字符串排序，再比較，如果不相同，則直接退出掉。這樣也能有效地減少復雜度，具體多少算不清。但能通過leetcode的檢查。

// Solution 2: The recursion version with sorting.
    // 鎺掑簭涔嬪悗鐨勫壀鏋濆彲浠ラ�榪嘗eetCode鐨勬鏌�
    public static boolean rec(String s1, String s2) {
        int len = s1.length();

        // the base case.
        if (len == 1) {
            return s1.equals(s2);
        }

        // sort to speed up.
        char[] s1ch = s1.toCharArray();
        Arrays.sort(s1ch);
        String s1Sort = new String(s1ch);

        char[] s2ch = s2.toCharArray();
        Arrays.sort(s2ch);
        String s2Sort = new String(s2ch);

        if (!s1Sort.equals(s2Sort)) {
            return false;
        }

        // 鍒掑垎2涓瓧絎︿覆
        for (int i = 1; i < len; i++) {
            // we have two situation;
            // the left-left right-right & left-right right-left
            if (rec(s1.substring(0, i), s2.substring(0, i))
                    && rec(s1.substring(i, len), s2.substring(i, len))) {
                return true;
            }

            if (rec(s1.substring(0, i), s2.substring(len - i, len))
                    && rec(s1.substring(i, len), s2.substring(0, len - i))) {
                return true;
            }
        }

        return false;
    }

 

3. 遞歸加Memory

我們在遞歸中加上記憶矩陣，也可以減少重復運算，但是我們現在就改一下之前遞歸的結構以方便加上記憶矩陣，我們用index1記憶S1起始地址，index2記憶S2起始地址，len 表示字符串的長度。這樣我們可以用一個三維數組來記錄計算過的值，同樣可以通過leetcode的檢查。這個三維數組一個是N^3的復雜度，在每一個遞歸中，要從1-len地計算一次所有的子串，所以一共的復雜度是N^4

// Solution 3: The recursion version with memory.
    // 閫氳繃璁板繂鐭╅樀鏉ュ噺灝戣綆楅噺
    public static boolean isScramble3(String s1, String s2) {
        if (s1 == null || s2 == null) {
            return false;
        }

        int len1 = s1.length();
        int len2 = s2.length();

        // the two strings should be the same length.
        if (len1 != len2) {
            return false;
        }

        int[][][] mem = new int[len1][len1][len1];
        for (int i = 0; i < len1; i++) {
            for (int j = 0; j < len1; j++) {
                for (int k = 0; k < len1; k++) {
                    // -1 means unseted.
                    mem[i][j][k] = -1;
                }
            }
        }

        return recMem(s1, 0, s2, 0, len1, mem);
    }

    // Solution 3: The recursion version with memory.
    // 閫氳繃璁板繂鐭╅樀鏉ュ噺灝戣綆楅噺
    public static boolean recMem(String s1, int index1, String s2, int index2,
            int len, int[][][] mem) {
        // the base case.
        if (len == 1) {
            return s1.charAt(index1) == s2.charAt(index2);
        }

        // LEN: 1 - totalLen-1
        int ret = mem[index1][index2][len - 1];
        if (ret != -1) {
            return ret == 1 ? true : false;
        }

        // 鍒濆鍖栦負false
        ret = 0;

        // 鍒掑垎2涓瓧絎︿覆. i means the length of the left side in S1
        for (int i = 1; i < len; i++) {
            // we have two situation;
            // the left-left right-right & left-right right-left
            if (recMem(s1, index1, s2, index2, i, mem)
                    && recMem(s1, index1 + i, s2, index2 + i, len - i, mem)) {
                ret = 1;
                break;
            }

            if (recMem(s1, index1, s2, index2 + len - i, i, mem)
                    && recMem(s1, index1 + i, s2, index2, len - i, mem)) {
                ret = 1;
                break;
            }
        }

        mem[index1][index2][len - 1] = ret;
        return ret == 1 ? true : false;
    }

 

4. 動態規划。

其實如果寫出了3，動態規划也就好寫了。

三維動態規划題目：

我們提出維護量res[i][j][n]，其中i是s1的起始字符，j是s2的起始字符，而n是當前的字符串長度，res[i][j][len]表示的是以i和j分別為s1和s2起點的長度為len的字符串是不是互為scramble。
有了維護量我們接下來看看遞推式，也就是怎么根據歷史信息來得到res[i][j][len]。判斷這個是不是滿足，其實我們首先是把當前s1[i...i+len-1]字符串劈一刀分成兩部分，然后分兩種情況：第一種是左邊和s2[j...j+len-1]左邊部分是不是scramble，以及右邊和s2[j...j+len-1]右邊部分是不是scramble；第二種情況是左邊和s2[j...j+len-1]右邊部分是不是scramble，以及右邊和s2[j...j+len-1]左邊部分是不是scramble。如果以上兩種情況有一種成立，說明s1[i...i+len-1]和s2[j...j+len-1]是scramble的。而對於判斷這些左右部分是不是scramble我們是有歷史信息的，因為長度小於n的所有情況我們都在前面求解過了（也就是長度是最外層循環）。
上面說的是劈一刀的情況，對於s1[i...i+len-1]我們有len-1種劈法，在這些劈法中只要有一種成立，那么兩個串就是scramble的。
總結起來遞推式是res[i][j][len] = || (res[i][j][k]&&res[i+k][j+k][len-k] || res[i][j+len-k][k]&&res[i+k][j][len-k]) 對於所有1<=k
如此總時間復雜度因為是三維動態規划，需要三層循環，加上每一步需要線行時間求解遞推式，所以是O(n^4)。雖然已經比較高了，但是至少不是指數量級的，動態規划還是相當有用的，空間復雜度是O(n^3)。代碼如下：

 

注：事實上這里最大的難點，是你怎么安排這三個循環。仔細看一下，計算len對應的解時，要用到一堆len-1的解。所以我們應該len 從0到1地這要子計算（三維啊都沒辦法通過畫圖來推導動態規划的遞增關系了！）

/*
     * Solution 4: The DP Version.
     */
    public static boolean isScramble4(String s1, String s2) {
        if (s1 == null || s2 == null) {
            return false;
        }

        int len1 = s1.length();
        int len2 = s2.length();

        // the two strings should be the same length.
        if (len1 != len2) {
            return false;
        }

        /*
         * i: The index of string 1. j: The index of string 2. k: The length of
         * the two string. 1 ~ len1
         * 
         * D[i][j][k] =
         */
        boolean[][][] D = new boolean[len1][len1][len1 + 1];
        for (int subLen = 1; subLen <= len1; subLen++) {
            for (int i1 = 0; i1 <= len1 - subLen; i1++) {
                for (int i2 = 0; i2 <= len1 - subLen; i2++) {
                    if (subLen == 1) {
                        D[i1][i2][subLen] = s1.charAt(i1) == s2.charAt(i2);
                        continue;
                    } 
                    
                    D[i1][i2][subLen] = false;
                    for (int l = 1; l < subLen; l++) {
                        if (D[i1][i2][l] && D[i1 + l][i2 + l][subLen - l]
                                || D[i1][i2 + subLen - l][l] && D[i1 + l][i2][subLen - l]
                                ) {
                            D[i1][i2][subLen] = true;
                            break;
                        }
                    }
                }
            }
        }

        return D[0][0][len1];
    }
    
    /*
     * Solution 4: The DP Version. REDO
     */
    public static boolean isScramble(String s1, String s2) {
        if (s1 == null || s2 == null) {
            return false;
        }
        
        int len = s1.length();
        
        if (s2.length() != len) {
            return false;
        }

        boolean[][][] D = new boolean[len][len][len + 1];
        
        // D[i][j][k] = D[i][]
        for (int k = 1; k <= len; k++) {
            // 注意這里的邊界選取。 如果選的不對，就會發生越界的情況.. orz..
            // attention: should use "<="
            for (int i = 0; i <= len - k; i++) {
                for (int j = 0; j <= len - k; j++) {
                    if (k == 1) {
                        D[i][j][k] = s1.charAt(i) == s2.charAt(j);
                        continue;
                    }
                    
                    D[i][j][k] = false;
                    for (int l = 1; l <= k - 1; l++) {
                        if (D[i][j][l] && D[i + l][j + l][k - l] 
                            || D[i][j + k - l][l] && D[i + l][j][k - l] ) {
                            D[i][j][k] = true;
                            break;
                        }
                    }
                }
            }
        }
        
        return D[0][0][len];
    }

 

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/9241a5148ba94d79c7dfcb3dbbbd3ad5474bdcf1/dp/IsScramble.java