lintcode(430)攀爬字符串

最新推荐文章于 2021-06-09 13:48:18 发布

原创最新推荐文章于 2021-06-09 13:48:18 发布 · 585 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #lintcode

本文介绍了一种递归算法，用于判断两个等长字符串s1和s2的关系，即s2是否可以通过对s1进行子字符串交换操作得到。通过递归拆分字符串并对比子串内容来实现这一目标。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description:

给定一个字符串 S1，将其递归地分割成两个非空子字符串,从而将其表示为二叉树。

下面是s1 = "great"的一个可能表达：

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

在攀爬字符串的过程中，我们可以选择其中任意一个非叶节点，然后交换该节点的两个儿子。

例如，我们选择了 "gr" 节点，并将该节点的两个儿子进行交换，从而产生了攀爬字符串 "rgeat"。

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

我们认为， "rgeat" 是 "great" 的一个攀爬字符串.

类似地，如果我们继续将其节点 "eat" 和 "at" 进行交换，就会产生新的攀爬字符串 "rgtae"。

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

同样地，"rgtae" 也是 "great"的一个攀爬字符串。

给定两个相同长度的字符串s1 和 s2，判定 s2 是否为 s1 的攀爬字符串。

Explanation:

Solution:

Recursion.递归操作，将两个字符串进行拆分，直至长度小于等于2，判断当前子串是否相同，如果相同则返回true。然后每次拆分有两种情况，即是否进行对调，所以每次递归分两种情况，两者之一为true即可。

运行时出现了请求超时，后来AC了。

public class Solution {
    /**
     * @param s1 A string
     * @param s2 Another string
     * @return whether s2 is a scrambled string of s1
     */
    public boolean isScramble(String s1, String s2) {
        // Write your code here
        int len = s1.length();
        if(len == 1){
            return s1.equals(s2);
        }
        if(len == 2){
            if(s1.equals(s2)) return true;
            if(s1.charAt(1) == s2.charAt(0) && s1.charAt(0) == s2.charAt(1)){
                return true;
            }
        }
        
        for(int i = 1;i<len;i++){
            String left1 = s1.substring(0,i);
            String left2 = s2.substring(0,i);
            
            String right1 = s1.substring(i,len);
            String right2 = s2.substring(i,len);
            
            String leftEnd = s2.substring(0,len-i);
            String rightStart = s2.substring(len-i,len);
            
            if( (isScramble(left1 , left2) && isScramble(right1 , right2)) || (isScramble(leftEnd , right1) && isScramble(rightStart , left1)) ){
                return true;
            }
        }
        return false;
    }
}