Leetcode学习之哈希表与字符串 （2）

开宗明义：本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》，刷题小白，旨在理解和交流，重在记录，望各位大牛指点！

---

Leetcode学习之哈希表与字符串 （2）

---

---

1、词语模式（字符串哈希）LeetCode 290.

题目来源：$LeetCode290.WordPattern$
描述：已知字符串 $pattern$ 与字符串 $str$，确认 $str$ 是否与 $pattern$ 匹配。其中，$str$ 与 $pattern$ 匹配代表字符串 $str$ 中的单词与 $pattern$ 中的字符一一对应。

分析：

测试代码：

#include <stdio.h>
#include <map>
#include <string>
using namespace std;

class Solutuon {
public:
	bool wordPattern(string pattern, string str) {
		map<string, char> word_map;  //单词到pattern字符的映射
		char used[128] = { 0 };  //记录已经映射的pattern字符
		string word; //临时保存拆分好的单词
		int pos = 0;	//当前指向的pattern字符，无需特殊处理最后一个单词
		str.push_back(' '); //str尾部push一个空格，使得遇到空格拆分单词  dog cat cat dog 

		for (int i = 0; i < str.length(); i++) {

			if (str[i] == ' ') {	//遇到空格即拆分出一个新单词
				if (pos == pattern.length()) {	//若分割出一个单词，但已无pattern字符对应，这边注意外面套的那个str.length循环
					return false;
				}//若单词尾出现在哈希映射中

				if (word_map.find(word) == word_map.end()) {  //如果找到这个单词dog，说明已经映射到

					if (used[pattern[pos]]) {  //这边 used[pattern[pos]] = used[b] 存在 表示这个映射已经存在
						return false;  //如果当前pattern字符已经使用
					}

					word_map[word] = pattern[pos];   //这个单词的映射还没完成，就建立一个新的映射
					used[pattern[pos]] = 1; //并且将这个记录是否被用的uesd设为1
				}
				else{
					if (word_map[word] != pattern[pos]) {	//表示string里面的单词对应的pattern的c已经建立，但是与pattern的字符c不对应
						return false;    //其中word表示dog等单词
					}
				}
				word = ""; //完成一个单词的插入和查询后，清空word
				pos++;  //pos向后移动一个 表示pattern向后移动
			}
			else {  //str里面的新单词没有遇到空格，也就是没有分割，继续挺进
				word = word + str[i];  //比如word为dog
			}
		}
		//到底了，表示长度不一样
		if (pos != pattern.length()) {
			return false;
		}
		return true;
	}
};

int main() {
	string pattern = "abb";
	string str = "dog cat cat dog";
	Solutuon solve;
	printf("%d\n", solve.wordPattern(pattern, str));
	system("pause");
	return 0;
}

效果图：

---

2、同字符词语分组（数组哈希）LeetCode 49.

题目来源：$LeetCode49.GroupAnagrams$
$anagram分组$：若某两个字符串，出现的各个字符数相同，则它们应该为同一分组。

描述：已知一组字符串，将所有的 $anagram$ (由颠倒字母顺序而构成的字)放到一起输出。

方法一：排序

分析：


测试代码：

#include <stdio.h>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {
		map<string, vector<string>> anagram;  //vector<string> ---> string
		//内部进行排序的各个单词为key，以字符串向量(vector<string>)为value，存储各个字符数量相同的字符串(anagram)
		vector<vector<string>> result; //存储最终的结果
		for (int i = 0; i < strs.size(); i++) {
			string str = strs[i];  //copy一下
			std::sort(str.begin(), str.end());	//对str内部进行排序
			if (anagram.find(str) == anagram.end()) {  //找不到的话
				vector<string> item;	//设置一个空的字符串向量
				anagram[str] = item;    //以排序后的str[i]作为key
			}
			anagram[str].push_back(strs[i]);	//在对应的字符串向量中push结果
		}
		map<string, vector<string>> ::iterator it;
		for (it = anagram.begin(); it != anagram.end(); it++) {
			result.push_back((*it).second);
		}
		return result;	//遍历哈希表，将哈希表的value push进入最终结果
	}
};

int main() {
	vector<string> strs;
	strs.push_back("eat");
	strs.push_back("tea");
	strs.push_back("tan");
	strs.push_back("ate");
	strs.push_back("nat");
	strs.push_back("bat");
	Solution solve;
	vector<vector<string>> result = solve.groupAnagrams(strs);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			printf("[%s]", result[i][j].c_str());
		}
		printf("\n");
	}
	system("pause");
	return 0;
}

效果图：

方法二：one-hot

分析：


测试代码：

#include <stdio.h>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

//将字符串str中的各个字符数量进行统计，存储至vec
void change_to_vector(string &str, vector<int> &vec) {
	for (int i = 0; i < 26; i++) {
		vec.push_back(0);
	}
	for (int i = 0; i < str.length(); i++) {
		vec[str[i] - 'a']++;
	}
}

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {
		map<vector<int>, vector<string>> anagram;
		vector<vector<string>> result;
		for (int i = 0; i < strs.size(); i++) {  //strs就是 dog cat cat dog 6个
			vector<int> vec;
			change_to_vector(strs[i], vec);  //将其存储在vec

			if (anagram.find(vec) == anagram.end()) { //还没映射好
				vector<string> item;
				anagram[vec] = item;
			}
			anagram[vec].push_back(strs[i]);
		}
		map<vector<int>, vector<string>> ::iterator it;  //迭代器
		for (it = anagram.begin(); it != anagram.end(); it++) {
			result.push_back((*it).second);
		}
		return result;
	}
};

int main() {
	vector<string> strs;
	strs.push_back("eat");
	strs.push_back("tea");
	strs.push_back("tan");
	strs.push_back("ate");
	strs.push_back("nat");
	strs.push_back("bat");
	Solution solve;
	vector<vector<string>> result = solve.groupAnagrams(strs);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			printf("[%s]", result[i][j].c_str());
		}
		printf("\n");
	}
	system("pause");
	return 0;
}

效果图：

---

3、无重复字符的最长子串（字符哈希）LeetCode 3.

题目来源：$LeetCode3.LongestSubstringWithoutRepeatingCharacters$
如：一个字符串 awbcdewgh
子串： awbc. awbcd awbcde …很多个子串，但是都是连续在一起 。
子序列： abc . abcd abcde … 很多个子序列，但是子序列中的字符在字符串中不一定是连在一起的。
所以，子串！=子序列。也就是子串连续，子序列不连续！
描述：已知一个字符串，求用该字符串的无重复字符的最长子串长度。

分析：


思路：

测试代码：

#include <stdio.h>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

//将字符串str中的各个字符数量进行统计，存储至vec
void change_to_vector(string &str, vector<int> &vec) {
	for (int i = 0; i < 26; i++) {
		vec.push_back(0);
	}
	for (int i = 0; i < str.length(); i++) {
		vec[str[i] - 'a']++;
	}
}

class Solution {
public:
	int lengthofLongestSubstring(string s) {
		int begin = 0;
		int result = 0;	//窗口的头指针
		string word = "";
		int char_map[128] = { 0 };

		for (int i = 0; i < s.length(); i++) {
			char_map[s[i]]++;  //将这个字符串的A码映射加++

			if (char_map[s[i]] == 1) {
				word += s[i];  //word单词里面导入
				if (result < word.length()) {  //这边无重复，纠正指针
					result = word.length();
				}
			}
			else{  //将重复的字符s[i]删去，这边char_map[s[i]]>1 
				while (begin < i && char_map[s[i]]>1) {  //注意这边的条件
					char_map[s[begin]]--;
					begin++;
				}
				word = "";		//清空word
				for (int j = begin; j <= i; j++) {
					word += s[j];
				}
			}
		}
		return result;
	}
};


int main() {
	string s = "abcbadab";
	Solution solve;
	printf("%d\n", solve.lengthofLongestSubstring(s));
	system("pause");
	return 0;
}

效果图：

---