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

讲解前首先引入两个概念

二分图最小点覆盖集

定义：

在二分图中求出一个最小点集
使得图中任意一条边至少有一个端点在点集内

解法：

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

二分图最大独立集

定义：

对于一张无向图
求出一个点数最大的点集
使得点集中任意两点没有边相连
这是图的最大独立集

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

解法：

对于一个有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;
}
?