刷题笔记 LeetCode 127 单词接龙

LeetCode 127 单词接龙

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：
1、每次转换只能改变一个字母。
2、转换过程中的中间单词必须是字典中的单词。

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

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

输出: 5

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

BFS 算法 —— 广度优先搜索

算法的基本思路：
广度优先搜索类似于树的层次遍历过程。它需要借助一个队列来实现。分层遍历，再逐个遍历每一层的每个顶点。

具体过程如下：
1.准备工作：创建一个visited数组，用来记录已被访问过的顶点；创建一个队列，用来存放每一层的顶点；初始化图G。
2.从图中的v0开始访问，将的visited[v0]数组的值设置为true，同时将v0入队
3.只要队列不空，则重复如下操作：
(1)队头顶点u出队。
(2)依次检查u的所有邻接顶点w，若visited[w]的值为false，则访问w，并将visited[w]置为true，同时将w入队。

以上思想参考原文：https://blog.youkuaiyun.com/weixin_40953222/article/details/80544928

private boolean[] visited;
//广度优先搜索
public void bfs(Graph G,int x){
	Queue<Integer> queue;
	visited[x] = true; // 标记起点
	queue.enqueue(s);
	while (!queue.isEmpty()) {
		int v = queue.dequeue();
		for (w : v邻接表) {
			if (!visited[w]) {
				visited[w] = true;
				queue.enqueue(w);
			}
		}
	}
}	

有了以上的理论支撑，这题怎么实现？先看看一个简单的BFS的例子，一个二叉树的层序遍历（按层打印）怎么做的。

思路：用队列来保存节点
1、两个int型变量，current保存本层还需要打印的节点数量，next记录下一层的节点数量
2、每次从队列头出队时，查找该节点是否有左右子节点，有则入队，有next记录下子节点层的总数
3、current=0时表示这层已经打印完，置current为next。

import java.util.*;
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val){
        this.val = val;
    }
}

public class Test{

    public static List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        TreeNode curNode = root;
        int current = 0;
        int next = 0;
        if (curNode != null)
            queue.add(curNode);
        //加入根节点
        current = 1;
        List<Integer> tmplist = new ArrayList<>();
        while (!queue.isEmpty()){
            TreeNode tempNode = queue.poll();
            //取出当前层节点
            tmplist.add(tempNode.val);
            current--;
            if(tempNode.left != null) {
                queue.addLast(tempNode.left);
                next++;
            }
            if(tempNode.right != null) {
                queue.addLast(tempNode.right);
                next++;
            }
            if(current==0){//当前层打印完了
                lists.add(new ArrayList<>(tmplist));
                tmplist.clear();
                current = next;
                next = 0;
            }
        }
        return lists;
    }

    public static void main(String[] args){
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(4);
        TreeNode node6 = new TreeNode(3);
        root.left = node1;
        root.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.left = node5;
        node2.right = node6;
        System.out.println(levelOrderBottom(root));
    }
}

然后再来看这道题，用例hit到cog的转变，每次只能改变一个字母，可以理解为一个BFS树，子节点在 [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]中寻找。此处需要设置visited数组，避免重复访问。
如下：

Level0 hit [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
Level1 hot [“dot”,“dog”,“lot”,“log”,“cog”]
Level2 dot lot [“dog”,“log”,“cog”]
Level3 dog log [“cog”]
Level5 cog

由此hit->cog需要5次转换
说明：int类型的curr和next作用和以上二叉树的层序遍历中一致，layer表示层，初值为1，因为level0没有参与搜索，最后输出layer需要+1，道理也是一样。

import java.util.*;
public class LeetCode127_BFS {
    public static int ladderLength(String beginWord, String endWord, List<String> wordList) {
        boolean[] visited = new boolean[wordList.size()];
        Queue<String> queue = new ArrayDeque<>();
        queue.add(beginWord);
        int curr = 1;
        int next = 0;
        int layer = 1;
        while (!queue.isEmpty()){
            String current = queue.poll();
            curr--;
            for (int i=0;i<wordList.size();i++){
                if(visited[i])
                    continue;
                //没有标记过
                String dic = wordList.get(i);
                if(canChange(current,dic)){
                    if(dic.equals(endWord))
                        return layer+1;  //要加上最后一层
                    queue.add(dic);
                    next++;
                    visited[i] = true;
                }
            }
            if(curr == 0){
                layer++;
                curr = next;
                next = 0;
            }
        }
        return 0;
    }

    //是否可以转换的辅助函数
    public static boolean canChange(String x,String y) {
        int diff = 0;
        for (int i=0;i<x.length();i++){
            if (x.charAt(i) != y.charAt(i))
                diff++;
        }
        return diff==1;
    }

    public static void main(String[] args){
        String beginWord = "hit";
        String endWord = "cog";
        List<String> wordList = new ArrayList<>();
        String[] words =  {"hot","dot","dog","lot","log","cog"};
        String[] words2 = {"hot","dot","dog","lot","log"};
        wordList = Arrays.asList(words);
        System.out.println(ladderLength(beginWord,endWord,wordList));
    }
}