算法题LC62：minimum-depth-of-binary-tree

字符串，动态规划：
题目描述：
题目给出一个字符串s1，我们可以用递归的方法将字符串分成两个非空的子串来将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的乱序字符串。

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.
输入描述：

输出描述：

示例1：
输入：

输出：
        
代码：

import java.util.*;
public class Solution {
    /*
    题意：求s2是不是s1的爬行字符串，其实就是s1任意交换字母，看能不能交换成s2
    1、当s1，s2长度为1时，直接判断s1==s2即可获得答案
    2、当s1为ab，那么s2只能ab或者ba
    3、
    例如：
    3.1、gr|eat 和 rg|eat从第2个位置进行分割，不进行交换
    a1=gr b1=eat a2=rg b2=eat
    此时需要判断
    (gr, rg) && (eat, eat)
    3.2、对于 re|at 和 ta|er从第2个位置进行分割
    a1=re b1=at a2=ta b2=er，这种显然这种是不符合的
    那么s2的两部分交换，那么s'=er|ta
    a1=re b1=at a2`=er b2`=ta，这种显然是符合条件的
    对于任意长度的字符串，我们可以把字符串s1分为a1，b1两部，s2分为a2，b2两部分
    满足 (a1~a2) && (b1~b2) || (a1~b2) && (a2~b1)
     
    4、剪枝，判断两个字符串是否有相同的字符集，没有则直接剪去这个分支
    */
    public boolean isScramble(String s1, String s2) {
        int len1 = s1.length();
        int len2 = s2.length();
        if (len1 != len2) {
            return false;
        }
        if(len1 == 1) {
            return s1.equals(s2);
        }
        char[] chs1 = s1.toCharArray();
        char[] chs2 = s2.toCharArray();
        Arrays.sort(chs1);
        Arrays.sort(chs2);
        String sortS1 = new String(chs1);
        String sortS2 = new String(chs2);
        if (!sortS1.equals(sortS2)) {
            return false;
        }
        for(int i = 1; i < len1; i++) {
            String s1Left = s1.substring(0, i);
            String s1Right = s1.substring(i, len1);
            String s2Left = s2.substring(0, i);
            String s2Right = s2.substring(i, len1);
            // 没有交换
            if(isScramble(s1Left, s2Left) && isScramble(s1Right, s2Right)) {
                return true;
            }
            // 交换比较
            s2Right = s2.substring(len1 - i, len1);
            s2Left = s2.substring(0, len1 - i);
            if(isScramble(s1Left, s2Right) && isScramble(s1Right, s2Left)) {
                return true;
            }
        }
        return false;
    }
}