Word Ladder
Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:
- Only one letter can be changed at a time
- Each intermediate word must exist in the dictionary
For example,
Given:
start = "hit"
end = "cog"
dict = ["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.
分析:真的 一看这个题没有思路,想到每次改变一个字母,一直改下去,却不知道如何求最短。搜索得知,此题用到图的方法,广度优先遍历查找最短路径的方法,于是拿出《算法导论》看了一下图的广度优先遍历,大致思路是:用一个优先队列来保存访问过的点,每次取队列头元素,然后判断依次访问此元素的后继,然后将此元素出列,依次循环直到队列为空。此题相当于求最短路径,则需要判断到该结点的路径长度。
该题的思路:创建一个优先队列管理未遍历的结点,还有一个map,来保存遍历到的结点和距离。首先将start插入优先队列,然后开始循环,每次从优先队列取一个元素,并从其中删除,依次访问和此元素相差一个字母的值,查看此值是否在set中,如果不在或者在距离是否大于取出的元素的距离+1,则更新map,并插入此值,依次循环直到队列为空。
注意:其中有个很无聊的问题,看题目中转换次数为4,但是返回的长度为5,意思是加上了头尾。在执行过程中,当下面时,就显示2,不知道意思是如果start和end只有一个字母不同时,中间值无需字典中,感觉和题目要求中的Each intermediate word must exist in the dictionary不相符,很恶心。这样的话,应该在开始加一个判断start和end有几个字母不同的计算,如果为1,则直接返回2。
Input: | "a", "c", ["a","b","c"] |
Output: | 3 |
Expected: | 2 |
代码如下:
class Solution {
public:
int ladderLength(string start, string end, unordered_set<string> &dict) {
if(start.empty()||end.empty()||start.length()!=end.length()||start == end){
return 0;
}
if(dict.empty()){
return 0;
}
unordered_map<string,int> pathMap;
pathMap.insert(make_pair(start,1));
queue<string> strQue;
strQue.push(start);
string tempStr;
while(!strQue.empty()){
tempStr = strQue.front();
strQue.pop();
for(int i=0; i<tempStr.size(); ++i){
for(char j='a'; j<='z'; ++j){
if(tempStr[i] == j){
continue;
}else{
string replaceStr = tempStr;
replaceStr[i] = j;
if(dict.find(replaceStr)!=dict.end() || replaceStr == end){
if(!pathMap[replaceStr] || pathMap[replaceStr] && pathMap[replaceStr] > pathMap[tempStr]+1){
if(replaceStr == end && pathMap[tempStr]+1 < 2){
continue;
}
pathMap[replaceStr] = pathMap[tempStr]+1;
strQue.push(replaceStr);
}
}
}
}
}
}
return pathMap[end];
}
};
2、Word Ladder II
Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:
- Only one letter can be changed at a time
- Each intermediate word must exist in the dictionary
For example,
Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
Return
[ ["hit","hot","dot","dog","cog"], ["hit","hot","lot","log","cog"] ]
Note:
- All words have the same length.
- All words contain only lowercase alphabetic characters.
分析:这个题和上题很像,但是特别复杂,我采用上次的思路,添加了一个unordered_map<string,vector<string>> prevStrVec来保存前缀,前缀都是从start到key的最短路径上的前一个词,然后再根据end向前追溯一直到start,每一条路径就是保存的路径,思路感觉没有问题,本地跑几个小数据也是对的,就是一直出错。
首次出错为:Output Limit Exceeded
输出超过限制,就是可能中间出现的循环折叠,没找到问题,然后设置了长度递归限制,当路径超过最短路径值时返回,此时又出错:
Time Limit Exceeded
大数据时,显示超时
代码如下:超时的代码:
class Solution {
public:
vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
//vector<vector<string> > paths;
if(start.empty()||end.empty()||start.length()!=end.length()||start == end){
return paths;
}
if(dict.empty()){
return paths;
}
swap(start,end);
unordered_map<string,int> pathMap;
pathMap.insert(make_pair(start,1));
queue<string> strQue;
strQue.push(start);
string tempStr;
unordered_map<string,vector<string>> prevStrVec;
while(!strQue.empty()){
tempStr = strQue.front();
strQue.pop();
for(int i=0; i<tempStr.size(); ++i){
for(char j='a'; j<='z'; ++j){
if(tempStr[i] == j){
continue;
}else{
string replaceStr = tempStr;
replaceStr[i] = j;
if(dict.find(replaceStr)!=dict.end() || replaceStr == end){
if(!pathMap[replaceStr] || pathMap[replaceStr] && pathMap[replaceStr] >= pathMap[tempStr]+1){
if(replaceStr == end && pathMap[tempStr]+1 < 2){
continue;
}
if(pathMap[replaceStr] && pathMap[replaceStr] > pathMap[tempStr]+1){
prevStrVec[replaceStr].clear();
}
prevStrVec[replaceStr].push_back(tempStr);
pathMap[replaceStr] = pathMap[tempStr]+1;
strQue.push(replaceStr);
}
}
}
}
}
}
if(pathMap[end]){
vector<string> tempVec;
tempVec.push_back(end);
int shortLength = pathMap[end];
findPaths(end,prevStrVec,tempVec,shortLength);
}
return paths;
}
void findPaths(string& end,unordered_map<string,vector<string>> &prevStrVec,vector<string> &path,int shortLength){
vector<string> preEndVec = prevStrVec[end];
if(preEndVec.empty()){
paths.push_back(path);
return;
}
if(path.size()==shortLength){
return;
}
for(int j=0; j<preEndVec.size(); ++j){
string preStr = preEndVec[j];
vector<string> tempPath = path;
tempPath.push_back(preStr);
findPaths(preStr,prevStrVec,tempPath,shortLength);
}
}
vector<vector<string> > paths;
};
改进,上述和第一题的区别是pathMap[replaceStr] 和pathMap[tempStr]+1 比较时,一个是>,一个是>=,后者将==的部分也放入队列了,这样时间复杂度高了好多,改进,==时不将数据放入队列,Accepted。
代码如下:
class Solution {
public:
vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
//vector<vector<string> > paths;
if(start.empty()||end.empty()||start.length()!=end.length()||start == end){
return paths;
}
if(dict.empty()){
return paths;
}
swap(start,end);
unordered_map<string,int> pathMap;
pathMap.insert(make_pair(start,1));
queue<string> strQue;
strQue.push(start);
string tempStr;
unordered_map<string,vector<string>> prevStrVec;
while(!strQue.empty()){
tempStr = strQue.front();
strQue.pop();
for(int i=0; i<tempStr.size(); ++i){
for(char j='a'; j<='z'; ++j){
if(tempStr[i] == j){
continue;
}else{
string replaceStr = tempStr;
replaceStr[i] = j;
if(dict.find(replaceStr)!=dict.end() || replaceStr == end){
if(!pathMap[replaceStr] || pathMap[replaceStr] && pathMap[replaceStr] >= pathMap[tempStr]+1){
if(replaceStr == end && pathMap[tempStr]+1 < 2){
continue;
}
if(pathMap[replaceStr] && pathMap[replaceStr] > pathMap[tempStr]+1){
prevStrVec[replaceStr].clear();
}else if(pathMap[replaceStr] && pathMap[replaceStr] == pathMap[tempStr]+1){
prevStrVec[replaceStr].push_back(tempStr);
continue;
}
pathMap[replaceStr] = pathMap[tempStr]+1;
strQue.push(replaceStr);
prevStrVec[replaceStr].push_back(tempStr);
}
}
}
}
}
}
if(pathMap[end]){
vector<string> tempVec;
tempVec.push_back(end);
int shortLength = pathMap[end];
findPaths(end,prevStrVec,tempVec,shortLength);
}
pathMap.clear();
return paths;
}
void findPaths(string& end,unordered_map<string,vector<string>> &prevStrVec,vector<string> &path,int shortLength){
vector<string> preEndVec = prevStrVec[end];
if(preEndVec.empty()){
paths.push_back(path);
return;
}
if(path.size()==shortLength){
return;
}
for(int j=0; j<preEndVec.size(); ++j){
string preStr = preEndVec[j];
vector<string> tempPath = path;
tempPath.push_back(preStr);
findPaths(preStr,prevStrVec,tempPath,shortLength);
}
}
vector<vector<string> > paths;
};