LeetCode Word Ladder II(BFS、SPFA)



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.

题意：给出一个字典，开始和结束字符串，问从开始字符串变为结束字符串最少的频数，输出所有的结果

思路：在用bfs方法时，根据已扩展的结束和当前结点，求出当前结点可以扩展出的结点，并将扩展出的结点的前驱结点记录下来，便于后面计算出变换路径;用SPFA算法时，也是用的队列，但是可以重复入队列，在路径值相等时，将当前结点加入到扩展结点的父结点数组中

bfs方法代码如下

public class Solution {
   
    private List<String> possibleNode(String cur, String end, Set<String> dict, Set<String> visited)
    {
        List<String> res = new ArrayList<String>();
        
        for (int i = 0; i < cur.length(); i++) {
            char[] ar = cur.toCharArray();
            for (char j = 'a'; j <= 'z'; j++) {
                ar[i] = j;
                String tmp = new String(ar);
                if (dict.contains(tmp) && !visited.contains(tmp)) res.add(tmp);
            } 
        }
        
        if (res.contains(end)) {
            res = new ArrayList<String>();
            res.add(end);
        }
        
        return res;
    }
    
    private List<List<String>> buildPaths(String start, String end, Map<String, Map<Integer, Set<String>>> parent)
    {
        List<List<String>> res = new ArrayList<List<String>>();
        Set<String> prevsteps = null;
        if (parent.containsKey(end)) {
            //获取上一层的字符串，i是按递增序访问的
            for (int i : parent.get(end).keySet()) {
                prevsteps = parent.get(end).get(i);
            }
        }
        
        if (prevsteps == null) {
            if (start.equals(end)) {
                List<String> path = new ArrayList<String>();
                path.add(end);
                res.add(path);
            }
            
            return res;
        }
        
        if (prevsteps.size() == 0) {
            List<String> path = new ArrayList<String>();
            path.add(end);
            res.add(path);
        } else {
            for (String s : prevsteps) {
                List<List<String>> path = buildPaths(start, s, parent);
                for (List<String> p : path) {
                    p.add(end);
                    res.add(p);
                }
            }
        }
        
        return res;
    }
    public List<List<String>> findLadders(String start, String end, Set<String> dict) 
    {
       dict.add(end);
       List<List<String>> paths  = new ArrayList<List<String>>();
       Queue<String> tovisit = new LinkedList<String>();
       Queue<Integer> level = new LinkedList<Integer>();
       Set<String> visited = new HashSet<String>();
       Map<String, Map<Integer, Set<String>>> parent = new HashMap<String, Map<Integer, Set<String>>>();
       tovisit.add(start);
       level.add(0);
       parent.put(start, new HashMap<Integer, Set<String>>());
       int max = Integer.MAX_VALUE;
       
       while (!tovisit.isEmpty()) {
           String current = tovisit.poll();
           int curStep = level.poll();
           visited.add(current);
           
           if (curStep > max) break;
           if (current.equals(end) && curStep < max) max = curStep;
           else {
               List<String> nodes = possibleNode(current, end, dict, visited);
               for (String s : nodes) {
                   if (!tovisit.contains(s)) {
                        tovisit.add(s);
                        level.add(curStep + 1);
                   }
                   
                   if (!parent.containsKey(s)) {
                       Map<Integer, Set<String>> levelParent = new HashMap<Integer, Set<String>>();
                       Set<String> parentSet = new HashSet<String>();
                       levelParent.put(curStep, parentSet);
                       parent.put(s, levelParent);
                   }
                   
                   if (parent.get(s).containsKey(curStep)) {
                       parent.get(s).get(curStep).add(current);
                   }
               }
           }
               
       }
       
       paths = buildPaths(start, end, parent);
       return paths;
    }

}

SPFA代码如下

public class Solution {
  
    private void connect(Map<String, ArrayList<String>> graph, Set<String> dict, String key)
    {
        graph.put(key, new ArrayList<String>());
        char[] cs = key.toCharArray();
        
        for (int i = 0, len = key.length(); i < len; i++) {
            char ch = cs[i];
            for (char c = 'a'; c <= 'z'; c++) {
                if (cs[i] == c) continue;
                cs[i] = c;
                String tmp = new String(cs);
                if (dict.contains(tmp)) graph.get(key).add(tmp);
            }
            cs[i] = ch;
        }
    }
    
    private void buildGraph(Map<String, ArrayList<String>> graph, Set<String> dict, String start, String end)
    {
        dict.add(start);
        dict.add(end);
        
        Iterator<String> it = dict.iterator();
        while (it.hasNext()) {
            String key = it.next();
            connect(graph, dict, key);
        }
    }
    
    private void spfa(Map<String, ArrayList<String>> graph, Map<String, ArrayList<String>> path, String start)
    {
        Map<String, Integer> d =  new HashMap<String, Integer>();
        Set<String> visit = new HashSet<String>();
        Queue<String> q = new LinkedList<String>();
        q.offer(start);
        visit.add(start);
        
        for (String key: graph.keySet()) {
            path.put(key, new ArrayList<String>());
            if (key.equals(start)) d.put(key, 0);
            else d.put(key, Integer.MAX_VALUE);
        }
        
        while (!q.isEmpty()) {
            String cur = q.poll();
            visit.remove(cur);
            
            ArrayList<String> adjList = graph.get(cur);
            for (int i = 0; i < adjList.size(); i++) {
                String next = adjList.get(i);
                if (d.get(next) > d.get(cur) + 1) {
                    d.put(next, d.get(cur) + 1);
                    ArrayList<String> p = new ArrayList<String>();
                    p.add(cur);
                    path.put(next, p);
                    if (!visit.contains(next)) {
                        q.offer(next);
                        visit.add(next);
                    }
                } else if (d.get(next) == d.get(cur) + 1) {
                    path.get(next).add(cur);
                }
            }
        }
    }
    
    
    private List<List<String>> buildPaths(String start, String end, Map<String, ArrayList<String>> parent)
    {
        List<List<String>> ans = new ArrayList<List<String>>();
        
        if (start.equals(end)) {
            List<String> p = new ArrayList<String>();
            p.add(start);
            ans.add(p);
            return ans;
        }
        
        if (parent.containsKey(end)) {
            ArrayList<String> prevs = parent.get(end);
            for (String prev: prevs) {
                List<List<String>> temp = buildPaths(start, prev, parent);
                for (List<String> t : temp) {
                    t.add(end);
                    ans.add(t);
                }
            }
        }
        return ans;
    }
    
    public List<List<String>> findLadders(String start, String end, Set<String> dict) 
    {
       List<List<String>> ans = new ArrayList<List<String>>();
       
       if (start.equals(end)) {
           List<String> t = new ArrayList<String>();
           t.add(end);
           ans.add(t);
           return ans;
       }
       
       Map<String, ArrayList<String>> graph = new HashMap<String, ArrayList<String>>();
       Map<String, ArrayList<String>> paths = new HashMap<String, ArrayList<String>>();
       buildGraph(graph, dict, start, end);
       spfa(graph, paths, start);
       ans = buildPaths(start, end, paths);
       
       return ans;
    }
}