127. 單詞接龍

給定兩個單詞（beginWord 和 endWord）和一個字典，找到從 beginWord 到 endWord 的最短轉換序列的長度。轉換需遵循如下規則：

每次轉換隻能改變一個字母。
轉換過程中的中間單詞必須是字典中的單詞。
說明:

• 如果不存在這樣的轉換序列，返回 0。
• 所有單詞具有相同的長度。
• 所有單詞只由小寫字母組成。
• 字典中不存在重複的單詞。
• 你可以假設 beginWord 和 endWord 是非空的，且二者不相同。

思路：建圖後跑最短路即可

var length int
var dif [][]int
var vis []bool
var result int
var d []int

const (
    INT_MAX = 1<<32-1
)

func getDif(s1 string, s2 string)(ans int){
    for i:= 0;i<len(s1);i++{
        if s1[i] != s2[i]{
            ans++
            if ans > 1{
                return
            }
        }
    }
    return
}

func ladderLength(beginWord string, endWord string, wordList []string) int {
    length = len(wordList)
    dif = make([][]int,length+2)
    vis = make([]bool,length+2)
    d = make([]int,length+2)

    for i:= 0;i<length+2;i++{
        dif[i] = make([]int,length+2)
        d[i] = INT_MAX
        vis[i] = false
    }

    dif[0][length+1] =  getDif(beginWord,endWord)
    dif[length+1][0] = dif[0][length+1]

    can := false
    for i :=0 ;i<length;i++{
        dif[0][i+1]  = getDif(beginWord,wordList[i])
        dif[i+1][0] = dif[0][i+1]
        dif[i+1][length+1] = getDif(endWord,wordList[i])
        dif[length+1][i+1] = dif[i+1][length+1]
        if dif[i+1][length+1] == 0{
            can = true
        }
    }

    if !can{
        return 0
    }

    for i:= 0;i<length;i++{
        for j:=i;j<length;j++{
            dif[i+1][j+1]  = getDif(wordList[i],wordList[j])
            dif[j+1][i+1] = dif[i+1][j+1]
        }
    }

    d[0] = 0
    count := 1
    for count <= length {
        minNum := INT_MAX
        ind := -1
        for i:=0;i<=length;i++{
            if d[i] < minNum && !vis[i]{
                minNum = d[i]
                ind = i;
            }
        }
        if ind == -1{
            break
        }
        vis[ind] = true
        for i:=0;i<=length+1;i++{
            if dif[ind][i] == 1 && d[i] > d[ind] + 1{
                d[i] = d[ind] + 1
            }
        }
        count++
    }
    if d[length+1] == INT_MAX{
        return 0
    }
    return d[length+1]+1
}