leetcode

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the word list

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

解题思路：

　　1/ 广度优先搜索 解决， 遍历过的数据便从 unordered_set中删除

unordered_set 特性： 每个element的查找速度都特别的快

　　http://www.cplusplus.com/reference/unordered_set/unordered_set/

　　2/ 通过 make_pair<string , int>  作为队列里面的元素，int 元素存走过的 步数 

　　3/ 刚开始的思路是 通过函数比较每两个单词的   错位 1 ，则 把该词压栈，并将unorder_set中所有错位为1的元素 进入到queue中 

该方法超时 ，通过visual 监测 是 通过每个字符a~z变换时间的 30倍

class Solution {
public:

    int ladderLength(string beginWord, string endWord, unordered_set<string>& wordList) {
	queue<pair<string,int>> t; t.push(make_pair(beginWord,1));
	if (wordList.empty()) return beginWord == endWord ? 0:0x7ffffff;
	while (!t.empty()){
		string s = t.front().first;
		int len = t.front().second;
		t.pop();
		if (isnear(s, endWord)) return len+1;		
		string r=ser(wordList,s);
		while (r != ""){
			t.push(make_pair(r,len+1));
			r = ser(wordList,s);
		}
	}
	return 0x7fffffff;
}
bool isnear(const string a,const string b){                 
	if (a.size() != b.size()) return false;
	int count = 0;
	for (int i = 0; i < a.size(); i++){
		if (a[i] != b[i]){
			count++;
			if (count == 2) return false;
		}
	}
	if (count == 1) return true;
	else return false;
}
string ser(unordered_set<string>&a,const string c){    //查找 错位 1 的所有字符 ，返回到一个vector中，并在unordered_set 中删除这些元素
	for (auto i = a.begin(); i != a.end();){
		int count = 0;
		string temp = *i;
		if (c.size() == temp.size()){
			for (int j = 0; j < temp.size(); j++){
				if (count >= 2) break;
				else{
					if (c[j] != temp[j]) count++;
				}
			}
			if (count == 1){
				a.erase(i++);         // 注意迭代器的失效问题
				return temp;
			}
			else i++;
		}
	}
	return "";
}
};

　　

class Solution {
public:
int ladderLength(string start, string end, unordered_set<string> &dict)
{
	if (start.empty() || end.empty())
		return 0;
	if (start.size() != end.size())
		return 0;
	if (start.compare(end) == 0)
		return 1;

	size_t size = start.size();

	queue<string> cur, next;
	cur.push(start);

	int length = 2;

	while (!cur.empty())
	{
		string org = cur.front();
		cur.pop();

		for (int i = 0; i< size; i++)
		{
			string tmp = org;
			for (char j = 'a'; j <= 'z'; j++)
			{
				if (tmp[i] == j)
					continue;
				//cout << "tmp = " << tmp << endl;
				if (tmp.compare(end) == 0)
					return length;
				tmp[i] = j;
				if (dict.find(tmp) != dict.end())
				{
					//cout << "push queue " << tmp << endl;
					next.push(tmp);
					dict.erase(dict.find(tmp));
				}
			}
		}
		if (cur.empty() && !next.empty())
		{
			swap(cur, next);
			length++;
		}
	}
	return 0;
}
};