天题系列： Scramble String -- 三维动态规划

最新推荐文章于 2019-06-29 11:58:00 发布

转载最新推荐文章于 2019-06-29 11:58:00 发布 · 134 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jiajiaxingxing/p/4562430.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.

参考：

http://www.blogjava.net/sandy/archive/2013/05/22/399605.html 引用一下题解部分

http://blog.youkuaiyun.com/fightforyourdream/article/details/17707187

“对付复杂问题的方法是从简单的特例来思考，从而找出规律。
先考察简单情况：
字符串长度为1：很明显，两个字符串必须完全相同才可以。
字符串长度为2：当s1="ab", s2只有"ab"或者"ba"才可以。
对于任意长度的字符串，我们可以把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，满足（(a1~a2) && (b1~b2)）或者（(a1~b2) && (a1~b2)）”

“
这里我使用了一个三维数组boolean result[len][len][len],其中第一维为子串的长度，第二维为s1的起始索引，第三维为s2的起始索引。result[k][i][j]表示s1[i...i+k]是否可以由s2[j...j+k]变化得来”

        if(s1==null || s2==null||s1.length()!=s2.length()) return false;
        int len = s1.length();
        boolean[][][] dp = new boolean[len][len][len];
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        
        for(int i=0;i<len;i++){
            for(int j=0;j<len;j++){
                dp[0][i][j] = c1[i]==c2[j];
            }
        }
        for(int k=2;k<=len;k++){ 
            for(int i=len-k;i>=0;i--){ // the order is from the base, i.e. begin from the last position
                for(int j=len-k;j>=0;j--){
                    boolean r = false;  // test if cut anywhere within k length, the scramble exists
                    for(int cut=1;!r&&cut<k;cut++){ // !r&& 是因为必须每种cut都通过
                        r = (dp[cut-1][i][j]&&dp[k-cut-1][i+cut][j+cut])||(dp[cut-1][i][j+k-cut]&&dp[k-cut-1][i+cut][j]); //前前 && 后后 || 前后 && 后前
                    }
                    dp[k-1][i][j]=r; // can r go through all cuts within k?
                }
            }
        }
        return dp[len-1][0][0];
    }

类似题目应该有

Interleaving String

转载于:https://www.cnblogs.com/jiajiaxingxing/p/4562430.html