【C++学习笔记】队列和广度优先搜索——打开转盘锁

题目：打开转盘锁

题目来源：https://leetcode.cn/leetbook/read/queue-stack/kj48j/

题目内容：

• 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。
• 锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。
• 列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。
• 字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

• 输入：deadends = ["0201","0101","0102","1212","2002"], target = "0202"
  输出：6
  解释：
  可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。
  注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的，
  因为当拨动到 "0102" 时这个锁就会被锁定。

C++代码实现：方法一

 将"0000"放入初始序列queue中，建立hashset

class Solution {
public:
    bool finddeadlock(vector<string>& deadends,string target){
        vector<string>::iterator iter=find(deadends.begin(),deadends.end(),"0000");
        if(iter==deadends.end()) return false;
        return true;
    }
    int openLock(vector<string>& deadends, string target) {
        int res=0;
        queue<string> team;
        unordered_set<string> hashset;
        if(finddeadlock(deadends,"0000")) return -1;//如果死亡序列里有0000，直接错误
        team.push("0000");//将初始值放入队列
        hashset.insert(deadends.begin(),deadends.end());//将全部的死亡序列放入哈希表
        while(!team.empty()){
            int length=team.size();
            for(int i=0;i<length;++i){
                string cur=team.front();//取队列中第一个解
                team.pop();
                if(cur==target) return res;//找到答案就返回
                for(int j=0;j<4;++j){//对四个密码锁进行值的改变
                    for(int k=-1;k<=1;k=k+2){//改变只有+1，-1两种可能
                        string temp=cur;
                        temp[j]=(cur[j]-'0'+10+k)%10+'0';//对每个密码锁更新值
                        if(hashset.count(temp)==0){//如果新的值不在哈希表里
                            hashset.insert(temp);//加入哈希表
                            team.push(temp);//加入队列
                        }
                    }
                }
            }
            res++;
        }
        return -1;
    }
};

C++代码实现：方法二

加一减一两种情况，方法一写在了一块，方法二分开列举。

class Solution {
public:
    int openLock(vector<string>& deadends, string target) {
        if(target=="0000") return 0;
        for(auto& d:deadends) lock.emplace(d);
        if(lock.count("0000")) return -1;
        return bfs(target);
    }

private:
    unordered_set<string> lock;
    int times = 0;
    int bfs(string target){
        queue<string> q;
        q.emplace("0000");
        lock.emplace("0000");
        while(!q.empty()){
           
            for(int i = q.size();i>0;i--){
                string cur = q.front();
                q.pop();
                if(cur==target) return times;

                for(int i = 0;i < 4;i++){
                    string s = cur;
                    s[i] = s[i]=='9' ? '0' : s[i]+1;
                    if(lock.count(s)==0) {
                        q.emplace(s);
                        lock.emplace(s);
                    }
                }
                for(int i = 0;i < 4; i++){
                    string s = cur;
                    s[i] = s[i]=='0' ? '9' : s[i]-1;
                    if(lock.count(s)==0){
                        q.emplace(s);
                        lock.emplace(s);
                    }
                }
            }
            times += 1;
        }
        return -1;
    }
};