Word Ladder II

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

思路：

　　bfs dfs结合

我的代码：

public class Solution {
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        if(isValid(start, end))
        {
            List<String> tmpList = new ArrayList<String>();
            tmpList.add(start);
            tmpList.add(end);
            list.add(tmpList);
            return list;
        }
        Set<String> rst = new HashSet<String>();
        for(String str : dict)
        {
            if(isValid(end,str))
            {
                rst.add(str);
            }
        }
        List<String> tmpList = new ArrayList<String>();
        dfs(tmpList, rst, dict, start, end);
        List<List<String>> result = new ArrayList<List<String>>();
        for(List<String> partList: list)
        {
            if(partList.size() == shortPath)
                result.add(partList);
        }
        return result;
    }
    private List<List<String>> list = new ArrayList<List<String>>();
    private int shortPath = Integer.MAX_VALUE;
    public void dfs(List<String> tmpList, Set<String> rst, Set<String> dict, String start, String end)
    {
        tmpList.add(start);
        if(rst.contains(start))  
        {
            tmpList.add(end);
            if(shortPath >= tmpList.size())
            {
                list.add(new ArrayList(tmpList));
                shortPath = tmpList.size();
            }
            tmpList.remove(tmpList.size()-1);
            tmpList.remove(tmpList.size()-1);
            return ;
        }
        for(char c = 'a'; c <= 'z'; c++)
        {
            for(int j = 0; j < start.length(); j++)
            {
                if(start.charAt(j) == c)  continue;
                String str = replace(start, j, c);
                if(dict.contains(str))
                {
                    dict.remove(str);
                    dfs(tmpList, rst, dict, str, end);
                    dict.add(str);
                }
            }
        }
        tmpList.remove(tmpList.size()-1);
    }
    private String replace(String s, int index, char c)
    {
        char[] chars = s.toCharArray();
        chars[index] = c;
        return new String(chars);
    }
    public boolean isValid(String one, String two)
    {
        int count = 0;
        for(int i = 0; i < one.length(); i++)
        {
            if(one.charAt(i) != two.charAt(i))
                count++;
        }
        return count == 1 ? true : false;
    }
}

他人代码：

public class Solution {
    public List<List<String>> findLadders(String start, String end,
            Set<String> dict) {
        List<List<String>> ladders = new ArrayList<List<String>>();
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        Map<String, Integer> distance = new HashMap<String, Integer>();

        dict.add(start);
        dict.add(end);
 
        bfs(map, distance, start, end, dict);
        
        List<String> path = new ArrayList<String>();
        
        dfs(ladders, path, end, start, distance, map);

        return ladders;
    }

    void dfs(List<List<String>> ladders, List<String> path, String crt,
            String start, Map<String, Integer> distance,
            Map<String, List<String>> map) {
        path.add(crt);
        if (crt.equals(start)) {
            Collections.reverse(path);
            ladders.add(new ArrayList<String>(path));
            Collections.reverse(path);
        } else {
            for (String next : map.get(crt)) {
                if (distance.containsKey(next) && distance.get(crt) == distance.get(next) + 1) { 
                    dfs(ladders, path, next, start, distance, map);
                }
            }           
        }
        path.remove(path.size() - 1);
    }

    void bfs(Map<String, List<String>> map, Map<String, Integer> distance,
            String start, String end, Set<String> dict) {
        Queue<String> q = new LinkedList<String>();
        q.offer(start);
        distance.put(start, 0);
        for (String s : dict) {
            map.put(s, new ArrayList<String>());
        }
        
        while (!q.isEmpty()) {
            String crt = q.poll();

            List<String> nextList = expand(crt, dict);
            for (String next : nextList) {
                map.get(next).add(crt);
                if (!distance.containsKey(next)) {
                    distance.put(next, distance.get(crt) + 1);
                    q.offer(next);
                }
            }
        }
    }

    List<String> expand(String crt, Set<String> dict) {
        List<String> expansion = new ArrayList<String>();

        for (int i = 0; i < crt.length(); i++) {
            for (char ch = 'a'; ch <= 'z'; ch++) {
                if (ch != crt.charAt(i)) {
                    String expanded = crt.substring(0, i) + ch
                            + crt.substring(i + 1);
                    if (dict.contains(expanded)) {
                        expansion.add(expanded);
                    }
                }
            }
        }

        return expansion;
    }
}

学习之处：

• 我的代码只能过小的数据集，大的数据集就超时了，主要是太多的的重复计算非最短路径中，需要先进行BFS确定哪些是最短的路径
• 直接复制的别人的代码AC的，有点浮躁啊，看看了，下次再刷leetcode的时候，再自己写一遍，到了hard的难度了，越来越多的题，hold不住了。
• 改掉自己身上不好的习惯，Day by day, 进步一点点