【二分图最佳匹配】移动棋子

重庆省选 2006

移动棋子(move)

 

在一个n*n的棋盘上有n枚棋子。每次可以把一枚棋子往上、下、左、右方向之一移动一格，最后排成一行、一列或者主、副对角线上（因此一共有2n+2条可能的目标状态），要求移动次数最小。

棋盘上有一些位置是障碍，棋子在任何时候都不能经过。棋子的初始位置保证不在障碍物上。任两枚棋子不能在同时到达   同一个格子。

【输入文件】

输入文件move.in第一行包含两个整数n, m，表示棋子的个数（它也是棋盘的边长）和障碍的个数。以下n行，每行两个整数(x, y)，表示第i个棋子的坐标（1<=x, y<=n），以下m行，每行给出一个障碍物的坐标。假设这n+m个坐标两两不重合。

 

【输出文件】

    输出文件仅包含一个整数，表示最小移动步数。如果无解，输出-1。

 

【样例】

move.in	move.out
5 1 1 2 2 4 3 4 5 1 5 3 1 1	6

 

【限制】

50%的数据满足：2<=n<=15，m=0

100%的数据满足：2<=n<=50,0<=m<=100

因为LCY的原因。。现在看到棋子，总会想到妻子。

第一次交，Wa50。但是我去看程序的时候，结果满篇都是错。。。神奇了。

只是二分图最佳匹配的题。先广搜预处理出距离（注意不能到的点距离为inf）。然后枚举每一条最后排列好的线，作为右半集，左半集固定不变为原来的点。

我把每一种情况都合并起来了，因为有变化的只是每一个排列好之后的点坐标，其他都不变，因此用了一个GETIND宏来实现。

最佳匹配权值和最小，因此初始化l数组的时候要找到左半集对应的最小的边，更新降低标准的时候也这样操作。

错误主要有：

1、内存溢出。规模为N^2，为2500，但是我算成了250。真TMD贰佰伍呀。

2、宏里面写的判断第一条对角线应该是2*N+1，写成了N+1。

3、不能到达的点距离为inf，我当做了0。

4、判断横线是否存在的时候，应该是hashx[Start-N]，写成了hashx[Start].

主要是变量名打错和下标打错。。果然是练代码能力的题。

第一次交的时候130+，第二次交190+。

#include <cstring>
#include <string>
#include <cstdio>

struct node
{
	long x;
	long y;
	long s;
};

long dx[4] = {0,1,0,-1};
long dy[4] = {1,0,-1,0};
#define GETIND(x) (\
Start<N+1?( ((x)-1)*N+Start ):(\
	Start<2*N+1?( (Start-N-1)*N+(x) ):(\
		Start==2*N+1?(((x)-1)*N+(x)):(((x)-1)*N+(N-(x)+1))\
)))

#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))

long N;long M;
long Start;
long m[5100];
node que[2600];
bool used[60][60];
bool v[5100];
long dist[60][2600];
long X[60];
long Y[60];
bool map[60][60];
long l[5100];
bool hashx[60];
bool hashy[60];
bool hashl[120];
bool hashr[120];

const long inf = 0x7f7f7f7f;

void Bfs(long u)
{
	long l = 0;
	long r = 0;
	++ r;
	que[r].x = X[u];
	que[r].y = Y[u];
	used[X[u]][Y[u]] = true;
	node next;
	
	while (l < r)
	{
		l ++;
		node now = que[l];
		
		for (long i=0;i<4;i++)
		{
			#ifdef Debug
			if (l == 371 )
			{
				printf("L;%ld 374;%ld\n",l,que[374].x);
			}
			#endif
			next.x = now.x + dx[i];
			next.y = now.y + dy[i];
			if (!map[next.x][next.y] && !used[next.x][next.y])
			{
				used[next.x][next.y] = true;
				next.s = now.s + 1;
				dist[u][(next.x-1)*N+next.y] = next.s;
				r ++ ;
				que[r] = next;
			}
		}
	}
}

bool KM(long u)
{
	v[u] = true;
	
	for (long i=N+1;i<2*N+1;i++)
	{
		long tmp = GETIND(i-N);
		if (!v[i] && l[u]+l[i] == dist[u][GETIND(i-N)] && dist[u][GETIND(i-N)]>-1)
		{
			v[i] = true;
			if (!m[i] || KM(m[i]))
			{
				m[i] = u;
				return true;
			}
		}
	}
	return false;
}

int main()
{
	freopen("move.in","r",stdin);
	freopen("move.out","w",stdout);
	scanf("%ld%ld",&N,&M);
	for (long i=1;i<N+1;i++)
	{
		long x;long y;
		scanf("%ld%ld",&x,&y);
		X[i] = x;
		Y[i] = y;
	}
	for (long i=1;i<M+1;i++)
	{
		long x;long y;
		scanf("%ld%ld",&x,&y);
		map[x][y] = true;
		hashx[x] = hashy[y] = hashl[x+y] = hashr[x-y+N] = true;
	}
	for (long i=0;i<N+2;i++)
	{
		map[0][i] = map[i][0] = map[i][N+1] = map[N+1][i] = true;
	}
	
	memset(dist,0x80,sizeof(dist));
	for (long i=1;i<N+1;i++)
	{
		memset(used,0,sizeof(used));
		Bfs(i);
		dist[i][(X[i]-1)*N+Y[i]] = 0;
	}
	
	long ans = inf;
	for (Start=1;Start<2*N+3;Start++)
	{	
		if (Start < N+1)
		{	
			if (hashy[Start])
				continue;	
		}
		else if (Start < 2*N+1)
		{
			if (hashx[Start-N])
				continue;
		}
		else if (Start == 2*N+1)
		{
			if (hashr[N])
				continue;
		}
		else
		{
			if (hashl[1+N])
				continue;
		}
		memset(l,0,sizeof(l));
		memset(m,0,sizeof(m));
		
		for (long i=1;i<N+1;i++)
		{
			l[i] = inf;
			for (long j=N+1;j<2*N+1;j++)
			{
				long ind = GETIND(j-N);
				if (dist[i][ind] > -1)
					l[i] = MIN(l[i],dist[i][ind]);
			}
		}
		
		for (long k=1;k<N+1;k++)
		{
			while (1)
			{
				memset(v,0,sizeof(v));
				if (KM(k)) break;
				
				long d = -inf;
				for (long i=1;i<N+1;i++)
				if (v[i])
					for (long j=N+1;j<2*N+1;j++)
					if (!v[j])
						if (l[i]+l[j]-dist[i][GETIND(j-N)] > d && dist[i][GETIND(j-N)]>-1)
							d = l[i]+l[j]-dist[i][GETIND(j-N)];
				for (long i=1;i<N+1;i++)
					if (v[i]) l[i] -= d;
				for (long i=N+1;i<2*N+1;i++)
					if (v[i]) l[i] += d;
			}
		}
		long _ans = 0;
		for (long i=N+1;i<2*N+1;i++)
		{
			_ans += dist[m[i]][GETIND(i-N)];
		}
		ans = MIN(ans,_ans);
	}
	
	printf("%ld",ans);
}