[Leetcode] Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

1. Only one letter can be changed at a time
2. 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.

Solution:

https://github.com/mengli/leetcode/blob/master/WordLadderII.java

1.　将start和end的值放入dict中，来统一进行操作。

2.　candidates包含两个HashSet，相继当做current和previous数组。

3.　prevMap包含了【current，list of previous nodes】这样的关系。

package POJ;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class Solution {
    public static void main(String[] args) {
        Solution so = new Solution();
        HashSet<String> dict=new HashSet<String>();
        dict.add("hot");
        dict.add("dog");
        System.out.println(so.findLadders("hot", "dog",dict ));
    }

    public ArrayList<ArrayList<String>> findLadders(String start, String end,
            HashSet<String> dict) {
        ArrayList<ArrayList<String>> ret = new ArrayList<ArrayList<String>>();
        dict.add(start);
        dict.add(end);
        HashMap<String, ArrayList<String>> prevMap = new HashMap<String, ArrayList<String>>();
        for (String s : dict) {
            prevMap.put(s, new ArrayList<String>());
        }
        ArrayList<HashSet<String>> candidates = new ArrayList<HashSet<String>>();
        candidates.add(new HashSet<String>());
        candidates.add(new HashSet<String>());

        int current = 0;
        int previous = 1;
        candidates.get(current).add(start);
        while (true) {
            current = current == 0 ? 1 : 0;
            previous = previous == 0 ? 1 : 0;

            candidates.get(current).clear();
            for (String s : candidates.get(previous))
                dict.remove(s);
            for (String wd : candidates.get(previous)) {
                for (int pos = 0; pos < wd.length(); ++pos) {
                    StringBuilder word = new StringBuilder(wd);
                    for (int i = 'a'; i <= 'z'; ++i) {
                        if (wd.charAt(pos) == i)
                            continue;
                        word.setCharAt(pos, (char) i);
                        if (dict.contains(word.toString())) {
                            candidates.get(current).add(word.toString());
                            prevMap.get(word.toString()).add(wd);
                        }
                    }
                }
            }

            if (candidates.get(current).contains(end))
                break;
            if (candidates.get(current).size() == 0)
                return ret;
        }
        ArrayList<String> al = new ArrayList<String>();
        dfs(ret, al, end, prevMap);
        return ret;
    }

    private void dfs(ArrayList<ArrayList<String>> ret, ArrayList<String> path,
            String word, HashMap<String, ArrayList<String>> prevMap) {
        // TODO Auto-generated method stub
        
        if(prevMap.get(word).size()==0){
            path.add(0,word);
            ArrayList<String> curPath = new ArrayList<String>(path);
            ret.add(curPath);
            path.remove(0);
            return;
        }
        
        path.add(0, word);
        for(String s: prevMap.get(word)){
            dfs(ret, path, s, prevMap);
        }
        path.remove(0);
    }
}

这里需要注意的是：

这种情况时，说明start和end之间没有路，直接返回空的ret即可。