OPTM-Optimal Marks-SPOJ839最小割

You are given an undirected graph G(V, E). Each vertex has a mark which is an integer from the range [0..231 – 1]. Different vertexes may have the same mark.

For an edge (u, v), we define Cost(u, v) = mark[u] xor mark[v].

Now we know the marks of some certain nodes. You have to determine the marks of other nodes so that the total cost of edges is as small as possible.

Input

The first line of the input data contains integer T (1 ≤ T ≤ 10) - the number of testcases. Then the descriptions of T testcases follow.

First line of each testcase contains 2 integers N and M (0 < N <= 500, 0 <= M <= 3000). N is the number of vertexes and M is the number of edges. Then M lines describing edges follow, each of them contains two integers u, v representing an edge connecting u and v.

Then an integer K, representing the number of nodes whose mark is known. The next K lines contain 2 integers u and p each, meaning that node u has a mark p. It’s guaranteed that nodes won’t duplicate in this part.

Output

For each testcase you should print N lines integer the output. The Kth line contains an integer number representing the mark of node K. If there are several solutions, you have to output the one which minimize the sum of marks. If there are several solutions, just output any of them.

Example

Input:
1
3 2
1 2
2 3
2
1 5
3 100

Output:
5
4
100

在Amber的最小割论文上看到的一道题。


考虑到是异或运算求最小cost之和，因为对于二进制，各个位之间是互不影响的，因此能够将问题转会为每一个二进制位的求解，而后求和便可。对于每一个二进制位，要么为0，要么为1, 就想到将整个图切割成两个点
集，即对于每一个点，都只有两种取值，能够当作是要将点集划分红两类。在这种分类思想的指导下，从新考察操做的意义：对于边的两个端点，若它们同类则边权无值；若它们异类则边权有值1。
建一源点S，汇点T
对于已经标号过的点：
1. 对于位为1的点建边 < S, V, INF, 0>
2. 对于位为0的点建边 < V, T, INF, 0>
对于全部的原边
建成流量为1的双向边< u, v, 1, 1>
这样求得最小割，即为当前位的最优解。
这样建边，求最小割时，保证了割边都是原边，求完后，全部与S相连的点能够标号为1, 全部与T相连的边标号为0, 那么这些割边即为相邻点异类的边，同时保证了他们的和最小。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;

const int MaxN = 550;

const int MaxM = 3100;

typedef struct node
{
    int u,v;
}Point;

typedef struct Node
{
    int v,next,cap;
}edge ;

Point a[MaxM];

edge e[MaxM*10];

int mark[MaxN],vis[MaxN],Ans[MaxN];

int H[MaxN];

int n,m,k,s,t,top;

void AddEdge(int u,int v,int w1,int w2)
{
    e[top].v = v; e[top].cap = w1;

    e[top].next = H[u]; H[u]= top++;

    e[top].v = u; e[top].cap = w2;

    e[top].next = H[v]; H[v] = top++;
}

bool BFS()
{
    memset(vis,0,sizeof(vis));

    queue<int>Q;

    vis[s] = 1;

    Q.push(s);

    while(!Q.empty())
    {
        int  u =Q.front();

        Q.pop();

        for(int i=H[u];~i;i=e[i].next)
        {
            if(e[i].cap>0&&!vis[e[i].v])
            {
                vis[e[i].v] = vis[u]+1;

                Q.push(e[i].v);
            }
        }
    }

    return vis[t];
}

int DFS(int u,int cap)
{
    if(u==t)
    {
        return cap;
    }

    int ans = 0;

    for(int i=H[u];~i;i=e[i].next)
    {
        if(e[i].cap>0&&vis[e[i].v]==vis[u]+1)
        {
            int ant = DFS(e[i].v,min(e[i].cap,cap));

            ans += ant;

            cap -= ant;

            e[i].cap-=ant;

            e[i^1].cap+=ant;

            if(cap==0)
            {
                break;
            }
        }
    }

    return ans;
}

void Dinic()
{
    while(BFS())
    {
        DFS(s,INF);
    }
}

void dfs(int u,int bite)
{
    vis[u] = 1;

    Ans[u]+=bite;

    for(int i = H[u];i!=-1;i=e[i].next)//和S相连都为1
    {
        if(e[i].cap>0&&!vis[e[i].v])
        {
            dfs(e[i].v,bite);
        }
    }
}
void Solve()
{
    int bite=1;

    memset(Ans,0,sizeof(Ans));

    while(1)
    {
        top = 0;

        memset(H,-1,sizeof(H));

        for(int i=1;i<=m;i++)
        {
            AddEdge(a[i].u,a[i].v,1,1);
        }

        bool flag=false;

        for(int i=1;i<=n;i++) //以每一位求一次最小割
        {
            if(mark[i]!=-1)
            {
                if(mark[i]>=1)
                {
                    flag=true;
                }
                if(mark[i]%2)
                {
                    AddEdge(s,i,INF,0);
                }
                else
                {
                    AddEdge(i,t,INF,0);
                }

                mark[i]>>=1;
            }
        }

        if(!flag)//都为零的时候算法结束
        {
            break;
        }

        Dinic();

        memset(vis,0,sizeof(vis));

        dfs(s,bite);

        bite<<=1;
    }

    for(int i=1;i<=n;i++)
    {
        if(i!=1) printf(" ");

        printf("%d",Ans[i]);
    }
    puts("");
}

int main()
{
    int T;

    scanf("%d",&T);

    int u,v,w;

    while(T--)
    {
        scanf("%d %d",&n,&m); 

        s=0,t=n+1;

        for(int i=1;i<=m;i++) scanf("%d %d",&a[i].u,&a[i].v);

        scanf("%d",&k);

        memset(mark,-1,sizeof(mark));

        for(int i=1;i<=k;i++)
        {
            scanf("%d %d",&u,&w);

            mark[u] = w; 
        }

        Solve();
    }
    return 0;
}