[LeetCode] Scramble String

字符串匹配与乱序转换算法

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

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

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

144 篇文章

订阅专栏

本文探讨了如何判断一个字符串是否可以通过交换另一个字符串中任意非叶子节点的左右子节点来形成，通过引入三维数组f[i][j][k]来记录特定子串的匹配情况，实现了算法的递归实现与优化。

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.

一个字符串是否由另一个字符串交换其二叉树表示的左右节点或子节点得到。

递归来做，很直观，但肯定爆....

用一个三维数组f[i][j][k]来保存S1从i开始和S2从j开始长为k的子串是否是scramble ,

它等于从S1的i开始和S2从j开始长为sublen的f && 从S1的i+sublen开始和S2的j+sublen开始唱为k-sublen的f (左半部分可转化，右半部分也可转化）

或者从S1的i开始和S2的k-sublen+j开始长为sublen的f && 从S1的i+sublen开始和S2的j开始唱为k-sublen的f(左半部分转化为右半部分，右半部分转化为左半部分）

递推方程如下

f[i][j][k] = f[i][j][sublen]&&f[i+sublen][j+sublen][k-sublen] || f[i][k-sublen+j][sublen]&&f[i+sublen][j][k-sublen] (1 <= sublen < k)

class Solution {
public:

    bool isScramble(string s1, string s2) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
       return change(s1,s2);
    }
    bool change(string s1, string s2) { 
        if(s1.size() != s2.size()) return false; 
        int n = s1.size(); 
        vector<vector<vector<bool>>> f(n, vector<vector<bool>>(n, vector<bool>(n+1, false) ) ); 
        for (int i = 0; i < n; ++i) { 
            for (int j = 0; j < n; ++j) { 
                f[i][j][1] = s1[i]==s2[j]; 
            } 
        } 
        for (int k = 2; k <= n; ++k) { 
            for (int i = 0; i+k-1 < n; ++i) { 
                for (int j = 0; j+k-1 < n; ++j) { 
                    for (int subLen = 1; subLen < k; ++subLen) { 
                        if(f[i][j][subLen]&&f[i+subLen][j+subLen][k-subLen] 
                            || f[i][k-subLen+j][subLen]&&f[i+subLen][j][k-subLen]) { 
                                f[i][j][k] = true; 
                                break; 
                            } 
                    } 
                } 
            } 
        } 
        return f[0][0][n]; 
    } 
};