每日一题 2020.11.5

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
}