洛谷P2774 方格取数问题 BZOJ 1143祭祀river【二分图最大独立集】

讲解前首先引入两个概念

二分图最小点覆盖集

[b]定义：[/b]

在二分图中求出一个最小点集

使得图中任意一条边至少有一个端点在点集内

[b]解法：[/b]

对二分图进行最大匹配

最大匹配数就是二分图的最小点覆盖集包含的点数

二分图最大独立集

[b]定义：[/b]

对于一张无向图

求出一个点数最大的点集

使得点集中任意两点没有边相连

这是图的最大独立集

而二分图的最大独立集就是字面意思

[b]解法：[/b]

对于一个有n个结点的二分图

它的最大独立集包含的点数就是n-最大匹配数

二分图最大点权独立集

[b]定义[/b]

要求点权和最大的二分图独立集

[b]解法：[/b]

超源向所有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 co
4000
l[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;
}