[DP 上下界最小流] BZOJ4200 [Noi2015]小园丁与老司机

最新推荐文章于 2022-11-17 08:58:05 发布
最新推荐文章于 2022-11-17 08:58:05 发布
阅读量1.8k 收藏
点赞数
分类专栏： 网络流 DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014609452/article/details/50908446
版权
DP 同时被 2 个专栏收录
150 篇文章 1 订阅
订阅专栏
网络流
44 篇文章 0 订阅
订阅专栏

膜拜大神题解： http://blog.csdn.net/popoqqq/article/details/47402925

http://www.cnblogs.com/maijing/p/4689740.html


不管怎么说，参观了很多大神的代码，还是把老司机给A掉了

第一二问 DP 但是细节很多 码出来的神犇很强 自己代码能力太差

然后之后还得来个DP 与第一遍方向相反 就是倒着走  用来判断是不是最长链上的一条边 %%PoPoQQQ

之后就是有下界的最小流 

”

求有上下界的最小流的做法是：
建立superS和superT；
in[i]表示i号点入边的下界和。
out[i]表示i号点出边的下界和。
superS连向每个点i一条容量为in[i]的边；每个点i连向superT一条容量为out[i]边；
原图的边的容量变成为上界-下界。

先不连S到T，求superS到superT的最大流。然后再连S到T一条容量为INF的边，再求supperS到superT的最大流，如果满流，则第二次增广的就是原图的最小流，其实就是满流减去第一次做的最大流。否则无解。

但这道题是肯定有解的，所以不用第二次增广，直接满流-第一次增广得到的最大流。

“ ——来自maijing


其他感想：

出这道题的神犇也很强！要是有点条件的变动，那么似乎就会很难做，比如只保留水平压痕。一道道题下来，真的想在OI这条路上走得更远。


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;

inline char nc(){
	static char buf[100000],*p1=buf,*p2=buf;
	if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
	return *p1++;
}

inline void read(int &x){
	char c=nc(),b=1;
	for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
	for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
int n;
struct Point{
	int x,y,idx;
	bool operator < (const Point &B) const{
		return y==B.y?x<B.x:y<B.y;
	}
}P[50005];

int Ans,Cnt,Minc;
int f[50005],h[50005],mx[50005];
int g[50005],pre[50005];
int pnt,lst[50005];

inline void load(int x,int y)
{
	int t;
	if (x<y)
	{
		for (t=y;t>x;t--) lst[++pnt]=t;
		while (P[t].y==P[t-1].y) t--;
		for (;t<=x;t++) lst[++pnt]=t;
	}
	else
	{
		for (t=y;t<x;t++) lst[++pnt]=t;
		while (P[t].y==P[t+1].y) t++;
		for (;t>=x;t--) lst[++pnt]=t;
	}
}

inline void Print()
{
	if (!Ans) { printf("\n"); return; } 
	int t=0;
	for (int i=1;i<=n && !t;i++)
		if (f[i]==Ans)
			t=i;
	for (int i=t;i;)
		if (pre[i])
			load(pre[i],i),i=g[pre[i]];
		else
			lst[++pnt]=i,i=g[i];
	for (int i=pnt;i>1;i--)
		printf("%d ",P[lst[i]].idx);
	printf("%d\n",P[lst[1]].idx);
}

map<int,int> m1,m2,m3;

inline void DP()
{
	int pos;
	m1.clear(); m2.clear(); m3.clear();
	m1[0]=m2[0]=m3[0]=0;
	for (int i=1;i<=n;i++) f[i]=-1<<30;
	for (int i=1,t;i<=n;i=t+1)
	{
		t=i;
		while (t+1<=n && P[t].y==P[t+1].y) t++;
		for (int j=i;j<=t;j++)
		{
			if (m1.find(P[j].x+P[j].y)!=m1.end())
			{
				pos=m1[P[j].x+P[j].y];
				if (f[j]<f[pos]+1) f[j]=f[pos]+1,g[j]=pos;
			}
			m1[P[j].x+P[j].y]=j;
			if (m2.find(P[j].x-P[j].y)!=m2.end())
			{
				pos=m2[P[j].x-P[j].y];
				if (f[j]<f[pos]+1) f[j]=f[pos]+1,g[j]=pos;
			}
			m2[P[j].x-P[j].y]=j;
			if (m3.find(P[j].x)!=m3.end())
			{
				pos=m3[P[j].x];
				if (f[j]<f[pos]+1) f[j]=f[pos]+1,g[j]=pos;
			}
			m3[P[j].x]=j;
		}
		for (int j=i;j<=t;j++) mx[j]=f[j];
		pos=-1;
		for (int j=i+1;j<=t;j++)
		{
			if (pos==-1 || f[j-1]>f[pos]) pos=j-1;
			if (mx[j]<f[pos]+j-i) 
				mx[j]=f[pos]+j-i,pre[j]=pos; 
		}
		pos=-1;
		for (int j=t-1;j>=i;j--)
		{
			if (pos==-1 || f[j+1]>f[pos]) pos=j+1;
			if (mx[j]<f[pos]+t-j) 
				mx[j]=f[pos]+t-j,pre[j]=pos; 
		}
		for (int j=i;j<=t;j++)
		{
			if (mx[j]>f[j])
				f[j]=mx[j];
			else
				pre[j]=0;
			Ans=max(Ans,f[j]);
		}
	}
	printf("%d\n",Ans);
	Print();
}

inline void EXDP()
{
	int pos;
	for (int i=1;i<=n;i++) 
		if (f[i]==Ans)
			h[i]=1;
		else 
			h[i]=-1<<30;
	m1.clear(); m2.clear(); m3.clear();
	for (int i=n,t;i;i=t-1)
	{
		t=i;
		while (t-1 && P[t].y==P[t-1].y) t--;
		for (int j=i;j>=t;j--)
		{
			if (m1.find(P[j].x+P[j].y)!=m1.end())
			{
				pos=m1[P[j].x+P[j].y];
				if (h[j]<h[pos]+1) h[j]=h[pos]+1;
			}
			m1[P[j].x+P[j].y]=j;
			if (m2.find(P[j].x-P[j].y)!=m2.end())
			{
				pos=m2[P[j].x-P[j].y];
				if (h[j]<h[pos]+1) h[j]=h[pos]+1;
			}
			m2[P[j].x-P[j].y]=j;
			if (m3.find(P[j].x)!=m3.end())
			{
				pos=m3[P[j].x];
				if (h[j]<h[pos]+1) h[j]=h[pos]+1;
			}
			m3[P[j].x]=j;
		}
		for (int j=i;j>=t;j--) mx[j]=h[j];
		pos=-1;  
        for (int j=t+1;j<=i;j++)  
        {  
            if (pos==-1 || h[j-1]+i-j+1>h[pos]+i-pos) pos=j-1;  
            if (h[pos]+i-pos>mx[j]) 
				mx[j]=h[pos]+i-pos;  
        }  
        pos=-1;  
        for (int j=i-1;j>=t;j--)  
        {  
            if (pos==-1 || h[j+1]+j+1-t>h[pos]+pos-t) pos=j+1;  
            if (h[pos]+pos-t>mx[j]) 
				mx[j]=h[pos]+pos-t;  
        }  
		for (int j=i;j>=t;j--)
			if (mx[j]>h[j]) 
				h[j]=mx[j];
	}
}

namespace DINIC{
	#define oo 1<<30
	#define V G[p].v
	#define cl(x) memset(x,0,sizeof(x))
	#define M 1000000+5
	#define N 60000+5
	struct edge{
		int u,v,f;
		int next;
	};
	edge G[M];
	int head[N],num=1;
	inline void add(int u,int v,int f,int p){
		G[p].u=u; G[p].v=v; G[p].f=f; G[p].next=head[u]; head[u]=p;
	}
	inline void link(int u,int v,int f){
		add(u,v,f,num+=2); add(v,u,0,num^1);
	}
	int S,T;
	int Que[N],l,r;
	int dis[N];
	inline bool bfs(){
		int u;
		memset(dis,-1,sizeof(dis)); cl(Que); l=r=-1;
		dis[S]=1; Que[++r]=S;
		while (l<r)
		{
			u=Que[++l];
			for (int p=head[u];p;p=G[p].next)
				if (G[p].f && dis[V]==-1)
				{
					dis[V]=dis[u]+1;
					Que[++r]=V;
					if (V==T) return true;
				}
		}
		return false;
	} 
	int minimum;
	int cur[N];
	inline bool dfs(int u,int mini){
		if (u==T) { minimum=mini; return true; }
		for (int p=cur[u];p;p=G[p].next)
		{
			cur[u]=p;
			if (G[p].f && dis[V]==dis[u]+1 && dfs(V,min(mini,G[p].f)))
			{
				G[p].f-=minimum; G[p^1].f+=minimum;
				return true;
			}
		}
		dis[u]=-1;
		return false;
	}
	inline int Dinic(){
		int ret=0;
		while (bfs())
		{
			memcpy(cur,head,sizeof(cur));
			while (dfs(S,oo)) ret+=minimum;
		}
		return ret;
	}
	inline void clear(){
		cl(G); cl(head); num=1;
	}
}

int du[50015];

inline void Solve()
{
	using namespace DINIC;
	int s=n+1,t=n+2,pos;
	S=n+3; T=n+4;
	m1.clear(); m2.clear(); m3.clear();
	for (int i=n;i>=0;i--)
	{
		if (m1.find(P[i].x+P[i].y)!=m1.end())
		{
			pos=m1[P[i].x+P[i].y];
			if (f[i]+h[pos]==Ans) link(i,pos,oo),du[i]--,du[pos]++;  
		}
		m1[P[i].x+P[i].y]=i;
		if (m2.find(P[i].x-P[i].y)!=m2.end())
		{
			pos=m2[P[i].x-P[i].y];
			if (f[i]+h[pos]==Ans) link(i,pos,oo),du[i]--,du[pos]++;  
		}
		m2[P[i].x-P[i].y]=i;
		if (m3.find(P[i].x)!=m3.end())
		{
			pos=m3[P[i].x];
			if (f[i]+h[pos]==Ans) link(i,pos,oo),du[i]--,du[pos]++;  
		}
		m3[P[i].x]=i;
	}
	for (int i=0;i<=n;i++)
		link(s,i,oo),link(i,t,oo);
	for (int i=0;i<=n;i++)
		if (du[i]>0) 
			Cnt+=du[i],link(S,i,du[i]);  
      	else
		  	link(i,T,-du[i]); 
	Minc=Dinic();
	Minc=Cnt-Minc;
	printf("%d\n",Minc);
}

int main()
{
	freopen("t.in","r",stdin);
	freopen("t.out","w",stdout);
	read(n);
	for (int i=1;i<=n;i++)
		read(P[i].x),read(P[i].y),P[i].idx=i;
	sort(P+1,P+n+1);
	DP();
	EXDP();
	Solve();
	return 0;
}


里阿奴摩西
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
上下界网络流
04-16
* BZOJ 1458：最小流 * 例题：有一个管子要运输液体物质，物体的流速不能超过管子的容量，且物质不能再节点有积累，即每个节点的流入量等于流出量，在第一个节点生产的物质的流速与第 n 个节点的流速一样，求第一个...
陈立杰历年课件和BZOJ代码
12-04
【陈立杰历年课件和BZOJ代码】是一个集合，包含了知名算法竞赛选手陈立杰（WJMZBMR）在过去的时间里所使用的课件以及他在BZOJ（Best Wrong Judge Online Judge）平台上提交的大部分代码。这个资源对于学习算法、C++...
有源汇上下界最小流（两种模板）
qq_45778406的博客
12-17 329
给定一个包含 n 个点 m 条边的有向图，每条边都有一个流量下界和流量上界。 给定源T点 S和汇点 T，求源点到汇点的最小流。 输入格式 第一行包含四个整数 n,m,S,T。 接下来 m行，每行包含四个整数 a,b,c,d 表示点 a 和 b 之间存在一条有向边，该边的流量下界为 c，流量上界为 d。 点编号从 1到 n。 输出格式 输出一个整数表示最小流。 如果无解，则输出 No Solution。 数据范围 1≤n≤50003,1≤m≤125003,1≤a,b≤n,0≤c≤d≤2147483647,数据
UVA1440 有下界的最小流
水
10-22 1598
题意很简单： 给出一张有向图，每次你可以从图中的任意一点出发，经过若干条边后停止，然后问你最少走几次可以将图中的每条边都走过至少一次，并且要输出方案 这个转化为网络流的话，就相当于 求一个最小流，并且存在下界，即每条边至少走一次 这让我联想到很久之前的一道题，也是有向图，问走多少条路径可以将整个图中的每条边都走过，但是跟本题不同的是，那题是不允许重复走边的。 那道题目的解是这样的：
SGU 176 Flow construction【有上下界最小流】
最新发布
eeeeety6208的博客
11-17 153
首先建立超级源汇ss，tt，没限制的边照常连，对于有限制的边(u,v,mn,mx)，连接(u,v,ss-tt)和辅助边(ss,v,mn)(u,tt,mn)（实际操作中，对每个点记录一个度就行了，然后正的连ss负的连tt），最后连接(t,s,inf)平衡流量。然后记录(t,s)的流量re，删掉(t,s)，答案就是ans=re-dinic()注意有一点，这个ans可能是负的，说明(t,s)和某些边形成了环，可以连接(ss,s,-ans)，跑以ss为源点，t为汇点的最大流。正好考到了所以翻一些题来做……
BZOJ4200: [Noi2015]小园丁与老司机 最小流
リーインカーネイション
04-10 1349
题意：平面上有N（N<=50000）个点，从原点出发，每次可以走上、左、右、左上45度、右上45度五种方向，只有碰到一个未走过的点才能停止，求： 1.最多走多少点 2.输出一种方案 3.对于所有最优方案，只保留上、左上、右上的边，求最少条数的路径将所有边都覆盖 同一y坐标的点不超过1000个 前两问DP一下即可，将所有点按y为一关键字x为二关键字排序，然后对于每一行的每个点，枚举是从这行之
POJ 3801 Crazy Circuits 有源汇的上下界最小流
代码改变世界，keep coding。
01-20 1469
点击打开链接 Crazy Circuits Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 512   Accepted: 421 Description You’ve just built a circuit board for your new
bzoj测试数据118题数据
05-07
八中OJ,又简作BZOJ,以原题巨多而著称，该数据为BZOJ上的1000-1109和1130-1139的测试数据节点，没有题目，有需要题目的可以到https://hydro.ac/d/bzoj/p网站查找对应的题目。
周东《浅析最大最小定理在信息学竞赛中的应用》
05-30
周东大神关于s-t平面图与对偶图的转化PPT 可以快速求解s-t平面图中的最大流问题 解释很详细，很有帮助
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
有流量上下界的最大流最小流算法实现
03-04
有流量上下界的最大流和最小流
有源汇上下界最小流[模板]
jziwjxjd的博客
08-26 415
这只是其中一种做法这只是其中一种做法这只是其中一种做法(我暂时还没有理解,只是先放个模板而已) 首先还是根据下界来建图,原图源点s,汇点t首先还是根据下界来建图,原图源点s,汇点t首先还是根据下界来建图,原图源点s,汇点t 然后因为流量守恒,新建超级源s1和超级汇t1向各个点连边然后因为流量守恒,新建超级源s1和超级汇t1向各个点连边然后因为流量守恒,新建超级源s1和超级汇t1向各个点连边 跑一遍s1到t1的最大流(也就是可行流)跑一遍s1到t1的最大流(也就是可行流)跑一遍s1到t1的最大流(也就是可行流
【BZOJ4200】【NOI2015】小园丁与老司机（动态规划，网络流）
小蒟蒻yyb的博客
07-10 346
题面 BZOJ权限题，洛谷链接 题解 一道二合一的题目 考虑第一问。 先考虑如何计算六个方向上的第一个点。 左右上很好考虑，只需要按照xxx或者yyy轴排序就行了。 对于454545度的斜角，两点一定在同一条直线上。 这条直线是x+y=bx+y=bx+y=b或x−y=bx−y=bx-y=b 所以按照x+yx+yx+y和x−yx−yx-y的值分类考虑，再按照顺序在xxx轴扫一遍...
【BZOJ4200】【UOJ132】【NOI2015】小园丁与老司机
cz_xuyixuan的博客
05-28 517
【题目链接】BZOJUOJ【思路要点】将所有点按照纵坐标排序，分别处理同一纵坐标的点。显然，每个点在各个方向上的后继点若存在，是唯一的，先预处理。记\(f_i\)表示从节点\(i\)出发，能够经过的最多的点数。若不考虑左右的移动，\(f_i\)就是\(i\)在三个方向上后继结点的\(f\)值的最大值加1，记这个值为\(tmp_i\)。不妨令同一纵坐标的点横坐标递增，那么有\(f_i=max\{tm...
bzoj4200 [Noi2015]小园丁与老司机（dp+记录路径+有源汇有上下界最小流）
Icefox的博客
12-21 416
这题。。。连想带写一整天gg 首先第一问，是个dp，先把所有点按y为第一关键字，x为第二关键字，从小到大排序，我们把所有y相等的点叫做一层。则一层一层的dp，隔层之间转移可以直接O(1)转移（每个点只能从最多三个点上来），层内可以O(n2)O(n^2)转移（如果不要求记录路径的话，可以做到O(n)）。同层怎么转移呢？首先我们有刚进入这一层时各个点的最优值，现在我们要求出从这一层出去的每个点的最优值
【模板】有源汇有上下界最小流
zxyoi_dreamer的博客（不定期诈尸）
08-20 215
参考题目：loj117 老规矩，先扔一个板子。改天更新，如有不足欢迎指正。 代码： #include&amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;gt; using namespace std; #define ll long long #define re register #define gc getchar #define pc putchar #define cs const #def...
4200: [Noi2015]小园丁与老司机
CRZbulabula的博客
12-29 1971
4200: [Noi2015]小园丁与老司机 Time Limit: 20 Sec  Memory Limit: 512 MBSec  Special Judge Submit: 139  Solved: 80 [Submit][Status][Discuss] Description 小园丁 Mr. S 负责看管一片田野，田野可以看作一个二维平面。田野上有 nn 棵许愿树，编号 1
2018.08.20 loj#117. 有源汇有上下界最小流（模板）
苟为蒟蒻又何妨
08-20 283
传送门 这题真有意思。。。 先是有一个点T的我怀疑人生。 然后学大佬们封装了我的dinic就莫名其妙的过了？？？ 所以说锅给谁好呢？ 给dinic吧。。。 解法就是先求出一段可行流，然后从t到s加一条容量为inf的边将能缩回去的都缩回去。 代码： #include&lt;bits/stdc++.h&gt; #define ll long long #define inf 0x3f3...
【bzoj4200】[Noi2015]小园丁与老司机 dp+有上下界的网络流
Oxer的专栏
02-29 1533
1、以y为第一关键字，x为第二关键字排序 2、对于y相同的点，处理出从一个点a只横着走走到b最多经过多少棵树，记作num[a][b] 3、DP，dp[i]表示走到第i个点的最多走过多少棵树，g[i]表示第i棵树是从哪棵树走过来的 4、输出方案 5、按照最优方案连边 6、建图最小流 这题细节太多了！！！ 建图的方法我是学PoPoQQQ大爷的，先正着dp一遍，再倒着dp一遍。
最小费用流算法详解与实现
"该资源提供了一个关于最小费用流问题的参考实现，主要涉及网络流理论、最大流算法和最短增广路算法。题目来源于BZOJ1292，通过残留图和代价矩阵来存储网络信息。" 最小费用流问题是在网络流的基础上引入费用概念，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值