leetcode 87 Scramble String(动态规划)

题目描述:
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.

分析:

这是一道三维动态规划的题目,我们提出维护量res[i][j][n],其中i是s1的起始字符编号,j是s2的起始字符编号,
而n是当前的字符串长度;res[i][j][len]表示的是:以i和j分别为s1和s2起点的长度为len的字符串是不是互为scramble。
有了维护量我们接下来看看递推式,也就是怎么根据历史信息来得到res[i][j][len]。
判断这个是不是满足,其实我们首先是把当前s1[i,……,i+len-1]字符串劈一刀分成两部分,然后分两种情况:
第一种情况是:左边和s2[j,……,j+len-1]左边部分是不是scramble,以及右边和s2[j...j+len-1]右边部分是不是scramble;
第二种情况是:左边和s2[j...j+len-1]右边部分是不是scramble,以及右边和s2[j...j+len-1]左边部分是不是scramble。
以上两种情况只要有一种成立,就说明s1[i,……,i+len-1]和s2[j,……,j+len-1]是scramble的。
对于判断这些左右部分是不是scramble,我们是有历史信息的,
因为长度小于n的所有情况我们都在前面求解过了(也就是长度是最外层循环)。
上面说的是劈一刀的情况,对于s1[i,……,i+len-1]我们有len-1种劈法
这些劈法中只要有一种成立,那么两个串就是scramble的
总结起来递推式如下:
res[i][j][len] ||=((res[i][j][k]&&res[i+k][j+k][len-k])||(res[i][j+len-k][k]&&res[i+k][j][len-k]))
对于所有1<=k<len,也就是对于所有len-1种劈法的结果求 或运算
因为信息都是计算过的,对于每种劈法只需要常量操作即可完成,因此求解递推式是需要O(len)(因为len-1种劈法)。
总时间复杂度:因为是三维动态规划,需要三层循环,加上每一步需要线行时间求解递推式,所以是O(n^4)
虽然已经比较高了,但是至少不是指数量级的,动态规划还是有很大优势的,空间复杂度是O(n^3)
c++代码:

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.length()!=s2.length()) return false;
        if (s1.length()==0) return true;
        vector<vector<vector<bool>>> res(s1.size(),vector<vector<bool>>(s2.size(),vector<bool>(s1.size()+1,false)));
        //res[i][j][len]表示的是:以i为s1的起点,同时以j为s2的起点,二者均取长度为len的子串,看看这2个子串是否互为Scramble String
        for(int i=0;i<s1.size();i++)
        {
            for(int j=0;j<s2.size();j++)
            {
                res[i][j][1]=(s1[i]==s2[j]);//计算len==1时,数组res的取值
            }
        }
        for(int len=2;len<=s1.size();len++)//计算len>1时,数组res的取值
            for(int i=0;i<s1.size()-len+1;i++)
                for(int j=0;j<s2.size()-len+1;j++)
                    for(int k=1;k<len;k++)
                    {
                        res[i][j][len]=((res[i][j][len])||(res[i][j][k]&&res[i+k][j+k][len-k])||(res[i][j+len-k][k]&&res[i+k][j][len-k]));
                    }
        return res[0][0][s1.length()];
    }
};
上述代码还可进行一点优化:观察最内层的for循环;
初始时res[i][j][len]为false,当res[i][j][len]变为true时,说明:以i为s1的起点,同时以j为s2的起点,
二者均取长度为len的子串,这两个子串满足Scramble String。此时,可通过break语句跳出最内层循环!!!
优化后的C++代码如下:

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.length()!=s2.length()) return false;
        if (s1.length()==0) return true;
        vector<vector<vector<bool>>> res(s1.size(),vector<vector<bool>>(s2.size(),vector<bool>(s1.size()+1,false)));
        //res[i][j][len]表示的是:以i为s1的起点,同时以j为s2的起点,二者均取长度为len的子串,看看这2个子串是否互为Scramble String
        for(int i=0;i<s1.size();i++)
        {
            for(int j=0;j<s2.size();j++)
            {
                res[i][j][1]=(s1[i]==s2[j]);//计算len==1时,数组res的取值
            }
        }
        for(int len=2;len<=s1.size();len++)//计算len>1时,数组res的取值
            for(int i=0;i<s1.size()-len+1;i++)
                for(int j=0;j<s2.size()-len+1;j++)
                    for(int k=1;k<len;k++)
                    {
                        if(res[i][j][len]==true) break;//跳出最内层for循环
                        else res[i][j][len]=((res[i][j][k]&&res[i+k][j+k][len-k])||(res[i][j+len-k][k]&&res[i+k][j][len-k]));
                    }
        return res[0][0][s1.length()];
    }
};
python代码如下:

class Solution(object):
    def isScramble(self, s1, s2):
        """
        :type s1: str
        :type s2: str
        :rtype: bool
        """
        if len(s1)!=len(s2):return False
        if len(s1)==0:return True
        lens=len(s1)
        res=[ [ [False]*(lens+1) for j in range(lens)] for i in range(lens)]#初值全部设为False
        #res[i][j][len]表示的是:以i为s1的起点,同时以j为s2的起点,二者均取长度为len的子串,看看这2个子串是否互为Scramble String
        for i in range(lens):
            for j in range(lens):
                res[i][j][1]=(s1[i]==s2[j])#计算len==1时,数组res的取值
        for length in range(2,lens+1):#计算len>1时,数组res的取值
            for i in range(0,lens-length+1):
                for j in range(0,lens-length+1):
                    for k in range(1,length):
                        res[i][j][length]=((res[i][j][length])or(res[i][j][k] and res[i+k][j+k][length-k])or(res[i][j+length-k][k] and res[i+k][j][length-k]))
        return res[0][0][lens]
同理,将上述代码中的最内层for循环 优化之后,代码如下:

class Solution(object):
    def isScramble(self, s1, s2):
        """
        :type s1: str
        :type s2: str
        :rtype: bool
        """
        if len(s1)!=len(s2):return False
        if len(s1)==0:return True
        lens=len(s1)
        res=[ [ [False]*(lens+1) for j in range(lens)] for i in range(lens)]#初值全部设为False
        #res[i][j][len]表示的是:以i为s1的起点,同时以j为s2的起点,二者均取长度为len的子串,看看这2个子串是否互为Scramble String
        for i in range(lens):
            for j in range(lens):
                res[i][j][1]=(s1[i]==s2[j])#计算len==1时,数组res的取值
        for length in range(2,lens+1):#计算len>1时,数组res的取值
            for i in range(0,lens-length+1):
                for j in range(0,lens-length+1):
                    for k in range(1,length):
                        if res[i][j][length]==True:
                            break #跳出最内层for循环
                        res[i][j][length]=((res[i][j][k] and res[i+k][j+k][length-k])or(res[i][j+length-k][k] and res[i+k][j][length-k]))
        return res[0][0][lens]

(完)


  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值