Leetcode 127: Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]

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.
• You may assume no duplicates in the word list.
• You may assume beginWord and endWord are non-empty and are not the same.

 

public class Solution {
    public class QueueNode
    {
        public string val;
        public int step;
        
        public QueueNode(string v, int s)
        {
            val = v;
            step = s;          
        }
    }
    
    public int LadderLength(string beginWord, string endWord, IList<string> wordList) {
        var hashset = new HashSet<string>();
        
        foreach (var s in wordList)
        {
            hashset.Add(s);
        }
        
        if (!hashset.Contains(endWord)) return 0;
        
        var queue = new Queue<QueueNode>();
        queue.Enqueue(new QueueNode(beginWord, 1));
        int len = beginWord.Length;
        
        while (queue.Count > 0)
        {
            var q = queue.Dequeue();
            
            for (int j = 0; j < len; j++)
            {
                for (int k = 0; k < 26; k++)
                {
                    var sb = new StringBuilder(q.val);
                    sb[j] = (char)((int)'a' + k);
                    
                    var ns = sb.ToString();
                    if (ns == endWord)
                    {
                        return q.step + 1;
                    } 
                    else if (hashset.Contains(ns))
                    {
                        queue.Enqueue(new QueueNode(ns, q.step + 1));
                        hashset.Remove(ns);
                    }
                }
            }
           
        }
        
        return 0;
    }
}