【Leetcode】87. Scramble String

题目地址：

https://leetcode.com/problems/scramble-string/

给定两个字符串$s_1$和$s_2$，允许将$s_1$做以下操作：
1、若$s_1=x+y$，$x$和$y$都是$s_1$的非空子串，那么可以将$s_1$变成$y+x$；
2、在1的基础上，对$x$和$y$继续做与$1$相同操作。也就是说，一旦进行了1的操作，还可以继续将$x$和$y$重新视为$s_1$来做分割交换的操作。
问$s_1$有无可能经历若干次变换变为$s_2$。

动态规划算法可以参考https://blog.csdn.net/qq_46105170/article/details/108701661，下面给出DFS和记忆化搜索的做法。

法1：DFS。如果$s_1=s_2$那直接返回true；如果长度不等则直接返回false（如果长度相等，设为$l$）；如果字母构成不一样（即要么字母类别不一样，要么某个字母出现次数不一样）也直接返回false。接着开始考虑变换的若干种情况。首先$s_1=x+y$的话，$x$的长度可以取$1\sim l-1$，这样$s_1$就有可能按照$x+y$的顺序继续变换，或者按照$y+x$的顺序继续变换。也就是说，一旦选定了$x$的长度，接下来的交不交换$x$和$y$就是两种可能性。而$s_1$能变为$s_2$当且仅当，或者$x$可以变为$s_2$的前$l_x$个字符并且$y$可以变为$s_2$的后$l_y$个字符，或者$x$可以变为$s_2$的后$l_x$个字符并且$y$可以变为$s_2$的前$l_y$个字符。这几个问题都是规模更小的问题，递归解决即可。代码如下：

public class Solution {
    public boolean isScramble(String s1, String s2) {
    	if (s1.length() != s2.length()) {
            return false;
        }
        
        if (s1.equals(s2)) {
            return true;
        }
        
        // 判断一下字母构成，如果不同则直接返回false
        int[] count = new int[26];
        for (int i = 0; i < s1.length(); i++) {
            count[s1.charAt(i) - 'a']++;
        }
        for (int i = 0; i < s2.length(); i++) {
            if (count[s2.charAt(i) - 'a'] == 0) {
                return false;
            }
            count[s2.charAt(i) - 'a']--;
        }
    
    	// 开始枚举s1 = x + y中的x的长度
        int len = s1.length();
        for (int i = 1; i <= len - 1; i++) {
        	// 分两种情况，只要一旦发现可以变换，就直接返回true
            if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i, len), s2.substring(i, len))) {
                return true;
            }
            if (isScramble(s1.substring(0, i), s2.substring(len - i, len)) && isScramble(s1.substring(i, len), s2.substring(0, len - i))) {
                return true;
            }
        }
        
        // 变不了，返回false
        return false;
    }
}

时间复杂度可以由递推式计算：$$T(n)=4\sum _{i=1}^{n-1}T(i)+n$$令$n$为$n-1$则有：$$T(n-1)=4\sum _{i=1}^{n-2}T(i)+n-1$$两式相减得：$T(n)-T(n-1)=4T(n-1)+1$，所以$T(n)=5T(n-1)+1=O(5^n)$空间复杂度$O(n)$。

法2：记忆化搜索。设$f[i][j][l]$表示$s_1[i:i+l-1]$和$s_2[j:j+l-1]$是否可以互相达到。我们发现这个信息是要反复计算的，所以可以缓存起来，做记忆化搜索。代码如下：

import java.util.Arrays;

public class Solution {
    /**
     * @param s1: A string
     * @param s2: Another string
     * @return: whether s2 is a scrambled string of s1
     */
    public boolean isScramble(String s1, String s2) {
        // write your code here
        if (s1.length() != s2.length()) {
            return false;
        }
        
        int len = s1.length();
        // dp就是上面所说的f
        int[][][] dp = new int[len][len][len + 1];
        // 先初始化为-1，-1表示未计算过
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[0].length; j++) {
                Arrays.fill(dp[i][j], -1);
            }
        }
        
        return check(s1, s2, 0, 0, len, dp);
    }
    
    // 返回s1[idx1 : idx1 + len - 1]和s2[idx2 : idx2 + len - 1]是否可以互相达到
    private boolean check(String s1, String s2, int idx1, int idx2, int len, int[][][] dp) {
    	// 如果已经计算过，就返回计算出来的值，1表示true，0表示false
        if (dp[idx1][idx2][len] != -1) {
            return dp[idx1][idx2][len] == 1;
        }
        
        // 如果两段相等则返回true，返回之前记忆
        if (s1.substring(idx1, idx1 + len).equals(s2.substring(idx2, idx2 + len))) {
            dp[idx1][idx2][len] = 1;
            return true;
        }
        
        // 如果两段字符组成不一样，返回false，返回之前记忆
        int[] count = new int[26];
        for (int i = idx1; i < idx1 + len; i++) {
            count[s1.charAt(i) - 'a']++;
        }
        for (int i = idx2; i < idx2 + len; i++) {
            char ch = s2.charAt(i);
            if (count[ch - 'a'] == 0) {
                dp[idx1][idx2][len] = 0;
                return false;
            }
            count[ch - 'a']--;
        }
        
        // 枚举截断的长度
        for (int l = 1; l < len; l++) {
            if (check(s1, s2, idx1, idx2, l, dp) && check(s1, s2, idx1 + l, idx2 + l, len - l, dp)) {
                dp[idx1][idx2][len] = 1;
                return true;
            }
            
            if (check(s1, s2, idx1, idx2 + len - l, l, dp) && check(s1, s2, idx1 + l, idx2, len - l, dp)) {
                dp[idx1][idx2][len] = 1;
                return true;
            }
        }
        
        // 枚举完都没发现能到达，则返回false，返回之前记忆
        dp[idx1][idx2][len] = 0;
        return false;
    }
}

时间复杂度$O(n^4)$，空间$O(n^3)$。