HDU3829(KB10-J 二分图最大独立集)

Cat VS Dog

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 125536/65536 K (Java/Others)
Total Submission(s): 4039    Accepted Submission(s): 1458

Problem Description

The zoo have N cats and M dogs, today there are P children visiting the zoo, each child has a like-animal and a dislike-animal, if the child's like-animal is a cat, then his/hers dislike-animal must be a dog, and vice versa.
Now the zoo administrator is removing some animals, if one child's like-animal is not removed and his/hers dislike-animal is removed, he/she will be happy. So the administrator wants to know which animals he should remove to make maximum number of happy children.

 

 

Input

The input file contains multiple test cases, for each case, the first line contains three integers N <= 100, M <= 100 and P <= 500.
Next P lines, each line contains a child's like-animal and dislike-animal, C for cat and D for dog. (See sample for details)

 

 

Output

For each case, output a single integer: the maximum number of happy children.

 

 

Sample Input

1 1 2 C1 D1 D1 C1 1 2 4 C1 D1 C1 D1 C1 D2 D2 C1

 

 

Sample Output

1 3

Hint

Case 2: Remove D1 and D2, that makes child 1, 2, 3 happy.

 

 

Source

2011 Multi-University Training Contest 1 - Host by HNU

 

在有矛盾的男孩之间连边，有矛盾定义为两种情况：

　　1.我喜欢的你不喜欢

　　2.我不喜欢的你喜欢

建图后，求最大的两两互不相连的顶点集合即为答案，即求图的最大独立集。

一般图的最大独立集难求，转换为二分图，对男孩进行拆点，为i和p+i。若i和j有矛盾，则i与p+j、j与p+i连边。记得匹配数要除2。

 

定理：二分图最大独立集 == 顶点数 - 最小顶点覆盖 == 顶点数 - 二分图最大匹配

//2017-08-25
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 2000;
const int M = 500000;
int head[N], tot;
struct Edge{
    int to, next;
}edge[M];

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

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

    edge[tot].to = u;
    edge[tot].next = head[v];
    head[v] = tot++;
}

int n, m, p;
string G[N];
int matching[N];
int check[N];

bool dfs(int u){
    for(int i =  head[u]; i != -1; i = edge[i].next){
        int v = edge[i].to;
        if(!check[v]){//要求不在交替路
            check[v] = 1;//放入交替路
            if(matching[v] == -1 || dfs(matching[v])){
                //如果是未匹配点，说明交替路为增广路，则交换路径，并返回成功
                matching[u] = v;
                matching[v] = u;
                return true;
            }
        }
    }
    return false;//不存在增广路
}

//hungarian: 二分图最大匹配匈牙利算法
//input: null
//output: ans 最大匹配数
int hungarian(){
    int ans = 0;
    memset(matching, -1, sizeof(matching));
    for(int u = 1; u <= p; u++){
        if(matching[u] == -1){
            memset(check, 0, sizeof(check));
            if(dfs(u))
                  ans++;
        }
    }
    return ans;
}

string like[N], dislike[N];

int main()
{
    std::ios::sync_with_stdio(false);
    //freopen("inputJ.txt", "r", stdin);
    while(cin>>n>>m>>p && n){
        init();
        for(int i = 1; i <= p; i++)
              cin>>like[i]>>dislike[i];
        for(int i = 2; i <= p; i++){
            for(int j = 1; j < i; j++){
                if(like[i] == dislike[j] || dislike[i] == like[j]){
                    add_edge(i, p+j);
                    add_edge(j, p+i);
                }
            }
        }
        cout<<p-hungarian()/2<<endl;
    }

    return 0;
}