poj 1178 Camelot floyd + 枚举

参照：http://wenku.baidu.com/view/daea9f6a561252d380eb6e06.html

http://www.cppblog.com/mythit/archive/2009/07/02/89123.html

题目大意：8*8的格子上，有一个国王和若干个骑士，骑士能走日字格，国王能走到其相邻的8个格子。

骑士走到国王的格子时，可以带着国王走，求国王和所有骑士相聚在一个格子所需的最少步数。

解题思路：floyd+枚举

先用floyd算法求出骑士在i位置到到j位置的最少步数knight[i][j], 还有国王在位置i到位置j的最少步数king[i][j]

枚举坐标上的每个位置节点。

先求出每个骑士到达这个枚举的点k时的总的步数，s = sum(knight[kn[i]][k])

kn[i]表示骑士i的位置坐标。

然后枚举国王到达位置w时，然后由一个骑士g带到终点k时的最少步数

king[pos][w] + knight[kn[g]][w] + knight[w][k]，然后和之前的s相加，相加时记得把g在s中剔除，要减去knight[kn[g]][k]因为g骑士充当携带了国王的角色，然后求出这些和的最小值即为所求。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn = 64;
char str[150];
int kn[maxn], king[maxn][maxn], knight[maxn][maxn];

int move1[8][2]={{-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}};
int move2[8][2]={{-1,-2}, {-2,-1}, {-2,1}, {-1,2}, {1,2}, {2,1}, {2,-1}, {1,-2}};

void init(int array[][maxn], int move[][2]);
void floyd(int array[][maxn]);

int main()
{
	
	init(king, move1);
	init(knight, move2);
	floyd(king);
	floyd(knight);
	
	while(scanf("%s", str) != EOF)
	{
		int len = strlen(str);
		int pos = (str[1] - '1') * 8 + (str[0] - 'A');
		int index = 0;
		for(int i = 2; i < len; i += 2)
			kn[index++] = (str[i + 1] - '1') * 8 + (str[i] - 'A');
			
		int ans = 0x7fffffff;	
		for(int i = 0; i < maxn; i++)
		{
			int s = 0;
			for(int k = 0; k < index; k++)
				s += knight[kn[k]][i];
			for(int j = 0; j < maxn; j++)
			{
				int t1 = king[pos][j];
				int t2 = 0x7fffffff;;
				for(int k = 0; k < index; k++)
					t2 = min(t2, knight[kn[k]][j] + knight[j][i] - knight[kn[k]][i]);
				ans = min(ans, s + t2 + t1);
			}
		}
		printf("%d\n", ans);
	}
	
	return 0;
}

void init(int array[][maxn], int move[][2])
{
	for(int i = 0; i < maxn; i++)
	{
		for(int j = 0; j < maxn; j++)
			array[i][j] = -1;
	}
	for(int i = 0; i < maxn; i++)
	{
		array[i][i] = 0;
		int x = i / 8, y = i % 8;
		for(int k = 0; k < 8; k++)
		{
			int tx = x + move[k][0], ty = y + move[k][1];
			if(tx >= 0 && tx < 8 && ty >= 0 && ty < 8)
				array[i][tx * 8 + ty] = 1;
		}
	}
}

void floyd(int array[][maxn])
{
	for(int k = 0; k < maxn; k++)
	{
		for(int i = 0; i < maxn; i++)
		{
			for(int j = 0; j < maxn; j++)
			{
				if(array[i][k] != -1 && array[k][j] != -1)
				{
					if(array[i][j] == -1)
						array[i][j] = array[i][k] + array[k][j];
					else
						array[i][j] = min(array[i][j], array[i][k] + array[k][j]);
				}
			}
		}
	}
}