哈希表初始化+双向BFS+剪枝优化（字典树+记录路径最短距离+记录总最短距离） 127. 单词接龙 126. 单词接龙 II

最新推荐文章于 2020-10-25 15:29:54 发布
最新推荐文章于 2020-10-25 15:29:54 发布
阅读量425 收藏
点赞数
分类专栏： leetcode BFS DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BLUEsang/article/details/106236041
版权
leetcode 同时被 3 个专栏收录
189 篇文章 0 订阅
订阅专栏
DFS
24 篇文章 1 订阅
订阅专栏
BFS
11 篇文章 0 订阅
订阅专栏

127. 单词接龙

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。
说明:

如果不存在这样的转换序列，返回 0。
所有单词具有相同的长度。
所有单词只由小写字母组成。
字典中不存在重复的单词。
你可以假设 beginWord 和 endWord 是非空的，且二者不相同。
示例 1:

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

输出: 5

解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog",
     返回它的长度 5。

示例 2:

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

输出: 0

解释: endWord "cog" 不在字典中，所以无法进行转换。

解题
将wordlist的每一种变法存在map中：map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);；

begin入队后将map中begin的可变化字符串挨个入队：

         for(int i=0;i<beginWord.size();i++){  //map里的三个都进去了
            for(auto t:map[beginWord.substr(0,i)+"*"+beginWord.substr(i+1)])
                Q.push(t);
                map.erase(beginWord.substr(0,i)+"*"+beginWord.substr(i+1));

并删除map中的该key；
找到endword则输出res，否则输出0；

单向BFS

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        //预处理，把单词放入*中
        for(string s:wordList){
            for(int i=0;i<s.size();i++)
            map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);
        }
        res=0;
        queue<string> Q;
        Q.push(beginword);
        //cout<<Q.front();
         while(!Q.empty()){
             ++res;
            int size=Q.size();
            while(size--){
            string tmp=Q.front();
            Q.pop();
            if(tmp==endWord) return res;
            for(int i=0;i<tmp.size();i++){  //map里的三个都进去了
            for(auto t:map[tmp.substr(0,i)+"*"+tmp.substr(i+1)])
                Q.push(t);
                map.erase(tmp.substr(0,i)+"*"+tmp.substr(i+1));
            }
            }
         }
        return 0;
    }
private:
    int res;
    unordered_map<string,vector<string>> map;
};

双向BFS
存储beginword一路变化过来的字符串到res1；
存储endword一路变化过来的字符串到res2；
若beginword正在变化的字符串在res2中出现过，返回当前res；
若endword正在变化的字符串在res1中出现过，返回当前res；

注意点
首先判断wordlist中有无endword，没有则直接返回0；

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        //预处理，把单词放入*中
        bool flag=0;
        for(string s:wordList){
            if(s==endWord) flag=1;
            for(int i=0;i<s.size();i++)
            map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);
        }
        if(!flag) return 0;
        result=0;
        queue<string> Q;
        queue<string> Q2;
        Q.push(beginWord);
        Q2.push(endWord);
 //反向查找

         while(!Q.empty()||!Q2.empty()){
            int size=Q.size();
            while(size--){
            string tmp=Q.front();
            if(res2[tmp]) return result;
            res1[tmp]=1;
            Q.pop();
            for(int i=0;i<tmp.size();i++){  //map里的三个都进去了
            for(auto t:map[tmp.substr(0,i)+"*"+tmp.substr(i+1)])
                Q.push(t);
                map.erase(tmp.substr(0,i)+"*"+tmp.substr(i+1));
            }
            }
            ++result;
            size=Q2.size();
            while(size--){
            string tmp=Q2.front();
            if(res1[tmp]) return result;
            res2[tmp]=1;
            Q2.pop();
            for(int i=0;i<tmp.size();i++){  //map里的三个都进去了
            for(auto t:map[tmp.substr(0,i)+"*"+tmp.substr(i+1)])
                Q2.push(t);
                map.erase(tmp.substr(0,i)+"*"+tmp.substr(i+1));
            }
        }
        ++result;
        }
        return 0;
    }
private:
    int result;
    unordered_map<string,vector<string>> map;
    unordered_map<string,bool> res1;
    unordered_map<string,bool> res2;
};

126. 单词接龙 II

给定两个单词（beginWord 和 endWord）和一个字典 wordList，找出所有从 beginWord 到 endWord 的最短转换序列。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。
说明:

如果不存在这样的转换序列，返回一个空列表。
所有单词具有相同的长度。
所有单词只由小写字母组成。
字典中不存在重复的单词。
你可以假设 beginWord 和 endWord 是非空的，且二者不相同。
示例 1:

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

输出:
[
  ["hit","hot","dot","dog","cog"],
  ["hit","hot","lot","log","cog"]
]

示例 2:

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

输出: []

解释: endWord “cog” 不在字典中，所以不存在符合要求的转换序列。

解题
上题字典优化的基础上再优化四步：
（1）BFS找最短距离
（2）BFS建立字典树
（3）BFS过程中找到每个单词的最短变化步数
（4）dfs时超过最短距离剪枝；curword超过该单词的最短步数剪枝；直接遍历字典树dfs更快；

BFS找最短距离，DFS找路径；

class Solution {
public:
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        for(auto s:wordList)
            for(int i=0;i<s.size();i++)
                map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);

        queue<string> Q;
        mincnt=-1;
        Q.push(beginWord);
        visited[beginWord]=1;
        bool flag=0;
        while(!Q.empty()){
            mincnt++;
            int size=Q.size();
            while(size--){
                string T=Q.front();
                Q.pop();
                if(T==endWord) {
                    flag=1;
                    break;
                }
                for(int i=0;i<T.size();i++)
                    for(auto s:map[T.substr(0,i)+"*"+T.substr(i+1)])
                    if(!visited[s]){
                        visited[s]=1;
                        Q.push(s);
                    }
            }
            if(flag) break;
        }
        visited.clear();
        dfs(beginWord,endWord,0);
        return res;

    }
private:
    unordered_map<string,vector<string>> map;
    vector<string> tmp;
    vector<vector<string>> res;
    unordered_map<string,bool> visited;
    int mincnt;
    void dfs(string curword, string endWord,int cnt){
        if(visited[curword]||cnt>mincnt) return;
        if(curword==endWord) {
           tmp.push_back(curword);
           res.push_back(tmp); 
           tmp.pop_back();
           return;
        } 
            visited[curword]=1;
            tmp.push_back(curword);
            for(int i=0;i<curword.size();i++)
               for(auto t:map[curword.substr(0,i)+"*"+curword.substr(i+1)])
                   dfs(t,endWord,cnt+1);
            tmp.pop_back();
            visited[curword]=0;
        return;
    }
};

DFS找路径，并且找最短距离；

class Solution {
public:
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        for(auto s:wordList)
            for(int i=0;i<s.size();i++)
                map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);

        mincnt=INT_MAX;
        dfs(beginWord,endWord,0);
        return res;

    }
private:
    unordered_map<string,vector<string>> map;
    vector<string> tmp;
    vector<vector<string>> res;
    unordered_map<string,bool> visited;
    int mincnt;
    void dfs(string curword, string endWord,int cnt){
        if(visited[curword]||cnt>mincnt) return;  //剪枝1
        if(!distance[curword]||distance[curword]>=cnt){  //剪枝2
            distance[curword]=cnt;
        }
        else return;
        if(curword==endWord) {
            if(cnt<mincnt){
                mincnt=cnt;
                res.clear();
            }
           tmp.push_back(curword);
           res.push_back(tmp); 
           tmp.pop_back();
           return;
        } 
            visited[curword]=1;
            tmp.push_back(curword);
            for(int i=0;i<curword.size();i++)
               for(auto t:map[curword.substr(0,i)+"*"+curword.substr(i+1)])
                   dfs(t,endWord,cnt+1);
            tmp.pop_back();
            visited[curword]=0;
        return;
    }
};

BFS找最短距离+建立字典树+DFS找路径+DFS路径剪枝

class Solution {
public:
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        for(auto s:wordList)
            for(int i=0;i<s.size();i++)
                map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);
         queue<string> Q;
        mincnt=-1;
        Q.push(beginWord);
        visited[beginWord]=1;
        mincnt=INT_MAX;
        int cnt=-1;
        while(!Q.empty()){
            cnt++;
            int size=Q.size();
            while(size--){
                string T=Q.front();
                Q.pop();
                if(T==endWord) {
                    mincnt=min(mincnt,cnt);
                }
                for(int i=0;i<T.size();i++)
                    for(auto s:map[T.substr(0,i)+"*"+T.substr(i+1)]){
                    HASHMAP[T].push_back(s);  //建立字典树优化
                    if(!visited[s]){
                        
                        visited[s]=1;
                        Q.push(s);
                    }
                    }
            }
        }
        visited.clear();
        dfs(beginWord,endWord,0);
        return res;

    }
private:
    unordered_map<string,int> distance;
    unordered_map<string,vector<string>> map;
    vector<string> tmp;
    vector<vector<string>> res;
    unordered_map<string,bool> visited;
    unordered_map<string,vector<string>> HASHMAP;
    int mincnt;
    void dfs(string curword, string endWord,int cnt){
        if(visited[curword]||cnt>mincnt) return;    //剪枝1

        if(!distance[curword]||distance[curword]>=cnt){  //剪枝2
            distance[curword]=cnt;
        }
        else return;

        if(curword==endWord) {
           tmp.push_back(curword);
           res.push_back(tmp); 
           tmp.pop_back();
           return;
        } 
            visited[curword]=1;
            tmp.push_back(curword);

            for(auto t:HASHMAP[curword])
                dfs(t,endWord,cnt+1);
            tmp.pop_back();
            visited[curword]=0;
        return;
    }
};

通过代码

将路径剪枝distance在bfs过程中完成，即可优化速度，通过所有样例
BFS——找最短距离+建立字典树+找到每个单词的最短变化步数

class Solution {
public:
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        for(auto s:wordList)
            for(int i=0;i<s.size();i++)
                map[s.substr(0,i)+"*"+s.substr(i+1)].push_back(s);
         queue<string> Q;
        mincnt=-1;
        Q.push(beginWord);
        visited[beginWord]=1;
        mincnt=INT_MAX;
        int cnt=-1;
        while(!Q.empty()){
            cnt++;
            int size=Q.size();
            while(size--){
                string T=Q.front();
                Q.pop();
                if(T==endWord) {
                    mincnt=min(mincnt,cnt);
                }
                for(int i=0;i<T.size();i++)
                    for(auto s:map[T.substr(0,i)+"*"+T.substr(i+1)]){
                    HASHMAP[T].push_back(s);  //建立字典树优化
                    if(!visited[s]){
                        distance[s]=cnt;
                        visited[s]=1;
                        Q.push(s);
                    }
                }
            }
        }
        visited.clear();
        dfs(beginWord,endWord,0);
        return res;

    }
private:
    unordered_map<string,int> distance;
    unordered_map<string,vector<string>> map;
    vector<string> tmp;
    vector<vector<string>> res;
    unordered_map<string,bool> visited;
    unordered_map<string,vector<string>> HASHMAP;
    int mincnt;
    void dfs(string curword, string endWord,int cnt){
        if(visited[curword]||cnt>mincnt) return;    //剪枝1

        if(distance[curword]<cnt-1) return; //剪枝2 

        if(curword==endWord) {
           tmp.push_back(curword);
           res.push_back(tmp); 
           tmp.pop_back();
           return;
        } 
            visited[curword]=1;
            tmp.push_back(curword);

            for(auto t:HASHMAP[curword])
                dfs(t,endWord,cnt+1);
            tmp.pop_back();
            visited[curword]=0;
        return;
    }
};
豌豆射手GCC
关注
专栏目录
牛客练习赛37 C（双向dfs+字典树）
cy41的博客
09-11 125
题目链接：C 筱玛的迷阵探险 题意：给定一个n*n(n&lt;=20n&lt;=20n<=20)大小的矩阵，矩阵中的每个点上有一个数字，初始时，你自身有一个数字，现在让你从(1,1)走到(n,n)，每次只能向下或向右走，将路径上的数字以及你自身的数字异或起来，问最小的异或值为多少。 首先考虑数据最值，直接大力搜索的话复杂度为C4020C_{40}^{20}C4020​，复杂度...
搜索问题之状态空间搜索（状态压缩+记忆化搜索+ BFS）
75 69 69 80 32 67 79 68 73 78 71 33
10-25 2086
1. 前言 之前介绍的回溯法常用于 解空间的搜索 问题，即 找到一个或者所有满足约束条件的解，它通常是将解空间组织成树或者图，然后进行DFS（深度优先遍历）并注意在搜索的时候进行 剪枝操作。 但是状态空间搜索则是需要 找到一条从起始状态到终止状态的路径，其一般需要考虑一下问题： 状态的表示，即我们怎样表示一个状态。 状态的转移，即通过研究初始状态和目标状态的 差别 ，我们定义怎样的操作来进行状态...
Double-Array Trie（双数组字典树）
huangwei.pro
07-22 1471
http://www.huang-wei.com/blog/?p=386Trie在ACM中已经十分普及，也是一种非常有效的索引结构，好处就不多说了。它的本质就是一个确定的有限状态自动机（DFA），关于它的实现也是有好几种，ACM中用的最多也是最容易实现的就是多路查找树。但是Trie最大的缺点就是占用空间过大，很容易爆内存，当然在ACM里对Trie树也有相应的优化，如限定高度，对分支较少的节点使用非随机访问的结构（减少宽度），但这些都是牺牲部分查找效率换取的。这里介绍一种实现，Double-Array Tri
Double Array Trie
weixin_34239592的博客
05-24 393
Trie树主要应用在信息检索领域，非常高效。今天我们讲Double Array Trie，请先把Trie树忘掉，把信息检索忘掉，我们来讲一个确定有限自动机（deterministic finite automaton ，DFA）的故事。所谓“确定有限自动机”是指给定一个状态和一个变量时，它能跳转到的下一个状态也就确定下来了，同时状态是有限的。请注意这里出现两个名词，一个是“状态”，一个是“变量”，...
双数组字典树(DATrie)详解及实现
huoji555的博客
03-10 6837
1.背景 Trie树本质是一个确定的有限状态自动机(DFA)，核心思想是空间换时间，利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。**但由于Trie树的稀疏现象严重，空间利用率较低。**为了让Trie树实现占用较少的空间，同时还要保证查询的效率，最后提出了用2个线性数组来进行Trie树的表示，即双数组Trie(Double Array Trie). 2.算法及公式解析 base[...
DoubleArrayTrie : DAT双数组Trie树
xlxxcc的专栏
03-28 1万+
本文参考： http://www.cnblogs.com/ooon/p/4883159.html推荐： 码农场的《双数组Trie树(DoubleArrayTrie)Java实现》 外文《An Implementation of Double-Array Trie》DoubleArrayTrie　　双数组Tire树是Tire树的升级版，Tire取自英文Retrieval中的一部分，即检索树，又称作
7、省选＋NOI-第七部分 计算几何_2020.08.27.pdf
11-25
7. **字典树**：用于存储字符串集合的数据结构。 8. **分块**：将数据分为多个块进行处理。 ### 五、动态规划 1. **背包DP**：解决物品选取问题。 2. **树形DP**：应用于树结构的问题。 3. **记忆化搜索**：避免...
6、省选＋NOI-第六部分 技巧与思想_2020.08.27.pdf
11-25
- **字典树（Trie）**：用于高效地处理字符串查询。 - **分块**：将大量数据分成较小的块，便于处理。 5. **动态规划（DP）** - **背包DP**、**树形DP**、**记忆化搜索**、**递推**。 - **区间DP**、**序列DP**...
单词接龙1
08-08
在搜索过程中，需要维护一个字典或哈希表来跟踪单词是否已经使用过，以及使用了几次。 **算法步骤** 1. 预处理单词列表，构建单词之间的连接图。 2. 从起始字母对应的单词开始，使用DFS或BFS进行遍历。 3. 在遍历...
WordLadder:构造从原始单词到目标单词的路径，其中中间单词与其相邻单词的字符不同
04-28
总的来说，实现WordLadder游戏的JavaScript代码涉及到数据结构（如队列、哈希表、字典树）、搜索算法（BFS）以及一些优化策略。这是一个很好的练习，可以帮助开发者提升问题解决能力和编程技能。
C++ unordered_map 使用详解(含C++20新特性)
Tyler_Zx的博客
05-06 1万+
目录 查找元素 迭代器 容量 修改操作 通接口 哈希策略 观察器 std::swap(std::unordered_map) std::erase_if(std::unordered_map) 简介 本篇博客介绍C++常用的无序关联容器unordered_map。unordered_map是C++11正式加入的对hashmap的官方实现（之前标准C++没有hashmap的官...
C++基础：STL之map
知行合一 止于至善
10-25 342
这篇文章介绍一下STL中map的基本使用方法。
Trie树（字典树，前缀树，键树）分析详解
热门推荐
Hyman's Blog
01-13 2万+
Trie树概述   Trie树，又称字典树、前缀树、单词查找树、键树，是一种多叉树形结构，是一种哈希树的变种。Trie这个术语来自于retrieval，发音为/tri:/ “tree”，也有人读为/traɪ/ “try”。Trie树典型应用是用于快速检索（最长前缀匹配），统计，排序和保存大量的字符串，所以经常被搜索引擎系统用于文本词频统计，搜索提示等场景。它的优点是最大限度地减少无谓的字符串比较，查
BFS+堆优化
转角的守望
06-07 1235
题解： 走迷宫问题的升级版 记录起点 把起点加入优先队列中 然后从起点开始BFS，需要破坏一个障碍物的时候  t++，每次走过一个点加入优先队列中 这样就可以保证每次从队列里面出来的是破坏障碍物数最小的了 下面代码中结构体里面的数据变量 z 可以不考虑（我之前用来记录走了几步） #include #include #include #include #incl
BFS和DFS算法分析对比及优化
依然spurs
07-10 4297
从noi2001两道题看最优化问题BFS与DFS算法的优化NOI2001－聪明的打字员　　阿兰是某机密部门的打字员，她现在接到一个任务：需要在一天之内输入几百个长度固定为6的密码。当然，她希望输入的过程中敲击键盘的总次数越少越好。不幸的是，出于保密的需要，该部门用于输入密码的键盘是特殊设计的，键盘上没有数字键，而只有以下六个键：Swap0, Swap1, Up, Down, Left, Right，为了说明这6个键的作用，我们先定义录入区的6个位置的编号，从左至右依次为1，2，3，4，5，6。下面列出每个键
字典树与双数组字典树总结
qq_16761099的博客
06-25 1109
字典树 字典树比较简单，本质是一个DFA（define finite automata. 具体可 关键词搜索leetcode trie tree 双向数组字典树 参考文献： http://www.docin.org/p-1433969315.html ...
C DFS+最短路径+邻接表表示+地铁换乘（map保存地铁线路） 1131 Subway Map (30分)
BLUEsang的博客
04-12 2369
1131 Subway Map (30分) In the big cities, the subway systems always look so complex to the visitors. To give you some sense, the following figure shows the map of Beijing subway. Now you are supposed t...
DFS+剪枝 BFS 鸣人和佐助
BLUEsang的博客
03-17 631
题目：鸣人和佐助 佐助被大蛇丸诱骗走了，鸣人在多少时间内能追上他呢？ 已知一张地图（以二维矩阵的形式表示）以及佐助和鸣人的位置。地图上的每个位置都可以走到，只不过有些位置上有大蛇丸的手下，需要先打败大蛇丸的手下才能到这些位置。鸣人有一定数量的查克拉，每一个单位的查克拉可以打败一个大蛇丸的手下。假设鸣人可以往上下左右四个方向移动，每移动一个距离需要花费1个单位时间，打败大蛇丸的手下不需要时间。如果...
DFS+最大连通子图数量 200. 岛屿数量+130. 被围绕的区域
BLUEsang的博客
04-20 603
200. 岛屿数量 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 00100 00011 输出: 3 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值