C++ 同构字符串/ 单词规律

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:

输入：s = "egg", t = "add"
输出：true

示例 2：

输入：s = "foo", t = "bar"
输出：false

class Solution {
public:
    bool isIsomorphic(string s, string t) {
 
            if(s.size()==0&&t.size()==0) {
                return true;
            }
 
            for(int i=0;i<s.size();i++) {
                if(s.find(s[i])!=t.find(t[i])) {
                    return false;
                }
            
            }
            return true;
    }
};

---

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", s = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", s = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", s = "dog cat cat dog"
输出: false

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        vector<string> res;
 
        res = split(s);
        set<char> set2(pattern.begin(),pattern.end());
        set<string> set3;
        for(auto i:res) {
            set3.insert(i);
        }
 
        if(pattern.size()!=res.size()) {
            return false;
        }
        if(set2.size()!=set3.size()) {
            return false;
        }
 
 
        unordered_map<char, string> map2;
        for(int i=0;i<pattern.size();i++) {
            map2[pattern[i]] = res[i];
        }   
 
        for(int i=0;i<pattern.size();i++) {
            if(map2[pattern[i]]!=res[i]) {
                return false;
            }
        }
 
        return true;
    }
 
    vector<string> split(string s) {
        int len = s.length();
        int i(0);
        string ans= "", temp;
        vector<string> res;
 
        while(i<len) {
            temp = "";
            while(i<len&&s[i]==' ') {i++;}
            while(i<len&&s[i]!=' ') {
                temp += s[i++];
            }
            res.push_back(temp);
        }
 
        return res;
    }
 
};