[LeetCode][JavaScript]Word Ladder

Word Ladder

Given two words (beginWord and endWord), and a dictionary, 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 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.

 https://leetcode.com/problems/word-ladder/

---

这题挂了无数次啊，一开始错把入参当做Array，其实是个Set，之后就一直超时...

bfs的思路是没错的，但首先不能构造图，复杂度O(n^2) 肯定不行。

然后尝试直接在Set里找，找到一个删除一个，也是超时。

最后只能换成了现在的方式。

这道题test case有特殊性，dict里的单词不会特别长，但是数据量很大。

最终改成在bfs队列中出队一个元素，一个个地用a-z替换每个字母，然后跟字典比较。

/**
 * @param {string} beginWord
 * @param {string} endWord
 * @param {set<string>} wordDict
 * @return {number}
 */
var ladderLength = function(beginWord, endWord, wordDict) {
    var queue = [];
    var i = 0;
    queue.push(beginWord);
    wordDict.delete(beginWord);
    if(oneCharDiff(beginWord, endWord) && wordDict.has(endWord)){
        return 2;
    }else{
        return bfs();
    }

    function bfs(){
        var depth = 1;
        while(queue.length > 0){
            depth++;
            var count = queue.length;
            while(count--){
                var curr = queue.shift();
                if(oneCharDiff(curr, endWord) && curr !== beginWord){
                    return depth;
                }
                for(var i = 0; i < curr.length; i++){
                    for(var j = 'a'.charCodeAt(); j <= 'z'.charCodeAt(); j++){
                        var testMatch = curr;
                        var ch = String.fromCharCode(j);
                        if(testMatch[i] !== ch){
                            testMatch = replaceChat(testMatch, i, ch);
                        }
                        if(wordDict.has(testMatch)){
                            queue.push(testMatch);
                            wordDict.delete(testMatch);
                        }
                    }
                }
            }
        }        
        return 0;
    }
    function replaceChat(source, pos, newChar){  
        var sFrontPart = source.substr(0, pos);  
        var sTailPart = source.substr(pos + 1, source.length);  
        return sFrontPart + newChar + sTailPart;  
    }  
    function oneCharDiff(a, b){
        if(a.length !== b.length){
            return false;
        }
        var count = 0;
        for(var i = 0; i < a.length; i++){
            if(a[i].toLowerCase() !== b[i].toLowerCase()){
                count++;
            }
            if(count >= 2){
                return false;
            }
        }
        if(count === 1){
            return true;
        }else{
            return false;
        }
    }
};