Isomorphic Strings——同构结构判断

问题描述：求两个字符串是否同构
Given two strings s and t, determine if they are isomorphic.

Two strings are isomorphic if the characters in s can be replaced to get t.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.

For example,
Given “egg”, “add”, return true.
Given “foo”, “bar”, return false.
Given “paper”, “title”, return true.

思路：
这里用到的工具是unordered_map。
设置两个map1，map2，分别对两个字符串作为key进行对应的赋值，如果出现一个map中的值不等于对应的map的键值，返回false，当所有元素对应，两个字符串同构。

程序如下：

#include<iostream>
#include <vector>
#include<string>
#include<unordered_map>
using namespace std;

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

void main()
{
    Solution so;
    string s = "egg";
    string t = "absb";
    cout << so.isIsomorphic(s, t) << endl;
}

再深入一点，word pattern问题，如下：
Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in str.

Examples:
pattern = “abba”, str = “dog cat cat dog” should return true.
pattern = “abba”, str = “dog cat cat fish” should return false.
pattern = “aaaa”, str = “dog cat cat dog” should return false.
pattern = “abba”, str = “dog dog dog dog” should return false.

同样方法类似：
这里还要用到一个工具：stringstream ss(str);头文件#include<sstream>
把字符串按空格分开，ss>>a;赋值给a；

程序如下：

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char,string> map1;
        unordered_map<string, char> map2;
        string a;
        stringstream ss(str);
        for (auto c : pattern)
        {
            if (!(ss >> a))
            {
                return false;
            }
            if (map1.find(c) == map1.end() && map2.find(a) == map2.end())
            {
                map1[c] = a;
                map2[a] = c;
            }
            if (map1[c] != a || map2[a] != c)
            {
                return false;
            }
        }
            if (!ss.eof()) 
            {
                return false;
            }

        return true;

    }
};