leetcode 126. Word Ladder II

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

Hackerzer

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

阅读量413

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/hackerzer/article/details/76403048

版权

算法专栏收录该内容

157 篇文章 0 订阅

订阅专栏

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.util.Map;
import java.util.Queue;
import java.util.Set;


public class Solution{
	public static void main(String[] args){
		Solution s = new Solution();
		List<String> wordList = new ArrayList<String>();
		wordList.add("hot");
		wordList.add("dot");
		wordList.add("dog");
		wordList.add("lot");
		wordList.add("log");
		wordList.add("cog");
//		wordList.add("cot");
		List<List<String>> res = s.findLadders("hit", "cog", wordList);
		System.out.println(res);
	}
	
    public List<List<String>> findLadders(String beginWord, String endWord, 
    		List<String> wordList) {
    	HashSet<String> dict = new HashSet<String>(wordList);
    	List<List<String>> res = new ArrayList<List<String>>();
    	Queue<String> queue = new LinkedList<String>();
    	Map<String, List<String>> strmap = new HashMap<String, List<String>>();
    	Map<String, Integer> distance = new HashMap<String, Integer>();
    	for(String str:dict){
    		strmap.put(str, new ArrayList<String>());
    	}
    	strmap.put(beginWord, new ArrayList<String>());
    	queue.add(beginWord);
    	queue.remove(endWord);
    	int string_size = beginWord.length();
    	int final_layer = Integer.MAX_VALUE;
    	int cur_layer = 0;
    	distance.put(beginWord, 0);
    	while(!queue.isEmpty()){
    		String cur = queue.poll();
    		char[] new_str = cur.toCharArray();
    		if(distance.get(cur)>=final_layer){
    			break;
    		}
    		boolean isFound = false;
    		for(int i=0;i<string_size;i++){
    			for(char c='a';c<='z';c++){
    				char origin_char = cur.charAt(i);
    				if(c==origin_char) continue;
    				new_str[i] = c;
    				String new_s = String.valueOf(new_str);
    				if(dict.contains(new_s)){
    					if(new_s.equals("log")){
    						int n = 1;
    					}
    					strmap.get(cur).add(new_s);
    					if(!distance.containsKey(new_s)){
    						distance.put(new_s, distance.get(cur)+1);
	    					if(new_s.equals(endWord)){
								final_layer = distance.get(cur)+1;
								System.out.println("final_layer "+final_layer);
							}else{
								queue.offer(new_s);
							}
    					}
    				}
    				new_str[i] = origin_char;
    			}
    		}
    	}
    	dfs(strmap,beginWord,endWord,res,final_layer,
    			new ArrayList<String>(),distance);
    	return res;
    }
    
    
    private ArrayList<String> getNeighbors(String node, Set<String> dict) {
    	  ArrayList<String> res = new ArrayList<String>();
    	  char chs[] = node.toCharArray();

    	  for (char ch ='a'; ch <= 'z'; ch++) {
    	      for (int i = 0; i < chs.length; i++) {
    	          if (chs[i] == ch) continue;
    	          char old_ch = chs[i];
    	          chs[i] = ch;
    	          if (dict.contains(String.valueOf(chs))) {
    	              res.add(String.valueOf(chs));
    	          }
    	          chs[i] = old_ch;
    	      }

    	  }
    	  return res;
    	}
    
    public void dfs(Map<String, List<String>> strmap, String beginWord, 
    		String endWord, List<List<String>> res, 
    		int final_layer, List<String> path,Map<String, Integer> distance){
    	path.add(beginWord);
    	if(path.size()==final_layer+1){
    		if(beginWord.equals(endWord)){
    			res.add(new ArrayList<String>(path));
//    			System.out.println(res);
    		}
//    		path.clear();
//    		System.out.println(res);
    		path.remove(path.size()-1);
    		return;
    	}
    	
    	for(String s: strmap.get(beginWord)){
    		if((distance.get(s)==distance.get(beginWord)+1))
    			dfs(strmap,s,endWord,res,final_layer,path,distance);
    	}
    	path.remove(path.size()-1);  // backtrack
    }
}