问题描述

给定两个单词（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" 不在字典中，所以无法进行转换。

解题思路

1、将问题转化为广度优先遍历的问题，求最短路径
2、从第一个单词开始，相连的单词只有一个字母不同
3、每一步只能改变一个字母，经过广度优先遍历算法，找到目标单词

代码

import java.util.*;

class Solution {

    private HashMap<String,HashSet<String>> map=null;//邻接表
    private HashSet<String> flag=null;//单词是否已遍历过标志
    private HashMap<String,Integer> level=null;//单词到第一个单词的层次

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        //如果wordList中不包含单词，也就不能转换
        if(!wordList.contains(endWord)){
            return 0;
        }
        //对邻接表进行初始化
        map=new HashMap<>();
        for (String w:wordList
             ) {
            map.put(w,new HashSet<>());
        }
        //beginWord没在wordList中
        map.put(beginWord,new HashSet<>());

        //添加beginWord到图中
        for(int j=0;j<wordList.size();j++){
            if(isNear(beginWord,wordList.get(j))){
                map.get(beginWord).add(wordList.get(j));
            }
        }
        //将wordList中的单词添加进图中
        for (int i=0;i<wordList.size();i++){
            String word=wordList.get(i);
            for(int j=0;j<wordList.size();j++){
                if(i==j){
                    continue;
                }
                //如果只有一个字母不同，建立一条边
                if(isNear(word,wordList.get(j))){
                    map.get(word).add(wordList.get(j));
                }
            }
            //beginWord建立边关系
            if(isNear(beginWord,word)){
                map.get(word).add(beginWord);
            }
        }
        flag=new HashSet<>();
        level=new HashMap<>();
        //初始化所有的单词深度为0
        for (String w:wordList
             ) {
            level.put(w,0);
        }
        level.put(beginWord,0);
        //开始遍历
        bfs(beginWord);
        return level.get(endWord);
    }

    /**
     * 以beginWord为起点进行广度优先遍历
     * @param beginWord
     */
    private void bfs(String beginWord) {
        if(flag.contains(beginWord)){
            return ;
        }
        //广度优先遍历所用的队列
        Queue<String> queue=new LinkedList<>();
        //将第一个单词添加进队列
        queue.add(beginWord);
        while (!queue.isEmpty()){
            //取出队列中的一个单词
            String word=queue.remove();
            for (String w:map.get(word)){
                //第一个单词的深度为1，注意这是个坑
                level.put(beginWord,1);
                if(!flag.contains(w)){
                    //深度加一
                    level.put(w,level.get(word)+1);
                    //遍历过标记
                    flag.add(w);
                    //将word的下一层添加进队列
                    queue.add(w);
                }
            }
        }
    }

    /**
     * 找到只有一个字母不同的单词
     * @param word
     * @param s
     * @return
     */
    private boolean isNear(String word, String s) {
        int count=0;
        for (int i=0;i<word.length();i++){
            if(word.charAt(i)==s.charAt(i)){
                count++;
            }
        }
        return count==word.length()-1?true:false;
    }
}