[Leetcode] Word Ladder

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence 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"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

Solution:

我自己的做法，大数据时会超时：

利用两个queue：

1个queue用来存放本层的单词，一个queue用来存放下一层的单词。

当本层的单词用完了以后，再将下一层的单词变成本层的就好，下一层清空。

注意，java的object是pass by reference的，得重新new一下才行。

public int ladderLength(String start, String end, Set<String> dict) {
        if(start==null||end==null||dict==null||dict.size()==0){
            return 0;
        }
        Queue<String> curQueue=new LinkedList<String>();
        Queue<String> nextQueue=new LinkedList<String>();
        curQueue.offer(start);
        int count=1;
        if(dict.contains(start))
            dict.remove(start);
        while(!curQueue.isEmpty()){              
            if(curQueue.peek().equals(end))
                return count;
            String haha=curQueue.poll();            
            for(int i=0;i<start.length();++i){
                char[] temp_c=haha.toCharArray();
                char m=temp_c[i];
                for(char j='a';j<='z';++j){
                    if(m==j)
                        continue;
                    temp_c[i]=j;
                    String temp=new String(temp_c);  
                    //System.out.println("size o Cur Queue==="+temp);
                    if(dict.contains(temp)){
                        
                        dict.remove(temp);
                        nextQueue.offer(temp);
                    }
                }
            }
            if(curQueue.isEmpty()){
                curQueue=new LinkedList<String>(nextQueue);
                nextQueue.clear();
                count++;
            }
        }
        return 0;
    }

---------------------------------------------------------------------------

网上看到的做法：

不用两个queue来分别存放上下两层的数据，只用一个queue来实现就好，但是分别用两个counter来计数，上层有多少个words，下层有多少个words。同理，当上层的words都从queue里poll出去了以后，上层counter=下层counter，下层counter清空。

public class Solution {
    public int ladderLength(String start, String end, Set<String> dict) {
        if(start==null||end==null||dict==null||dict.size()==0)
            return 0;
        Queue<String> queue=new LinkedList<String>();
        queue.offer(start);
        int curNum=1;
        int nextNum=0;
        int level=1;
        while(!queue.isEmpty()){
            if(queue.peek().equals(end)){
                return level;
            }
            curNum--;
            String temp=queue.poll();
            for(int i=0;i<temp.length();++i){
                char[] c=temp.toCharArray();
                for(char j='a';j<='z';++j){
                    c[i]=j;
                    String sc=new String(c);
                    // if(sc.equals(end)){
                    //     return level;
                    // }
                    if(dict.contains(sc)){
                        dict.remove(sc);
                        nextNum++;
                        queue.offer(sc);
                    }
                }
            }
            if(curNum==0){
                curNum=nextNum;
                nextNum=0;
                level++;
            }
        }
        return 0;
    }
}