NOIP2014提高组第二轮day1 - T3：飞扬的小鸟

#题目链接

[NOIP2014 提高组] 飞扬的小鸟

题目描述

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

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

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

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

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

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

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

输入格式

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

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

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

输出格式

共两行。

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

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

样例 #1

样例输入 #1

样例输出 #1

1
6

样例 #2

样例输入 #2

样例输出 #2

0
3

提示

【输入输出样例说明】

如下图所示，蓝色直线表示小鸟的飞行轨迹，红色直线表示管道。

【数据范围】

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

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

对于 $70\%$ 的数据： $\leq n \leq 1000, 5 \leq m \leq 100$ ；

对于 $100\%$ 的数据： $\leq n \leq 10000$ ， $\leq m \leq 1000$ ， $\leq k < n$ ， $0 < x, y < m$ ， $0 < p < n$ ， $\leq l < h \leq m$ ， $l + 1 < h$ 。

算法思想

根据题目描述，在每一个单位时间内，有多种选择。如果把每个单位时间内点击屏幕看成一个阶段，可以有下面若干种情况：

可以选择点击 $0$ 次，下降 $y$
点击 $1$ 次，上升 $x$
点击 $2$ 次，上升 $2\times x$
…
点击 $k$ 次，上升 $k\times x$

该问题属于有限制的选择优化问题，因此可以采用类似完全背包的思想进行处理。

状态表示

$f [i] [j]$ 表示沿横坐标方向右移 $i$ 个单位、并且飞行高度为 $j$ 时需要最少点击屏幕数。

状态计算

从最后一步分析，要计算 $f [i] [j]$ ，可以根据上一阶段，也就是在第 $i - 1$ 个单位时间的选择分成下面若干种情况：

在第 $i - 1$ 个单位时间不点击屏幕，飞到横坐标 $i$ 时高度会下降 $y$ 才能到达 $j$ ，此时最少点击屏幕数为 $f [i - 1] [j + y]$ ，其中 $j+y\le m$
在第 $i - 1$ 个单位时间点击 $1$ 次屏幕，飞到横坐标 $i$ 时高度会上升 $x$ 才能到达 $j$ ，此时最少点击屏幕数为 $f [i - 1] [j - x] + 1$
在第 $i - 1$ 个单位时间点击 $2$ 次屏幕，飞到横坐标 $i$ 时高度会上升 $2\times x$ 才能到达 $j$ ，此时最少点击屏幕数为 $f[i-1][j-2\times x]+2$
…
在第 $i - 1$ 个单位时间点击 $k$ 次屏幕，飞到横坐标 $i$ 时高度会上升 $k\times x$ 才能到达 $j$ ，此时最少点击屏幕数为 $f[i-1][j-k\times x]+k$ ，其中 $j-k\times x \gt 0$

因此， $f[i][j]=min\{f[i-1][j+y], f[i-1][j-x]+1, f[i-1][j-2\times x]+2,...,f[i-1][j-k\times x]+k\}$ 。

初始状态

求点击次数的最小值， $f [i] [j]$ 应初始化为无穷大
小鸟从游戏界面最左边任意整数高度位置出发，因此 $f [0] [j] = 0$ ，其中 $0\lt j\le m$ 。

边界情况

在计算状态的过程中需要处理下面的边界情况：

小鸟高度等于 $0$ 或者小鸟碰到管道时，游戏失败

因此，枚举高度 $j$ 时，应保证 $j\gt 0$ ，并且 $l\lt j\lt h$ ， $l$ 表示此管道缝隙的下边沿高度， $h$ 表示管道缝隙上边沿的高度。

小鸟高度为 $m$ 时，无法再上升

意味着状态 $f [i] [m]$ 可以由 $i - 1$ 阶段的任意状态转移过来。例如当高度为 $j$ 时，到 $m$ 的距离是 $m - j$ ，每次点击屏幕上升 $x$ ，那么需要点击 $\lceil \frac{m-j}{x}\rceil$ 次。因此 $f[i][m]=min\{f[i][m], f[i-1][j] + \lceil \frac{m-j}{x}\rceil\}$ ，其中 $1\le j\lt m$ 。
除此之外，在 $i - 1$ 阶段高度为 $m$ 时点击 $1$ 次屏幕也可以转移到 $f [i] [m]$ ，因此， $f[i][m]=min\{f[i][m], f[i-1][m] + 1\}$

时间复杂度

状态数： $n\times m$
在状态计算过程中需要枚举点击屏幕次数 $k$ ， $k\le m$

因此时间复杂度为 $O(nm^2)=10000\times 1000^2=10^{10}$ ，只能拿到 $85$ 分。

代码实现（85分）

#include <iostream>
#include <cstring>
using namespace std;
const int N = 10010, M = 1010, INF = 0x3f3f3f3f;
int f[N][M], x[N], y[N], L[N], H[N];
int main()
{
    int n, m, k;
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 1; i <= n; i ++) scanf("%d%d", &x[i], &y[i]);
    for(int i = 1; i <= k; i ++)
    {
        int p, l, h;
        scanf("%d%d%d", &p, &l, &h);
        L[p] = l, H[p] = h;
    }
    //初始状态
    memset(f, 0x3f, sizeof f);
    for(int j = 1; j <= m; j ++) f[0][j] = 0;
    
    //状态计算，枚举横坐标
    for(int i = 1; i <= n; i ++)
    {
        //枚举高度
        for(int j = 1; j <= m; j ++)
        {
            //没有管道，飞行的高度在两根管道之间
            if(H[i] == 0 || j > L[i] && j < H[i])
            {
                //点击k次屏幕飞到(i,j)时
                for(int k = 1; k * x[i] < j; k ++)
                    f[i][j] = min(f[i][j], f[i - 1][j - k * x[i]] + k);
                //不点击屏幕
                if(j + y[i] <= m) f[i][j] = min(f[i][j], f[i - 1][j + y[i]]);
            }   
        }
        //f[i][m]可以由i-1阶段的任意状态转移过来
        if(H[i] == 0) //没有管道
        {
            //当i-1阶段在最高处时，再点击1下也能转移到f[i][m]
            f[i][m] = min(f[i][m], f[i - 1][m] + 1); 
            //计算其它高度走到最高处的点击次数，距离(m-j)除以(上升高度x)向上取整
            for(int j = 1; j < m; j ++)
            {
                f[i][m] = min(f[i][m], f[i - 1][j] + (m - j + x[i] - 1) / x[i]);
            }
        }
    }
    int ans = INF;
    for(int j = 1; j <= m; j ++) ans = min(ans, f[n][j]);
    //能够到达终点
    if(ans < INF) printf("1\n%d", ans);
    else //不能到达终点
    {
        //从后向前找到最后能到达的位置
        for(int i = n; i >= 0; i --)
            for(int j = 1; j <= m; j ++)
            {
                if(f[i][j] < INF) //能够到达该位置
                {
                    int cnt = 0; //统计管道数量，注意从横坐标为0开始统计
                    for(int k = 0; k <= i; k ++)
                    {
                        if(H[k] != 0) //有管道
                             cnt ++;
                    }
                    printf("0\n%d", cnt);
                    return 0;
                }
            }
    }
}

优化思想

依据状态计算方法， $f[i][j]=min\{f[i-1][j+y], f[i-1][j-x]+1, f[i-1][j-2\times x]+2,...,f[i-1][j-k\times x]+k\}$ ，需要枚举 $k$ 计算 $min\{f[i-1][j-x]+1, f[i-1][j-2\times x]+2,...,f[i-1][j-k\times x]+k\}$ ，尝试利用空间换时间，将计算的中间结果保存下来。

不妨设 $g[i][j]=min\{f[i-1][j-x]+1, f[i-1][j-2\times x]+2,...,f[i-1][j-k\times x]+k\}$ ，
而 $g[i][j-x]=min\{f[i-1][j-2\times x]+1,...,f[i-1][j-k\times x]+k\}$ ，
可得 $g[i][j]=min\{f[i-1][j-x]+1,g[i][j-x]+1\}$ ，
那么 $f[i][j]=min\{f[i-1][j+y], g[i][j]\}$ ，也就是说计算 $f [i] [j]$ 不再需要枚举 $k$ 。

时间复杂度

状态数： $n\times m$
在状态计算的时间复杂度为 $O (1)$

因此时间复杂度为 $O(nm)=10000\times 1000=10^{7}$ 。

代码实现（100分）

#include <iostream>
#include <cstring>
using namespace std;
const int N = 10010, M = 1010, INF = 0x3f3f3f3f;
int f[N][M], x[N], y[N], L[N], H[N], g[N][M];
int main()
{
    int n, m, k;
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 1; i <= n; i ++) scanf("%d%d", &x[i], &y[i]);
    for(int i = 1; i <= k; i ++)
    {
        int p, l, h;
        scanf("%d%d%d", &p, &l, &h);
        L[p] = l, H[p] = h;
    }
    //初始状态
    memset(f, 0x3f, sizeof f);
    memset(g, 0x3f, sizeof g);
    for(int j = 1; j <= m; j ++) f[0][j] = 0;
    
    //状态计算，枚举横坐标
    for(int i = 1; i <= n; i ++)
    {
        //枚举高度
        for(int j = 1; j <= m; j ++)
        {
            //处理g数组
            if(j > x[i]) g[i][j] = min(f[i - 1][j - x[i]] + 1, g[i][j - x[i]] + 1);
            
            //没有管道，飞行的高度在两根管道之间
            if(H[i] == 0 || j > L[i] && j < H[i])
            {
                //优化后f[i][j]=min(f[i-1][j+y], g[i][j])
                f[i][j] = g[i][j];
                //不点击屏幕
                if(j + y[i] <= m) f[i][j] = min(f[i][j], f[i - 1][j + y[i]]);
            }   
        }
        //f[i][m]可以由i-1阶段的任意状态转移过来
        if(H[i] == 0) //没有管道
        {
            //当i-1阶段在最高处时，再点击1下也能转移到f[i][m]
            f[i][m] = min(f[i][m], f[i - 1][m] + 1); 
            //计算其它高度走到最高处的点击次数，距离(m-j)除以(上升高度x)向上取整
            for(int j = 1; j < m; j ++)
            {
                f[i][m] = min(f[i][m], f[i - 1][j] + (m - j + x[i] - 1) / x[i]);
            }
        }
    }
    int ans = INF;
    for(int j = 1; j <= m; j ++) ans = min(ans, f[n][j]);
    //能够到达终点
    if(ans < INF) printf("1\n%d", ans);
    else //不能到达终点
    {
        //从后向前找到最后能到达的位置
        for(int i = n; i >= 0; i --)
            for(int j = 1; j <= m; j ++)
            {
                if(f[i][j] < INF) //能够到达该位置
                {
                    int cnt = 0; //统计管道数量，注意从横坐标为0开始统计
                    for(int k = 0; k <= i; k ++)
                    {
                        if(H[k] != 0) //有管道
                             cnt ++;
                    }
                    printf("0\n%d", cnt);
                    return 0;
                }
            }
    }
}