POJ 2444 The Accomodation of Students 黑白染色+二分匹配 簡單題

有n個人，編號為1~n，其中有m對朋友，現在給出m對朋友，問能不能把這n個人分成2個組，使得每一個組裡面的人都是互相不認識的？

若不可以，輸出No

若可以，問現在將認識的人兩兩配對，輸出最多可以有多少對

說白了，這道題就是首先要判斷是不是二分圖，不是的話輸出No，是的話輸出最大匹配

判斷二分圖：用黑白染色法，注意，整個關係圖有可能是不連通的，所以要遍歷所有的點

這裡求最大匹配不是用匈牙利算法，而是直接轉化為最大流

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int maxn=210;
const int inf=0x3f3f3f3f;

inline int min(int a,int b)
{
    return a<b?a:b;
}

bool link[maxn][maxn];
struct Edge
{
    int to,next;
};
Edge edge[maxn*maxn*2];
int head[maxn];
int tot;
bool flag;
int dye[maxn];
int level[maxn];
int iter[maxn];
const int s=0;
int t;

void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

void init(int n)
{
    memset(link,false,sizeof link);
    memset(head,-1,sizeof head);
    memset(dye,-1,sizeof dye);
    tot=0;
    flag=true;
}

void to_dye(int pre ,int u)
{
    if(pre==-1)
        dye[u]=1;
    else
        dye[u]=!dye[pre];

    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==pre)
            continue;
        if(dye[v]!=-1)
        {
            if(dye[v]!=dye[u])
                continue;
            else
            {
                flag=false;
            }
        }
        else
         to_dye(u,v);
    }
}

struct Flow_Edge
{
    int to,cap,rev;
};
vector<Flow_Edge>flow_edge[maxn];

void add(int from,int to,int cost)
{
    flow_edge[from].push_back((Flow_Edge){to,cost,flow_edge[to].size()});
    flow_edge[to].push_back((Flow_Edge){from,0,flow_edge[from].size()-1});
}

void build_graph(int n)
{
    for(int i=0;i<=n;i++)
        flow_edge[i].clear();

    t=n+1;
    for(int i=1;i<=n;i++)
    {
        if(dye[i]==1)
            add(s,i,1);
        else
            add(i,t,1);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                continue;
            if(link[i][j]||link[j][i])
            {
                if(dye[i]==1)
                    add(i,j,1);
                else
                    add(j,i,1);
                link[i][j]=false;
                link[j][i]=false;
            }
        }
    }
}

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

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

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        init(n);

        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            link[u][v]=link[v][u]=true;
            addedge(u,v);
            addedge(v,u);
        }

        for(int i=1;i<=n;i++)
        {
            if(dye[i]==-1)
                to_dye(-1,i);
        }

        //printf("eee
");

        if(!flag)
        {
            printf("No
");
            continue;
        }
        else
        {
            build_graph(n);
            int flow=max_flow(n);
            printf("%d
",flow);
        }
    }
    return 0;
}