你有一個帶有四個圓形撥輪的轉盤鎖。每個撥輪都有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" 時這個鎖就會被鎖定。
示例 2:

輸入: deadends = ["8888"], target = "0009"
輸出：1
解釋：
把最後一位反向旋轉一次即可 "0000" -> "0009"。
示例 3:

輸入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
輸出：-1
解釋：
無法旋轉到目標數字且不被鎖定。
示例 4:

輸入: deadends = ["0000"], target = "8888"
輸出：-1

提示：

1 <=deadends.length <= 500
deadends[i].length == 4
target.length == 4
target 不在 deadends 之中
target 和 deadends[i] 僅由若干位數字組成

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/open-the-lock
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

1：因為數字只能是0-9999,所以先建立一長度為10000的陣列，將來記錄從0轉到改數字時所用的次數。
2：再定義一個list,來記錄相同次數的數字。
3：從0開始，對每一位數字旋轉，會產生8個數字，把這些數字，記錄到list中。
4：之後遍歷list，再對其中的每個數字旋轉，排除掉鎖住的數字，其他數字放到list中。不斷的迴圈判斷，直到找到目標數字。
5：為了方便判斷是否時鎖住的數字，可以用map來記錄，當然也可以在陣列中用一個負數來標記。

    public int openLock(String[] deadends, String target) {
        int[] arr = new int[10000];
        for (String deadend : deadends) {
            arr[Integer.parseInt(deadend)] = -1;
        }
        int t = Integer.parseInt(target);
        if (arr[0] == -1 || arr[t] == -1) {
            return -1;
        }
        if (t == 0) {
            return 0;
        }
        List<Integer> list = new ArrayList<>(10000);
        List<Integer> list2 = new ArrayList<>(10000);

        list.add(0);
        arr[0] = 1;
        int n = 2;
        while (!list.isEmpty()) {
            for (Integer value : list) {
                if (value == t) {
                    return n - 2;
                }
                int aa = find(value, 1000, 1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 1000, -1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 100, 1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 100, -1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 10, 1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 10, -1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 1, 1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
                aa = find(value, 1, -1);
                if (arr[aa] == 0) {
                    arr[aa] = n;
                    list2.add(aa);
                }
            }
            list = list2;
            list2 = new ArrayList<>(10000);
            n++;
        }

        return -1;
    }

    private int find(int value, int c, int flag) {
        int v = value % (c * 10) / c;
        int r;
        if (v == 9 && flag == 1) {
            r = value - 9 * c;
        } else if (v == 0 && flag == -1) {
            r = value + 9 * c;
        } else {
            r = value + c * flag;
        }
        return r;
    }