POJ 1466 Girls and Boys 黑白染色 + 二分匹配 （最大独立集） 好题

有n个人， 其中有男生和女生，接着有n行，分别给出了每一个人暗恋的对象（不止暗恋一个）

现在要从这n个人中找出一个最大集合，满足这个集合中的任意2个人，都没有暗恋这种关系。

输出集合的元素个数。

刚开始想，把人看成顶点，若有暗恋的关系，就连一条边，构成一个图

独立集的概念：一个图中两两互不相连的顶点集合

所以这道题，就是要求最大独立集

有：最大独立集+最小顶点覆盖=|V|(顶点的总个数)

那就求最小顶点覆盖了

根据题意：

暗恋的对象性别不同，所以a暗恋b，b暗恋c，c暗恋a这种关系不可能存在

也就是说，这个图的顶点可以根据性别分成2个集合，男生和女生

即这是一个二分图

我们知道，在二分图中，最小顶点覆盖=最大匹配

则：最大独立集=|V|-最大匹配

所以思路就清晰了：

1.黑白染色：确定男生和女生

2.建图：s连边到所有男生，所有女生连边到t，若男生i和女生j有关系，则连一条边，边的容量都是1

3.二分匹配转化为最大流求解

4.|V|-最大匹配

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<queue>

 using namespace std;

 const int maxn=;
 const int inf=0x3f3f3f3f;
 int s;
 int t;

 inline int min(int x,int y)
 {
     return x<y?x:y;
 }

 struct Edge
 {
     int to,cap,rev;
 };
 vector<Edge>edge[maxn];
 int level[maxn];
 int iter[maxn];
 int dye[maxn];

 void addedge(int from,int to,int cap)
 {
     edge[from].push_back((Edge){to,cap,edge[to].size()});
     edge[to].push_back((Edge){from,,edge[from].size()-});
 }

 struct Edge1
 {
     int to,next;
 };
 Edge1 edge1[maxn*];
 int head[maxn],tot;

 void init()
 {
     memset(head,-,sizeof head);
     tot=;
     memset(dye,-,sizeof dye);
 }

 void addedge1(int from,int to)
 {
     edge1[tot].to=to;
     edge1[tot].next=head[from];
     head[from]=tot++;
 }

 void get_dye(int u,int pre)
 {
     if(pre==-)
         dye[u]=;
     else
         dye[u]=!dye[pre];
     for(int i=head[u];~i;i=edge1[i].next)
     {
         int v=edge1[i].to;
         if(v==pre)
             continue;
         if(dye[v]!=-)
             continue;
         get_dye(v,u);
     }
 }

 void build_graph(int n)
 {
     s=n;
     t=n+;
     for(int i=;i<=t;i++)
         edge[i].clear();
     for(int i=;i<n;i++)
     {
         if(dye[i]==)
         {
             addedge(s,i,);
             for(int j=head[i];~j;j=edge1[j].next)
             {
                 int v=edge1[j].to;
                 addedge(i,v,);
             }
         }
         else
             addedge(i,t,);
     }
 }

 void bfs()
 {
     memset(level,-,sizeof level);
     queue<int>que;
     while(!que.empty())
         que.pop();
     que.push(s);
     level[s]=;
     while(!que.empty())
     {
         int u=que.front();
         que.pop();
         for(int i=;i<edge[u].size();i++)
         {
             Edge &e=edge[u][i];
             if(e.cap>&&level[e.to]<)
             {
                 level[e.to]=level[u]+;
                 que.push(e.to);
             }
         }
     }
 }

 int dfs(int u,int f)
 {
     if(u==t)
         return f;
     for(int &i=iter[u];i<edge[u].size();i++)
     {
         Edge &e=edge[u][i];
         if(e.cap>&&level[e.to]>level[u])
         {
             int d=dfs(e.to,min(e.cap,f));
             if(d)
             {
                 e.cap-=d;
                 edge[e.to][e.rev].cap+=d;
                 return d;
             }
         }
     }
     return ;
 }

 int solve()
 {
     int flow=;
     while()
     {
         bfs();
         if(level[t]<)
             return flow;
         memset(iter,,sizeof iter);
         int f;
         while(f=dfs(s,inf))
         {
             flow+=f;
         }
     }
 }

 int main()
 {
     int n;
     while(~scanf("%d",&n))
     {
         init();
         for(int i=;i<n;i++)
         {
             int j;
             char ch;
             scanf("%d%c",&j,&ch);
             char str[];
             scanf("%s",str);
             int len=strlen(str);
             int num=;
             for(int k=;k<len-;k++)
             {
                 num=num*+(str[k]-'');
             }
             for(int k=;k<num;k++)
             {
                 int tmp;
                 scanf("%d",&tmp);
                 addedge1(j,tmp);
                 addedge1(tmp,j);
             }
         }

         for(int i=;i<n;i++)
         {
             if(dye[i]==-)
                 get_dye(i,-);
         }
         build_graph(n);
         printf("%d\n",n-solve());
     }
     return ;
 }