【BZOJ4200】[Noi2015]小园丁与老司机 DP+最小流

【BZOJ2839】[Noi2015]小园丁与老司机

Description

小园丁 Mr. S 负责看管一片田野，田野可以看作一个二维平面。田野上有 nn 棵许愿树，编号 1,2,3,…,n1,2,3,…,n，每棵树可以看作平面上的一个点，其中第 ii 棵树 （1≤i≤n1≤i≤n） 位于坐标 (xi,yi)(xi,yi)。任意两棵树的坐标均不相同。
老司机 Mr. P 从原点 (0,0)(0,0) 驾车出发，进行若干轮行动。每一轮，Mr. P 首先选择任意一个满足以下条件的方向：
为左、右、上、左上 45∘45∘ 、右上 45∘45∘ 五个方向之一。
沿此方向前进可以到达一棵他尚未许愿过的树。
完成选择后，Mr. P 沿该方向直线前进，必须到达该方向上距离最近的尚未许愿的树，在树下许愿并继续下一轮行动。如果没有满足条件的方向可供选择，则停止行动。他会采取最优策略，在尽可能多的树下许愿。若最优策略不唯一，可以选择任意一种。
不幸的是，小园丁 Mr. S 发现由于田野土质松软，老司机 Mr. P 的小汽车在每轮行进过程中，都会在田野上留下一条车辙印，一条车辙印可看作以两棵树（或原点和一棵树）为端点的一条线段。
在 Mr. P 之后，还有很多许愿者计划驾车来田野许愿，这些许愿者都会像 Mr. P 一样任选一种最优策略行动。Mr. S 认为非左右方向（即上、左上 45∘45∘ 、右上 45∘45∘ 三个方向）的车辙印很不美观，为了维护田野的形象，他打算租用一些轧路机，在这群许愿者到来之前夯实所有“可能留下非左右方向车辙印”的地面。
“可能留下非左右方向车辙印”的地面应当是田野上的若干条线段，其中每条线段都包含在某一种最优策略的行进路线中。每台轧路机都采取满足以下三个条件的工作模式：
从原点或任意一棵树出发。
只能向上、左上 45∘45∘ 、右上 45∘45∘ 三个方向之一移动，并且只能在树下改变方向或停止。
只能经过“可能留下非左右方向车辙印”的地面，但是同一块地面可以被多台轧路机经过。
现在 Mr. P 和 Mr. S 分别向你提出了一个问题:
请给 Mr .P 指出任意一条最优路线。
请告诉 Mr. S 最少需要租用多少台轧路机。

Input

输入文件的第 1 行包含 1 个正整数 n，表示许愿树的数量。

接下来 n 行，第 i+1 行包含 2个整数 xi,yi，中间用单个空格隔开，表示第 i 棵许愿树的坐标。

Output

输出文件包括 3 行。
输出文件的第 1 行输出 1 个整数 m，表示 Mr. P 最多能在多少棵树下许愿。
输出文件的第 2 行输出 m 个整数，相邻整数之间用单个空格隔开，表示 Mr. P 应该依次在哪些树下许愿。
输出文件的第 3 行输出 1 个整数，表示 Mr. S 最少需要租用多少台轧路机。

Sample Input

6

-1 1

1 1

-2 2

0 8

0 9

0 10

Sample Output

3

2 1 3

3

explanation

最优路线 2 条可许愿 3 次：(0,0)→(1,1)→(−1,1)→(−2,2) 或 (0,0)→(0,8)→(0,9)→(0,10)(0,0)→(0,8)→(0,9)→(0,10)。 至少 3 台轧路机，路线是 (0,0)→(1,1)(0,0)→(1,1)，(−1,1)→(−2,2)和 (0,0)→(0,8)→(0,9)→(0,10)。
题解：超级码农题，我一共进行了下面5个操作：

1.预处理出每个点在5个方向上最近的点。
2.正着进行第一次DP，求出f[i]表示从原点到i的最长路径长度，顺便记录个路径。
3.递归输出路径。
4.反着再来一次DP，求出哪些路径在最优路线上。
5.求最小流。

细节有点多，自己的做法也有点麻烦，一个一个说吧~

1.排个序，开3个map搞定。
2.向上转移倒是容易，但是左右转移就有点麻烦了。用f0表示由向上转移得到的DP值，f1表示由左右转移或向上转移得到的DP值。我们先从左往右扫一遍，用f0的前缀最大值+i左边的点的个数来更新i的f1。顺便记录一下i的f0和f1都是从谁转移过来的。再同样的从右往左扫一遍。
3.递归输出即可。如果有左右转移，要把左（右）边所有点都输出，具体顺序好像无所谓。
4.最恶心的一步！因为要求最小流，所以我们要把所有在最优路线上的点都找出来，一个可行的方法就是反过来DP一遍，用g[i]表示从任意一个最优的结束点到i的最长路径长度。如果f[i]+g[j]=最长路径长度，那么i-j这条边在最优路线上。

但是我的方法更麻烦。给每个节点都打一个vis标记，起初最优结束点的vis=2。如果vis&1说明它可以向下传递标记，如果vis&2说明它可以左右传递标记。如果标记能沿着一条路径传递，则说明这条路径在最优路线上。具体地，vis&2的标记在左右传递后vis变成1，vis&1的标记在向下传递后vis变成2，如果一个点的f0=f1，且vis=1或2，那么vis=3。感觉正常人应该不懂我在说什么~

5.最小流。这里学到了一种求最小流的新方法：先不练T到S的那条边，跑从SS到TT的最大流，设流量为x1，再连从T到S，容量inf的边，跑从SS到TT的最大流，设增加的流量为x2，如果第二次满流则说明有解。但是本题一定是能满流的，所以不需要跑第二次，甚至不需要S和T两点，直接用满流-x1就行了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
const int maxn=50010;
const int inf=1<<30;
//0左1右2上3左上4右上
typedef long long ll;
struct tree
{
int x,y,np[5],vis,org,ls,rs,p1,p2;
}p[maxn];
int n,cnt,S,T,flag,top;
ll tot,ans;
map<int,int> m2,m3,m4;
int f0[maxn],f1[maxn],mn[maxn],st[maxn],d[maxn],p1[maxn],p2[maxn];
int to[1000000],next[1000000],val[1000000],head[maxn];
queue<int> q;
bool cmpy(tree a,tree b)
{
return (a.y==b.y)?(a.x<b.x):(a.y<b.y);
}
void getnp()
{
sort(p,p+n+1,cmpy);
int i,j;
for(i=n;i;i--)
{
p[i].np[2]=m2[p[i].x],p[i].np[3]=m3[p[i].x+p[i].y],p[i].np[4]=m4[p[i].x-p[i].y];
if(p[i-1].y==p[i].y)	p[i-1].np[1]=i,p[i].np[0]=i-1;
m2[p[i].x]=m3[p[i].x+p[i].y]=m4[p[i].x-p[i].y]=i;
}
for(i=1;i<=n;i++)
{
if(!p[i].np[1])	for(j=p[i].np[0];j;j=p[j].np[0])	p[j].rs=p[p[j].np[1]].rs+1;
if(!p[i].np[0])	for(j=p[i].np[1];j;j=p[j].np[1])	p[j].ls=p[p[j].np[0]].ls+1;
}
}
void print(int a)
{
if(a==1)	return ;
if(p[p1[a]].y==p[a].y)
{
print(p2[p1[a]]);
int j;
if(p[p1[a]].x<p[a].x)
{
for(j=p1[a];j;j=p[j].np[0])	printf("%d ",p[j].org);
for(j=p[p1[a]].np[1];j!=a;j=p[j].np[1])	printf("%d ",p[j].org);
}
else
{
for(j=p1[a];j;j=p[j].np[1])	printf("%d ",p[j].org);
for(j=p[p1[a]].np[0];j!=a;j=p[j].np[0])	printf("%d ",p[j].org);
}
}
else	print(p1[a]);
printf("%d ",p[a].org);
}
void add(int a,int b,int c)
{
to[cnt]=b,val[cnt]=c,next[cnt]=head[a],head[a]=cnt++;
to[cnt]=a,val[cnt]=0,next[cnt]=head[b],head[b]=cnt++;
//printf("*%d %d %d\n",a,b,c);
}
void DP()
{
//0从下面上来的1同行转移
memset(f0,0x80,sizeof(f0));
memset(f1,0x80,sizeof(f1));
int i,j,k,mx,mf;
f0[1]=f1[1]=0;
for(i=1;i<=n;i++)
{
if(!p[i].np[0])	for(mx=0,j=i;j;j=p[j].np[1])
{
f1[j]=f0[j],p1[j]=p2[j];
if(f0[mx]+p[j].ls>f1[j])	f1[j]=f0[mx]+p[j].ls,p1[j]=mx;
if(f0[j]>f0[mx])	mx=j;
}
if(!p[i].np[1])
{
for(mx=0,j=i;j;j=p[j].np[0])
{
if(f0[mx]+p[j].rs>f1[j])	f1[j]=f0[mx]+p[j].rs,p1[j]=mx;
if(f0[j]>f0[mx])	mx=j;
}
for(j=i;j;j=p[j].np[0])	for(k=2;k<=4;k++)	if(p[j].np[k])
if(f0[p[j].np[k]]<f1[j]+1)	f0[p[j].np[k]]=f1[j]+1,p2[p[j].np[k]]=j;
}
}
for(mf=n+1,i=1;i<=n;i++)	if(f1[i]>f1[mf])	mf=i;
printf("%d\n",f1[mf]);
print(mf);
printf("\n");
for(i=n;i>=1;i--)
{
if(!p[i].np[1])
{
for(top=0,mx=-inf,j=i;j;j=p[j].np[0])
{
if(f1[j]==f1[mf])	p[j].vis=2;
for(k=2;k<=4;k++)	if(p[j].np[k])
{
if((p[p[j].np[k]].vis&1)&&f0[p[j].np[k]]==f1[j]+1)
{
mn[p[j].np[k]]++,mn[j]--,add(j,p[j].np[k],inf),p[j].vis|=2;
}
}
if(p[j].vis&&f1[j]==f0[j])	p[j].vis|=1;
if((p[j].vis&2)&&mx+p[j].rs==f1[j])
{
while(top)	p[st[top--]].vis|=1;
}
if(f0[j]>mx)	mx=f0[j],top=0;
if(!(p[j].vis&1)&&f0[j]==mx)	st[++top]=j;
}
}
if(!p[i].np[0])
{
for(top=0,mx=-inf,j=i;j;j=p[j].np[1])
{
if((p[j].vis&2)&&mx+p[j].ls==f1[j])
{
while(top)	p[st[top--]].vis|=1;
}
if(f0[j]>mx)	mx=f0[j],top=0;
if(!(p[j].vis&1)&&f0[j]==mx)	st[++top]=j;
}
}
}
}
int rd()
{
int ret=0,f=1;	char gc=getchar();
while(gc<'0'||gc>'9')	{if(gc=='-')f=-f;	gc=getchar();}
while(gc>='0'&&gc<='9')	ret=ret*10+gc-'0',gc=getchar();
return ret*f;
}
int dfs(int x,int mf)
{
if(x==T)	return mf;
int k,temp=mf,i;
for(i=head[x];i!=-1;i=next[i])
{
if(d[to[i]]==d[x]+1&&val[i])
{
k=dfs(to[i],min(temp,val[i]));
if(!k)	d[to[i]]=0;
val[i]-=k,val[i^1]+=k,temp-=k;
if(!temp)	break;
}
}
return mf-temp;
}
int bfs()
{
memset(d,0,sizeof(d));
while(!q.empty())	q.pop();
int i,u;
q.push(S),d[S]=1;
while(!q.empty())
{
u=q.front(),q.pop();
for(i=head[u];i!=-1;i=next[i])
{
if(!d[to[i]]&&val[i])
{
d[to[i]]=d[u]+1;
if(to[i]==T)	return 1;
q.push(to[i]);
}
}
}
return 0;
}
int main()
{
n=rd();
int i;
memset(head,-1,sizeof(head));
for(i=1;i<=n;i++)	p[i].x=rd(),p[i].y=rd(),p[i].org=i;
n++;
getnp(),DP();
S=n+1,T=n+2;
for(i=1;i<=n;i++)
{
if(mn[i]>0)	tot+=mn[i],add(S,i,mn[i]);
if(mn[i]<0)	add(i,T,-mn[i]);
}
while(bfs())	ans+=dfs(S,inf);
printf("%lld",tot-ans);
return 0;
}