leetcode 87 字符串多次翻转 分治+区间dp

解法一：分治，记忆化
开始的想法很朴素，先找到切分位置，然后切分后处理，其中，用素数存状态来判断是否一个分割位置合理。这种做法有个问题就是，一旦有一次切分错了，可能就回不来了，这个很致命。所以应该考虑每种切分情况，但这样是一定会超时的，加个记忆化即可。
此外，检查词频是否相同，可以直接用循环，不一定非得用素数，因为26个字母可以算是O(1)了。

class Solution {
vector<int> primes;
typedef pair<string, string> P;
map<P, bool> m;
public:
    bool divide_conquer(string s1, string s2)
    {
        if(s1.size() == 1)return s1 == s2;
        if(m.count(P(s1, s2)))return m[P(s1, s2)];

        // 线性判断分割位置
        int l1 = 0, l2 = 0, r2 = 0;
        string s11, s12, s21, s22;
        for(int i=0;i<s1.size()-1;i++)
        {
            l1 += primes[s1[i] - 'a'];
            l2 += primes[s2[i] - 'a'];
            r2 += primes[s2[s1.size()-i-1] - 'a'];
            if(l1 == l2)
            {
                // 分治
                s11 = s1.substr(0, i+1), s12 = s1.substr(i+1);
                s21 = s2.substr(0, i+1), s22 = s2.substr(i+1);
                bool b1 = divide_conquer(s11, s21), b2 = divide_conquer(s12, s22);
                m[P(s11, s21)] = b1, m[P(s12, s22)] = b2;
                if(b1 && b2)return true;
            }
            if(l1 == r2)
            {
                s11 = s1.substr(0, i+1), s12 = s1.substr(i+1);
                s21 = s2.substr(s2.size()-i-1), s22 = s2.substr(0, s2.size()-i-1);
                bool b1 = divide_conquer(s11, s21), b2 = divide_conquer(s12, s22);
                m[P(s11, s21)] = b1, m[P(s12, s22)] = b2;
                if(b1 && b2)return true;
            }
        }
        m[P(s1, s2)] = false;
        return false;
    }

    bool isScramble(string s1, string s2) {
        // 线性筛打质数表
        vector<int> is_prime(200, 1);
        for(int i=2;primes.size()<26;i++)
        {
            if(is_prime[i])primes.push_back(i);
            for(auto num: primes)
            {
                if(num*i >= 200)break;
                is_prime[num*i] = 0;
                if(i%num == 0)break;
            }
        }

        return divide_conquer(s1, s2);
    }
};

解法二：区间dp
上述代码将字符串存在了map里，实际，我们可以用dp[i][j][len]来记录，即表示s1从i开始，s2从j开始，长度为len的子串是否匹配。这样查询其实更省时间，在红黑树里查毕竟是NlogN的。此外比较低效的一点就是，就算要比较的两个子串相同，这种存法也不能用O(1)的时间完成，但解法一的记忆化是可以的。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        int N = s1.size();
        int dp[N][N][N+1];
        memset(dp, 0, sizeof(dp));
        
        // 初始化：长度为1
        for(int i=0;i<N;i++)
        {
            for(int j=0;j<N;j++)
            {
                if(s1[i] == s2[j])dp[i][j][1] = 1;
            }
        }

        // 递推
        for(int len=2;len<=N;len++)
        {
            for(int i=0;i<=N-len;i++)
            {
                for(int j=0;j<=N-len;j++)
                {
                    for(int k=1;k<len;k++)
                    {
                        if(dp[i][j][k] && dp[i+k][j+k][len-k])dp[i][j][len] = 1;
                        if(dp[i][j+len-k][k] && dp[i+k][j][len-k])dp[i][j][len] = 1;
                    }
                }
            }
        }

        return dp[0][0][N];
    }
};

代码很简洁，但细节很多，由于维数较高不太好调试，要注意循环的范围，等号，以及递推方程的下标。这里的递推公式是，判断i，j，len是否满足条件，要看是否能把他分割开，让两边都相等，和记忆化思想一致。