[BZOJ4200][Noi2015]小园丁与老司机

4200: [Noi2015]小园丁与老司机

Time Limit: 20 Sec Memory Limit: 512 MBSec Special Judge
Submit: 106 Solved: 58
[Submit][Status][Discuss]

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)→(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)(−1,1)→(−2,2) 和 (0,0)→(0,8)→(0,9)→(0,10)(0,0)→(0,8)→(0,9)→(0,10)。

HINT

Source

[Submit][Status][Discuss]

HOME Back

第一问按Y排序，map记录每个向上、左、右方向最近的点，对于y坐标相同的点按x排序，如果$x_i>x_j$，一定是从j走到最左在走回i，如果$x_i<x_j$，一定是从j走到最走在走回i。维护一个单调栈即可。

第二问只需要在DP的同时记录决策点，输出路径。

第三问相当于判断每条边是否可以存在于最长路中，然后下界为1跑最小流。如果判断每条边可以倒着DP一遍考虑是否两端和等于ans。注意，倒着DP和正着DP会有差别。

#include<map>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 50050
#define S (n+1)
#define T (n+2)
#define SS (n+3)
#define TT (n+4)
using namespace std;
struct dp{int x,y,id,f,from;bool f1,f2;}a
,b
;
int n,f
,g
,X
,Y
;
int head
,tot,d
;
struct edge{int next,to,v;}e[2100000];
inline void add(int u,int v,int w)
{
e[tot]=(edge){head[u],v,w};
head[u]=tot++;
e[tot]=(edge){head[v],u,0};
head[v]=tot++;
}
int SAP(int start,int end,int n)
{
int u,neck,tmp,i,flow_ans=0,cur_flow;
int numh
,d
,cure
,pre
;
memset(d,0,sizeof(d));
memset(numh,0,sizeof(numh));
memset(pre,-1,sizeof(pre));
for(int i=0;i<=n;i++)
cure[i]=head[i];
numh[0]=n;
u=start;
while(d[start]<n)
{
if(u==end)
{
cur_flow=1e9;
for(i=start;i!=end;i=e[cure[i]].to)
if(cur_flow>e[cure[i]].v)
neck=i,cur_flow=e[cure[i]].v;
for(i=start;i!=end;i=e[cure[i]].to)
{
tmp=cure[i];
e[tmp].v-=cur_flow;
e[tmp^1].v+=cur_flow;
}
flow_ans+=cur_flow;
u=neck;
}
for(i=cure[u];i!=-1;i=e[i].next)
if(e[i].v&&d[u]==d[e[i].to]+1)break;
if(i!=-1)
{
cure[u]=i;
pre[e[i].to]=u;
u=e[i].to;
}
else
{
if(--numh[d[u]]==0)break;
cure[u]=head[u];
for(tmp=n,i=head[u];i!=-1;i=e[i].next)
if(e[i].v)tmp=min(tmp,d[e[i].to]);
d[u]=tmp+1;
numh[d[u]]++;
if(u!=start)u=pre[u];
}
}
return flow_ans;
}
bool operator<(dp x,dp y)
{
if(x.y!=y.y)return x.y<y.y;
return x.x<y.x;
}
inline void update(int i,int j)
{
if(a[i].f<a[j].f+1)
a[i].f=a[j].f+1,a[i].from=j,a[i].f1=0;
}
void print(int x,bool f)
{
if(x==n+1)return;
if(!f)print(a[x].from,a[x].f1);
else print(b[x].from,0);
if(!a[x].f1||f)
printf("%d ",a[x].id);
else if(!a[x].f2)
{
for(int i=a[x].from-1;a[i].y==a[x].y;i--)
printf("%d ",a[i].id);
for(int i=a[x].from+1;i<=x;i++)
printf("%d ",a[i].id);
}
else
{
for(int i=a[x].from+1;a[i].y==a[x].y;i++)
printf("%d ",a[i].id);
for(int i=a[x].from-1;i>=x;i--)
printf("%d ",a[i].id);
}
}
map<int,int>L,R,U;
void solve(int ans)
{
memset(head,-1,sizeof(head));
L.clear();
R.clear();
U.clear();
for(int i=1;i<=n;i++)
X[i]=a[n+1-i].x,Y[i]=a[n+1-i].y;
X[n+1]=Y[n+1]=0;
for(int i=1;i<=n;i++)f[i]=1;
for(int l=1,r,x;l<=n+1;l=r+1)
{
for(r=l;r<=n&&Y[r+1]==Y[r];r++);
for(int i=l;i<=r;i++)
{
x=U[X[i]];
if(x)
{
f[i]=max(f[i],f[x]+1);
if((a[n+1-i].f||i==n+1)&&a[n+1-i].f+f[x]==ans)
{
add(n+1-x,n+1-i,1e9);
d[n+1-x]--;d[n+1-i]++;
}
}
x=L[X[i]+Y[i]];
if(x)
{
f[i]=max(f[i],f[x]+1);
if((a[n+1-i].f||i==n+1)&&a[n+1-i].f+f[x]==ans)
{
add(n+1-x,n+1-i,1e9);
d[n+1-x]--;d[n+1-i]++;
}
}
x=R[X[i]-Y[i]];
if(x)
{
f[i]=max(f[i],f[x]+1);
if((a[n+1-i].f||i==n+1)&&a[n+1-i].f+f[x]==ans)
{
add(n+1-x,n+1-i,1e9);
d[n+1-x]--;d[n+1-i]++;
}
}
U[X[i]]=i;
L[X[i]+Y[i]]=i;
R[X[i]-Y[i]]=i;
}
for(int i=l;i<=r;i++)g[i]=f[i];
int maxid=0;
for(int i=l+1;i<=r;i++)
{
if(!maxid||g[i-1]+(r-i+1)>g[maxid]+(r-maxid))maxid=i-1;
if(f[i]<g[maxid]+(r-maxid))
f[i]=g[maxid]+(r-maxid);
}
maxid=0;
for(int i=r-1;i>=l;i--)
{
if(!maxid||g[i+1]+(i+1-l)>g[maxid]+(maxid-l))maxid=i+1;
if(f[i]<g[maxid]+(maxid-l))
f[i]=g[maxid]+(maxid-l);
}
}
for(int i=0;i<=n;i++)
add(S,i,1e9),add(i,T,1e9);
for(int i=0;i<=n;i++)
if(d[i]>0)add(SS,i,d[i]);
else add(i,TT,-d[i]);
SAP(SS,TT,TT+1);
add(T,S,1e9);
SAP(SS,TT,TT+1);
printf("%d\n",e[tot-1].v);
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d%d",&a[i].x,&a[i].y),a[i].id=i;
sort(a+1,a+n+1);
U[0]=L[0]=R[0]=n+1;
for(int l=1,r,x;l<=n;l=r+1)
{
for(r=l;r<n&&a[r+1].y==a[r].y;r++);
for(int i=l;i<=r;i++)
{
x=U[a[i].x];
if(x)update(i,x);
x=L[a[i].x+a[i].y];
if(x)update(i,x);
x=R[a[i].x-a[i].y];
if(x)update(i,x);
}
for(int i=l;i<=r;i++)b[i]=a[i];
int maxid=0;
for(int i=l+1;i<=r;i++)
{
if(b[i-1].f>b[maxid].f)maxid=i-1;
if(maxid&&a[i].f<b[maxid].f+(i-l))
{
a[i].f=b[maxid].f+(i-l);
a[i].f1=1;a[i].f2=0;a[i].from=maxid;
}
}
maxid=0;
for(int i=r-1;i>=l;i--)
{
if(b[i+1].f>b[maxid].f)maxid=i+1;
if(maxid&&a[i].f<b[maxid].f+(r-i))
{
a[i].f=b[maxid].f+(r-i);
a[i].f1=1;a[i].f2=1;a[i].from=maxid;
}
}
for(int i=l;i<=r;i++)
if(a[i].f)
{
U[a[i].x]=i;
L[a[i].x+a[i].y]=i;
R[a[i].x-a[i].y]=i;
}
}
int ans=0,id=n+1;
for(int i=1;i<=n;i++)
if(a[i].f>ans)
ans=a[i].f,id=i;
printf("%d\n",ans);
print(id,0);puts("");
solve(ans);
}

View Code