leetcode 探索 隊列與棧 打開轉盤鎖

題目

你有一個帶有四個圓形撥輪的轉盤鎖。每個撥輪都有10個數字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每個撥輪可以自由旋轉：例如把 ‘9’ 變爲 ‘0’，‘0’ 變爲 ‘9’ 。每次旋轉都只能旋轉一個撥輪的一位數字。
鎖的初始數字爲 ‘0000’ ，一個代表四個撥輪的數字的字符串。
列表 deadends 包含了一組死亡數字，一旦撥輪的數字和列表裏的任何一個元素相同，這個鎖將會被永久鎖定，無法再被旋轉。
字符串 target 代表可以解鎖的數字，你需要給出最小的旋轉次數，如果無論如何不能解鎖，返回 -1。
示例 1:

輸入：deadends = [“0201”,“0101”,“0102”,“1212”,“2002”], target = “0202”
輸出：6
解釋：
可能的移動序列爲 “0000” -> “1000” -> “1100” -> “1200” -> “1201” -> “1202” -> “0202”。
注意 “0000” -> “0001” -> “0002” -> “0102” -> “0202” 這樣的序列是不能解鎖的，
因爲當撥動到 “0102” 時這個鎖就會被鎖定。

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/open-the-lock/

分析

解體思路，來自題解裏的不是歸人。

仍然是廣度優先搜索，廣度優先搜索需要結合隊列。廣度優先搜索是有模板的，即把第一個節點加入隊列，然後找該節點的相鄰的節點，是爲第一層，第一層取完了，判斷完了，再取第二層，進行判斷。判斷過的節點，要注意設置爲已經訪問，同時如果是deadends，就不要作爲判斷節點了，即不要再加入待判斷的隊列了。

這裏的step計算，要注意。

其中每一步都有八種可能，四個元素每個都可上可下，即4*2，我們要把這八種可能都加入到帶判斷的隊列。這裏通過將string轉換成char型數組，然後將其對應位置+1或者-1進行修改，生成新的解鎖鑰匙key。

另外一個小技巧，將byte裏的數字，減去’0’ 即可轉換爲10進制，再加回’0’ 即可轉換回byte

解法

func openLock(deadends []string, target string) int {
    var deadset = make(map[string]bool, len(deadends))
    for _, v:= range deadends {
        deadset[v] = true
    }
    if deadset["0000"] {
        return -1
    }
    if "0000" == target {
        return 0
    }
    
    queue := make([]string, 0)
    visited := make(map[string]bool)
    
    queue = append(queue, "0000")
    // visited["0000"] = struct{}{}
    step := 0
    for len(queue) > 0 {
        // step 要在何時加啊，不能每次取出一個就加。而是每次撥動一次之後，再加
        step++
        size := len(queue)
        // 把當前的queue 遍歷完了，就是一次撥片，即一次撥片的所有撥法
        for i:=0; i < size; i++ {
            // front := queue[0]
            // queue = queue[1:]
            front := queue[i]
            
            // fmt.Printf("front: %s, %v\n", front, queue)

            // 是否訪問過，沒有就將其設爲訪問
            if visited[front] {
                continue
            }
            visited[front] = true

            // 找出front的八個周邊,然後加入到隊列
            for i := range front {
                downKey := down(front, i)
                // 是否是key
                if downKey == target {
                    return step
                }
                // 是不是dead lock
                if !deadset[downKey] && !visited[downKey] {
                    queue = append(queue, downKey)
                }
                
                upKey := up(front, i)
                // 是否是key
                if upKey == target {
                    return step
                }
                // 是不是dead lock
                if !deadset[upKey] && !visited[upKey] {
                    queue = append(queue, upKey)
                }
            }
        }
        queue = queue[size:]
    }
    return -1
}

// 往上撥
func up(s string, i int) string {
    chars := []byte(s)
    chars[i] = (chars[i] - '0' + 1) % 10 + '0'
    return string(chars)
}

// 往下撥
func down(s string, i int) string {
    chars := []byte(s)
    // 將byte裏的數字，減去'0' 即可轉換爲10進制，再加回'0' 即可轉換回byte
    chars[i] = (chars[i]- '0' - 1 + 10) % 10 + '0'
    return string(chars)
}