【LeetCode】Scramble String

最新推荐文章于 2021-08-22 16:17:09 发布

Snowwolf_Yang

最新推荐文章于 2021-08-22 16:17:09 发布

阅读量499

点赞数

分类专栏：动态规划 LeetCode 树

本文链接：https://blog.csdn.net/snowwolf_yang/article/details/26483807

版权

LeetCode 同时被 3 个专栏收录

86 篇文章 0 订阅

订阅专栏

动态规划

17 篇文章 0 订阅

订阅专栏

树

9 篇文章 0 订阅

订阅专栏

参考链接

http://blog.csdn.net/sunjilong/article/details/8266313
http://blog.csdn.net/doc_sgl/article/details/12401335

http://blog.csdn.net/pickless/article/details/11501443

http://www.blogjava.net/sandy/archive/2013/05/22/399605.html

题目描述

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

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

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

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

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

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

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

题目分析

分析：

这个问题是google的面试题。由于一个字符串有很多种二叉表示法，貌似很难判断两个字符串是否可以做这样的变换。
对付复杂问题的方法是从简单的特例来思考，从而找出规律。
先考察简单情况：
字符串长度为1：很明显，两个字符串必须完全相同才可以。
字符串长度为2：当s1="ab", s2只有"ab"或者"ba"才可以。
对于任意长度的字符串，我们可以把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，满足（(a1~a2) && (b1~b2)）或者（(a1~b2) && (a1~b2)）

如此，我们找到了解决问题的思路。首先我们尝试用递归来写。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1.size()!=s2.size()) return false;
        if(s1==s2) return true;
        //if(字符不相同) return false;
        string str1=s1;sort(str1.begin(),str1.end());
        string str2=s2;sort(str2.begin(),str2.end());
        if(str1!=str2) return false;
        int len=s1.size(),i;
        for(i=1;i<len;i++)
        {
            //if（左左&&右右)||(左右&&右左) return true;
            if((isScramble(s1.substr(0,i),s2.substr(0,i))&&isScramble(s1.substr(i),s2.substr(i)))
            ||(isScramble(s1.substr(0,i),s2.substr(len-i))&&isScramble(s1.substr(i),s2.substr(0,len-i))))
            return true;
        }
        return false;
    }
};

解法一（递归）

两个字符串的相似的必备条件是含有相同的字符集。简单的做法是把两个字符串的字符排序后，然后比较是否相同。
加上这个检查就可以大大的减少递归次数。

动态规划。

定义F[i][j][k]，

当F[i][j][k]=true时，表示S1[i..i+k-1] == S2[j..j+k-1]。

用白话表达：F[i][j][k]记录的是S1从i开始k个字符与S2从j开始k个字符是否为Scramble String。

最简单的情况为k=1时，即S1[i]与S2[j]是否为Scramble String。

因此F[i][j][1] = S1[i] == S2[j]。

当K=2时，

F[i][j][2] = (F[i][j][1] && F[i+1][j+1][1]) || (F[i][j+1][1] && F[i+1][j][1])。

F[i][j][1] && F[i+1][j+1][1]表达的是 S1[i] == S2[j] && S1[i+1]==S2[j+1]（例如：“AC”和“AC”），如果这个条件满足，那么S1[i..i+1]与S2[j..j+1]自然为Scramble String，即F[i][j][2] = true。

F[i][j+1][1] && F[i+1][j][1]表达的是S1[i+1] == S2[j] && S1[i] == S2[j + 1] （例如： “AB”和“BA”），同样如果该条件满足，F[i][j][2] = true。

当K为更大的数时，同递归算法一样，我们需要枚举分割点，假设左边长度为l，即S[i..i+l-1]，右边长度为k-l，即S[i+l..i+k-1]。

同样存在两种情况，S1左 = S2左 && S1右 = S2右或者 S1左 = S2右 && S1右 = S2左。

public class Solution {
    public boolean isScramble(String s1, String s2) {
        int len = s1.length();
        if(len!=s2.length()){
            return false;
        }
        if(len==0){
            return true;
        }
        
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        
        boolean[][][] result = new boolean[len][len][len];
        for(int i=0;i<len;++i){
            for(int j=0;j<len;++j){
                result[0][i][j] = (c1[i]==c2[j]);
            }
        }
        
        for(int k=2;k<=len;++k){
            for(int i=len-k;i>=0;--i){
              for(int j=len-k;j>=0;--j){
                  boolean r = false;
                  for(int m=1;m<k && !r;++m){
                      r = (result[m-1][i][j] && result[k-m-1][i+m][j+m]) || (result[m-1][i][j+k-m] && result[k-m-1][i+m][j]);
                  }
                  result[k-1][i][j] = r;
              }
            }
        }
        
        return result[len-1][0][0];
    }
}