BZOJ2150 || 洛谷P2172 [国家集训队]部落战争【有上下界最小流 or DAG最小路径覆盖】

于 2020-09-21 14:03:06 发布
阅读量193 收藏 1
点赞数
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niiick/article/details/88557283
版权

Time Limit: 10 Sec
Memory Limit: 259 MB

Description

lanzerb的部落在A国的上部，他们不满天寒地冻的环境，于是准备向A国的下部征 战来获得更大的领土。 A国是一
个M*N的矩阵，其中某些地方是城镇，某些地方是高山深涧无人居住。lanzerb把自己的部落分成若干支军队，他们
约定：

  1. 每支军 队可以从任意一个城镇出发，并只能从上往向下征战，不能回头。
    途中只能经过城镇，不能经过高山深涧。
  2. 如果某个城镇被某支军+队到过，则其他军队不能再去那个城镇了。
  3. 每支军 队都可以在任意一个城镇停止征战。
  4. 所有军 队都很奇怪，他们走的方法有点像国际象棋中的马。
    不过马每次只能走12的路线，而他们只能走RC的路线。
    lanzerb的野心使得他的目标是统一全国，但是兵 力的限制使得他们在配备人手时力不从心。假设他们每支军队都
    能顺利占领这支军 队经过的所有城镇，请你帮lanzerb算算至少要多少支军 队才能完成统一全国的大业。
Input

第一行包含4个整数M、N、R、C，意义见问题描述。
接下来M行每行一个长度为N的字符串。
如果某个字符是’.’，表示这个地方是城镇；如果这个字符时’x’，表示这个地方是高山深涧。
1<=M,N<=50，1<=R,C<=10。

Output

输出一个整数，表示最少的军 队个数

解法一：有上下界最小流

每个城镇拆成入点和出点，由其入点向出点连边，下界1，上界1，表示必须且只能经过一次
对于u能到达的城镇v，u的出点向v的入点连边，下界0，上界inf
虚拟源点s向每个入点连边，下界0，上界inf
每个出点向虚拟汇点t连边，下界0，上界inf

按照有上下界网络流套路建图后求s到t的最小流即可

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long lt;

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;
const int maxn=100010;
int n,m,r,c;
struct node{int v,f,nxt;}E[maxn<<1];
int head[maxn],tot=1;
int lev[maxn],deg[maxn];
int rem[55][55];
char ss[110];
int nX[]={1,1},nY[]={-1,1};

void add(int u,int v,int f)
{
    E[++tot].nxt=head[u];
    E[tot].v=v; E[tot].f=f;
    head[u]=tot;
    
    E[++tot].nxt=head[v];
    E[tot].v=u; E[tot].f=0;
    head[v]=tot;
}

int bfs(int s,int t)
{
    queue<int> q; q.push(s);
    memset(lev,-1,sizeof(lev)); lev[s]=0;
    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 1;
                q.push(v);
            }
        }
    }
    return 0;
}

int dfs(int u,int cap,int t)
{
    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&&flow)
        {
            int f=dfs(v,min(E[i].f,flow),t);
            E[i].f-=f; E[i^1].f+=f;
            flow-=f;
        }
    }
    return cap-flow;
}

int dicnic(int s,int t)
{
    int maxf=0;
    while(bfs(s,t)) maxf+=dfs(s,inf,t);
    return maxf;
}

int main()
{
    n=read();m=read();
    r=read();c=read();
    
    for(int i=1;i<=n;++i)
    {
        scanf("%s",&ss);
        for(int j=0;j<m;++j)
        if(ss[j]=='x') rem[i][j+1]=1;
    }
    
    int s=n*m*2+1,t=s+1;
    for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j)
    {
        if(rem[i][j]) continue;
        int u=(i-1)*m+j;
        add(s,u,inf); add(u+n*m,t,inf);//l=0,r=inf
        
        add(u,u+n*m,0);//l=1,r=1
        deg[u]--; deg[u+n*m]++;
    }
    
    for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j)
    {
        if(rem[i][j]) continue;
        int u=(i-1)*m+j;
        for(int k=0;k<2;++k)
        {
            int x=i+nX[k]*r,y=j+nY[k]*c,v=(x-1)*m+y;
            if(x>=1&&x<=n&&y>=1&&y<=m) 
            if(!rem[x][y]) add(u+n*m,v,inf);
        }
        if(r!=c)
        for(int k=0;k<2;++k)
        {
            int x=i+nX[k]*c,y=j+nY[k]*r,v=(x-1)*m+y;
            if(x>=1&&x<=n&&y>=1&&y<=m) 
            if(!rem[x][y]) add(u+n*m,v,inf);
        }
    }
    
    int ss=t+1,tt=ss+1;
    for(int i=1;i<=t;++i)
    {
        if(deg[i]>0) add(ss,i,deg[i]);
        else if(deg[i]<0) add(i,tt,-deg[i]);
    }
    add(t,s,inf);
    
    dicnic(ss,tt);
    int ans=E[tot].f;
    head[t]=E[head[t]].nxt;
    head[s]=E[head[s]].nxt;
    printf("%d",ans-dicnic(t,s));
    return 0;
}
解法二：DAG最小路径覆盖

有题意知所有可能的道路连接起来组成的一定是一个有向无环图
又有每个点必须且只能经过一次
这恰好对应DAG最小路径覆盖

依然是每个城镇拆成入点和出点，u到v的道路即连接u的入点到v的出点
城镇总数-最大匹配数即为答案

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long lt;
 
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;
const int maxn=100010;
int n,m,r,c;
struct node{int v,f,nxt;}E[maxn<<1];
int head[maxn],tot=1;
int lev[maxn],deg[maxn];
int rem[55][55],ans;
char ss[110];
int nX[]={1,1},nY[]={-1,1};
 
void add(int u,int v,int f)
{
    E[++tot].nxt=head[u];
    E[tot].v=v; E[tot].f=f;
    head[u]=tot;
     
    E[++tot].nxt=head[v];
    E[tot].v=u; E[tot].f=0;
    head[v]=tot;
}
 
int bfs(int s,int t)
{
    queue<int> q; q.push(s);
    memset(lev,-1,sizeof(lev)); lev[s]=0;
    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 1;
                q.push(v);
            }
        }
    }
    return 0;
}
 
int dfs(int u,int cap,int t)
{
    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&&flow)
        {
            int f=dfs(v,min(E[i].f,flow),t);
            E[i].f-=f; E[i^1].f+=f;
            flow-=f;
        }
    }
    return cap-flow;
}
 
int dicnic(int s,int t)
{
    int maxf=0;
    while(bfs(s,t)) maxf+=dfs(s,inf,t);
    return maxf;
}
 
int main()
{
    n=read();m=read();
    r=read();c=read();
     
    ans=n*m;
    for(int i=1;i<=n;++i)
    {
        scanf("%s",&ss);
        for(int j=0;j<m;++j)
        if(ss[j]=='x') rem[i][j+1]=1,ans--;
    }
     
    int s=n*m*2+1,t=s+1;
    for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j)
    {
        if(rem[i][j]) continue;
        int u=(i-1)*m+j;
        add(s,u,1); add(u+n*m,t,1);
    }
     
    for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j)
    {
        if(rem[i][j]) continue;
        int u=(i-1)*m+j;
        for(int k=0;k<2;++k)
        {
            int x=i+nX[k]*r,y=j+nY[k]*c,v=(x-1)*m+y;
            if(x>=1&&x<=n&&y>=1&&y<=m) 
            if(!rem[x][y]) add(u,v+n*m,1);
        }
        if(r!=c)
        for(int k=0;k<2;++k)
        {
            int x=i+nX[k]*c,y=j+nY[k]*r,v=(x-1)*m+y;
            if(x>=1&&x<=n&&y>=1&&y<=m) 
            if(!rem[x][y]) add(u,v+n*m,1);
        }
    }
    printf("%d",ans-dicnic(s,t));
    return 0;
}
niiick
关注
专栏目录
BZOJ 2150. 部落战争（最小路径覆盖问题）【BZOJ千题计划】
繁凡さん的博客
09-16 480
【BZOJ修复计划 #15】BZOJ 2150 部落战争 【国家集训队2011】
洛谷P1505 [国家集训队]旅游（BZOJ2157）
forezxl的博客
06-06 331
树链剖分 洛谷题目传送门 BZOJ题目传送门 操作有点多的裸树剖。套路下放边权后就是打板子。注意操作的时候不要包括LCA。 代码： #include&lt;cctype&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #define N 20005 #define F inline ...
（拆点+最小路径覆盖） bzoj 2150
weixin_30652491的博客
05-01 108
2150: 部落战争 Time Limit:10 SecMemory Limit:259 MBSubmit:518Solved:298[Submit][Status][Discuss] Description lanzerb的部落在A国的上部，他们不满天寒地冻的环境，于是准备向A国的下部征战来获得更大的领土。 A国是一个M*N的矩阵，其中某些地方是城镇，某些地方是高山...
bzoj 2150
lleozhang的博客
10-05 133
蜜汁互测题... 有一个思路是显而易见的：爆搜！ 期望得分30 #include &lt;cstdio&gt; #include &lt;cmath&gt; #include &lt;cstring&gt; #include &lt;cstdlib&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;q...
[bzoj2150] 部落战争(二分图最小边覆盖)
Edt!
06-23 511
2150: 部落战争 Time Limit: 10 Sec  Memory Limit: 259 MB Submit: 1021  Solved: 572 [Submit][Status][Discuss] Description lanzerb的部落在A国的上部，他们不满天寒地冻的环境，于是准备向A国的下部征战来获得更大的领土。 A国是一个M*N的矩阵，其中某些地方是城镇，某些地方
[BZOJ2150]部落战争（二分图匹配）
zyf2000
11-10 693
题目描述传送门题解可以发现这道题实际上是一个有向图的最小路径覆盖问题。 可以转化为二分图匹配来做。 将每一个点拆成两个点，入点和出点。两个点有边相连时，从起点的出点向终点的入点连边，然后用匈牙利算法求最大匹配。 最小路径覆盖即为点数-最大匹配。代码#include<iostream> #include<cstring> #include<cstdio> using namespace std;
BZOJ1797: [Ahoi2009]Mincut 最小割（洛谷P4126）
forezxl的博客
09-26 209
最小割 Tarjan BZOJ题目传送门 洛谷题目传送门 结论题。。。 跑一遍最小割，对残量网络进行缩点，使得剩下的边都是满流边。 一条边属于最小割的并集当这条边两个端点所在的联通块不同。 一条边属于最小割的交集当这条边两个端点所在的联通块分别与源点和汇点相同。 下面给出口胡： 如果这条边的两个端点在同一个联通块内，那么它就不是满流边，一定没有割它流入的满流边划算，也就不是最小割。 一条边如果一个...
BZOJ 2150 浅谈二分图Bipartite Graph及DAG最小路径覆盖
BerryKanry的博客
10-11 680
世界真的很大 DAG最小路径这种题还是做过很多次了，对模型也较为熟悉 恼火的是每次这种题考试的时候都能被贪心什么的水过去，然而我的正解又常常写挂，导致老是无用武之地 这道题写得快，还是调了一会儿，主要原因是我把x，y坐标看反了。。看题先：description： lanzerb的部落在A国的上部，他们不满天寒地冻的环境，于是准备向A国的下部征战来获得更大的领土。 A国是一个M*N的矩阵，其
洛谷2093 [国家集训队]JZPFAR
yanpanyan的博客
05-07 452
平面上有n个点。现在有m次询问，每次给定一个点(px, py)和一个整数k，输出n个点中离(px, py)的距离第k大的点的标号。如果有两个(或多个)点距离(px, py)相同，那么认为标号较小的点距离较大。 Input 　　第一行，一个整数n，表示点的个数。 下面n行，每行两个整数x_i, y_i，表示n个点的坐标。点的标号按照输入顺序，分别为1…n。 下面一行，一个整数m，表示询问个数。 下面...
BZOJ 2150 部落战争（最小路径覆盖）
顺
02-17 624
题目链接：BZOJ 2150 这道题应该是裸的最小路径覆盖。我们知道：最小路径覆盖=总结点数-最大匹配数。对于二分图的最大匹配数，可以用最大流求，也可以用匈牙利算法求。但是我现在还不会匈牙利算法（请神犇自动无视），所以我用dinic写的。对于这道题，最后的答案就是： ‘.’的个数-最大流。 建图：把每个节点拆成两个点，u（流入），v（流出），加入源点S，和汇点T。将S与v连边，u与T连边，u与
bzoj2150【二分图匹配】
leijp
03-30 349
水水水。。裸最小路径覆盖。。我为何这么水。#include &lt;cstdio&gt; #include &lt;cstring&gt; using namespace std; int dx[5],dy[5]; int n,m,r,c,sz; bool a[55][55]; struct edge { int v,next; }e[10010]; int cnt,head[5010];...
上下界网络流
DZYO的博客
08-22 290
。
POJ - 2396 Budget && 洛谷P4311 士兵占领【有上下界网络流】
niiick
03-14 222
POJ - 2396 Budget Time limit3000 ms Memory limit65536 kB We are supposed to make a budget proposal for this multi-site competition. The budget proposal is a matrix where the rows represent different k...
[BZOJ2150]部落战争-二分图匹配
「嫌われ者のフィロソフィ」
10-30 456
部落战争Descriptionlanzerb的部落在A国的上部，他们不满天寒地冻的环境，于是准备向A国的下部征战来获得更大的领土。 A国是一个M*N的矩阵，其中某些地方是城镇，某些地方是高山深涧无人居住。lanzerb把自己的部落分成若干支军队，他们约定： 2. 如果某个城镇被某支军队到过，则其他军队不能再去那个城镇了。 3. 每支军队都可以在任意一个城镇停止征战。 4. 所有军队都
【bzoj2150】 部落战争 二分图匹配
Oxer的专栏
08-17 1059
裸的有向无环图最小不相交路径覆盖，直接拆点，然后原图点数-最大匹配就可以。数组开小了，WA了一发。 #include #include #include #include #include #include #define maxn 2610 using namespace std; int a[maxn][maxn],lk[maxn],f[maxn][maxn],num[maxn]
loj2134/uoj132/洛谷P2304/bzoj4200 小园丁与老司机 DP+有上下界网络流
litble的成(tui)长(fei)史
05-26 1562
题目分析 老司机 关于老司机的这一部分，显而易见是个dp。将纵坐标相等的点组成的集合称为层，则我们要逐层dp。 将(0,0)这个点看作一棵树，算出答案后再减去它的贡献。 首先预处理出每棵树向左上，上，右上会到哪棵树，这个可以离散+桶完成，正上的处理就是将x坐标放桶里，左上右上的就把经过该点的直线y=x+b1y=x+b1y=x+b_1和y=x−b2y=x−b2y=x-b_2对应的b1b1b_...
有上下界的网络流小结
Dizzz的博客
07-11 430
1. 无源汇可行流 对于有下界的网络流，首先要想办法去掉下界，做法是把原图中的流量分成流b和f’,其中b的流量为原流量下界，f′=f−bf'=f-b。 虚拟一个源点s和一个汇点t，对每个点u，设D(u)=∑bin−∑boutD(u)=\sum_{}b_{in}-\sum_{}b_{out},若D(u)>0D(u)>0，从s连一条容量为D(u)的流到u,否则连一条容量为-D(u)的流到t。其实这个
矩阵,洛谷P4194,二分+有源汇上下界可行流
Deep_Kevin的娱乐空间
09-18 175
正题 首先答案是有二分性的,所以我们先二分这个max. 那么我们就知道b的每行每列的取值范围了,建个二分图,左边是b的行,右边是b的列,中间的边是个完全图,上下界是[l,r],源汇到二分图的两边连行列的取值范围,然后就是一个有源汇上下界网络流的板子. #include<bits/stdc++.h> using namespace std; const int N=410; struct edge{ int y,nex,c; }s[N*N]; int first...
洛谷P4843 清理雪道【有上下界最小流】
niiick
03-13 168
时空限制 1000ms / 128MB 题目描述 滑雪场坐落在FJ省西北部的若干座山上。 从空中鸟瞰，滑雪场可以看作一个有向无环图，每条弧代表一个斜坡（即雪道），弧的方向代表斜坡下降的方向。 你的团队负责每周定时清理雪道。你们拥有一架直升飞机，每次飞行可以从总部带一个人降落到滑雪场的某个地点，然后再飞回总部。从降落的地点出发，这个人可以顺着斜坡向下滑行，并清理他所经过的雪道。 由于每次飞行的耗费是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值