【DP】【P1941】【NOIP2014D1T3】飞扬的小鸟

传送门

Description

Flappy Bird是一款风靡一时的休闲手机游戏。玩家需要不断控制点击手机屏幕的频率来调节小鸟的飞行高度，让小鸟顺利通过画面右方的管道缝隙。如果小鸟一不小心撞到了水管或者掉在地上的话，便宣告失败。

为了简化问题，我们对游戏规则进行了简化和改编:

游戏界面是一个长为 n ，高为 m 的二维平面，其中有 k 个管道（忽略管道的宽度）。

小鸟始终在游戏界面内移动。小鸟从游戏界面最左边任意整数高度位置出发，到达游戏界面最右边时，游戏完成。

小鸟每个单位时间沿横坐标方向右移的距离为 1 ，竖直移动的距离由玩家控制。如果点击屏幕，小鸟就会上升一定高度 X ，每个单位时间可以点击多次，效果叠加；如果不点击屏幕，小鸟就会下降一定高度 Y 。小鸟位于横坐标方向不同位置时，上升的高度 X 和下降的高度 Y 可能互不相同。

小鸟高度等于 0 或者小鸟碰到管道时，游戏失败。小鸟高度为 m 时，无法再上升。

现在,请你判断是否可以完成游戏。如果可以，输出最少点击屏幕数；否则，输出小鸟最多可以通过多少个管道缝隙。

Input

第 1 行有 3 个整数 n, m, k分别表示游戏界面的长度，高度和水管的数量，每两个整数之间用一个空格隔开；

接下来的 n 行，每行 2 个用一个空格隔开的整数 X 和 Y ，依次表示在横坐标位置0∼n−1 上玩家点击屏幕后，小鸟在下一位置上升的高度 X ，以及在这个位置上玩家不点击屏幕时，小鸟在下一位置下降的高度 Y 。

接下来 k 行，每行 3 个整数 P, L, H，每两个整数之间用一个空格隔开。每行表示一个管道，其中 P 表示管道的横坐标， L 表示此管道缝隙的下边沿高度， H 表示管道缝隙上边沿的高度（输入数据保证 P 各不相同，但不保证按照大小顺序给出）。

Output

第一行，包含一个整数，如果可以成功完成游戏，则输出 1 ，否则输出 0 。

第二行，包含一个整数，如果第一行为 1 ，则输出成功完成游戏需要最少点击屏幕数，否则，输出小鸟最多可以通过多少个管道缝隙。

Sample Input_1

Sample Output_1

Sample Input_2

Sample Output_2

Hint

对于 30%的数据：5≤n≤10,5≤m≤10,k=0 ，保证存在一组最优解使得同一单位时间最多点击屏幕 33 次；

对于 50%的数据： 5≤n≤20,5≤m≤10 ，保证存在一组最优解使得同一单位时间最多点击屏幕 33次；

对于 70%的数据：5≤n≤1000,5≤m≤100 ；

对于 100%的数据： 5≤m≤1000 ， 0 \leq k < n0≤k<n , 0 < X < m,0<Y<m , 0 < P < n0≤L<H≤m , L + 1 < H

Solution

　　　　这题真恶心……活生生调了我一天。

　　　　看到题目显然是个DP，考虑朴素做法，使用f[i][j]表示坐标在(i,j)的ans。转移使用刷表法易于实现。即：

　　　　　　　　f[i+1][j+up[i]*k]=min{f[i][j]+k | j+up[i]*k<ceil[i+1]}

　　　　　　　　f[i+1][j-down[i]]=min{f[i][j] | j-down[i}>floor[i+1]}

　　　　其中up,down代表在i列的上升、下降高度。ceil代表上方管道的下边界，floor代表下方管道的上边界。

　　　　在上述方程中，枚举m、n、k进行转移。当up特别小但是ceil-floor特别大时，算法的上界复杂度为O(nm²)

　　　　考虑进行优化。

　　　　我们发现，向上转移的时候，类似于一个无限背包，f[i+1][j+up[i]*2]实际上与f[i+1][j+up[i]*1]+1等价。那么事实上在枚举时，只需要在上一行的j-up[i-1]和当前行的j-up[i-1]中选择进行转移即可。着么枚举省掉了O(k)的循环，复杂度降至O(nm)，可以通过本题。

　　　　考虑枚举顺序，刷表法难以完成本题，所以我们改成填表法。

　　　　枚举顺序上，因为在这一秒先掉下去再飞上来显然是不合法的，所以必须将所有向上飞的枚举完以后再重新枚举向下掉的情况。

　　　　细节上，当高度为m的时候可以点击屏幕但不会死掉，需要十分恶心的特判。

　　　　在转移时，需要注意的是，从上一行转移过来的，必须保证上一行的状态合法，在当前行枚举过来的，不需要保证状态合法。

　　　　因为在枚举f[i][j]从f[i][j-up[i-1]]转移时，事实上相当于从f[i-1][j-up[i-1]*k]转移过来，由于每次点击一下，所以当前行的状态不一定合法。但用于递推后面合法的状态，这些状态仍然需要保留。

　　　　例如，f[i][j]应该从f[i-1][j-2*up[i-1]]转移，而j-up[i-1]是柱子，不合法。对于我们的递推方式，转移路线为f[i-1][j-2*up[i-1]]  =>  f[i][j-up[i-1]]  =>  f[i][j]。可以发现，需要通过同一列上的不可行解的ans推出可行解的ans。所以不可行解必须保留。在判断解的存在性时，只扫描可行解即可。

　　　　真恶心。

Code

#include<cstdio>
#include<cstring>
#include<cstdlib>
#define maxm 1010
#define maxn 10010
#define INF 0x3f3f3f3f

inline void qr(int &x) {
    char ch=getchar(),last=' ';
    while(ch>''||ch<'') last=ch,ch=getchar();
    while(ch>=''&&ch<='')    x=(x<<)+(x<<)+(ch^),ch=getchar();
    if(last=='-')    x=-x;
}

inline int max(const int &a,const int &b) {if(a>b) return a;return b;}
inline int min(const int &a,const int &b) {if(a<b) return a;return b;}
inline int abs(const int &a) {if(a>=) return a;return -a;}

inline void swap(int &a,int &b) {int temp=a;a=b;b=temp;}

int n,m,k,up[maxn],down[maxn],a,b,c,ans=INF;
int frog[maxn][maxm],sum[maxn];

struct M {
    int u,d;
};
M MU[maxn];

int main() {
    qr(n);qr(m);qr(k);
    for(int i=;i<n;++i) {qr(up[i]);qr(down[i]);MU[i].u=m;MU[i].u=m+;MU[i].d=;}
    for(int i=;i<=k;++i) {a=b=c=;qr(a);qr(b);qr(c);MU[a].d=b;MU[a].u=c;}
    if(MU[].u!=m+||MU[].d!=) sum[]=;
    for(int i=;i<n;++i) {sum[i]=sum[i-];if(MU[i].d!=||MU[i].u!=m+) ++sum[i];}
    MU[].d=;MU[].u=m+;MU[n].u=m+;MU[n].d=;
    memset(frog,0x3f,sizeof frog);
    for(int i=;i<=m;++i) frog[][i]=;
    for(int i=;i<n;++i) {
        bool changed=false;
        int di=i+;
        for(int j=MU[i].d+;j<MU[i].u;++j) {
            if(frog[i][j]==INF)    continue;
            changed=true;
            for(int k=;;++k) {
                int nxt=j+up[i]*k;
                if(nxt<=MU[di].d) continue;
                if(nxt>=m&&MU[di].u==m+) {frog[di][m]=min(frog[di][m],frog[i][j]+k);break;}
                if(nxt>=MU[di].u) break;
                frog[di][nxt]=min(frog[di][nxt],frog[i][j]+k);
            }
            int nxt=j-down[i];
            if(nxt>MU[di].d&&nxt<MU[di].u) frog[di][nxt]=min(frog[di][nxt],frog[i][j]);
        }
        if(!changed) {printf("0\n%d\n",i?sum[i-]:);exit();}
    }
    for(int i=;i<=m;++i) ans=min(ans,frog[n][i]);
    if(ans==INF) printf("0\n%d\n",sum[n-]);
    else printf("1\n%d\n",ans);
    return ;
}

75分无优化

#include<cstdio>
#include<cstring>
#include<cstdlib>
#define maxm 1010
#define maxn 10010
#define INF 0x3f3f3f3f

inline void qr(int &x) {
    char ch=getchar(),last=' ';
    while(ch>''||ch<'') last=ch,ch=getchar();
    while(ch>=''&&ch<='')    x=(x<<)+(x<<)+(ch^),ch=getchar();
    if(last=='-')    x=-x;
}

inline int max(const int &a,const int &b) {if(a>b) return a;return b;}
inline int min(const int &a,const int &b) {if(a<b) return a;return b;}
inline int abs(const int &a) {if(a>=) return a;return -a;}

inline void swap(int &a,int &b) {int temp=a;a=b;b=temp;}

int n,m,k,up[maxn],down[maxn],a,b,c,ans=INF;
int frog[maxn][maxm],sum[maxn];

struct M {
    int u,d;
};
M MU[maxn];

int main() {
    qr(n);qr(m);qr(k);
    for(int i=;i<n;++i) {qr(up[i]);qr(down[i]);MU[i].u=m;MU[i].u=m+;MU[i].d=;}
    for(int i=;i<=k;++i) {a=b=c=;qr(a);qr(b);qr(c);MU[a].d=b;MU[a].u=c;}
    if(MU[].u!=m+||MU[].d!=) sum[]=;
    for(int i=;i<n;++i) {sum[i]=sum[i-];if(MU[i].d!=||MU[i].u!=m+) ++sum[i];}
    MU[].d=;MU[].u=m+;MU[n].u=m+;MU[n].d=;
    memset(frog,0x3f,sizeof frog);
    for(int i=;i<=m;++i) frog[][i]=;
    for(int i=;i<=n;++i) {
        int di=i-;bool judge=false;
        for(int j=;j<=m;++j) {
            int nxt=j-up[di],cnt=;while(nxt>=MU[di].u) nxt-=up[di],++cnt;
            if(nxt>MU[di].d) frog[i][j]=frog[di][nxt]+cnt;
            if(j-up[di]>) frog[i][j]=min(frog[i][j],frog[i][j-up[di]]+);
        }
        if(MU[di].u==m+&&MU[di].d<m) frog[i][m]=min(frog[i][m],frog[di][m]+);
        if(MU[i].u==m+) for(int j=;j<=m;++j) if(m-j>MU[di].d&&m-j<MU[di].u) frog[i][m]=min(frog[i][m],frog[di][m-j]+(j-)/up[di]+);
        for(int j=;j<=m;++j) {
            if(j+down[di]<MU[di].u&&j+down[di]>MU[di].d) frog[i][j]=min(frog[i][j],frog[i-][j+down[di]]);
            if(j>MU[i].d&&j<MU[i].u&&frog[i][j]<INF) judge=true;
        }
        if(!judge) {printf("0\n%d\n",sum[i-]);exit();}
    }
    for(int i=;i<=m;++i) ans=min(ans,frog[n][i]);
    if(ans==INF) printf("0\n%d\n",sum[n-]);
    else printf("1\n%d\n",ans);
    return ;
}

Summary

　　　　1、对拍大法好，大难来时把命保。

　　　　2、转移细节！细节！细节！