126 word Ladder

最新推荐文章于 2022-02-07 22:27:20 发布

aiuou

最新推荐文章于 2022-02-07 22:27:20 发布

阅读量341

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/aiuou/article/details/44515673

版权

LeetCode 专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一种寻找两个单词间最短转换路径的算法，通过字典查找和递归方式实现从起始单词到目标单词的所有可能转换序列。该算法确保每次只改变一个字母，并且每个中间状态都是有效单词。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

public class Solution {
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        List<List<String>> result=new ArrayList<List<String>>();
        HashMap<String,Integer> map=ladderLength(start,end,dict);
        if (map.containsKey(end)==false) return result;
        int ladderSize=map.get(end);
        result=getLadders(start,end,map,ladderSize);
        return result;
    }
    public List<List<String>> getLadders(String start, String end, HashMap<String, Integer> map,int ladderSize){
        List<List<String>> result=new ArrayList<List<String>>();
        List<String> oneStep = new ArrayList<String>();
        if(ladderSize==1){
            oneStep.add(start);
            result.add(oneStep);
            return result;
        }
        String temp="";
        for(int i=0;i<end.length();i++){
            for(int j=0;j<26;j++){
                char m=(char)('a'+j);
                temp=end.substring(0,i)+m+end.substring(i+1);
                if(map.containsKey(temp)&&map.get(temp)==ladderSize-1){
                    oneStep.add(temp);
                }
            }
        }
        for(int i=0;i<oneStep.size();i++){
            List<List<String>> tempList=getLadders(start,oneStep.get(i),map,ladderSize-1);
            for(int j=0;j<tempList.size();j++){
                List<String> tempPath=tempList.get(j);
                tempPath.add(end);
             result.add(tempPath);
            }
        }
        return result;
    }
    
    public HashMap<String,Integer> ladderLength(String start, String end, Set<String> dict) {
        HashMap<String,Integer> map=new HashMap<String,Integer>();
        Queue<String>q=new LinkedList<String>();
        String word="",temp="";
        q.add(start);
        map.put(start,1);
        int curstep=0;
        while(q.isEmpty()==false){
            word=q.poll();
            curstep=map.get(word);
            if(word.compareTo(end)==0) break;
            for(int i=0;i<word.length();i++){
                for(int j=0;j<26;j++){
                    char m=(char)('a'+j);
                    temp=word.substring(0,i)+m+word.substring(i+1,word.length());
                    if(dict.contains(temp)&&!map.containsKey(temp)){
                        map.put(temp,curstep+1);
                        q.add(temp);
                    }
                }
            }
        }
            return map;
        }
 }