讲解前首先引入两个概念
二分图最小点覆盖集
定义：
在二分图中求出一个最小点集
使得图中任意一条边至少有一个端点在点集内
解法：
对二分图进行最大匹配
最大匹配数就是二分图的最小点覆盖集包含的点数
***************************************
二分图最大独立集
定义：
对于一张无向图
求出一个点数最大的点集
使得点集中任意两点没有边相连
这是图的最大独立集
而二分图的最大独立集就是字面意思
解法：
对于一个有n个结点的二分图
它的最大独立集包含的点数就是n-最大匹配数
************************************************
二分图最大点权独立集
定义
要求点权和最大的二分图独立集
解法：
超源向所有x部的点连边，容量为该点点权
y部所有点向超汇连边，容量为该点点权
对于二分图原有的边，容量为inf
然后跑最大流即可
洛谷 P2774 方格取数问题
传送门
题目描述
在一个有 m*n 个方格的棋盘中，每个方格中有一个正整数。现要从方格中取数，使任意 2 个数所在方格没有公共边，且取出的数的总和最大。试设计一个满足要求的取数算法。对于给定的方格棋盘，按照取数要求编程找出总和最大的数。
输入格式：
第 1 行有 2 个正整数 m 和 n，分别表示棋盘的行数和列数。接下来的 m 行，每行有 n 个正整数，表示棋盘方格中的数。
输出格式：
程序运行结束时，将取数的最大总和输出
输入样例
3 3
1 2 3
3 2 3
2 3 1
输出样例
11
说明
m,n<=100
***********************************
分析
这题要求所取的方格不相邻
那么对每个格子黑白染色
我们由黑点向所有与他相邻的白点连边
就构成了一个二分图
到这里不难发现题目要求的就是二分图的最大点权独立集
点权！！！是点权！！！
所以这里我们就用上述方法解决
所有黑点向超汇连边，容量为该点点权
超源向所有白点连边，容量为该点点权
对于上面所述用于构成二分图的边，容量为inf
然后跑最大流就好
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<‘0‘||ss>‘9‘){if(ss==‘-‘)f=-1;ss=getchar();}
while(ss>=‘0‘&&ss<=‘9‘){x=x*10+ss-‘0‘;ss=getchar();}
return f*x;
}
const int inf=1e9;
int n,m;
int s=0,t;
int col[110][110];
struct node{int v,f,nxt;}E[1000010];
int head[100010],tot=1;;
int lev[100010];
int addx[]={0,0,1,-1},addy[]={1,-1,0,0};
int sum,ans;
void add(int u,int v,int f)
{
E[++tot].nxt=head[u];
E[tot].f=f;
E[tot].v=v;
head[u]=tot;
}
bool bfs()
{
memset(lev,-1,sizeof(lev)); lev[s]=0;
queue<int> q; q.push(s);
while(!q.empty())
{
int u=q.front(); q.pop();
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(lev[v]==-1&&E[i].f)
{
lev[v]=lev[u]+1;
if(v==t) return true;
q.push(v);
}
}
}
return false;
}
int dfs(int u,int cap)
{
if(u==t) return cap;
int flow=cap;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(lev[v]==lev[u]+1&&E[i].f>0&&flow)
{
int f=dfs(v,min(E[i].f,flow));
flow-=f;
E[i].f-=f;
E[i^1].f+=f;
}
}
return cap-flow;
}
int main()
{
n=read();m=read();
t=n*m+1;
for(int i=1;i<=n;i++)//黑白染色，1为黑，0为白
for(int j=1;j<=m;j++)
{
if( (i%2 && j%2) || (i%2==0 && j%2==0)) col[i][j]=1;
else col[i][j]=0;
}
for(int i=1;i<=n;i++)//构图
{
for(int j=1;j<=m;j++)
{
int x=read(); sum+=x;
int num=m*(i-1)+j;//计算该点的编号
if(col[i][j]) add( num,t,x ),add( t,num,0 );//黑点向超汇连边
else
{
add(s,num,x);add(num,s,0);//超源向白点连边
for(int k=0;k<4;k++)//原二分图中的边
{
int nx=i+addx[k],ny=j+addy[k];
if(nx>0&&nx<=n &&ny>0&&ny<=m)
add(num,m*(nx-1)+ny,inf),add(m*(nx-1)+ny,num,0);
}
}
}
}
while(bfs())//最大流
ans+=dfs(s,inf);
cout<<sum-ans;
return 0;
}BZOJ 1143 [CTSC2008]祭祀river
传送门
Description
在遥远的东方，有一个神秘的民族，自称Y族。他们世代居住在水面上，奉龙王为神。每逢重大庆典， Y族都
会在水面上举办盛大的祭祀活动。我们可以把Y族居住地水系看成一个由岔口和河道组成的网络。每条河道连接着
两个岔口，并且水在河道内按照一个固定的方向流动。显然，水系中不会有环流
由于人数众多的原因，Y族的祭祀活动会在多个岔口上同时举行。出于对龙王的尊重，这些祭祀地点的选择必
须非常慎重。准确地说，Y族人认为，如果水流可以从一个祭祀点流到另外一个祭祀点，那么祭祀就会失去它神圣
的意义。族长希望在保持祭祀神圣性的基础上，选择尽可能多的祭祀的地点。
Input
第一行包含两个用空格隔开的整数N、M，分别表示岔口和河道的数目，岔口从1到N编号。
接下来M行，每行包含两个用空格隔开的整数u、v，
描述一条连接岔口u和岔口v的河道，水流方向为自u向v。
N≤100M≤1000
Output
第一行包含一个整数K，表示最多能选取的祭祀点的个数。
Sample Input
4 4
1 2
3 4
3 2
4 2
Sample Output
2
【样例说明】
在样例给出的水系中，不存在一种方法能够选择三个或者三个以上的祭祀点。包含两个祭祀点的测试点的方案有两种：
选择岔口1与岔口3（如样例输出第二行），选择岔口1与岔口4。
水流可以从任意岔口流至岔口2。如果在岔口2建立祭祀点，那么任意其他岔口都不能建立祭祀点
但是在最优的一种祭祀点的选取方案中我们可以建立两个祭祀点，所以岔口2不能建立祭祀点。对于其他岔口
至少存在一个最优方案选择该岔口为祭祀点，所以输出为1011。
****************************
分析：
简化题目意思
就是选取一个点集，其中任意两点不在一条链上
并使得点数最大
这不就是图的最大独立集嘛！！！
然而要怎么处理两点是否在一条链上呢
用传递闭包+floyd的思想
读入时对于一条u到v的边，使map[u][v]=1
再利用floyd将连通性传递
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
map[i][j]|=(map[i][k]&map[k][j]);传递完后直接在图上跑二分图最大匹配就好了
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<‘0‘||ss>‘9‘){if(ss==‘-‘)f=-1;ss=getchar();}
while(ss>=‘0‘&&ss<=‘9‘){x=x*10+ss-‘0‘;ss=getchar();}
return f*x;
}
const int maxn=110;
int n,m;
int map[maxn][maxn];
bool vis[maxn];
int match[maxn];
int ans;
bool dfs(int u)
{
for(int v=1;v<=n;v++)
{
if(!map[u][v]||vis[v]) continue;
vis[v]=true;
if(!match[v]||dfs(match[v]))
{
match[v]=u;
return true;
}
}
return false;
}
int main()
{
n=read();m=read();
for(int i=1;i<=m;++i)
{
int u=read(),v=read();
map[u][v]=1;
}
for(int k=1;k<=n;k++)//floyd实现传递闭包
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
map[i][j]|=(map[i][k]&map[k][j]);
for(int i=1;i<=n;i++)
{
memset(vis,false,sizeof(vis));
if(dfs(i))ans++;
}
cout<<n-ans;
return 0;
}
?