哈希表的简单应用（一）：LeetCode 205 & 290

LeetCode 205：同构字符串

给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 ：

输入: s = “egg”, t = “add”
输出: true
输入: s = “foo”, t = “bar”
输出: false
输入: s = “paper”, t = “title”
输出: true

采用哈希表的解法,两个字符串相互映射

class Solution {
public:
    bool isIsomorphic(string s, string t) 
    {
        unordered_map<char,char> smap;
        unordered_map<char,char> tmap;
        for(int i = 0; s[i] != '\0'; i++)
        {
            char first = s[i];
            char sec = t[i];
            if(smap.count(first))
            {
                if(smap[first] != sec)	return false;
            }
            else if(tmap.count(sec))
            {
                if(tmap[sec] != first)  return false;
            }
            else
            {
                smap[first] = sec;
                tmap[sec] = first;
            }
        }
        return true;
    }
};

其实，也有更为简洁的方法，对比两个字符串对应位置的字符在字符串内第一次出现的位置即可。

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

LeetCode 209：单词规律

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例：

输入:pattern = “abba”, str = “dog cat cat fish”
输出: false
输入: pattern = “abba”, str = “dog cat cat dog”
输出: true

算法思路：
建立str到patter的哈希表。

首先，将str的字符串按照空格分隔成多个字符串，可用一个字符串数组存储，也可以设置一个字符串变量，每分割一个就在哈希表中进行查找比较（我采用的是后一种办法），如果采用字符串数组存储，需要遍历两遍str字符串，第一遍建立哈希表映射关系，第二遍扫描判断str是否符合pattern的模式，而设置字符串变量就只需要扫描一遍str即可。

除此之外，我们还需要一个数组used存储pattern的字符状态，是否已经放入哈希表中，设置一个int变量pos表示pattern相对应字符的下标。

接下来，就是遍历str了，首先判断字符是否为空格，若不是则将该字符加到设置的字符串变量words上，若是空格，说明前面已经分割好一个单词了。

然后，判断该单词是否已在哈希表中，若已在哈希表中，比较与之对应的字符和在哈希表中的字符是否相同，若相同，继续运行，若不相同，则return false；若不在哈希表中，判断该单词对应的字符是否已在哈希表中，若在，return false，若不在，则将这对映射放入哈希表中，将数组used相应的字符状态设为1.

最后注意str的字符数量和pattern分割后的单词数量是否相同，须比较！！

代码如下：

class Solution {
public:
    bool wordPattern(string pattern, string str) 
    {
        unordered_map<string,char> word_map;
        int used[128]={0};//已映射的字符
        string words;//保存分割的单词
        str.push_back(' ');//在str结尾增加一个空格，故空格数和单词数相同
        int pos=0;//pattern字符的下标
        for(int i=0;i<str.size();i++)
        {
            if(str[i]!=' ')
            {
                words+=str[i];
            }
            else
            {
                if(pos==pattern.size()) return false;
                if(word_map.count(words)==0)//words have never appeared before
                {
                    if(used[pattern[pos]]) return false;
                    used[pattern[pos]]=1;
                    word_map[words]=pattern[pos];
                }
                else//words在哈希表中
                {
                    if(word_map[words]!=pattern[pos]) return false;
                }
                words="";//接着下一个单词，需清空
                pos++;
            }
        }   
        if(pos!=pattern.size())  return false;
        return true;
    }
};