291 单词规律 II

题目描述：
给你一种规律 pattern 和一个字符串 str，请你判断 str 是否遵循其相同的规律。

这里我们指的是 完全遵循，例如 pattern 里的每个字母和字符串 str 中每个 非空 单词之间，存在着 双射 的对应规律。双射 意味着映射双方一一对应，不会存在两个字符映射到同一个字符串，也不会存在一个字符分别映射到两个不同的字符串。

示例 1：
输入：pattern = “abab”, s = “redblueredblue”
输出：true
解释：一种可能的映射如下：
‘a’ -> “red”
‘b’ -> “blue”

示例 2：
输入：pattern = “aaaa”, s = “asdasdasdasd”
输出：true
解释：一种可能的映射如下：
‘a’ -> “asd”

示例 3：
输入：pattern = “abab”, s = “asdasdasdasd”
输出：true
解释：一种可能的映射如下：
‘a’ -> “a”
‘b’ -> “sdasd”
注意 ‘a’ 和 ‘b’ 不能同时映射到 “asd”，因为这里的映射是一种双射。

示例 4：
输入：pattern = “aabb”, s = “xyzabcxzyabc”
输出：false

提示：
0 <= pattern.length <= 20
0 <= s.length <= 50
pattern 和 s 由小写英文字母组成

方法1：
主要思路：
（1）使用回溯法，并使用哈希进行标识；
（2）使用unordered_map<char,string> 来标识字符和字符串的映射，再配合unordered_set 来保证映射的一一对应性；
（3）使用回溯的两个终止条件，一个是对于两个字符串都同时遍历到了字符串的末尾，说明此时匹配正确，则返回true，但若只是其中的一个遍历到了字符串的末尾，则返回false；
（4）每次先从模式字符串中取出一个字符，再在给定的需要判断的字符串中找各个可能的字符串，判断该字符和字符串对应的关系，若存在该对应关系，则进一步进行递归判断，若不存在，则将当前关系插入到map和set中，并进一步判断，并在回溯的时候，进行还原；

class Solution {
public:
    bool backtrace(string& pattern,string& s,int index_p,int index_s,unordered_map<char,string>& mp,unordered_set<string>& st){
        if(index_p==pattern.size()&&index_s==s.size()){//说明当前模式可以匹配
            return true;
        }
        else if(index_p==pattern.size()||index_s==s.size()){//说明当前模式不能匹配
            return false;
        }
        char ch=pattern[index_p];//当前模式字符串中的需要判断的字符
        //找出需要判断的字符串中的各个子字符串
        for(int i=index_s;i<s.size();++i){
            string cur_str=s.substr(index_s,i-index_s+1);//当前需要判断的子字符串
            if(mp.count(ch)&&mp[ch]==cur_str){//若当前映射关系存在
                if(backtrace(pattern,s,index_p+1,i+1,mp,st)){//进一步的递归判断
                    return true;
                }
            }
            else if(!mp.count(ch)){//若当前映射关系不存在
                if(!st.count(cur_str)){//且字符串之前也没用被映射为其他的字符
                	//添加映射关系
                    mp[ch]=cur_str;
                    st.insert(cur_str);
                    if(backtrace(pattern,s,index_p+1,i+1,mp,st)){//进一步判断
                        return true;
                    }
                    //回溯
                    st.erase(cur_str);
                    mp.erase(ch);
                }
            }
        }
        return false;
    }
    bool wordPatternMatch(string pattern, string s) {
        if(pattern.size()>s.size()){//特殊的情形
            return false;
        }
        unordered_map<char,string> mp;//统计映射关系
        unordered_set<string> st;//保证映射关系是一一映射
        return backtrace(pattern,s,0,0,mp,st);//回溯
    }
};

方法2：
主要思路：
（1）也是回溯方法，且和上述方法基本一致的思路，只不过调整了相关的判断顺序

class Solution {
public:
    bool backtrace(string& pattern,string& s,unordered_map<char,string>& mp,unordered_set<string>& st,int index_p,int index_s){
        if(index_p==pattern.size()&&index_s==s.size()){//两个字符串同时到末尾，说明模式匹配正确
            return true;
        }
        else if(index_p==pattern.size()||index_s==s.size()){//若只有一个字符串遍历到了末尾，则匹配不正确
            return false;
        }
        char ch=pattern[index_p];//模式字符串中当前需要判断的字符
        if(mp.count(ch)){//若字符存在映射关系
            string cur_str=mp[ch];//找出对应映射的字符串
            for(int i=0;i<cur_str.size();++i){//并在给出的需要判断的字符串中，当前的位置，判断是否存在该映射的字符串
                if(index_s+i>=s.size()||s[index_s+i]!=cur_str[i]){//若不存在，则直接返回false
                    return false;
                }
            }
            return backtrace(pattern,s,mp,st,index_p+1,index_s+cur_str.size());//若存在，在进一步进行判断
        }
        else{//当不存在当前字符的映射关系时
            int end_pos=s.size()-(pattern.size()-index_p);//需要判断的字符串在判断时的终止位置
            for(int i=index_s;i<=end_pos;++i){//找出各个可能的子字符串进行判读
                string cur_str=s.substr(index_s,i-index_s+1);//找出当前的子字符串
                if(!st.count(cur_str)){//若该子字符串之前没有被映射到其他的字符
                    st.insert(cur_str);//将当前字符串的映射关系保存
                    mp[ch]=cur_str;
                    if(backtrace(pattern,s,mp,st,index_p,index_s)){//进一步判断
                        return true;
                    }
                    st.erase(cur_str);//回溯
                }
            }
            mp.erase(ch);//回溯
            return false;//跳出判断，返回false
        }
    }
    bool wordPatternMatch(string pattern, string s) {
        if(pattern.size()>s.size()){//处理特殊的情形
            return false;
        }
        //存储映射关系，并保证映射关系为一一映射
        unordered_map<char,string> mp;
        unordered_set<string>st;
        return backtrace(pattern,s,mp,st,0,0);
    }
};