[hihocoder #1127 : 二分图三·二分图最小点覆盖和最大独立集]

[hihocoder #1127 : 二分图三·二分图最小点覆盖和最大独立集]

题目链接：[hihocoder #1127 : 二分图三·二分图最小点覆盖和最大独立集]
题意描述：N个顶点M条边( 2≤N≤1,000，1≤M≤5,000)的无向图，求最小点覆盖数和最大独立集数。
解题思路：
给一个学习链接：《最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配》

三个重要的性质：
1. 由König定理可知最小点覆盖的点数 = 二分图最大匹配
König 定理是一个二分图中很重要的定理，它的意思是，一个二分图中的最大匹配数等于这个图中的最小点覆盖数。如果你还不知道什么是最小点覆盖，我也在这里说一下：假如选了一个点就相当于覆盖了以它为端点的所有边，你需要选择最少的点来覆盖所有的边。
2. 最大独立集的点数 = 总点数 - 二分图最大匹配
独立集：图中任意两个顶点都不相连的顶点集合。
3. 最小路径覆盖＝｜G｜－最大匹配数
在一个 N*N 的有向图中，路径覆盖就是在图中找一些路经，使之覆盖了图中的所有顶点，且任何一个顶点有且只有一条路径与之关联；（如果把这些路径中的每条路径从它的起始点走到它的终点，那么恰好可以经过图中的每个顶点一次且仅一次）；如果不考虑图中存在回路，那么每条路径就是一个弱连通子集．
由上面可以得出：
1.一个单独的顶点是一条路径；
2.如果存在一路径 p1,p2,……pk，其中 p1 为起点，pk 为终点，那么在覆盖图中，顶点 p1,p2,……pk 不再与其它的顶点之间存在有向边．最小路径覆盖就是找出最小的路径条数，使之成为 G 的一个路径覆盖．
路径覆盖与二分图匹配的关系：最小路径覆盖＝｜G｜－最大匹配数；

求二分图的最大匹配算法常用的算法是匈牙利算法和Hopcroft-Carp算法。时间复杂度分别是O(V * E)和O($\sqrt V * E$)。

/**
 * 匈牙利算法
 */
#include <queue>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

//#pragma comment(linker, "/STACK:1024000000,1024000000")

#define FIN             freopen("input.txt","r",stdin)
#define FOUT            freopen("output.txt","w",stdout)
#define fst             first
#define snd             second

//typedef __int64 LL;
//typedef long long LL;
typedef pair<int, int> PII;

const int MAXN = 1000 + 5;
const int MAXE = 5000 + 5;

int T, N, M;
struct Edge {
    int v, next;
    Edge() {}
    Edge (int v, int next) : v (v), next (next) {}
} edges[MAXE << 1];
int head[MAXN], ESZ;
int link[MAXN], uN;
bool used[MAXN];
void init() {
    ESZ = 0;
    memset (head, -1, sizeof (head) );
}
void add_edge (int u, int v) {
    edges[ESZ] = Edge (v, head[u]);
    head[u] = ESZ ++;
}
bool dfs (int u) {
    int v;
    for (int i = head[u]; ~i; i = edges[i].next) {
        v = edges[i].v;
        if (!used[v]) {
            used[v] = true;
            if (link[v] == -1 || dfs (link[v]) ) {
                link[v] = u;
                return true;
            }
        }
    }
    return false;
}
int hungry() {
    int ret = 0;
    memset (link, -1, sizeof (link) );
    for (int u = 1; u <= uN; u++) {
        memset (used, false, sizeof (used) );
        if (dfs (u) ) ret ++;
    }
    return ret;
}
int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    int u, v;
    while (~scanf ("%d %d", &N, &M) ) {
        init();
        for (int i = 0; i < M; i++) {
            scanf ("%d %d", &u, &v);
            add_edge (u, v), add_edge (v, u);
        }
        uN = N;
        int ret = hungry();
        ret >>= 1;
        printf ("%d\n%d\n", ret, N - ret);
    }
    return 0;
}

/**
 * Hopcroft-Carp算法
 */
#include <queue>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

//#pragma comment(linker, "/STACK:1024000000,1024000000")

#define FIN             freopen("input.txt","r",stdin)
#define FOUT            freopen("output.txt","w",stdout)
#define fst             first
#define snd             second

//typedef __int64 LL;
//typedef long long LL;
typedef pair<int, int> PII;

const int MAXN = 1000 + 5;
const int MAXE = 5000 + 5;
const int INF = 0x3f3f3f3f;
int T, N, M;
struct Edge {
    int v, next;
    Edge() {}
    Edge (int v, int next) : v (v), next (next) {}
} edges[MAXE << 1];
int head[MAXN], ESZ;
int uN;
int Mx[MAXN], My[MAXN];
int dx[MAXN], dy[MAXN];
int dis;
bool used[MAXN];

void init() {
    ESZ = 0;
    memset (head, -1, sizeof (head) );
}
void add_edge (int u, int v) {
    edges[ESZ] = Edge (v, head[u]);
    head[u] = ESZ ++;
}

bool search_path() {
    int u,  v;
    queue<int> Q;
    dis = INF;
    memset (dx, -1, sizeof (dx) );
    memset (dy, -1, sizeof (dy) );
    for (int i = 1 ; i <= uN; i++)
        if (Mx[i] == -1) {
            Q.push (i);
            dx[i] = 0;
        }
    while (!Q.empty() ) {
        u = Q.front();
        Q.pop();
        if (dx[u] > dis) break;
        for (int i = head[u]; ~i; i = edges[i].next) {
            v = edges[i].v;
            if (dy[v] == -1) {
                dy[v] = dx[u] + 1;
                if (My[v] == -1) dis = dy[v];
                else {
                    dx[My[v]] = dy[v] + 1;
                    Q.push (My[v]);
                }
            }
        }
    }
    return dis != INF;
}
bool dfs (int u) {
    int v;
    for (int i = head[u]; ~i; i = edges[i].next) {
        v = edges[i].v;
        if (!used[v] && dy[v] == dx[u] + 1) {
            used[v] = true;
            if (My[v] != -1 && dy[v] == dis) continue;
            if (My[v] == -1 || dfs (My[v]) ) {
                My[v] = u;
                Mx[u] = v;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch() {
    int res = 0;
    memset (Mx, -1, sizeof (Mx) );
    memset (My, -1, sizeof (My) );
    while (search_path() ) {
        memset (used, false, sizeof (used) );
        for (int i = 1; i <= uN; i++)
            if (Mx[i] == -1 && dfs (i) )
                res++;
    }
    return res;
}
int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    int u, v;
    while (~scanf ("%d %d", &N, &M) ) {
        init();
        for (int i = 0; i < M; i++) {
            scanf ("%d %d", &u, &v);
            add_edge (u, v), add_edge (v, u);
        }
        uN = N;
        int ret = MaxMatch();
        ret >>= 1;
        printf ("%d\n%d\n", ret, N - ret);
    }
    return 0;
}