87. 扰乱字符串

87. 扰乱字符串

题目描述

给定一个字符串 s1，我们可以把它递归地分割成两个非空子字符串，从而将其表示为二叉树。

下图是字符串 s1 = "great" 的一种可能的表示形式。

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

在扰乱这个字符串的过程中，我们可以挑选任何一个非叶节点，然后交换它的两个子节点。

例如，如果我们挑选非叶节点 "gr" ，交换它的两个子节点，将会产生扰乱字符串 "rgeat" 。

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

我们将 "rgeat” 称作 "great" 的一个扰乱字符串。

同样地，如果我们继续交换节点 "eat" 和 "at" 的子节点，将会产生另一个新的扰乱字符串 "rgtae" 。

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

我们将 "rgtae” 称作 "great" 的一个扰乱字符串。

给出两个长度相等的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。

示例 1:

输入: s1 = "great", s2 = "rgeat"
输出: true

示例 2:

输入: s1 = "abcde", s2 = "caebd"
输出: false

---

题解：

首先判断 s1 和 s2 长度是否相等，不相等肯定不满足。然后判断包含的字符种类是否一样且每一种字符出现的数量也一样，不满足的话，s2 一定不是 s1 的旋变字符串。

假设字符串长度为 n，s1 在 i 位置开始翻转，分以下两种情况：

• 该节点不翻转，若 s1[0..i] 与 s2[0...i] 互为翻转，且 s1[i+1...n-1] 与 s2[i+1...n-1] 互为翻转，则 s1 和 s2 互为翻转
• 该节点翻转，若 s1[0..i] 与 s2[n-i-1...n-1] 互为翻转，且 s1[i+1...n-1] 与 s2[0...n-i-2] 互为翻转，则 s1 和 s2 互为翻转

法一：

爆搜 + 剪枝。

如果 s1 的字符和 s2 字符种类不等或者数量不等，肯定不互为翻转。

如果 s1 == s2 ，那么 s1 和 s2 互为翻转。

时间复杂度：$O(5^n)$

额外空间复杂度：$O(n)$

因为加了剪枝，时间复杂度不定，理论的上界是 $O(5^n)$。。。

class Solution {
public:
    bool dfs( const string& s1, const string& s2, int l1, int l2, int k ) {
        string t1 = s1.substr( l1, k );
        string t2 = s2.substr( l2, k );
        if ( t1 == t2 ) return true;
        sort( t1.begin(), t1.end() );
        sort( t2.begin(), t2.end() );
        if ( t1 != t2 ) return false;
        for ( int i = 1; i < k; ++i )
            if( (dfs( s1, s2, l1, l2, i ) && dfs( s1, s2, l1 + i, l2 + i, k - i ))
                || (dfs( s1, s2, l1, l2 + k - i, i ) && dfs( s1, s2, l1 + i, l2, k - i )) )
                return true;
        return false;
    }
    bool isScramble(string s1, string s2) {
        if ( s1.size() != s2.size() ) return false;
        return dfs( s1, s2, 0, 0, s1.size() );
    }
};
/*
时间：4ms，击败：94.73%
内存：7.3MB，击败：88.80%
*/

法二：

记忆化搜索。

设 f[l1][l2][k] 表示 s1 从 l1 开始，S2 从 l2 开始，连续的 k 个字符组成的子串是否互为翻转，f 的值为 -1 状态未出现过。

但是记忆化搜索对于法一的优化基本为零，因为递归的四个分支产生的重复子状态很少很少。。。

class Solution {
public:
    vector<vector<vector<int>>> f;
    bool dfs( const string& s1, const string& s2, int l1, int l2, int k ) {
        if ( f[l1][l2][k] != -1 ) return f[l1][l2][k];
        string t1 = s1.substr( l1, k );
        string t2 = s2.substr( l2, k );
        if ( t1 == t2 ) return f[l1][l2][k] = true;
        sort( t1.begin(), t1.end() );
        sort( t2.begin(), t2.end() );
        if ( t1 != t2 ) return f[l1][l2][k] = false;
        bool ans = false;
        for ( int i = 1; i < k; ++i ) {
            ans |= ( dfs( s1, s2, l1, l2, i ) && dfs( s1, s2, l1 + i, l2 + i, k - i ) );
            if ( ans ) return f[l1][l2][k] = true;
            ans |= ( dfs( s1, s2, l1, l2 + k - i, i ) && dfs( s1, s2, l1 + i, l2, k - i ) );
            if ( ans ) return f[l1][l2][k] = true;
        }
        return f[l1][l2][k] = false;
    }
    bool isScramble(string s1, string s2) {
        if ( s1.size() != s2.size() ) return false;
        f = vector<vector<vector<int>>>( s1.size(), vector<vector<int>>( s1.size(), vector<int>( s1.size() + 1, -1 ) ) );
        return dfs( s1, s2, 0, 0, s1.size() );
    }
};
/*
时间：8ms，击败：83.14%
内存：14.3MB，击败：10.52%
*/

而如果我们对于法一不剪枝，下面是超时版本的代码：

class Solution {
public:
    bool dfs( const string& s1, const string& s2, int l1, int l2, int k ) {
        if ( k == 1 ) return s1[l1] == s2[l2];
        for ( int i = 1; i < k; ++i )
            if( (dfs( s1, s2, l1, l2, i ) && dfs( s1, s2, l1 + i, l2 + i, k - i ))
                || (dfs( s1, s2, l1, l2 + k - i, i ) && dfs( s1, s2, l1 + i, l2, k - i )) )
                return true;
        return false;
    }
    bool isScramble(string s1, string s2) {
        if ( s1.size() != s2.size() ) return false;
        unordered_map<char, int> hash;
        for ( auto& it : s1 ) ++hash[it];
        for ( auto& it : s2 ) {
            if ( --hash[it] < 0 ) return false;
        }
        return dfs( s1, s2, 0, 0, s1.size() );
    }
};
/*
超时代码
*/

对这个版本代码使用记忆化搜索：

class Solution {
public:
    vector<vector<vector<int>>> f;
    bool dfs( const string& s1, const string& s2, int l1, int l2, int k ) {
        if ( f[l1][l2][k] != -1 ) return f[l1][l2][k];
        if ( k == 1 ) return f[l1][l2][k] = (s1[l1] == s2[l2]);
        bool ans = false;
        for ( int i = 1; i < k; ++i ) {
            ans |= ( dfs( s1, s2, l1, l2, i ) && dfs( s1, s2, l1 + i, l2 + i, k - i ) );
            if ( ans ) return f[l1][l2][k] = true;
            ans |= ( dfs( s1, s2, l1, l2 + k - i, i ) && dfs( s1, s2, l1 + i, l2, k - i ) );
            if ( ans ) return f[l1][l2][k] = true;
        }
        return f[l1][l2][k] = false;
    }
    bool isScramble(string s1, string s2) {
        if ( s1.size() != s2.size() ) return false;
        f = vector<vector<vector<int>>>( s1.size(), vector<vector<int>>( s1.size(), vector<int>( s1.size() + 1, -1 ) ) );
        return dfs( s1, s2, 0, 0, s1.size() );
    }
};
/*
时间：16ms，击败：61.92%
内存：13MB，击败：18.96%
*/

提升还是挺明显的。。。

法三：

动态规划。

设 f[l1][l2][k] 表示 s1 从 l1 开始，S2 从 l2 开始，连续的 k 个字符组成的子串是否互为翻转。

时间复杂度：$O(n^4)$

额外空间复杂度：$O(n^3)$

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if ( s1.size() != s2.size() ) return false;
        int n = s1.size();
        vector<vector<vector<bool>>> f( n, vector<vector<bool>>( n, vector<bool>( n + 1 ) ) );
        for ( int i = 0; i < n; ++i )
            for ( int j = 0; j < n; ++j )
                f[i][j][1] = s1[i] == s2[j];
        for ( int k = 2; k <= n; ++k ) {
            for ( int l1 = 0; l1 <= n - k; ++l1 ) {
                for ( int l2 = 0; l2 <= n - k; ++l2 ) {
                    for ( int i = 1; i < k; ++i ) {
                        if ( (f[l1][l2][i] && f[l1 + i][l2 + i][k - i])
                             ||
                             (f[l1][l2 + k - i][i] && f[l1 + i][l2][k - i]) )
                            f[l1][l2][k] = true;
                    }
                }
            }
        }
        return f[0][0][n];
    }
};
/*
时间：48ms，击败：27.01%
内存：9.9MB，击败：44.39%
*/

综上，还是 爆搜+剪枝 效率高。。。