Leetcode-DSF-Scramble String_leet dsf-优快云博客

本文探讨了Scramble String问题的解决方案，该问题是通过递归地将字符串分割成两个非空子串来构建二叉树表示。文章详细介绍了如何通过特定的方法判断一个字符串是否为另一个字符串的混乱字符串。

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

思路
Problem
Code

思路

此题有两难。

其一规律很难找寻，寻找scramble string 之间的关系需要敏锐的眼光。
没有快捷的算法，stack, DP, DC等等行不通，需尝试最傻的方法DSF。

Problem

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.

Code

typedef unordered_map<char, int> mcint;
class Solution {
public:
    bool isE(string &s1, string &s2) {
        unordered_map<char, int> A,B;
        for (auto c : s1)
            A[c]?A[c]++:A[c] = 1;
        for (auto c : s2)
            B[c]?B[c]++:B[c] = 1;
        for (auto a : A) {
            if (!(B[a.first] && B[a.first] == a.second)) 
                return false;
        }
        return true;
    }
    bool isMapE(mcint &A, mcint &B) {
        for (auto a : A) {
            if (!(B[a.first] && B[a.first] == a.second)) 
                return false;
        }
        return true;
    }
    vector<int> calSamePos(string &s1, string &s2) {
        vector<int> res;
        unordered_map<char, int> A,B;
        char c = 0;
        for (int i = 0; i+1 < s1.size(); ++i) {
            c = s1[i];
            A[c]?A[c]++:A[c] = 1;
            c = s2[i];
            B[c]?B[c]++:B[c] = 1;
            if (isMapE(A,B)) {
                res.push_back(i);
            }
        }
        return res;
    }
    bool isScramble(string s1, string s2) {
        if (s1.size() == s2.size()) {
            if (s1.size() <= 3) {
                if(isE(s1, s2)) 
                    return true;
                else return false;
            }
        } else {
            return false;
        }
        auto samPro = [&]()->bool {
            auto Spos = calSamePos(s1,s2);
            for (auto i : Spos) {
                string ts11(s1.begin(), s1.begin()+i+1),ts12(s1.begin()+i+1, s1.end()),
                       ts21(s2.begin(), s2.begin()+i+1),ts22(s2.begin()+i+1, s2.end());
                if (isScramble(ts11,ts21) && isScramble(ts12,ts22))
                    return true;
            }
            return false;
        };
        // case 1
        if (samPro())return true;
        // case 2
        // reverse s1
        string s10(s1.rbegin(), s1.rend());
        s1 = s10;
        if (samPro())return true;
        return false;
    }
};