【LeetCode】word ladder I&& II

最新推荐文章于 2020-05-10 10:41:33 发布
最新推荐文章于 2020-05-10 10:41:33 发布
阅读量691 收藏
点赞数
分类专栏： LeetCode 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowwolf_yang/article/details/26340651
版权

参考链接


http://www.cnblogs.com/x1957/p/3274819.html

http://www.cnblogs.com/x1957/p/3526838.html






题目描述

Word Ladder

 

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:

  1. Only one letter can be changed at a time
  2. 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.

Word Ladder II

 

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

  1. Only one letter can be changed at a time
  2. 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.


题目分析

I 思路应该是按层遍历，字典中与某个单词只有一个字母之差的都是这个字母的孩子，构建一棵树，再按层遍历，遍历到目标单词时的层数就是转换次数。

II 需要记录每一个孩子的父亲结点，注意的事，父亲不只有一个。

总结


代码示例

int ladderLength(string start, string end, unordered_set<string> &dict) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
		if(start.size() != end.size()) return 0;
		if(start.empty() || end.empty())return 0;
		
		queue<string> path;
		path.push(start);
		int level = 1;
		int count = 1;
		dict.erase(start);
		while(dict.size() > 0 && !path.empty())
		{
			string curword = path.front();
			path.pop();count--;
			for(int i = 0; i < curword.size(); i++)
			{
				string tmp = curword;
				for(char j='a'; j<='z'; j++)
				{
					if(tmp[i]==j)continue;
					tmp[i] = j;
					if(tmp==end)return level+1;
					if(dict.find(tmp) != dict.end()) path.push(tmp);
					dict.erase(tmp);
				}
			}
			if(count==0)
			{
				count = path.size();
				level++;
			}
		}
		return 0;
    }


class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(start == end) return 1;
        queue<string > que;
        map<string , int> dist;
        dist[start] = 0;
        que.push(start);
        while(!que.empty()){
            string top = que.front();que.pop();
            for(int i = 0 ; i < top.length() ; i++){
                for(int j = 'a' ; j <= 'z' ; j++){
                    if(j != top[i]){
                        string next = top;
                        next[i] = j;
                        if(next == end){
                            return dist[top] + 2;
                        }
                        if(dict.find(next) != dict.end() && dist.find(next) == dist.end()){
                            dist[next] = dist[top] + 1;
                            que.push(next);
                        }
                    }
                }
            }
        }
        return 0;
    }
};








class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict)
    {
        result_.clear();
        unordered_map<string, vector<string>> prevMap;
        for(auto iter = dict.begin(); iter != dict.end(); ++iter)
            prevMap[*iter] = vector<string>();
        vector<unordered_set<string>> candidates(2);
        int current = 0;
        int previous = 1;
        candidates[current].insert(start);
        while(true)
        {
            current = !current;
            previous = !previous;
            for (auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
                dict.erase(*iter);
            candidates[current].clear();
            
            for(auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
            {
                for(size_t pos = 0; pos < iter->size(); ++pos)
                {
                    string word = *iter;
                    for(int i = 'a'; i <= 'z'; ++i)
                    {
                        if(word[pos] == i)continue;
                        word[pos] = i;
                        if(dict.count(word) > 0)
                        {
                            prevMap[word].push_back(*iter);
                            candidates[current].insert(word);
                        }
                    }
                }
            }
            if (candidates[current].size() == 0)
                return result_;
            if (candidates[current].count(end)) break;
        }
        vector<string> path;
        GeneratePath(prevMap, path, end);
        return result_;
    }
    
private:
    void GeneratePath(unordered_map<string, vector<string>> &prevMap, vector<string>& path, const string& word)
    {
        if (prevMap[word].size() == 0)
        {
            path.push_back(word);
            vector<string> curPath = path;
            reverse(curPath.begin(), curPath.end());
            result_.push_back(curPath);
            path.pop_back();
            return;
        }
        path.push_back(word);
        for (auto iter = prevMap[word].begin(); iter != prevMap[word].end(); ++iter)
            GeneratePath(prevMap, path, *iter);
        path.pop_back();
    }
    vector<vector<string>> result_;
};

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
          vector<vector<string> >ans;
          if(start == end) return ans;
          unordered_set<string>current , next;
          unordered_set<string> flag;
          unordered_map<string,vector<string> > father;
          
          current.insert(start);

          bool found = false;
         
          while(!current.empty() && !found) {
              //expand
              for(const auto &x : current) {
                  flag.insert(x);
              }
              
              for(auto x : current) {
                  for(int i = 0 ; i < x.size() ; ++i) {
                      for(int j = 'a' ; j <= 'z' ; ++j) {
                          if(x[i] == j) continue;
                          string tmp = x;
                          tmp[i] = j;
                          if(tmp == end) found = true;
                          if(dict.find(tmp) != dict.end() && flag.find(tmp) == flag.end()) {
                              next.insert(tmp);
                              father[tmp].push_back(x);
                          }
                     }
                  }
              }
              //end expand
              
              current.clear();
              swap(current, next);
          }
          //start foudn father
          
          if(found) {
              vector<string> c;
              dfs(ans , father , c , start , end);
          }
          return ans;
    }
private:
    void dfs(vector<vector<string> >&ans, 
             unordered_map<string,vector<string> >& father ,
             vector<string>& c , 
             string& start ,
             string& now) {
                 
        c.push_back(now);
        if(now == start) {
            ans.push_back(c);
            reverse(ans.back().begin() , ans.back().end());
            c.pop_back();
            return;
        }
        auto que = father.find(now) -> second;
        for(auto& x : que) {
            dfs(ans , father , c , start , x);
        }
        c.pop_back();
    }
};



Snowwolf_Yang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode126—Word Ladder II
上善若水
05-26 4726
LeetCode126—Word Ladder II
LeetCode题解：Word Ladder
追风筝的吃货，汪～
10-02 1080
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:Only one letter can be changed at a time
leetcode Word Ladder II
12-05 119
和上题Word Ladder I题目差不多，不过这里是要记录所有最段路径的可能。 不同点在于，我们不能再BFS每层的时候把相距一个字符的字符串在dict中删除，因为hot -> hit 的话其他的例如 jit -> hit 就是hit可以出现在两条路径里头。所以不能立马删除。但是我们发现我们可以删除的是我们遍历完的每层的字符串，我们用known来存遍历完的层，unknow...
LeetCode word-ladder-ii
water_likud的博客
05-20 251
题目描述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 timeEach intermediate word must exi...
【LeetCode】解题126：Word Ladder II（BFS算法）
Fayedily的博客
04-18 572
LeetCode解题 126：Word Ladder II（BFS算法）Problem 126: Word Ladder II [Hard]解题思路Solution (Java)修改过程 Problem 126: Word Ladder II [Hard] Given two words (beginWord and endWord), and a dictionary’s word list, ...
图解LeetCode：Word Ladder
码农的荒岛求生
12-06 452
文章目录思考过程建立索引代码实现总结 这是LeetCode的第127号题目Word Ladder，也就是单词梯子，那这个题目是什么意思呢？ 给定两个单词，一个为开头单词beginWord，一个为结尾单词endWord，并且给定一个单词列表，找出从开头单词到结尾单词的最短转换路径，转换规则是这样的： 一次只能转换单词中的一个字符 每次转换后的单词必须存在于单词列表中 比如给定开头单词“hit”，...
Leetcode 126. Word Ladder II (python+cpp)
qq_37821701的博客
05-10 607
Leetcode 126. Word Ladder II题目解析 题目 解析 这道题目是接127的一道follow up。127是让你计算最短路径的长度，而这边则要让你大音每条最短路径。这道题目有很多的解法，每个人的思路也不一样，但是为了跟127的解法保持一致性呢，我这边采用一种比较初级的方法：BFS+backtracking。具体如下： 复用127的BFS方法，但是在BFS的过程中，利用一个字典来保存每条路径，更正确的说应该是保存每个节点之间的path 然后利用backtracking的方式从字典中还
Leetcode 126. Word Ladder II Python BFS 实现
chelseajcole的专栏
06-29 1473
题目：126.Word Ladder II https://leetcode.com/problems/word-ladder-ii/ Given two words (beginWordandendWord), and a dictionary's word list, find all shortest transformation sequence(s) frombeginWor...
Leetcode 127. Word Ladder(python+cpp)
qq_37821701的博客
05-07 343
Leetcode 127. Word Ladder题目解析： 题目 解析： 这道题目本质上是个无向图的题目，wordlist中每个单词作为一个节点，每个节点之间如果只差一个字母则有边相连。求开始节点到结束节点的最短距离。方法好像挺多的，最快的是双向BFS，但是我这边只提供最简单易懂的单向BFS，双向的方法后面再说吧。 最简单的思路包含三个部分： 第一是一个字典，字典的key为通用的word p...
【LeetCode】Permutations && Combinations 排列组合
Snowwolf_Yang的程序化生活
04-15 1202
参考链接 http://blog.csdn.net/sunjilong/article/details/8259936 题目描述 题目分析 总结 代码示例 推荐学习C++的资料 C++标准函数库 http://download.csdn.net/detail/chinasnowwolf/7108919
【LeetCode】Binary Tree Preorder Traversal
Snowwolf_Yang的程序化生活
03-30 932
题目描述 http://oj.leetcode.com/problems/binary-tree-preorder-traversal/ Binary Tree Preorder Traversal   Given a binary tree, return the preorder traversal of its nodes' values.
【LeetCode】Binary Tree Postorder Traversal
Snowwolf_Yang的程序化生活
03-27 879
参考链接： 参考1：在写非递归时遇到一点困难，一直没想明白应该怎么写，最后参加这个代码终于写出来的。 http://www.cnblogs.com/changchengxiao/p/3416402.html 谢谢分享！ 参考2：这个方法很有意思，利用堆栈很按后序的逆序输入再做一次逆序，赞！！！ http://www.cnblogs.com/xinsheng/p/3460480.h
【LeetCode】Insertion Sort List
Snowwolf_Yang的程序化生活
03-25 848
题目链接 http://oj.leetcode.com/problems/insertion-sort-list/ 题目说明： 对链表起先插入排序 题目分析： 这个没什么难点就是考察对链表的操作程序。 链表操作需要注意几个问题： 1-头结点判空 2-读任何一个结点之前要保证该结点不为NULL 上代码 {CS
【LeetCode】Jump Game & Jump Game II
Snowwolf_Yang的程序化生活
04-21 831
参考链接 题目描述 题目分析 总结 代码示例 推荐学习C++的资料 C++标准函数库 http://download.csdn.net/detail/chinasnowwolf/7108919 在线C++API查询 http://www.cplusplus.com/ map使用方法 htt
【LeetCode】LRU Cache
Snowwolf_Yang的程序化生活
03-26 779
参考链接： 参考1：http://www.cnblogs.com/xinsheng/p/3514968.html 这个博主也刷了不少leetclde，这道题目写的非常精简。本文代码主要参考这一博客 题目描述 Design and implement a data structure for Least Recently Used (LRU) cache. It should sup
【LeetCode】博客模板
Snowwolf_Yang的程序化生活
04-03 733
参考链接 题目描述 题目分析 代码示例 总结 推荐学习C++的资料 C++标准函数库 http://download.csdn.net/detail/chinasnowwolf/7108919 在线C++API查询 http://www.cplusplus.com/ map使用方法 htt
【LeetCode】Max Points on a Line
Snowwolf_Yang的程序化生活
04-01 733
参考： http://blog.csdn.net/ict2014/article/details/17400345 题目： Max Points on a Line   Given n points on a 2D plane, find the maximum number of points that lie on the same straigh
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值