spoj 839(Optimal Marks)

题意描述：一个无向图，一些顶点有权值而一些顶点却没有权值，其中图中边的权值为其关联的两个顶点的异或，现在让你在没有权值的顶点上填上权值后使得要求所有的边权之和最小，输出每个顶点的权值

题目链接：http://www.spoj.pl/problems/OPTM/

分析：考虑到边权为两个关联点权的异或，而异或仅仅只影响当前位，不影响其它的二进制位！那么要求所有边权之和最小即要求边上的两个顶点的异或值产生的代价最小，又因为异或运算的特殊性，那么可以将其拆成一位一位的看，这样拆了以后顶点的权值就可以看成为要么为0，要么为1，那么这和最小割模型相似了，因为是异或运算，所以只要求每一位的所有所有边产生的代价尽可能小，因为是异或运算所以只有当顶点的权值（这里所指的权值是0/1）不同时，则会产生代价，那么建图求割即为能产生的代价，最小割即为产生的最小代价！

建图的方法：已经有权值的顶点若该顶点的当前位为1则和源点相连，权值为无穷大，若为1则和汇点相连权值为无穷大，对于所有原边建立变成双向的有向边

详情见07年集训队刘伯涛论文

代码如下：

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int N = 550;
const int M = 3010;

struct node
{
	int x, y, nxt,c;
}edge[4*M];
int a[N][N],tag[N];
int b[N][33];
const int inf=0x3f3f3f3f;
int e,head[N];
int dep[N],que[N],cur[N];
void addedge(int u,int v,int c)
{
	edge[e].x=u;
	edge[e].y=v;
	edge[e].nxt=head[u];
	edge[e].c=c;
	head[u]=e++;

	edge[e].x=v;
	edge[e].y=u;
	edge[e].nxt=head[v];
	edge[e].c=0;
	head[v]=e++;
}

int maxflow(int s,int t)
{
	int i,j,k,front,rear,top,min,res=0;
	while(1)
	{
		memset(dep,-1,sizeof(dep));
		front=0;
		rear=0;
		que[rear++]=s;
		dep[s]=0;
		while(front!=rear)
		{
			i=que[front++];
			for(j=head[i];j!=-1;j=edge[j].nxt)
				if(edge[j].c&&dep[edge[j].y]==-1)
				{
					dep[edge[j].y]=dep[i]+1;
					que[rear++]=edge[j].y;
				
				}
		}
		if(dep[t]==-1)
			break;
		memcpy(cur,head,sizeof(head)); 
		for(i=s,top=0;;)
		{
			if(i==t)
			{
				min=inf;
				for(k=0;k<top;k++)
					if(min>edge[que[k]].c)
					{
						min=edge[que[k]].c;
						front=k;
					}
				for(k=0;k<top;k++)
				{
					edge[que[k]].c-=min;
					edge[que[k]^1].c+=min;
				}
				res+=min;
				i=edge[que[top=front]].x;
				
			}
			for(j=cur[i];cur[i]!=-1;j=cur[i]=edge[cur[i]].nxt)
				if(dep[edge[j].y]==dep[i]+1&&edge[j].c)
					break;
			if(cur[i]!=-1)
			{
				que[top++]=cur[i];
				i=edge[cur[i]].y;
			}
			else
			{
				if(top==0)
					break;
				dep[i]=-1;
				i=edge[que[--top]].x;
			}
		}
	}
	return res;
}

void dfs(int u)
{
	tag[u]=1;
	for(int i = head[u];i!=-1;i=edge[i].nxt)
	{
	   int	y=edge[i].y;
		if(edge[i].c&&tag[y]==0)
			dfs(y);
	}
}
int main()
{
	int t,n,m,w[N],flag[N];//w[i]记住第i个顶点的权值标号
	int i, u, v,k,c,j;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&n,&m);
		memset(a,0,sizeof(a));
		memset(w,0,sizeof(w));
		memset(b,0,sizeof(b));
		memset(flag,0,sizeof(flag));
		for(i=0;i<m;i++)
		{
			scanf("%d%d",&u, &v);
            a[u][v]=1;
			a[v][u]=1;
		}
		scanf("%d",&k);
		int maxbit=0;
		for(i=0;i<k;i++)
		{
			scanf("%d%d",&u,&c);
			flag[u]=1;
			w[u]=c;
			j=0;
			while(c>0)
			{
				b[u][j++]=c%2;
				c=c/2;
			}
			if(maxbit<j)
				maxbit=j;
		}

		for(i=0;i<maxbit;i++)//建图
		{
			memset(head,-1,sizeof(head));
			e = 0;
			for(j=1;j<=n;j++)
				for(k=1;k<=n;k++)
				  if(a[j][k])
					  addedge(j,k,1);
			for(j=1;j<=n;j++)
				if(flag[j]&&b[j][i])
					addedge(0,j,inf);
				else if(flag[j]&&b[j][i]==0)
					addedge(j,n+1,inf);
				maxflow(0,n+1);
				memset(tag,0,sizeof(tag));
				dfs(0);
				for(j=1;j<=n;j++)
					if(!flag[j]&&tag[j])
						b[j][i]=1;
		}
		for(i=1;i<=n;i++)
		{
			if(flag[i]==0)
		    	for(j=0;j<maxbit;j++)
					if(b[i][j])
				    	w[i]+=(1<<j);
		}
		for(i=1;i<=n;i++)
			printf("%d\n",w[i]);
	}
	return 0;
}