[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[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[N],d[N],cure[N],pre[N];
    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);
}