hiho #1308 : 搜索二·骑士问题

#1308 : 搜索二·骑士问题

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi：小Ho你会下国际象棋么？

小Ho：应该算会吧，我知道每个棋子的移动方式，马走日象飞田什么的...

小Hi：象飞田那是中国象棋啦！

小Ho：哦，对。国际象棋好像是走斜线来着。

小Hi：不过马走日倒是对了。国际象棋中的马一般叫做骑士，关于它有个很有意思的问题。

小Ho：什么啊？

小Hi：骑士巡游问题，简单来说就是关于在棋盘上放置若干个骑士，然后探究移动这些骑士是否能满足一定的而要求。举个例子啊：一个骑士从起始点开始，能否经过棋盘上所有的格子再回到起点。

小Ho：哦，看上去好像很难的样子。

小Hi：其实也还好了。简单一点的比如棋盘上有3个骑士，能否通过若干次移动走到一起。

小Ho：能够么？

小Hi：当然能够了。由于骑士特殊的移动方式，放置在任何一个初始位置的骑士，都可以通过若干次移动到达棋盘上任意一个位置。

小Ho：那么只要选定一个位置，把它们全部移动过去就好了是吧？

小Hi：是的，那么这里又有另一个问题了：要选择哪一个位置汇合，使得3个骑士行动的总次数最少？

小Ho：嗯，这个好像不是很难，让我想一想。

提示：骑士问题

输入

第1行：1个正整数t，表示数据组数，2≤t≤10。

第2..t+1行：用空格隔开的3个坐标, 每个坐标由2个字符AB组成，A为'A'~'H'的大写字母，B为'1'~'8'的数字，表示3个棋子的初始位置。

输出

第1..t行：每行1个数字，第i行表示第i组数据中3个棋子移动到同一格的最小行动步数。

样例输入

2
A1 A1 A1
B2 D3 F4

样例输出

0
2

 

思路：

利用队列做bfs，求出当前位置到棋盘上所有位置的最短距离，然后，三个棋子到棋盘位置的最短距离和

 

AC代码：

#include "iostream"
#include "string.h"
#include "queue"

using namespace std;

typedef pair<int, int> pii;
char ss[3];
int vis[3][8][8];
int d[8][2] = { { -2,1 },{ -2,-1 },{ -1,-2 },{ -1,2 },{ 2,-1 },{ 2,1 },{ 1,-2 },{ 1,2 } };
int step = 0;

pii pos; //马位置

bool in(pii p)
{
    if (p.first < 0 || p.second < 0 || p.first>7 || p.second>7)
        return false;
    else
        return true;
}

void bfs(int vi[8][8])
{
    step = 0;
    queue<pii> q;
    memset(vi, -1, 256);
    q.push(pos);
    vi[pos.first][pos.second] = 0;

    while (!q.empty())
    {
        pii pfront = q.front();
        q.pop();
        for (int i = 0; i < 8; i++)
        {
            pii temp;
            temp.first = pfront.first + d[i][0];
            temp.second = pfront.second + d[i][1];
            if (in(temp) && vi[temp.first][temp.second] == -1)
            {
                vi[temp.first][temp.second] = vi[pfront.first][pfront.second] + 1;
                q.push(temp);
            }
        }
    }
}

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        scanf("%s", ss);
        pos = make_pair(ss[0] - 'A', ss[1] - '1');
        bfs(vis[0]);

        scanf("%s", ss);
        pos = make_pair(ss[0] - 'A', ss[1] - '1');
        bfs(vis[1]);

        scanf("%s", ss);
        pos = make_pair(ss[0] - 'A', ss[1] - '1');
        bfs(vis[2]);

        int ans = 1e9;
        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                int temp = 0;
                for (int k = 0; k < 3; k++)
                {
                    temp += vis[k][i][j];
                }
                if (temp < ans)
                    ans = temp;                
            }            
        }
        cout << ans << endl;        
    }
}

 

补充：

提供另一种思路，因为是8x8的棋盘，可以模拟成8进制的一个数，这样3个旗子就是一个6位的8进制数。

由此可以通过一个大小为8^6的布尔数组来进行状态的判重。而每一次的状态转移也从原来的仅枚举8个方向，变成了枚举骑士加枚举方向，一共有3*8=24种可能。

此方法的伪代码为：

queue.push( initialStatus ) // 将初始的8进制数加入队列中
while (!queue.isEmpty())
	now_status = queue.pop()	// 弹出队列头元素
	For i = 1 .. 3
	// 枚举移动的其实
		For j = 1 .. 8
		// 枚举8种可能的移动
		next_status = move(now_status, i, j)	// 移动骑士并记录状态	
		If (next_status is valid AND not visited[ next_status ])
			step[ next_status ] = step[ now_status ] + 1
			queue.push( next_status )
			If (check(next_status)) Then
				// 检查这个八进制数是否满足3个坐标重合
				Return step[ next_status ]
			End If 
		End If
	End For
End While

在进行检查是否已经走到一起时，可以通过一个位运算来做：

check(status):
	Return ((status and 0x3f) == ((status rsh 6) and 0x3f)) and (((status rsh 6) and 0x3f) == ((status rsh 12) and 0x3f))
	// rsh表示右移操作

小Ho：哦，这样就可以不用计算出每个骑士走到每个点的步数，而是在过程中就有可能直接求解到最先汇合位置的步数。

小Hi：对，不过这个算法中状态的转移会稍微复杂一点。你可以选择一个你比较喜欢的方法来实现。

小Ho：好！