[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[N],b[N];
 int n,f[N],g[N],X[N],Y[N];
 int head[N],tot,d[N];
 struct edge{int next,to,v;}e[];
 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,};
     head[v]=tot++;
 }
 int SAP(int start,int end,int n)
 {
     int u,neck,tmp,i,flow_ans=,cur_flow;
     int numh[N],d[N],cure[N],pre[N];
     memset(d,,sizeof(d));
     memset(numh,,sizeof(numh));
     memset(pre,-,sizeof(pre));
     for(int i=;i<=n;i++)
     cure[i]=head[i];
     numh[]=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^].v+=cur_flow;
             }
             flow_ans+=cur_flow;
             u=neck;
         }
         for(i=cure[u];i!=-;i=e[i].next)
         if(e[i].v&&d[u]==d[e[i].to]+)break;
         if(i!=-)
         {
             cure[u]=i;
             pre[e[i].to]=u;
             u=e[i].to;
         }
         else
         {
             if(--numh[d[u]]==)break;
             cure[u]=head[u];
             for(tmp=n,i=head[u];i!=-;i=e[i].next)
             if(e[i].v)tmp=min(tmp,d[e[i].to]);
             d[u]=tmp+;
             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+)
     a[i].f=a[j].f+,a[i].from=j,a[i].f1=;
 }
 void print(int x,bool f)
 {
     if(x==n+)return;
     if(!f)print(a[x].from,a[x].f1);
     else print(b[x].from,);
     if(!a[x].f1||f)
     printf("%d ",a[x].id);
     else if(!a[x].f2)
     {
         for(int i=a[x].from-;a[i].y==a[x].y;i--)
         printf("%d ",a[i].id);
         for(int i=a[x].from+;i<=x;i++)
         printf("%d ",a[i].id);
     }
     else
     {
         for(int i=a[x].from+;a[i].y==a[x].y;i++)
         printf("%d ",a[i].id);
         for(int i=a[x].from-;i>=x;i--)
         printf("%d ",a[i].id);
     }
 }
 map<int,int>L,R,U;
 void solve(int ans)
 {
     memset(head,-,sizeof(head));
     L.clear();
     R.clear();
     U.clear();
     for(int i=;i<=n;i++)
     X[i]=a[n+-i].x,Y[i]=a[n+-i].y;
     X[n+]=Y[n+]=;
     for(int i=;i<=n;i++)f[i]=;
     for(int l=,r,x;l<=n+;l=r+)
     {
         for(r=l;r<=n&&Y[r+]==Y[r];r++);
         for(int i=l;i<=r;i++)
         {
             x=U[X[i]];
             if(x)
             {
                 f[i]=max(f[i],f[x]+);
                 if((a[n+-i].f||i==n+)&&a[n+-i].f+f[x]==ans)
                 {
                     add(n+-x,n+-i,1e9);
                     d[n+-x]--;d[n+-i]++;
                 }
             }
             x=L[X[i]+Y[i]];
             if(x)
             {
                 f[i]=max(f[i],f[x]+);
                 if((a[n+-i].f||i==n+)&&a[n+-i].f+f[x]==ans)
                 {
                     add(n+-x,n+-i,1e9);
                     d[n+-x]--;d[n+-i]++;
                 }
             }
             x=R[X[i]-Y[i]];
             if(x)
             {
                 f[i]=max(f[i],f[x]+);
                 if((a[n+-i].f||i==n+)&&a[n+-i].f+f[x]==ans)
                 {
                     add(n+-x,n+-i,1e9);
                     d[n+-x]--;d[n+-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=;
         for(int i=l+;i<=r;i++)
         {
             if(!maxid||g[i-]+(r-i+)>g[maxid]+(r-maxid))maxid=i-;
             if(f[i]<g[maxid]+(r-maxid))
             f[i]=g[maxid]+(r-maxid);
         }
         maxid=;
         for(int i=r-;i>=l;i--)
         {
             if(!maxid||g[i+]+(i+-l)>g[maxid]+(maxid-l))maxid=i+;
             if(f[i]<g[maxid]+(maxid-l))
             f[i]=g[maxid]+(maxid-l);
         }
     }
     for(int i=;i<=n;i++)
     add(S,i,1e9),add(i,T,1e9);
     for(int i=;i<=n;i++)
     if(d[i]>)add(SS,i,d[i]);
     else add(i,TT,-d[i]);
     SAP(SS,TT,TT+);
     add(T,S,1e9);
     SAP(SS,TT,TT+);
     printf("%d\n",e[tot-].v);
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     scanf("%d%d",&a[i].x,&a[i].y),a[i].id=i;
     sort(a+,a+n+);
     U[]=L[]=R[]=n+;
     for(int l=,r,x;l<=n;l=r+)
     {
         for(r=l;r<n&&a[r+].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=;
         for(int i=l+;i<=r;i++)
         {
             if(b[i-].f>b[maxid].f)maxid=i-;
             if(maxid&&a[i].f<b[maxid].f+(i-l))
             {
                 a[i].f=b[maxid].f+(i-l);
                 a[i].f1=;a[i].f2=;a[i].from=maxid;
             }
         }
         maxid=;
         for(int i=r-;i>=l;i--)
         {
             if(b[i+].f>b[maxid].f)maxid=i+;
             if(maxid&&a[i].f<b[maxid].f+(r-i))
             {
                 a[i].f=b[maxid].f+(r-i);
                 a[i].f1=;a[i].f2=;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=,id=n+;
     for(int i=;i<=n;i++)
     if(a[i].f>ans)
     ans=a[i].f,id=i;
     printf("%d\n",ans);
     print(id,);puts("");
     solve(ans);
 }