【leetcode】Scramble String

最新推荐文章于 2019-08-26 13:50:26 发布

原创最新推荐文章于 2019-08-26 13:50:26 发布 · 313 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

222 篇文章

订阅专栏

本文介绍了一种用于判断两个字符串是否互为Scramble的动态规划算法，并提供了详细的实现思路及代码示例。

From：https://leetcode.com/problems/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.

思路：

动态规划。

数组dp[k][i][j]表示长度为k-1，s中从i开始的长为k-1的串和t中从j开始长为k-1的串是否是scrambled。

对于任意k,i,j，只要存在一种情况，使得两个子串满足scrambled，那么dp[k][i][j]为true，否则为false。

对于任意k,i,j，scramble的情形有两种，情形一：

如果两个绿色满足scrambled，且两个黄色满足scrambled，那么dp[k][i][j]为true。

情形二：

也是绿色为scrambled且黄色为scrambled，有dp[k][i][j]为true。

说白了，scramble就是要左边和左边一致且右边和右边一致，或者左边和右边一致，右边和左边一致。

故要求：

对任意的k，i，j，有

                    boolean can = false;
                    for(int m=1; m<k && !can; ++m) {
                        can = dp[m-1][i][j] && dp[k-m-1][i+m][j+m] || dp[m-1][i][j+k-m] && dp[k-m-1][i+m][j];
                    }
                    dp[k-1][i][j] = can;

下面是代码：

public class Solution {
    public boolean isScramble(String s1, String s2) {
        int n = s1.length();
        if(n != s2.length()) {
            return false;
        }
        if(0 == n) {
            return true;
        }
        
        boolean[][][] dp = new boolean[n][n][n];
        // dp[k][i][j] means length is k-1, s1 from i, s2 from j.
        for(int i=0; i<n; ++i) {
            for(int j=0; j<n; ++j) {
                dp[0][i][j] = (s1.charAt(i) == s2.charAt(j));
            }
        }
        
        for(int k=2; k<=n; ++k) {
            for(int i=n-k; i>=0; --i) {
                for(int j=n-k; j>=0; --j) {
                    boolean can = false;
                    for(int m=1; m<k && !can; ++m) {
                        can = dp[m-1][i][j] && dp[k-m-1][i+m][j+m] || dp[m-1][i][j+k-m] && dp[k-m-1][i+m][j];
                    }
                    dp[k-1][i][j] = can;
                }
            }
        }
        
        return dp[n-1][0][0];
    }
}