Open the Lock(bfs)

Question

Now an emergent task for you is to open a password lock. The password is consisted of four digits. Each digit is numbered from 1 to 9.
Each time, you can add or minus 1 to any digit. When add 1 to ‘9’, the digit will change to be ‘1’ and when minus 1 to ‘1’, the digit will change to be ‘9’. You can also exchange the digit with its neighbor. Each action will take one step.
Now your task is to use minimal steps to open the lock.
Note: The leftmost digit is not the neighbor of the rightmost digit.

Input

The input file begins with an integer T, indicating the number of test cases.
Each test case begins with a four digit N, indicating the initial state of the password lock. Then followed a line with anotther four dight M, indicating the password which can open the lock. There is one blank line after each test case.

Output

For each test case, print the minimal steps in one line.

Simple Input

2
1234
2144

---

1111
9999

Simple Output

2
4

Code

#include 
#include 
#include 
#include 
using namespace std;
int ab[10][10][10][10];
int a[5], b[5];
struct node
{
    int a[5];
    int step;
};
int judge1(node mid)
{
    if (ab[mid.a[1]][mid.a[2]][mid.a[3]][mid.a[4]] == 1)
        return 1;
    else
        return 0;
}
void bfs()
{
    queueq;
    node start, mid, next;
    for (int i = 1; i < 5; i++)
        start.a[i] = a[i];
    start.step = 0;
    q.push(start);
    while (!q.empty())
    {
        int flage = 1;
        mid = q.front();
        q.pop();
        if (judge1(mid))
            continue;
        ab[mid.a[1]][mid.a[2]][mid.a[3]][mid.a[4]] = 1;
        //判断是否访问过该点。
        for (int i = 1; i < 5;i++)
        if (mid.a[i] != b[i])
        {
            flage = 0;
            break;
        }
        if (flage)
        {
            cout << mid.step << endl;
            return ;
        }
        for (int i = 1; i < 5; i++)
        {
            if (i < 4)
            {
                next = mid;//实现加运算
                next.a[i]++;
                if (next.a[i] == 10)
                    next.a[i] = 1;
                next.step++;
                q.push(next);
                next = mid;//实现减运算
                next.a[i]--;
                if (next.a[i] == 0)
                    next.a[i] = 9;
                next.step++;
                q.push(next);
                next = mid;//实现交换运算
                next.a[i] = mid.a[i + 1];
                next.a[i + 1] = mid.a[i];
                next.step++;
                q.push(next);
            }
            else if (i == 4)
            //由于交换运算我们只考虑当前位置和下一位置的交换。
            //故当运算到第四个数事不再进行交换运算。
            {
                next = mid;
                next.a[i]++;
                if (next.a[i] == 10)
                    next.a[i] = 1;
                next.step++;
                q.push(next);
                next = mid;
                next.a[i]--;
                if (next.a[i] == 0)
                    next.a[i] = 9;
                next.step++;
                q.push(next);
            }
        }
    }
    return ;
}

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        string c;
        cin >> c;
        for (int i = 1; i <= 4; i++)
            a[i] = c[i - 1] - 48;
        cin >> c;
        for (int j = 1; j <= 4; j++)
            b[j] = c[j - 1] - 48;
        memset(ab, 0, sizeof(ab));
        bfs();
    }

    return 0;
}

bfs学习小结：
bfs问题关键在于对已访问的位置的记录，一般讨论的数串有几位就要开几维的数组，若是访问的对象只需遍历一遍即可，则开与访问对象相同大小的数组记录即可。