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.

package leetcode;

import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;

public class Solution {

	class NODE{
		String string;
		int length;
	}
	public int ladderLength(String start, String end, Set<String> dict) {
		
		if(start.equals(end)&&dict.contains(start)){
			return 1;
		}
		NODE node = new NODE();
		node.length =1;
		node.string = start;
		Queue<Solution.NODE>queue = new LinkedList<Solution.NODE>();
		queue.add(node);
		int length = 0;
		dict.add(end);
		dict.remove(start);
		while (!queue.isEmpty()) {
			node = queue.remove();
			if(end.equals(node.string)){
				length = node.length;
				break;
			}
			for (int i = 0; i < node.string.length(); i++) {
				for(char j = 'a';j<='z';j++){
					StringBuffer buffer = new StringBuffer(node.string);
					buffer.setCharAt(i,j);
					if(dict.contains(buffer.toString())){
						NODE temp = new NODE();
						temp.length = node.length+1;
						temp.string = buffer.toString();
						dict.remove(buffer.toString());
						queue.add(temp);					}
				}
				
			}
		}
		
		return length;
        
    }
	public static void main(String [] args){
		
		Solution solution = new Solution();
		Set<String> dict = new HashSet<String>();
		dict.add("hot");
		dict.add("dot");
		dict.add("dog");
		dict.add("lot");
		dict.add("log");
		
		System.out.println(solution.ladderLength("hit", "cog", dict));
	}
}