LC752 打开转盘锁

题目描述：

 方法：bfs广度遍历

class Solution {
      public int openLock(String[] deadends, String target) {

        Queue<String> queue = new LinkedList<String>();//主动队列
        Set<String> visited=new HashSet<>();
        Set<String> dead=new HashSet<>();
for(String deadend:deadends){
    dead.add(deadend);
}
        int step=0;//记录步数

        queue.add("0000");//添加进队列

        //visited防止重复
visited.add("0000");

        while(!queue.isEmpty()){
            int size=queue.size();
            //向周围的结点扩散
            for(int i=0;i<size;i++){
                String key = queue.poll();
                //判断终点
                if(dead.contains(key)){//包含死亡密码
                    continue;
                }
                if(key.equals(target)){//判断目标是否相等
                    return step;
                }
                for(int j=0;j<4;j++){
                    String up = up(key, j);
                    if(!visited.contains(up)){
                        queue.add(up);
                        visited.add(up);
                    }
                    String down = down(key, j);
                    if(!visited.contains(down)){
                        queue.add(down);
                        visited.add(down);
                    }
                }
            }
            step++;
        }
return -1;
    }
    public String up(String key,int index){
        char[] chars = key.toCharArray();
        if(chars[index]=='9'){
            chars[index]='0';
        }else chars[index]+=1;
        return String.valueOf(chars);
    }

    public String down(String key,int index){
        char[] chars = key.toCharArray();
        if(chars[index]=='0'){
            chars[index]='9';
        }else chars[index]-=1;
        return String.valueOf(chars);
    }
}

方法二：双向dfs 使用集合来判断数据是否存在 即存在交集

class Solution {
      public int openLock(String[] deadends, String target) {
//双向dfs 这里不用队列了 用集合来判断交集 快速判断元素是否存在
    Set<String> start=new HashSet<>();
     Set<String> end=new HashSet<>();
        Set<String> visited=new HashSet<>();
        Set<String> dead=new HashSet<>();
for(String deadend:deadends){
    dead.add(deadend);
}
        int step=0;//记录步数
       start.add("0000");
       end.add(target);

        while(!start.isEmpty()&&!end.isEmpty()){//p1,p2两个集合不为空
        Set<String> temp=new HashSet<>();//temp存储start的扩散结果
        if(start.size()<end.size()){//先扩散更大的集合 优化算法
  Set<String> change=start;
  start=end;
  end=change;
        }
    //start时最大的集合 扩散start
 for(String s:start){
     if(dead.contains(s)){
         continue;
     }
     if(end.contains(s)){//重合了
return step;
     }

     //将每一个结点的未遍历结点放入集合
     for(int i=0;i<4;i++){
              String up = up(s, i);
                    if(!visited.contains(up)){
                        temp.add(up);
                        visited.add(up);
                    }
                    String down = down(s, i);
                    if(!visited.contains(down)){
                          temp.add(down);
                        visited.add(down);
                    }
     }
 }
      step++;
     //temp相当于q1了 交换q1和q2
     start=end;
     end=temp;
        }
return -1;
    }
    public String up(String key,int index){
        char[] chars = key.toCharArray();
        if(chars[index]=='9'){
            chars[index]='0';
        }else chars[index]+=1;
        return String.valueOf(chars);
    }

    public String down(String key,int index){
        char[] chars = key.toCharArray();
        if(chars[index]=='0'){
            chars[index]='9';
        }else chars[index]-=1;
        return String.valueOf(chars);
    }
}