TZOJ2902: 聪明的打字员（广搜bfs、模拟）

TZOJ2902: 聪明的打字员

题目传送门

描述

阿兰是某机密部门的打字员，她现在接到一个任务：需要在一天之内输入几百个长度固定为6的密码。当然，她希望输入的过程中敲击键盘的总次数越少越好。

不幸的是，出于保密的需要，该部门用于输入密码的键盘是特殊设计的，键盘上没有数字键，而只有以下六个键：Swap0, Swap1, Up, Down, Left, Right，为了说明这6个键的作用，我们先定义录入区的6个位置的编号，从左至右依次为1，2，3，4，5，6。下面列出每个键的作用：
Swap0：按Swap0，光标位置不变，将光标所在位置的数字与录入区的1号位置的数字（左起第一个数字）交换。如果光标已经处在录入区的1号位置，则按Swap0键之后，录入区的数字不变；
Swap1：按Swap1，光标位置不变，将光标所在位置的数字与录入区的6号位置的数字（左起第六个数字）交换。如果光标已经处在录入区的6号位置，则按Swap1键之后，录入区的数字不变；
Up：按Up，光标位置不变，将光标所在位置的数字加1（除非该数字是9）。例如，如果光标所在位置的数字为2，按Up之后，该处的数字变为3；如果该处数字为9，则按Up之后，数字不变，光标位置也不变；
Down：按Down，光标位置不变，将光标所在位置的数字减1（除非该数字是0），如果该处数字为0，则按Down之后，数字不变，光标位置也不变；
Left：按Left，光标左移一个位置，如果光标已经在录入区的1号位置（左起第一个位置）上，则光标不动；
Right：按Right，光标右移一个位置，如果光标已经在录入区的6号位置（左起第六个位置）上，则光标不动。
当然，为了使这样的键盘发挥作用，每次录入密码之前，录入区总会随机出现一个长度为6的初始密码，而且光标固定出现在1号位置上。当巧妙地使用上述六个特殊键之后，可以得到目标密码，这时光标允许停在任何一个位置。
现在，阿兰需要你的帮助，编写一个程序，求出录入一个密码需要的最少的击键次数。

输入

数据有一行，含有两个长度为6的数，前者为初始密码，后者为目标密码，两个密码之间用一个空格隔开。

输出

输出一行，含有一个正整数，为最少需要的击键次数。

样例输入

123456 654321

样例输出

11

解题思路

题目给出了长度为6的特殊密码，让我们通过指定的6种操作将其转换为原始密码，求最少的操作次数。可以看出这是一道广搜bfs+模拟的题目，根据题意进行模拟即可。稍微注意一下题目给出的内存范围，标记时每一位的数字还有光标位置都要记录即可。

代码

#include <bits/stdc++.h>
using namespace std;
#define ll int
#define IOS ios::sync_with_stdio(0),cin.tie(0)
struct info {
    string s;
    ll p, t;
};
bool st[10][10][10][10][10][10][7];
bool ck(string s, ll p) {
    return st[s[1] - '0'][s[2] - '0'][s[3] - '0'][s[4] - '0'][s[5] - '0'][s[6] - '0'][p];
}
void Do(string s, ll p) {
    st[s[1] - '0'][s[2] - '0'][s[3] - '0'][s[4] - '0'][s[5] - '0'][s[6] - '0'][p] = 1;
}
void solve() {
    string s1, s2; cin >> s1 >> s2;
    s1 = "." + s1;
    s2 = "." + s2;
    queue<info> q;
    q.push({s1, 1, 0});
    while (q.size()) {
        info u = q.front(); q.pop();
        string s = u.s;
        if (s == s2) {
            cout << u.t << endl;
            return;
        }
        for (int i = 1; i <= 6; ++i) {
            if(i == 1) {
                if(u.p != 1) {
                    swap(s[u.p], s[1]);
                    if(!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    swap(s[u.p], s[1]);
                }
            } else if(i == 2) {
                if(u.p != 6) {
                    swap(s[u.p], s[6]);
                    if(!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    swap(s[u.p], s[6]);
                }
            } else if(i == 3) {
                if(s[u.p] != '9') {
                    ++ s[u.p];
                    if (!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    -- s[u.p];
                }
            } else if(i == 4) {
                if(s[u.p] != '0') {
                    -- s[u.p];
                    if (!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    ++ s[u.p];
                }
            } else if(i == 5) {
                if (u.p != 1) {
                    -- u.p;
                    if(!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    ++ u.p;
                }
            } else if (i == 6) {
                if (u.p != 6) {
                    ++ u.p;
                    if(!ck(s, u.p)) {
                        Do(s, u.p);
                        q.push({s, u.p, u.t + 1});
                    }
                    -- u.p;
                }
            }
        }
    }
}
int main() {
    IOS;
//    ll t; cin >> t;
    ll t = 1;
    while (t--) solve();
    return 0;
}