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=505;
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,0,edge[from].size()-1});
}

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

void init()
{
    memset(head,-1,sizeof head);
    tot=0;
    memset(dye,-1,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==-1)
        dye[u]=1;
    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]!=-1)
            continue;
        get_dye(v,u);
    }
}

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

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

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

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

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