BZOJ 2744: [HEOI2012]朋友圈

2744: [HEOI2012]朋友圈

Time Limit: 30 Sec Memory Limit: 128 MB
Submit: 1493 Solved: 507
[Submit][Status][Discuss]

Description

在很久很久以前，曾经有两个国家和睦相处，无忧无虑的生活着。一年一度的评比大会开始了，作为和平的两国，一个朋友圈数量最多的永远都是最值得他人的尊敬，所以现在就是需要你求朋友圈的最大数目。
两个国家看成是AB两国，现在是两个国家的描述：
1. A国：每个人都有一个友善值，当两个A国人的友善值a、b，如果a xor b mod 2=1，
那么这两个人都是朋友，否则不是；
2. B国：每个人都有一个友善值，当两个B国人的友善值a、b，如果a xor b mod 2=0
或者 (a or b)化成二进制有奇数个1，那么两个人是朋友，否则不是朋友；
3. A、B两国之间的人也有可能是朋友，数据中将会给出A、B之间“朋友”的情况。
4. 在AB两国，朋友圈的定义：一个朋友圈集合S，满足
S∈A∪ B ，对于所有的i，j∈ S ，i 和 j 是朋友
由于落后的古代，没有电脑这个也就成了每年最大的难题，而你能帮他们求出最大朋 友圈的人数吗？

Input

第一行t<=6,表示输入数据总数。
接下来t个数据：
第一行输入三个整数A,B,M，表示A国人数、B国人数、AB两国之间是朋友的对数；第二行A个数ai，表示A国第i个人的友善值；第三行B个数bi，表示B国第j个人的友善值；
第4——3+M行，每行两个整数（i，j），表示第i个A国人和第j个B国人是朋友。

Output

输出t行，每行，输出一个整数，表示最大朋友圈的数目。

Sample Input

2 4 7

1 2

2 6 5 4

1 1

1 2

1 3

2 1

2 2

2 3

2 4

Sample Output

5

【样例说明】

最大朋友圈包含A国第1、2人和B国第1、2、3人。

HINT

【数据范围】

两类数据

第一类：|A|<=200 |B| <= 200

第二类：|A| <= 10 |B| <= 3000

Source

题解：
如果是一个没有任何性质的图的最大团，似乎是一个NP问题。
不过这道题显然是有什么性质的。。。
首先对于A，对于是朋友的那些人，他们的友善值的奇偶性肯定是不同的，所以A最多只会有2个人是朋友。再看B，如果单纯求B的最大团不好求，但是可以转化为求B的补图的最大独立集。B的最大团=B的补图的最大独立集。
再来分析B的补图，奇与奇之间是没边的，偶与偶之间也没有，奇偶之间可能有，这就是一个二分图，二分图的最大独立集=点数-最大匹配数。
然后再利用A最多两个人是朋友的这个性质暴力枚举就行了。
注意选了A中的人之后要在求到B的补图的最大独立集的基础上+A的人数。

匈牙利的话是可以用时间戳优化（不用每次清空vis数组，只需要记录vis数组是否是这次用到的就行了），dinic也可以用一个数组保留这个节点是否合法。这样就可以只建一次图。

之前每次将流量更新的时候是先枚举起点连出去的边，终点连进来的边，再枚举B中为奇数的点连出去的边，后来cxy大佬告诉我可能会更新到反向边，即为奇数的点和起点相连的边，这条边会被更新到2次，且被错误地更新。其实换个顺序就好了。但这样其实比直接暴力枚举每条边更新要慢。

#include<bits/stdc++.h>
using namespace std;

inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9') {if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int N = 3000 + 10;
const int M = 200 + 10;
const int MM = N*N;
const int inf = 0x73f3f3f;

int n,m,k,s=0,t;
int a[N],b[N],ans;
bool mp[M][N],vis[N];

struct node{
    int pre,v,f;
}e[MM];

int num=1,head[N];
void addedge(int from,int to){
    e[++num].pre=head[from],e[num].v=to;
    e[num].f=1;head[from]=num;
    e[++num].pre=head[to],e[num].v=from;
    e[num].f=0;head[to]=num;
}

int count(int x){
    int cnt=0;
    while(x) ++cnt,x&=(x-1);
    return cnt&1;
}

int dis[N];
queue<int> q;
bool bfs(){
    dis[s]=1,q.push(s);
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head[u];i;i=e[i].pre){
            int v=e[i].v;
            if(vis[v]&&!dis[v]&&e[i].f){
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return dis[t];
}

int dfs(int u,int delta){
    if(u==t||delta==0) return delta;
    int ans=0;
    for(int i=head[u];i;i=e[i].pre){
        int v=e[i].v;
        if(vis[v]&&dis[v]==dis[u]+1&&e[i].f){
            int dd=dfs(v,min(delta,e[i].f));
            e[i].f-=dd;
            e[i^1].f+=dd;
            ans+=dd;
            delta-=dd;
        }
    }
    if(!ans) dis[u]=-1;
    return ans;
}

#define ms(x,y) memset(x,y,sizeof(x))
void zero(){
    ms(dis,0);
    while(!q.empty()) q.pop();
}

int maxflow(){
    int ans=0;
    while(1){
        zero();
        if(!bfs()) break;
        ans+=dfs(s,inf);
    }
    return ans;
}

int main(){
    n=read(),m=read(),k=read();
    for(int i=1;i<=n;++i) a[i]=read();
    for(int i=1;i<=m;++i) b[i]=read();
    while(k--){
        int u=read(),v=read();
        mp[u][v]=1;
    }   
    for(int i=1;i<=m;++i){
        if(!(b[i]&1)) continue;
        for(int j=1;j<=m;++j){
            if(i==j) continue;
            if(b[j]&1) continue;
            if(!count(b[i]|b[j])) addedge(i,j);
        }
    }
    t=m+1;vis[s]=vis[t]=true;
    for(int i=1;i<=m;++i){
        vis[i]=true;
        if(b[i]&1) addedge(s,i);
        else addedge(i,t);
    }
    ans=m-maxflow();
    for(int i=1;i<=n;++i){
       //for(int j=2;j<=num;j+=2) e[j].f=1,e[j^1].f=0;
        int tot=0;
        for(int j=1;j<=m;++j){
            vis[j]=false;
            if(!mp[i][j]) continue;
            vis[j]=true;++tot;
            if(b[j]&1)
            for(int d=head[j];d;d=e[d].pre) e[d].f=1,e[d^1].f=0;
        }
        for(int j=head[s];j;j=e[j].pre) e[j].f=1,e[j^1].f=0;
        for(int j=head[t];j;j=e[j].pre) e[j].f=0,e[j^1].f=1;       
        ans=max(ans,tot-maxflow()+1);
    }
    for(int i=1;i<n;++i){
        for(int j=i+1;j<=n;++j){
            if(!((a[i]^a[j])&1)) continue;
            //for(int j=2;j<=num;j+=2) e[j].f=1,e[j^1].f=0;
            int tot=0;
            for(int d=1;d<=m;++d){
                vis[d]=false;
                if(mp[i][d]&&mp[j][d]) {
                    ++tot;
                    vis[d]=true;
                    if(b[d]&1)
                    for(int z=head[d];z;z=e[z].pre) e[z].f=1,e[z^1].f=0;
                }
            }
            for(int i=head[s];i;i=e[i].pre) e[i].f=1,e[i^1].f=0;
            for(int i=head[t];i;i=e[i].pre) e[i].f=0,e[i^1].f=1;            
            ans=max(ans,tot-maxflow()+2);
        }
    }
    printf("%d\n",ans);
    return 0;
}