[LeetCode]Word Ladder II

最新推荐文章于 2017-07-30 19:43:37 发布
原创 最新推荐文章于 2017-07-30 19:43:37 发布 · 446 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#leetcode
本文介绍如何使用BFS算法解决Word Ladder I和II问题，包括寻找两个单词之间的最短转换序列及其所有最短路径。通过构建邻接表和剪枝优化，实现了高效的路径搜索。

WordLadder I

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 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.

题目比较简单，基本可以看做最短路径问题。Word Ladder I求最短路径的径长，Word Ladder II找出所有的最短路径。

对于寻找最短路径的长度，通过常规的BFS就可以解决。因为BFS实际上是逐层遍历的，这样先达到终点的这条路径就是最短的。

除此之外，还要注意一般情况下，字典的中键的长度比较短，但是数目往往都是很多的，并且键是放在哈希表中，理想情况下查找可以视为O(1)。所以我们抵达一个单词，比如hit，对每一位设置所有可能的26个字母，并去查找是否在哈希表中，每一个层级的复杂度可以视为O(26n) = O(n),n为键长。

WordLadder II

这道题目，需要打印出全部最短路径。如果采用回溯的方法，使用dfs暴力搜索，无论怎样剪枝都会TLE。

所以还是要采用BFS的方法，同时也需要剪枝才能满足时间要求。

BFS找最短路径在WordLadder I中已经提到过，接下来有两个问题：

1、使用BFS打印出全部最短路径。
2、针对BFS剪枝优化。

使用BFS打印出全部最短路径

首先，如果在BFS的过程中打印经过的最短路径？BFS不像DFS，DFS在递归的过程中可以借助递归栈回溯到根节点。在BFS中，保存某个点经过的路径，需要对每个点构造邻接表。

这里写图片描述

在本题中，通过BFS可以遍历到最后的终点如上图。如果要打印出所有路径，实际上是要从后往前打印，因为只有遍历到终点，才知道这是一条可达路径，这和DFS相同。

打印的方法就是反向建立邻接表，如下图：

这里写图片描述

邻接表，可以使用哈希表，在每个节点存储一个链表来实现。这样我们从cog开始，利用dfs即可打印到最后。方法如下：

    private void buildPath(String curWord, String start, List<String> path, List<List<String>> results, Map<String, List<String>> map) {
    //map就是每个节点存储的邻接表。
        if (curWord.equals(start)) {
            path.add(0,start);
            results.add(new ArrayList<>(path));
            path.remove(0);
            return;
        }
        path.add(0,curWord);
        if (map.containsKey(curWord)) {
            for (String nextWord : map.get(curWord)) {
                buildPath(nextWord,start,path,results,map);
            }
        }
        path.remove(0);
    }

针对BFS剪枝优化

接下来，因为对时间要求十分严格，所以还需要对BFS剪枝。最短路径问题，BFS加上剪枝，其实就可以想到Dijkstra算法了。

在每个节点，记录根节点到当前节点的最短距离dis，同样可以采用map数据结构。
当从一个节点可以抵达一个相邻点时，首先计算step = 当前节点的dis +１，与目的点的dis进行对比，如果step>dis，那么说明当前点到下一点所构成的路径肯定比到下一点的其它最短路径长，所以不可能构成一条新的最短路径，直接pass掉这种可能，寻找其它可能。达到剪枝的目的，同样也就是Dijkstra算法的松弛操作。

整体BFS中，基本就分为两步：
1、松弛操作
2、构建邻接表

代码如下：

        Queue<String> queue= new ArrayDeque<String>();
        queue.add(start);
        map = new HashMap<>();
        Map<String, Integer> ladder = new HashMap<>();
        dict.add(end);
        for (String str :dict) ladder.put(str, Integer.MAX_VALUE);
        //ladder，记录每一点，根节点当其的最短距离。
        ladder.put(start, 0);

        while (!queue.isEmpty()) {
            String cur = queue.poll();
            int nextStep = ladder.get(cur) + 1;
            if (nextStep > min) break;
            for (int i =0;i<cur.length();i++) {
                StringBuilder builder = new StringBuilder(cur);
                for (char ch='a';ch<='z';ch++) {
                    builder.setCharAt(i,ch);
                    String nextWord = builder.toString();
                    if (ladder.containsKey(nextWord)) {
                        int dis = ladder.get(nextWord);
                        //松弛操作。
                        //等于的时候，表明目的点已经在队列了，不加到队列里，防止多余的遍历。
                        if (nextStep > dis) continue;
                        else if (nextStep < dis) {
                            queue.add(nextWord);
                            ladder.put(nextWord, nextStep);
                        }

                       //构建邻接表。
                        if (map.containsKey(nextWord)) {
                            map.get(nextWord).add(cur);
                        }else {
                            List<String> adjacent = new ArrayList<>();
                            adjacent.add(cur);
                            map.put(nextWord, adjacent);
                        }

                        if (nextWord.equals(end)) min = nextStep;

                    }

                }
            }
        }

完整代码如下：

public class Solution {
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        Map<String,List<String>> map;
        List<List<String>> results;
        results= new ArrayList<List<String>>();
        if (dict.size() == 0)
            return results;

        int min=Integer.MAX_VALUE;

        Queue<String> queue= new ArrayDeque<String>();
        queue.add(start);
        map = new HashMap<>();
        Map<String, Integer> ladder = new HashMap<>();
        dict.add(end);
        for (String str :dict) ladder.put(str, Integer.MAX_VALUE);
        ladder.put(start, 0);

        while (!queue.isEmpty()) {
            String cur = queue.poll();
            int nextStep = ladder.get(cur) + 1;
            if (nextStep > min) break;
            for (int i =0;i<cur.length();i++) {
                StringBuilder builder = new StringBuilder(cur);
                for (char ch='a';ch<='z';ch++) {
                    builder.setCharAt(i,ch);
                    String nextWord = builder.toString();
                    if (ladder.containsKey(nextWord)) {
                        int dis = ladder.get(nextWord);
                        if (nextStep > dis) continue;
                        else if (nextStep < dis) {
                            queue.add(nextWord);
                            ladder.put(nextWord, nextStep);
                        }
                        //等于的时候，不加到队列里，防止多余的遍历。
                        if (map.containsKey(nextWord)) {
                            map.get(nextWord).add(cur);
                        }else {
                            List<String> adjacent = new ArrayList<>();
                            adjacent.add(cur);
                            map.put(nextWord, adjacent);
                        }

                        if (nextWord.equals(end)) min = nextStep;

                    }

                }
            }
        }


        LinkedList<String> path = new LinkedList<>();
        buildPath(end, start, path,results,map);
        System.out.print(results);
        return results;
    }

    private void buildPath(String curWord, String start, List<String> path, List<List<String>> results, Map<String, List<String>> map) {
        if (curWord.equals(start)) {
            path.add(0,start);
            results.add(new ArrayList<>(path));
            path.remove(0);
            return;
        }
        path.add(0,curWord);
        if (map.containsKey(curWord)) {
            for (String nextWord : map.get(curWord)) {
                buildPath(nextWord,start,path,results,map);
            }
        }
        path.remove(0);
    }


}
LeetCode126—Word Ladder II
上善若水
05-26 4884
LeetCode126—Word Ladder II
LeetCode——Word Ladder II
niaokedaoren的专栏
05-04 8934
链接：http://leetcode.com/onlinejudge#question_126 原题： Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that: Only one
LeetCode 127. Word Ladder II
Stephen Wong的专栏
02-11 867
感觉思路不像网上一些博主说的那么复杂... 用dis(map<string, int>类型)记录每个单词离start的距离，通过BFS记录每个单词的前继单词paths(map<string, vector<string>>); 再通过paths信息从end递归(可以理解为DFS), 求出到end的道路即可。
leetcode 126 Word Ladder II
dong12276的博客
06-30 307
题目连接 https://leetcode.com/problems/word-ladder-ii/ Word Ladder II Description Given two words (beginWordandendWord), and a dictionary's word list, find all shortest transformation sequenc...
leetcode 126. Word Ladder II
独钓寒江雪
07-30 546
leetcode 126. Word Ladder II   写这一题 真的非常适合复习bfs与dfs啊 import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.ut
leetcode:Find All Anagrams in a String 滑动窗口方法总结
yy254117440的博客
11-03 9330
今天做了几道滑动窗口的题，稍微总结一下。 起因源于早上在leetcode上pick one，随机到了一个easy的题目，想着随便做了，结果半天也找不到最优解，耗时300多ms，A是A了，不过就是暴力罢了。 题目是：Find All Anagrams in a String，链接在https://leetcode.com/problems/find-all-anagrams-in-a-string
二叉树常见问题整理
yy254117440的博客
11-22 4865
做leetcode二叉树的题目做了不少，觉得有必要总结一下。因为题型多归多，但其实无非就是dfs和bfs，总结一些常见的解法，对于加深这两周算法的理解很有帮助。 在做dfs的时候，主要思路是可以从上到下也可以从下到上，也就是分析每一个子树的根节点，然后分析该子树的内部子树或者外部子树的根节点，以此得出递归关系，也即是分治的思想。同时，对于每个节点的处理尝试利用前序、后序、中序遍历三种方法。 做b
[LeetCode] Remove Boxes
yy254117440的博客
03-28 2460
题目 Given several boxes with different colors represented by different positive numbers. You may experience several rounds to remove boxes until there is no box left. Each time you can choose some
动态规划解题入门
yy254117440的博客
10-28 2146
动态规划是一种算法思想，刚入门的时候可能感觉十分难以掌握，总是会有看了题不知道怎么做，但是一看答案就恍然大悟的感觉。结合这一段时间的学习，在这里做一下总结。解题思路在解题的过程中，首先可以主动寻找递推关系，比如对当前数组进行逐步拉伸，看新的元素和已有结果是否存在某种关系。 对于没有思路的题目，求解可以分为暴力递归（回溯），记忆性搜索，递归优化，时间或空间最终优化四个阶段。 在碰到一道可以使用动态
［LeetCode]Meeting Rooms II
yy254117440的博客
12-26 1956
Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],…] (si < ei), find the minimum number of conference rooms required. For example, Given [[0, 30],[5
KMP的两种写法
yy254117440的博客
02-12 1230
KMP算法可以用来匹配模式字符串，或者寻找最小重复单元，比如abcabcabc，最小重复单元就是abc。qweqweqwe，最小重复单元是qwe。寻找最小重复单元就是计算出字符串的最长公共前缀的长度a，如果 a != 0 && len %(len-a) == 0即找到最小重复单元。详细内容见KMP算法 核心在于next数组的计算，因此列出getNext的不同计算方法。1、next[i]表示长度为i
[leetcode] 树状数组 BIT
yy254117440的博客
03-26 1068
Binary Index Tree关于BIT，可以参考一篇文章： http://blog.csdn.net/int64ago/article/details/7429868。个人的理解是，相当于在原数组建立了一个具备原数组某些区间和的新的数组。这个数组类似于一个数，最上面的节点又下面的节点构成。比如原数组中ak，对BIT中某些节点有影响。构建树的时候从底向上 k += k & -k 更新BIT节点，
[Leetcode] Count of Smaller Numbers After Self
yy254117440的博客
12-21 804
题目： You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].Example:G
[LeetCode] Create Maximum Number
yy254117440的博客
03-15 756
Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array
kmp算法题解
yy254117440的博客
11-11 726
题目是leetcode上的Implement strStr()，题目大意就是在字符串haystack中寻找字符串needle的是否存在，并返回位置。 地址是： https://leetcode.com/problems/implement-strstr/，可以用来训练一下KMP算法的实现。学习KMP算法的过程中，参考了这篇文章： http://blog.csdn.net/yutianzuiji
回文串问题 Palindrome
yy254117440的博客
12-01 706
回文串问题是一个常见的问题，回文串就是一个字符串头尾指针向中间移动时每一时刻指针指向的字符都相等，比如aabbaa。 判断一个回文串，最简单的方法就是如定义一样，给一个头尾指针，向中间移动判断就行，这里不赘述。 比较巧妙的是利用回文串的性质去解题。最长回文子串问题先看一道题目，地址： https://leetcode.com/problems/longest-palindromic-subst
[LeetCode] Count of Range Sum
yy254117440的博客
12-22 643
题目： Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive. Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i ≤ j),
[Leetcode] Split Array Largest Sum
yy254117440的博客
02-23 638
Given an array which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays. Write an algorithm to minimize the largest sum among these m suba
[LeetCode] Sliding Window Median
yy254117440的博客
03-08 586
题目 Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value. Examples: [2,3,4] , the
[LeetCode] Max Sum of Rectangle No Larger Than K
yy254117440的博客
02-09 569
题目 Given a non-empty 2D matrix matrix and an integer k, find the max sum of a rectangle in the matrix such that its sum is no larger than k. Example: Given matrix = [ [1, 0, 1], [0,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值