[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( 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;
}