二分图相关

二分图匹配有自己的匈牙利算法，不过我更习惯用网络流的算法搞。

首先一些概念：

最大匹配：
在所有的匹配中，边数最多的那个匹配就是二分图的最大匹配
顶点覆盖：
在顶点集合中，选取一部分顶点，这些顶点能够把所有的边都覆盖了。这些点就是顶点覆盖集
最小顶点覆盖：
在所有的顶点覆盖集中，顶点数最小的那个叫最小顶点集合。
独立集：
在所有的顶点中选取一些顶点，这些顶点两两之间没有连线，这些点就叫独立集
最大独立集：
在所有的独立集中，顶点数最多的那个集合
路径覆盖：
在图中找一些路径，这些路径覆盖图中所有的顶点，每个顶点都只与一条路径相关联。
最小路径覆盖：
在所有的路径覆盖中，路径个数最小的就是最小路径覆盖了。

最大匹配=最小顶点覆盖（就像网络流中最大流=最小割）

最大独立集=顶点个数-最小顶点覆盖（最大匹配）

hdu1054：

最开始用贪心做这个题。。后来发现树形dp可解。。这次用二分图（流）做的

把树上的每个点左边一排，右边一排，无向图所以连两个边，求最大流，然后最大流/2

这题可以这么做是因为它是树，所以可以红白染色并保证两组点内部之间没有连线，如果是一个三角环就不太好搞了。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;

int n;

const int maxnode = 3000 + 5;
const int maxedge = 2*100000 + 5;
const int oo = 1000000000;
int node, src, dest, nedge;
int head[maxnode], point[maxedge], next1[maxedge], flow[maxedge], capa[maxedge];//point[x]==y±íʾµÚxÌõ±ßÁ¬½Óy£¬head£¬nextΪÁÚ½Ó±í£¬flow[x]±íʾx±ßµÄ¶¯Ì¬Öµ£¬capa[x]±íʾx±ßµÄ³õʼֵ
int dist[maxnode], Q[maxnode], work[maxnode];//dist[i]±íʾiµãµÄµÈ¼¶
void init(int _node, int _src, int _dest){//³õʼ»¯£¬node±íʾµãµÄ¸öÊý£¬src±íʾÆðµã£¬dest±íʾÖÕµã
    node = _node;
    src = _src;
    dest = _dest;
    for (int i = 0; i < node; i++) head[i] = -1;
    nedge = 0;
}
void addedge(int u, int v, int c1, int c2){//Ôö¼ÓÒ»Ìõuµ½vÁ÷Á¿Îªc1£¬vµ½uÁ÷Á¿Îªc2µÄÁ½Ìõ±ß
    point[nedge] = v, capa[nedge] = c1, flow[nedge] = 0, next1[nedge] = head[u], head[u] = (nedge++);
    point[nedge] = u, capa[nedge] = c2, flow[nedge] = 0, next1[nedge] = head[v], head[v] = (nedge++);
}
bool dinic_bfs(){
    memset(dist, 255, sizeof (dist));
    dist[src] = 0;
    int sizeQ = 0;
    Q[sizeQ++] = src;
    for (int cl = 0; cl < sizeQ; cl++)
        for (int k = Q[cl], i = head[k]; i >= 0; i = next1[i])
            if (flow[i] < capa[i] && dist[point[i]] < 0){
                dist[point[i]] = dist[k] + 1;
                Q[sizeQ++] = point[i];
            }
    return dist[dest] >= 0;
}
int dinic_dfs(int x, int exp){
    if (x == dest) return exp;
    for (int &i = work[x]; i >= 0; i = next1[i]){
        int v = point[i], tmp;
        if (flow[i] < capa[i] && dist[v] == dist[x] + 1 && (tmp = dinic_dfs(v, min(exp, capa[i] - flow[i]))) > 0){
            flow[i] += tmp;
            flow[i^1] -= tmp;
            return tmp;
        }
    }
    return 0;
}
int dinic_flow(){
    int result = 0;
    while (dinic_bfs()){
        for (int i = 0; i < node; i++) work[i] = head[i];
        while (1){
            int delta = dinic_dfs(src, oo);
            if (delta == 0) break;
            result += delta;
        }
    }
    return result;
}
//½¨Í¼Ç°,ÔËÐÐÒ»±éinit()£»
//¼Ó±ßʱ£¬ÔËÐÐaddedge(a,b,c,0),±íʾµãaµ½bÁ÷Á¿ÎªcµÄ±ß½¨³É£¨×¢ÒâµãÐòºÅÒª´Ó0¿ªÊ¼£©
//Çó½â×î´óÁ÷ÔËÐÐdinic_flow(),·µ»ØÖµ¼´Îª´ð°¸

int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		int i,j,ta,tb,tc,ans,temp;
		init(2*n+2,0,2*n+1);
		for(i=1;i<=n;i++)
		{
			scanf("%d: (%d)",&ta,&tb);
			ta++;
			while(tb--)
			{
				scanf("%d",&tc);
				tc++;
				addedge(ta,n+tc,1,0);
				addedge(tc,n+ta,1,0);
			}
			addedge(0,ta,1,0);
			addedge(n+ta,n*2+1,1,0);
		}
		temp=dinic_flow();
		ans=temp/2;
		printf("%d\n",ans);
	}
	return 0;
}