[leetcode] 87.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.
题意：
给两个长度一样的字符串，查看能否相互转换。比如great与rgtae,可以把great看成两个部分，第一部分是gr，第二部分是eat，gr变换两个字符的顺序就可以变成rg。eat可以看成两个部分e和at，先把e与at对换，变成了ate，然后at中两个字符对换变成了tae，所以great最终可以变成rgtae。
思路：
这道题目是查看一个字符串能否通过变换得到另一个字符串。简单做法就是把字符串分成两个子字符串，再去看子字符串能否成功转换。比如上面的great（原串），与rgtae（目标串），比如我们可以把这两个字符串分成长度为2和3的两个部分：

1. 对于原串great即分成gr和eat；
2. great转变后的目标串可能是gr的部分在前，也可能eat的部分在前，所以目标串的构成应该是2+3或者3+2这两种可能。递归的去对子串再进行比较。

所以很容易想到一个递归的过程。即把串A分成两个部分，把串B也分成两个部分，如果子串对应一一可以转变，那就能转变。而递归的终止条件是字符串A=字符串B。我们递归的过程进行优化。

1. 递归过程中我们可以增加剪枝的操作，比如长度为len的串A与长度为len的串Ｂ，如果两个字符串中包含的各字符的个数不同，那么一定不能互相转换。代码比较简单，参考如下：

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1.empty() || s1.length() != s2.length())return false;
        else if(s1 == s2)return true;
        else if(s1.length() == 1)return false;
        vector<int> charNum(26,0);
        int length = s1.length();
        for(int i = 0; i < length; i++) {
            charNum[s1[i] - 'a']++;
            charNum[s2[i] - 'a']--;
        }
        for(auto n:charNum) {
            if(n != 0)return false;
        }
        for(int i = 1; i < length; i++) {
            if(isScramble(s1.substr(0,i), s2.substr(0,i)) && isScramble(s1.substr(i), s2.substr(i)))return true;
            if(isScramble(s1.substr(0,i), s2.substr(s2.length() - i,i)) && isScramble(s1.substr(i), s2.substr(0, s2.length() - i)))return true;
        }
        return false;
    }

};

2.上面的递归过程只是使用了简单的剪枝，我们可以使用DP，保存某个字符串能否转化为另一个字符串。比如需要转化字符串A到字符串B，那么我们可以把字符串A与B连接成AB，如果A能转化为B，那么在哈希表中就将AB对应的值设为true，否则将AB对应的值设为false。所以可以通过查看表来确定之前是否已经计算过AB能否转化。再考虑下优化下，因为哈希中使用string作为键值的话空间开销比较大，所以可以将string哈希到int值，以该int作为键值。C11中已经提供了hash函数，来完成键值的一个转换工作。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1.empty() || s1.length() != s2.length())return false;
        else if(s1 == s2)return true;
        else if(s1.length() == 1)return false;
        vector<int> charNum(26,0);
        int length = s1.length();
        for(int i = 0; i < length; i++) {
            charNum[s1[i] - 'a']++;
            charNum[s2[i] - 'a']--;
        }
        for(auto n:charNum) {
            if(n != 0)return false;
        }

        int hash_num = hash_fun(s1+s2);
        auto iter = hashTable.find(hash_num);
        if(iter != hashTable.end())return iter->second;
        for(int i = 1; i < length; i++) {
            bool result = isScramble(s1.substr(0,i), s2.substr(0,i)) && isScramble(s1.substr(i), s2.substr(i));
            result |= (isScramble(s1.substr(0,i), s2.substr(s2.length() - i,i)) && isScramble(s1.substr(i), s2.substr(0, s2.length() - i)));
            if(result) {
                hashTable.insert(pair<int, bool>(hash_num, true));
                return true;
            }
        }
        hashTable.insert(pair<int, bool>(hash_num,false));
        return false;
    }
private:
    unordered_map<int,bool> hashTable;
    hash<string> hash_fun;

};