「前端刷题」87. 扰乱字符串

「这是我参与11月更文挑战的第25天，活动详情查看：2021最后一次更文挑战」。

题目

链接：leetcode-cn.com/problems/sc…

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

1. 如果字符串的长度为 1 ，算法停止
2. 如果字符串的长度 > 1 ，执行下述步骤：
   • 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
   • 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
   • 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1 和 s2，判断 s2是否是 s1的扰乱字符串。如果是，返回 true ；否则，返回 false 。

示例 1：

输入： s1 = "great", s2 = "rgeat"

输出： true 解释： s1 上可能发生的一种情形是：

"great" --> "gr/eat" // 在一个随机下标处分割得到两个子字符串
"gr/eat" --> "gr/eat" // 随机决定：「保持这两个子字符串的顺序不变」
"gr/eat" --> "g/r / e/at" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割
"g/r / e/at" --> "r/g / e/at" // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」
"r/g / e/at" --> "r/g / e/ a/t" // 继续递归执行此算法，将 "at" 分割得到 "a/t"
"r/g / e/ a/t" --> "r/g / e/ a/t" // 随机决定：「保持这两个子字符串的顺序不变」
算法终止，结果字符串和 s2 相同，都是 "rgeat"
这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true

示例 2：

**输入：**s1 = "abcde", s2 = "caebd" **输出：**false

示例 3：

**输入：**s1 = "a", s2 = "a" **输出：**true

提示：

• s1.length == s2.length
• 1 <= s1.length <= 30
• s1 和 s2 由小写英文字母组成

解题思路

这道题只需要考虑边界情况，然后递归就可以了，但是递归的话，最后两道直接溢出，后面用hash去重可以通过。

边界情况：
1、如果s1，s2的长度为1，则返回s1 === s2的结果
2、要比较s1，s2两个字符串之间的字符数量相等，不相等直接返回false
3、如果s1 === s2，返回true
4、循环s1，从索引1开始，截取索引值的两边字符串，s2要考虑两种情况从前面截取和从后面截取，一方不行就得比较另一方

优化：
1、判断截取的两串字符串的长度，先从短的开始比，如果不行，就不需要比较长的了
2、内存问题，最后两道的长度有30位左右，字符类型只有4个，所以能比较的次数非常多，多到超时，所以采用hash去重的方式，如果前面有比较过结果的，直接取值

代码

/**
 * @param {string} s1
 * @param {string} s2
 * @return {boolean}
 */
var isScramble = function(s1, s2) {
    let map = new Map()
    function isScrambleFun(s1, s2) {
        if (map.get(s1 + s2) !== undefined) {
            return map.get(s1 + s2)
        }
        if (s1.length === 1) {
            map.set(s1 + s2, s1 == s2)
            return s1 == s2
        }
        if (!compare(s1, s2)) {
            map.set(s1 + s2, false)
            return false
        }

        if (s1 === s2) {
            map.set(s1 + s2, true)
            return true
        }

        let l1 = '', r1 = '', l2 = '', r2 = '', l3 = '', r3 = ''
        
        for (let i = 1; i < s1.length; i++) {
            l1 = s1.slice(0, i)
            r1 = s1.slice(i)
            
            l2 = s2.slice(0, i)
            r2 = s2.slice(i)
            
            l3 = s2.slice(s2.length - i)
            r3 = s2.slice(0, s2.length - i)

            if (l1.length < r1.length) {
                if (isScrambleFun(l1, l2) && isScrambleFun(r1, r2) || isScrambleFun(l1, l3) && isScrambleFun(r1, r3)) {
                    map.set(s1 + s2, true)
                    return true
                }
            } else {
                if (isScrambleFun(r1, r2) && isScrambleFun(l1, l2) || isScrambleFun(r1, r3) && isScrambleFun(l1, l3)) {
                    map.set(s1 + s2, true)
                    return true
                }

            }
        }
        map.set(s1 + s2, false)
        return false
    }

    return isScrambleFun(s1, s2)
};

function compare(s1, s2) {
    let a1 = new Array(26).fill(0)
    let a2 = new Array(26).fill(0)

    for (let i = 0; i < s1.length; i++) {
        a1[s1.charCodeAt(i) - 97]++
        a2[s2.charCodeAt(i) - 97]++
    }

    for (let i = 0; i < 27; i++) {
        if (a1[i] !== a2[i]) {
            return false
        }
    }

    return true
}