SPOJ_839_OPTM

最小割，该题因为要求XOR后的最小值，我们可以通过二进制的知识知道，XOR后的结果各个位置上是互不影响的，XOR只有在两数不同的时候才会得到1.

于是，我们在建图的时候可以将原图G中每个点属于V拆成31位，每位成为一个点，属于同一位的所有点构成一副新图G‘.

假如新图中任意两位所属的原图中的点相连，那么将新图中这两点连一条容量为1的边.

另外如果该位为已知位，假如它是1，那么将它与原点连一条容量为INF的边，如果它是0，那么将它与汇点连一条容量为INF的边。

对于未知位，将它与原点和汇点分别连一条容量为1的边.

最后做一遍最大流，然后从原点出发做一遍DFS，找到与原点相连的点，找到这些点中属于未知位的点，将他们赋值为1，并更新到原图节点。

之所以满足最小割模型是因为，我们要保证每一位要不是1（与原点相连），要不就是0（与汇点相连），又要保证他们XOR出来的值最小。因为他们XOR出来的值=（Mincut - |v|)*2^x(|v|代表未知位的个数，x代表第几位），从这个公式可以知道，只要保证了最小割，那么它XOR出来的值必然最小，所以可以用最小割求解。

/*
 *NAME: OPTM
 *LANG: C++
 */
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#define INF 0x7FFFFFFF
using namespace std;

int tt,n,m,s,t,ans,edgeNum;
struct node{
    int x,y;
}link_fuck[100001];//表示大点边的相连情况
int p[5001],pp[5001],ppp[5001];//p表示该节点数字，pp表示该节点剩余数字
struct edge_node{
    int v,c,next;
}e[100000];//边集数组
int v[5000],d[5000],c[5000];//v储存边集，d储存深度，c储存该层节点数
bool cover[5001];

void insert(int a,int b,int c){
    edgeNum++;
    e[edgeNum].v=b;e[edgeNum].c=c;e[edgeNum].next=v[a];v[a]=edgeNum;
    edgeNum++;
    e[edgeNum].v=a;e[edgeNum].c=0;e[edgeNum].next=v[b];v[b]=edgeNum;
}
void graphInit(){
    s=n+1;t=n+2;edgeNum=0;
    memset(cover,false,sizeof(cover));
    memset(v,0,sizeof(v));
    memset(d,0,sizeof(d));
    memset(c,0,sizeof(c));
    memset(e,0,sizeof(e));
}
void graphMake(){
    for (int i=1;i<=n;++i)
	if (p[i]==-1)
	    insert(s,i,1),insert(i,t,1);
	else{
	    int tmp = pp[i] % 2;pp[i]/=2;
	    tmp==1?insert(s,i,INF):insert(i,t,INF);
	}
    for (int i=1;i<=m;++i)
	insert(link_fuck[i].x,link_fuck[i].y,1),insert(link_fuck[i].y,link_fuck[i].x,1);
}
void update(int len,int pos){
    cover[pos]=true;
    int tmp=v[pos];
    while (tmp>0){
	if (!cover[e[tmp].v] && e[tmp].c>0){
	    if (p[e[tmp].v]==-1)
		ppp[e[tmp].v]+=pow(2,len);
	    update(len,e[tmp].v);
	}
	tmp=e[tmp].next;
    }
}
int opp(int x){
    return (x%2==1)?x+1:x-1;
}
int maxflow(int x,int lim){
    int ret,min_num,i,j,max_flow;
    if (x==t) return lim;
    max_flow=0;min_num=t;
    j=v[x];
    while (j!=0){
	if (e[j].c>0){
	    if (d[e[j].v]+1==d[x]){
		ret=min(lim,e[j].c);
		ret=maxflow(e[j].v,ret);
		e[j].c-=ret;e[opp(j)].c+=ret;
		lim-=ret;max_flow+=ret;
		if (d[s]>=t) return max_flow;
	    }
	    min_num=min(min_num,d[e[j].v]+1);
	}
	j=e[j].next;
    }
    if (d[x]==min_num) return max_flow;
    --c[d[x]];
    if (c[d[x]]==0) d[s]=t;
    d[x]=min_num;++c[d[x]];
    return max_flow;
}
void init(){
    scanf("%d %d",&n,&m);memset(link_fuck,0,sizeof(link_fuck));
    for (int i=1;i<=m;++i) scanf("%d %d",&link_fuck[i].x,&link_fuck[i].y);
    int know;scanf("%d",&know);memset(p,0,sizeof(p));
    for (int i=0,a,b;i<know;++i){scanf("%d %d",&a,&b);p[a]=b;}
    for (int i=1;i<=n;++i) {ppp[i]=pp[i]=p[i];if (!p[i]) p[i]-=1;}
}
void print(){
    for (int i=1;i<=n;++i) 
	printf("%d\n",ppp[i]);
}
int main(){
    scanf("%d",&tt);
    for (int k=1;k<=tt;++k){
	init();
	//solve
	for (int i=0;i<=31;++i){
	    //makeGraph
	    graphInit();
	    graphMake();
	    //get minCut
	    c[0]=n+2;ans=0;
	    while (d[s]<t) ans+=maxflow(s,INF);
	    //update
	    update(i,s);
	}
	print();
    }
    return 0;
}