题目链接：https://vjudge.net/problem/SPOJ-OPTM

题意：给定一个无向图，每个顶点都有对应值，每条边的权值为val[u] ^ val[u]，同时已知其中某些点的值，求其他点的权值使得最终的图的边权和最小？

解法：首先将mark拆成31位来看待，对每一位都进行一次求解。于是问题就变成了顶点的标号可以为1也可以为0，边权和最小的问题，于是按标号为1或者为0就可以把顶点划分成两个集合，而连通这两个集合的边的数量就是我们需要累加的边权，为了让数量最少，于是就变成了最小割问题。 这样我们将S和所有mark为1的点连起来，容量为INF，将所有mark为0的点和T连起来，容量为INF，至于那些还没标号的点就不和源点汇点连了，他们的标号取决于做完最小割之后属于哪个集合。接着将其他边建好，容量为1，之后就可以做最大流了，做完最大流后从S出发沿容量不为0的边走所能到达的点都是属于mark为1的这个集合的。


#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 510;
const int maxm = 100010;
const int inf = 0x3f3f3f3f;
struct G
{
    int v, cap, next;
    G() {}
    G(int v, int cap, int next) : v(v), cap(cap), next(next) {}
} E[maxm];
struct Edge{
    int x, y;
}edge[maxm];
struct List{
    int id, mark;
}lable[maxm];
int p[maxn], T;
int n, m, k, source, sink, mark[maxn], vis[maxn];
int d[maxn], temp_p[maxn], qw[maxn]; //d顶点到源点的距离标号,temp_p当前狐优化，qw队列
void init()
{
    memset(p, -1, sizeof(p));
    T = 0;
}
void add(int u, int v, int cap)
{
    E[T] = G(v, cap, p[u]);
    p[u] = T++;
    E[T] = G(u, 0, p[v]);
    p[v] = T++;
}
bool bfs(int st, int en, int nn)
{
    int i, u, v, head, tail;
    for(i = 0; i <= nn; i++) d[i] = -1;
    head = tail = 0;
    d[st] = 0;
    qw[tail] = st;
    while(head <= tail)
    {
        u = qw[head++];
        for(i = p[u]; i + 1; i = E[i].next)
        {
            v = E[i].v;
            if(d[v] == -1 && E[i].cap > 0)
            {
                d[v] = d[u] + 1;
                qw[++tail] = v;
            }
        }
    }
    return (d[en] != -1);
}
int dfs(int u, int en, int f)
{
    if(u == en || f == 0) return f;
    int flow = 0, temp;
    for(; temp_p[u] + 1; temp_p[u] = E[temp_p[u]].next)
    {
        G& e = E[temp_p[u]];
        if(d[u] + 1 == d[e.v])
        {
            temp = dfs(e.v, en, min(f, e.cap));
            if(temp > 0)
            {
                e.cap -= temp;
                E[temp_p[u] ^ 1].cap += temp;
                flow += temp;
                f -= temp;
                if(f == 0)  break;
            }
        }
    }
    return flow;
}
int dinic(int st, int en, int nn)
{
    int i, ans = 0;
    while(bfs(st, en, nn))
    {
        for(i = 0; i <= n; i++) temp_p[i] = p[i];
        ans += dfs(st, en, inf);
    }
    return ans;
}
void build(int cur){
    init();
    for(int i=1; i<=m; i++) add(edge[i].x,edge[i].y,1), add(edge[i].y,edge[i].x,1);
    for(int i=1; i<=k; i++){
        if((lable[i].mark>>cur)&1) add(source, lable[i].id, inf);
        else add(lable[i].id, sink, inf);
    }
}
void DFS(int cur, int k){
    vis[cur] = 1;
    mark[cur] |= (1<<k);
    for(int i = p[cur]; ~i; i=E[i].next){
        if(!vis[E[i].v]&&E[i].cap)
            DFS(E[i].v, k);
    }
}
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d %d", &n,&m);
        for(int i=1; i<=m; i++) scanf("%d %d", &edge[i].x,&edge[i].y);
        scanf("%d", &k);
        for(int i=1; i<=k; i++) scanf("%d %d", &lable[i].id, &lable[i].mark);
        source = 0, sink = n+1;
        LL ans = 0;
        memset(mark, 0, sizeof(mark));
        for(int i=0; i<31; i++){
            build(i);
            ans += dinic(source, sink, sink+1) * (1LL<<i);
            memset(vis, 0, sizeof(vis));
            DFS(source, i);
        }
        for(int i=1; i<=n; i++) printf("%d\n", mark[i]);
    }
}