1930: [Shoi2003]pacman 吃豆豆

1930: [Shoi2003]pacman 吃豆豆

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 1969  Solved: 461
[Submit][Status][Discuss]

Description

两个PACMAN吃豆豆。一开始的时候，PACMAN都在坐标原点的左下方，豆豆都在右上方。PACMAN走到豆豆处就会吃掉它。PACMAN行走的路线很奇怪，只能向右走或者向上走，他们行走的路线不可以相交。 请你帮这两个PACMAN计算一下，他们俩加起来最多能吃掉多少豆豆。

Input

第一行为一个整数N，表示豆豆的数目。 接下来 N 行，每行一对正整数，表示第i个豆豆的坐标。任意两个豆豆的坐标都不会重合。

Output

仅有一行包含一个整数，即两个PACMAN加起来最多能吃掉的豆豆数量

Sample Input

8

8 1

1 5

5 7

2 2

7 8

4 6

3 3

6 4

Sample Output

7

HINT

N < = 2000

Source

 

[Submit][Status][Discuss]

题目大意：
　　两个 PACMAN 吃豆豆。一开始的时候，PACMAN 都在坐标原点的左下方，豆豆都在右上方。

PACMAN 走到豆豆处就会吃掉它。PACMAN 行走的路线很奇怪，只能向走或者向上走，他们行走的路线不可以相交。

请你帮这两个 PACMAN 计算一下，他们俩加起来最多能吃掉多少豆豆。

解析：
　　每个点拆成两个，之间连一条流量为1，费用为1的边；
　　如果从一个点出发可以到达另一个点，就将前一个点的出点连向后一个点的入点
　　跑费用流。但是这样显然是会TLE的
　　如果i能到j，j能到k，那么显然无需连i->k这条边 这是一个剪枝
　　加了这个剪枝之后可能会WA 因此还要考虑一个点经过多次的情况
　　即每个点从入点向出点再连一条流量为1，费用为0的边
　　加了这个之后就能过了 剪枝不强 但是没有什么情况能把这个卡掉
　　MS是可以证明复杂度是根号级别的

//204 ms

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int read(){
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
const int N=;
const int inf=0x3f3f3f3f;
struct node{int x,y;}g[N];
struct edge{int v,cap,cost,next;}e[N*];int tot=,head[N];
int n,m,ans,S,T,dis[N],Prev[N],flow[N],q[N*];
bool vis[N];
bool cmp(const node &a,const node &b){
    if(a.x!=b.x) return a.x<b.x;
    return a.y<b.y;
}
void add(int x,int y,int z,int cost){
    e[++tot].v=y;e[tot].cap=z;e[tot].cost=cost;e[tot].next=head[x];head[x]=tot;
    e[++tot].v=x;e[tot].cap=;e[tot].cost=-cost;e[tot].next=head[y];head[y]=tot;
}
bool spfa(){
    for(int i=S;i<=T;i++) vis[i]=,dis[i]=-;
    //int h=0,t=1; RE*32!!!
    //改：用下面的unsigned short或用循环队列
    unsigned short h=,t=;q[t]=S;dis[S]=;flow[S]=inf;
    while(h!=t){
        int x=q[++h];vis[x]=;
        for(int i=head[x];i;i=e[i].next){
            if(e[i].cap&&dis[e[i].v]<dis[x]+e[i].cost){
                dis[e[i].v]=dis[x]+e[i].cost;
                Prev[e[i].v]=i;
                flow[e[i].v]=min(flow[x],e[i].cap);
                if(!vis[e[i].v]){
                    vis[e[i].v]=;
                    if(dis[e[i].v]>dis[x])
                        q[h--]=e[i].v;
                    else
                        q[++t]=e[i].v;
                }
            }
        }
    }
    return dis[T]!=-;
}
void augment(){
    for(int i=T;i!=S;i=e[Prev[i]^].v){
        e[Prev[i]].cap-=flow[T];
        e[Prev[i]^].cap+=flow[T];
    }
    ans+=dis[T]*flow[T];
}
int main(){
    n=read();
    for(int i=;i<=n;i++) g[i].x=read(),g[i].y=read();
    sort(g+,g+n+,cmp);
    int sink=n<<|,sour=sink+;S=;T=sour+;
    for(int i=;i<=n;i++){
        add(sink,i,,);
        add(i,i+n,,);
        add(i,i+n,,);
        add(i+n,sour,,);
    }
    for(int i=;i<=n;i++){
        int tmp=-;
        for(int j=i-;j;j--){
            if(g[j].y<=g[i].y&&g[j].y>tmp){
                tmp=g[j].y;
                add(j+n,i,,);
            }
        }
    }
    add(S,sink,,);
    add(sour,T,,);
    while(spfa()) augment();
    printf("%d",ans);
    return ;
}

//=================================================================

dp:

首先建出图，f[i][j]表示a吃到了i点，b吃到了j点的最大值，转移的时候转移拓扑序小的那一维，如果i拓扑序小于j，那么转移到f[k][j]，否则转移到f[i][k],建出的图边数也要优化，不然会超时。优化的方法是假如i,j连边，那么如果有一条边(i,k),x[k]>x[j]并且y[k]>y[j]那么(i,k)这条边就没有必要存在了。因为先取(i,j)在去(j,k)会比直接取(i,k)要好。

//612 ms

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=;
const int M=;
struct node{int x,y;}g[N];
struct edge{int v,next;}e[N*];int tot,head[N];
int n,cnt,T,rd[N],id[N],ID[N],q[N*];
int f[M][M];
inline void add(int x,int y){
    e[++tot].v=y;e[tot].next=head[x];head[x]=tot;
    e[++tot].v=x;e[tot].next=head[y];head[y]=tot;
}
inline bool cmp(const node &a,const node &b){
    if(a.x!=b.x) return a.x<b.x;
    return a.y<b.y;
}
inline void top_sort(){
    unsigned short h=,t=;q[t]=;
    while(h!=t){
        int x=q[++h];
        id[x]=++cnt;
        ID[cnt]=x;
        for(int i=head[x];i;i=e[i].next){
            if(--rd[e[i].v]==){
                q[++t]=e[i].v;
            }
        }
    }
}
inline void dp(int x,int y){
    for(int i=head[x];i;i=e[i].next){
        int a=e[i].v,b=y;
        if(id[a]>id[b]) swap(a,b);
        if(a!=b)
            f[a][b]=max(f[a][b],f[x][y]+);
        else
            f[a][b]=max(f[a][b],f[x][y]);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d%d",&g[i].x,&g[i].y);
    sort(g+,g+n+,cmp);
    for(int i=;i<=n;i++){
        int tmp=2e9;
        for(int j=i+;j<=n;j++){
            if(i!=j&&g[i].x<=g[j].x&&g[i].y<=g[j].y&&g[j].y<tmp){
                tmp=g[j].y;
                rd[j]++;
                add(i,j);
            }
        }
    }
    T=n+;
    for(int i=;i<=n;i++){
        add(,i);rd[i]++;
        add(i,T);rd[T]++;
    }
    top_sort();
    for(int i=;i<=cnt;i++){
        for(int j=i;j<=cnt;j++){
            dp(ID[i],ID[j]);
        }
    }
    printf("%d",f[T][T]-);
    return ;
}