由leetcode 87扰乱字符串引出的两个Java问题

87. 扰乱字符串

难度困难388收藏分享切换为英文接收动态反馈

使用下面描述的算法可以扰乱字符串 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

解：

        要解决这道扰乱字符串，首先要明确字符串s1和字符串s2互为扰乱字符串，是存在s1和s2分割字符串相同长度的左起字符串sl1和sl2和右边剩余的sr1和sr2分别互为扰乱字符串，这个分割方式可以枚举。当然因为可以交换两个子字符串，也可以存在s1左起的子字符串和s2右起的子字符串以及剩余的一对字符串分别互为扰乱字符串。只要枚举s1的分割方式中上述两种情况有一种成立，就可以说s1和s2互为扰乱字符串。这就把大规模的问题分成了若干子问题的递推关系，而当问题规模小到一定程度时问题就可以很自然的解决。这里是当子字符串的长度为1时，只要他们相同就可以互为扰乱字符串，这就是动态规划的思想。递推的关系式为

        然后我们就想办法加速这个原始的动态规划算法，首先判断两个字符串互为扰乱字符串需要递归，但是只要两个字符串的各种元素数量不相等就可以判断他们不是，这就可以提前返回。然后对于计算过的子串对，我们可以把它们的结果保存下来，下次再枚举到就不递归了，这就是记忆化搜索。因为判断的字串长度相等，所以我们只要有s1中子串的开始位置start1,s2的开始位置start2,和长度len就可以表示一个字串对，然后用一个map来保存计算后的结果，这就涉及到多个值组合作为key的问题了。

         Java由于没有元组，HashMap如果需要多个值（可能是不同类型）共同作为key，通常有两种方法。第一种是用一个对象把多个值包起来，但是这样要重写这个对象的hashCode()和equals()函数，使得两个包含的值分别相同的两个对象的上述两个函数的返回值相同。一般idea默认生成的函数就可以达到该目的。注意是同时重写两个函数，因为HashMap同时使用上述两个函数的返回值来判断是不是指定的key值。第二种是使用一个HashMap的嵌套，像HashMap<k1,HashMap<k2,HashMap<k3,Value>>>这种方法的缺点也很明显，写起来麻烦，但是无需担心效率问题，因为HashMap的查找是O(1)时间复杂度的。

        另外要注意，HashMap 的put方法返回的是设置之前的value,也就是说如果是新的key-value，返回的值会是null。

        代码如下：

public class Solution {

    private String str1,str2;
    private HashMap<memSearch,Boolean> memMap;
    public boolean isScramble(String s1, String s2) {
        memMap=new HashMap<>();
        str1=s1;
        str2=s2;
        return recursion(0,0,s1.length());
    }

    private boolean recursion(int start1,int start2,int len)
    {
        var newSearch=new memSearch(start1,start2,len);
        if(memMap.containsKey(newSearch))
            return memMap.get(newSearch);
        var string1=str1.substring(start1,start1+len);
        var string2=str2.substring(start2,start2+len);
        if(len==1)
            return string1.equals(string2);
        var keyNumArray=new int[26];
        for(int i=0;i<len;i++)
        {
            int k1=string1.charAt(i)-'a';
            int k2=string2.charAt(i)-'a';
            keyNumArray[k1]++;
            keyNumArray[k2]--;
        }
        for(int i=0;i<26;i++)
        {
            if(keyNumArray[i]!=0) {
                memMap.put(newSearch,false);
                return false;
            }
        }
        for(int i=1;i<len;i++)
        {
            if(recursion(start1,start2,i)&&recursion(start1+i,start2+i,len-i)) {
                memMap.put(newSearch, true);
                return true;
            }
            if(recursion(start1,start2+len-i,i)&&recursion(start1+i,start2,len-i)) {
                memMap.put(newSearch, true);
                return true;
            }
        }
        memMap.put(newSearch,false);
        return false;
    }
    public static class memSearch{
            int a,b,c;

        public memSearch(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        @Override
            public int hashCode()
            {
                return Objects.hash(a,b,c);
            }
            @Override
            public boolean equals(Object obj)
            {
                if(obj==this)
                    return true;
                if(obj==null||obj.getClass()!=this.getClass())
                    return false;
                memSearch transObj=(memSearch)obj;
                return transObj.a==this.a&&transObj.b==this.b&&transObj.c==this.c;
            }

    }
}