spoj 839 OPTM - Optimal Marks（最小割应用）

spoj 839

    异或操作是不好处理的，于是不妨将mark拆成31位来看待，对每一位都进行一次求解。

    于是问题就变成了顶点的标号可以为1也可以为0，边权和最小的问题，于是按标号为1或者为0就可以把顶点划分成两个集合，而连通这两个集合的边的数量就是我们需要累加的边权，为了让数量最少，于是就变成了最小割问题。

    这样我们将S和所有mark为1的点连起来，容量为INF，将所有mark为0的点和T连起来，容量为INF，至于那些还没标号的点就不和源点汇点连了，他们的标号取决于做完最小割之后属于哪个集合。接着将其他边建好，容量为1，之后就可以做最大流了，做完最大流后从S出发沿容量不为0的边走所能到达的点都是属于mark为1的这个集合的。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>

#define MEM(a,x) memset(a,x,sizeof a)
#define eps 1e-8
#define MOD 10009
#define MAXN 1010
#define INF 99999999
#define ll long long
#define bug cout<<"here"<<endl;
#define fread freopen("ceshi.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)

using namespace std;

struct Edge
{
    int from,to,cap,flow;
    bool operator <(const Edge e) const
    {
        if(e.from!=from)  return from<e.from;
        else return to<e.to;
    }
    Edge() {}
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow) {}
};

struct Dinic
{
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool vis[MAXN];//BFS使用
    int d[MAXN];   //从起点到i的距离
    int cur[MAXN]; //当前弧下标
    int n,m,s,t,maxflow;   //节点数 边数（包括反向弧） 源点编号和弧点编号

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<=n;i++)
            G[i].clear();
        edges.clear();
    }

    void addedge(int from,int to,int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,cap,0));//当是无向图时，反向边容量也是cap,有向边时，反向边容量是0
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool bfs()
    {
        MEM(vis,0);
        MEM(d,-1);
        queue<int> q;
        q.push(s);
        d[s]=maxflow=0;
        vis[s]=1;
        while(!q.empty())
        {
            int u=q.front(); q.pop();
            int sz=G[u].size();
            for(int i=0;i<sz;i++)
            {
                Edge e=edges[G[u][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    d[e.to]=d[u]+1;
                    vis[e.to]=1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int u,int a)
    {
        if(u==t||a==0)  return a;
        int sz=G[u].size();
        int flow=0,f;
        for(int &i=cur[u];i<sz;i++)
        {
            Edge &e=edges[G[u][i]];
            if(d[u]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[u][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)  break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s=s; this->t=t;
        int flow=0;
        while(bfs())
        {
            MEM(cur,0);
            flow+=dfs(s,INF);
        }
        return flow;
    }

}Dic;

struct List
{
    int id,mark;
}li[1010];

int s,t;
int k;
int mark[MAXN];
int n,m;
int mp[MAXN][MAXN];

void build(int cur)
{
    Dic.init(t);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            if(mp[i][j])
                Dic.addedge(i,j,1);
        }
    for(int i=0;i<k;i++)
    {
        if(li[i].mark&(1<<cur))
        {
            Dic.addedge(s,li[i].id,INF);
        }
        else
        {
            Dic.addedge(li[i].id,t,INF);
        }
    }
}

int v[MAXN];

void DFS(int cur,int x)
{
//    bug;
//    cout<<cur<<endl;
    v[cur]=1;
    mark[cur]|=1<<x;
    for(int i=0;i<Dic.G[cur].size();i++)
    {
        Edge e=Dic.edges[Dic.G[cur][i]];
        if(!v[e.to]&&e.cap>e.flow)
            DFS(e.to,x);
    }
}

int main()
{
//    fread;
    int tc;
    scanf("%d",&tc);
    while(tc--)
    {
        MEM(mp,0);
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            mp[a][b]=mp[b][a]=1;
        }
        scanf("%d",&k);
        for(int i=0;i<k;i++)
            scanf("%d%d",&li[i].id,&li[i].mark);
        s=0,t=n+1;
        ll ans=0;
        MEM(mark,0);
        for(int i=0;i<31;i++)
        {
            build(i);
            Dic.Maxflow(s,t);
            MEM(v,0);
            DFS(s,i);
        }
        for(int i=1;i<=n;i++)
            printf("%d\n",mark[i]);
    }
    return 0;
}