leetcode 752——打开转盘锁

题目描述：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/open-the-lock
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题一：bfs

class Solution {
public:
    int openLock(vector<string>& deadends, string target) 
    {
        const string start ="0000";     //初始状态
        unordered_set<string> dead(deadends.begin(),deadends.end());    //将死亡数字存储到unordered_set中
        if(dead.count(start)) return -1;   //开始状态就是死亡数字
        if(target == start) return 0;      //开始状态就是密码
        
        unordered_set<string> visited;
        visited.insert(start);
        queue<string> q;
        q.push(start);
        int steps = 0;

        while(!q.empty())
        {
            steps++;
            const int size = q.size();//接收一下size,后面size的值会改变
            for(int i = 0;i < size ; i++)
            {
                const string curNode = q.front(); q.pop();
                for(int i=0;i<4;i++)
                {
                    for(int j=-1;j<=1;j+=2)
                    {
                        string nextNode = curNode;
                        nextNode[i] = (nextNode[i]-'0'+j+10)%10+'0';
                        if(nextNode == target) return steps;
                        if(visited.count(nextNode)||dead.count(nextNode)) continue;
                        q.push(nextNode);
                        visited.insert(nextNode);
                    }
                }
            }
        }
        return -1;
    }
};

解题二：双向bfs

//双向bfs
class Solution {
public:
	int openLock(vector<string>& deadends, string target) 
	{
		const string start = "0000";
		unordered_set<string> dead(deadends.begin(), deadends.end());
		if (dead.count(start)) return -1;
		if (target == start) return 0;

		queue<string> q1;
		queue<string> q2;
		unordered_set<string> v1{ start };
		unordered_set<string> v2{ target };

		int s1 = 0;
		int s2 = 0;
		q1.push(start);
		q2.push(target);
		while (!q1.empty() && !q2.empty())
		{
			if (!q1.empty()) ++s1;
			const int size = q1.size();
			for (int i = 0; i < size; ++i) 
			{
				const string curr = q1.front();
				q1.pop();
				for (int i = 0; i < 4; ++i)
					for (int j = -1; j <= 1; j += 2)
					{
						string next = curr;
						next[i] = (next[i] - '0' + j + 10) % 10 + '0';
						if (v2.count(next)) return s1 + s2;
						if (dead.count(next) || v1.count(next)) continue;
						q1.push(next);
						v1.insert(next);
					}
			}
			swap(q1, q2);
			swap(v1, v2);
			swap(s1, s2);
		}

		return -1;
	}
};

解题三：双向bfs+int状态+动态数组

//双向bfs+int状态+动态数组
class Solution {
public:
  int openLock(vector<string>& deadends, string target) {
    constexpr int kMaxN = 10000;
    const vector<int> bases{1, 10, 100, 1000};
    const int start = 0;
    const int goal = stoi(target);
    
    queue<int> q1;
    queue<int> q2;
    vector<int> v1(kMaxN, 0);
    vector<int> v2(kMaxN, 0);  
    for (const string& deadend : deadends)
        v1[stoi(deadend)] = v2[stoi(deadend)] = -1;
    
    if (v1[start] == -1) return -1;
    if (start == goal) return 0;
    
    v1[start] = 1;
    v2[goal] = 1;
    
    int s1 = 0;
    int s2 = 0;
    q1.push(start);
    q2.push(goal);
    while (!q1.empty() && !q2.empty()) {      
      if (!q1.empty()) ++s1;
      const int size = q1.size();
      for (int i = 0; i < size; ++i) {
        const int curr = q1.front(); 
        q1.pop();
        for (int i = 0; i < 4; ++i) {
          int r = (curr / bases[i]) % 10;
          for (int j = -1; j <= 1; j += 2) {
            const int next = curr + ((r + j + 10) % 10 - r) * bases[i];
            if (v2[next] == 1) return s1 + s2;
            if (v1[next]) continue;            
            q1.push(next);
            v1[next] = 1;
          }
        }
      }
      swap(q1, q2);
      swap(v1, v2);
      swap(s1, s2);
    }    
    return -1;
  }
};