leetcode DFS,借助队列——打开转盘锁

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有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

提示：

死亡列表 deadends 的长度范围为 [1, 500]。
目标数字 target 不会在 deadends 之中。
每个 deadends 和 target 中的字符串的数字会在 10,000 个可能的情况 ‘0000’ 到 ‘9999’ 中产生。
https://leetcode-cn.com/explore/learn/card/queue-stack/217/queue-and-bfs/873/
题目思路，一个队列保存将要访问的结点，一个集保存访问过的结点。
先把题目标识的几个限制的字符串加进去，在以层进行DFS，一旦找到，立马返回。

import java.util.*;

class Solution {
    public int openLock(String[] deadends, String target) {
    	int times=1;//搜寻的层数
    	if(target.equals("0000")) return 0;
        Set<String> visited=new HashSet<>();/*保存访问过和禁止的结点，hashset无序，效率高*/
        for(int i=0;i<deadends.length;i++) {//加入禁止的结点入集合
        	visited.add(deadends[i]);
        }
        Queue<String> queue=new LinkedList<>();//存放暂时的队列
        queue.offer("0000");	//这个点作为根结点，直接加进去
        while(!queue.isEmpty()) {
        	int length=queue.size();/*注意这个地方，因为在遍历的时候我们会加上某个结点的邻接点，所以这个不能直接是queue.size()，而应该是这个队列没有开始遍历的初始值*/
        	for(int i=0;i<length;i++) {
        		String str=queue.poll();//对头依次出队，对出队进行操作
        		if(visited.contains(str)) continue ;//是被访问过的结点
            	if(str.equals(target))	return times;//找到
            	visited.add(str);//放入被访问的集合中
            	String[] neigh=Neigh(str);//得到邻结点
            	for(int j=0;j<neigh.length;j++) {//对得到的邻接点操作
            		if(neigh[j].equals(target))	return times;
            		if(visited.contains(neigh[j]))	continue;
            		queue.offer(neigh[j]);	//入队，所以之前的size要是个定值
            	}
        	}       	
        	times++;		//一层遍历完整结束，+1
        }
        return -1 ;	//通过结点任然没有搜寻到，直接返回-1
    }
    public String[] Neigh(String str) {//返回该点的邻接点，在本题中，一个四位数是一个结点，可以朝8个地方进行扩展，分别是1,2,3,4位上的+ -。
    	char a1=(char) (((str.charAt(0)-'0')+1)%10+'0');
		char a2=(char) (((str.charAt(0)-'0')-1+10)%10+'0');
		char b1=(char) (((str.charAt(1)-'0')+1)%10+'0');
		char b2=(char) (((str.charAt(1)-'0')-1+10)%10+'0');
		char c1=(char) (((str.charAt(2)-'0')+1)%10+'0');
		char c2=(char) (((str.charAt(2)-'0')-1+10)%10+'0');
		char d1=(char) (((str.charAt(3)-'0')+1)%10+'0');
		char d2=(char) (((str.charAt(3)-'0')-1+10)%10+'0');
		String[] nei=new String[8];
		nei[0]=a1+str.substring(1,4);
		nei[1]=a2+str.substring(1,4);
		nei[2]=str.substring(0,1)+b1+str.substring(2,4);
		nei[3]=str.substring(0,1)+b2+str.substring(2,4);
		nei[4]=str.substring(0,2)+c1+str.substring(3,4);
		nei[5]=str.substring(0,2)+c2+str.substring(3,4);
		nei[6]=str.substring(0,3)+d1;
		nei[7]=str.substring(0,3)+d2;
		return nei;
    }
    /*public static void main(String[] args) {
    	String deadends[]= {"8887","8889","8878","8898","8788","8988","7888","9888"};
    	String target="8888";
    	int ans=new Solution().openLock(deadends, target);
    	System.out.println(ans);
    }*/
}