leetCode 290. Word Pattern 哈希表

290. 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:

1. pattern = "abba", str = "dog cat cat dog" should return true.

2. pattern = "abba", str = "dog cat cat fish" should return false.

3. pattern = "aaaa", str = "dog cat cat dog" should return false.

4. pattern = "abba", str = "dog dog dog dog" should return false.

Notes:
You may assume pattern contains only lowercase letters, and str contains lowercase letters separated by a single space.

思路：

1.將源字符串分割存入vector中。

2.使用2個map來存對應的鍵值對。map1<char,string>,map2<string,char>

3.遍歷字符串數組，然後比較插入到map中。直到找到不符合條件的return false.

代碼如下：

1.map版

class Solution {
public:
        vector<string> stringSplit(string s, const char * split)
        {
        	vector<string> result;
        	const int sLen = s.length();
        	char *cs = new char[sLen + 1];
        	strcpy(cs, s.data());
        	char *p;
        	p = strtok(cs, split);
        	while (p)
        	{
        		printf("%s\n", p);
        		string tmp(p);
        		result.push_back(tmp);
        		p = strtok(NULL, split);
        	}
        	return result;
        }
        bool wordPattern(string pattern, string str) {
        	const char* split = " ";
        	vector<string > strVector = stringSplit(str, split);
        	if (pattern.length() != strVector.size())
        		return false;
        	map<char, string> mymap;
        	map<string, char> mymap2;
        	for (int i = 0; i < pattern.length(); i++)
        	{
        		if (mymap.find(pattern[i]) == mymap.end() && mymap2.find(strVector[i]) == mymap2.end())
        		{
        			mymap.insert(pair<char, string>(pattern[i], strVector[i]));
        			mymap2.insert(pair<string, char>(strVector[i], pattern[i]));
        		}
        		else
        		{
        			if ((strcmp(mymap[pattern[i]].data(), strVector[i].data()) != 0) ||
        				( mymap2[strVector[i]] != pattern[i]) )
        			{
        				return false;
        			}
        		}
        	}
        	return true;
        }
};

2.unordered map版

bool wordPattern(string pattern, string str) {
	unordered_map<char, string> map;
	unordered_map<string, char> map2;
	vector<string> vec;
	int j = 0;
	for (int i = 0; i<str.size(); i++){
		if (str[i] == ' '){
			string tmp = str.substr(j, i - j);
			vec.push_back(tmp);
			j = i + 1;
		}
		if (i == str.size() - 1){
			string tmp = str.substr(j, i - j + 1);
			vec.push_back(tmp);
		}

	}
	if (pattern.size() != vec.size())
		return false;
	for (int i = 0; i<pattern.size(); i++){
		if (map.find(pattern[i]) == map.end() && map2.find(vec[i]) == map2.end()){
			map.insert(make_pair(pattern[i], vec[i]));
			map2.insert(make_pair(vec[i], pattern[i]));
		}
		else if (map[pattern[i]] != vec[i] || map2[vec[i]] != pattern[i])
		{
				return false;
		}
	}
	return true;
}

最後記錄一下unordered_map與map的區別：

1、boost::unordered_map， 它與 stl::map的區別就是，stl::map是按照operator<比較判斷元素是否相同，以及比較元素的大小，然後選擇合適的位置插入到樹中。所以，如果對map進行遍歷（中序遍歷）的話，輸出的結果是有序的。順序就是按照operator< 定義的大小排序。而boost::unordered_map是計算元素的Hash值，根據Hash值判斷元素是否相同。所以，對unordered_map進行遍歷，結果是無序的。

2、用法的區別就是，stl::map 的key需要定義operator< 。 而boost::unordered_map需要定義hash_value函數並且重載operator==。對於內置類型，如string，這些都不用操心。對於自定義的類型做key，就需要自己重載operator< 或者hash_value()了。

2016-08-10 10:43:48