LeetCode | 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.

class Solution {
public:
    bool anagram(string s1, string s2){
        if(s1.size() != s2.size()) return false;
        sort(s1.begin(), s1.end());
        sort(s2.begin(), s2.end());
        return s1 == s2;
    }
    bool isScramble(string s1, string s2) {
        if (s1.empty() && s2.empty()) return true;
        if (s1.length() != s2.length()) return false;
        if (s1 == s2) return true;
        if (!anagram(s1, s2)) return false;
        bool ret = false;
        int n = s1.length();
        
        for (int i = 1; i < n; i++) {
            ret = isScramble(s1.substr(0, i), s2.substr(n - i, i)) && isScramble(s1.substr(i, n - i), s2.substr(0, n - i));
            if (ret) return true;
            ret = isScramble(s1.substr(0, i), s2.substr(0, i)) && isScramble(s1.substr(i, n - i), s2.substr(i, n - i));
            if (ret) return true;
        }
        return ret;
    }
};

递归的算法一开始TLE，知道要试着剪枝，看了discussion之后发现可以加了anagram检测之后就AC了。。。

动态规划的算法想不出来。其实关键是把重复的子问题找出来。下午真是脑子生锈了。。。google了一下发现其实也挺简单的。。。算了，下次再做。

---

Method II

class Solution {
public:
    bool isScramble(string s1, string s2) {
        int n1 = s1.length(), n2 = s2.length();
        if (n1 != n2) return false;
        if (n1 == 0) return true;
    
        //vector<vector<vector<bool> > > dp(n1, vector<vector<bool> >(n1, vector<bool>(n1 + 1, false)));
        //bool *** dp = new bool**[n1];
        bool dp[100][100][100];
        memset(dp, 0, 1000000*sizeof(bool));
        for (int i = 0; i < n1; ++i) {
            //dp[i] = new bool*[n1];
            for (int j = 0; j < n2; ++j) {
                //dp[i][j] = new bool[n1 + 1];
                //memset(dp[i][j], 0, sizeof(bool) * (n1 + 1));
                if (s1[i] == s2[j]) dp[i][j][1] = true;
            }
        }
        
        
        for (int len = 2; len <= n1; ++len) {
            for (int i = 0; i <= n1 - len; ++i) {
                for (int j = 0; j <= n2 - len; ++j) {
                    for (int l = 1; l < len; ++l) {
                        if ((dp[i][j][l] && dp[i + l][j + l][len - l]) || (dp[i][j + len - l][l] && dp[i + l][j][len - l])) {
                            dp[i][j][len] = true;
                            break;
                        }
                    }
                }
            }
        }
        
        return dp[0][0][n1];
    }
};

如果用vector的话，accepted需要570ms；如果用数组的话就可以60msaccepted。递归其实才28ms。。。。

动态规划的时间复杂度是O(n^4)。

第三次写。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.length() != s2.length()) return false;
        int n1 = s1.length(), n2 = s2.length();
        bool dp[100][100][100];
        
        for (int len = 1; len <= n2; len++) {
            for (int i = 0; i + len <= n1; i++) {
                for (int j = 0; j + len <= n2; j++) {
                    dp[i][j][len] = (len == 1 && s1[i] == s2[j]);
                    for (int m = 1; m < len; m++) {
                        dp[i][j][len] = (dp[i][j][m] && dp[i + m][j + m][len - m]) || (dp[i][j + len - m][m] && dp[i + m][j][len - m]);
                        if (dp[i][j][len]) break;
                    }
                }
            }
        }
        return dp[0][0][n1];
    }
};