Word Pattern

这个hash的模式之前也用过，Isomorphic Strings这道题用过，就是搞两个表，对两个比较的模式，key塞字符串，值塞第一次出现的位置，然后两个表的字符串，如果是对应的，那么相应的key的值是一样的，如果不对应（模式不一样），那么相应的key的值就不一样。

还有一个就是字符串有空格，怎样拆分，这里用了一个流的模式：

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        vector<string> word;
        stringstream ss(str);
        string str1;
        while(ss>>str1)
        {
            word.push_back(str1);
        }
       
        
        if(pattern.length()!=word.size())
        {
            return false;
        }
        
        unordered_map<char,int> pat;
        unordered_map<string,int> st;
        for(int i=0;i<pattern.size();i++)
        {
            if(pat.find(pattern[i])==pat.end()&&st.find(word[i])==st.end())
            {
                pat[pattern[i]]=i+1;
                st[word[i]]=i+1;
            }
            else if(pat.find(pattern[i])!=pat.end()&&st.find(word[i])!=st.end())
            {
                if(pat[pattern[i]]!=st[word[i]])
                return false;
            }
            else
            return false;
        }
        
        return true;
    }
};

这是另一种，和我的思路是一样的，区别是它以str为主，用流输出，然后两个是否等长在过程中和结尾判断，i==n是判断是否等长的。然后map我的有key是否存在的界限，这个其实可以不判定，如果key没有，你用了比如pat[a]，那么就相当于是一个构造函数了，初始值构造成了0.

bool wordPattern(string pattern, string str) {
    map<char, int> p2i;
    map<string, int> w2i;
    istringstream in(str);
    int i = 0, n = pattern.size();
    for (string word; in >> word; ++i) {
        if (i == n || p2i[pattern[i]] != w2i[word])
            return false;
        p2i[pattern[i]] = w2i[word] = i + 1;
    }
    return i == n;
}