解题报告(1)——飞扬的小鸟

飞扬的小鸟【NOIP2014提高组】

题目背景

NOIP2014提高组 Day1试题。

题目描述

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


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

1.游戏界面是一个长为 n,高为 m 的二维平面,其中有k个管道(忽略管道的宽度)。

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

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

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

 

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

 

输入格式

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

 

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

 

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

 

输出格式

输出文件共两行:

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

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

 

样例数据 1

输入 

10 10 6

3 9

9 9

1 2

1 3

1 2

1 1

2 1

2 1

1 6

2 2

1 2 7

5 1 5

6 3 5

7 5 8

8 7 9

9 1 3

输出

1

6

样例数据 2

输入 

10 10 4

1 2

3 1

2 2

1 8

1 8

3 2

2 1

2 1

2 2

1 2

1 0 2

6 7 9

9 1 4

3 8 10

输出

0

3

备注

【样例说明】

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

【数据范围】

对于 30%的数据:5n105m10k=0,保证存在一组最优解使得同一单位时间最多点击屏幕 3 次;

对于 50%的数据:5n205m10,保证存在一组最优解使得同一单位时间最多点击屏幕 3 次;

对于 70%的数据:5n10005m100

对于 100%的数据:5n100005m10000k<n0<X<m0<Y<m0<P<n0L<HmL+1<H

 

算法分析:

方法一:直接模拟+动归 预计得分:70

1)f[i][j]表示在横坐标为i,纵坐标为j时,最小的跳跃次数。(因担心MLE,所以实际代码由滚动数组处理),初始化f[0][j]全部为零。

2)依次枚举每个横纵坐标,,判断其是否在上轮可以到达,再依次将本轮可到达的位置标注记录。(注意不要超过上下限)

3)若有管道进行判断是否在可行范围内。

4)每轮纵坐标循环后,将未更新的点标注为-1(不可到达),方便下轮判断。

5)若检测到某轮结束全部点位为-1,输出0,计算已过管道并输出,结束程序。

6)最后一轮成功进行完毕,比较f[n][j],得到不等于-1,且最小的一个,输出1,输出最小值,结束程序。


Source 

#include
#include
#include
#include
#include
 
using namespace std;
 
int n,m,k,po,j1,j2,mi,sum,pic;
/*n:横坐标;m:纵坐标;k:管道数; po:临时位置记录; j1,j2:滚动数组推到用*/
/*mi:记录最小跳跃次数;sum:记录本轮无法到达的点位个数;pic:记录已通过管道数*/
int up[10001],down[10001];
/*up[i]:若i-1时点击屏幕,i时的上升高度*/ 
/*down[i]:若i-1时不点击屏幕,i时的下降高度*/
int pid[10001],piu[10001];
/*pid[i]:i处管道下方的最高点*/
/*piu[i]:i处管道上方的最低点*/ 
int f[2][10001];
/*滚动数组,记录当前行和上一行的最优解*/
 
inline void R(int &v)/*读入优化*/ 
{
      v=0;
      char c=0;
      bool p=true;
      while(c>'9'||c<'0')
      {
            if(c=='-')
            {
                  p=false;
            }
            c=cin.get();
      }
      while(c<='9'&&c>='0')
      {
            v=(v<<3)+(v<<1)+c-'0';
            c=cin.get();
      }
      if(p==false)
      {
            v=-v;
      }
}
 
int main(void)
{
      ios::sync_with_stdio(false);
      cin.tie(NULL);              /*cin解绑*/
      R(n);
      R(m);
      R(k);
      for(int i=1;i<=n;++i)
      {
            R(up[i]);
            R(down[i]);
      }
      for(int i=1;i<=k;++i)
      {
            R(po);
            R(pid[po]);
            R(piu[po]);
      }
 
      for(int i=1;i<=m;++i)  /*初始化为0*/
      {
            f[0][i]=0;
      }
      j1=0;
      j2=1;                  /*滚动数组的坐标初始化*/
      for(int i=1;i<=n;++i)   /*枚举横坐标*/
      {
            if(piu[i]>0)        /*若当前列存在管道*/
            {
                  pic++;         /*管道计数加1*/
            }
            j1=(j1+1)%2;       /*改变滚动数组坐标*/
            j2=(j2+1)%2;       /*改变滚动数组坐标*/ 
            memset(f[j1],127,sizeof(f[j1])); /*初始化当前行最优解*/
            for(int j=1;j<=m;++j)  /*枚举纵坐标*/
            {
                  if(f[j2][j]!=-1)    /*若上轮判定可以到达*/
                  {
                        int q=j;
                        int cnt=0;
                        while(q<=m)     /*判断点击次数和可以到达的位置*/
                        {
                              q=q+up[i];
                              cnt++;     /*点击次数*/
                              if(piu[i]!=0) /*若存在管道*/
                              {
                                    if(qpid[i]) /*保证在可以停留的范围*/
                                    {
                                          f[j1][q]=min(f[j2][j]+cnt,f[j1][q]);/*更新最优解*/
                                    }
                                    else
                                    {
                                          if(q>=piu[i]) /*若已经大于高处管道的最低点*/
                                          {
                                                break;  /*跳出循环*/ 
                                          }
                                    }
                              }
                              else
                              {
                                    if(q>m)
                                    {
                                        f[j1][m]=min(f[j2][j]+cnt,f[j1][m]);
                                        /*若超过高线,则停留在高线*/
                                    }
                                    else
                                    {
                                          f[j1][q]=min(f[j2][j]+cnt,f[j1][q]);
                                          /*若未超过,更新当前位置*/                                    
                                    }
                              }
                        }
                        q=j;
                        cnt=0;     /*清零计数*/
                        q=q-down[i]; /*判断若直接下降*/
                        if(piu[i]!=0) /*若有管道*/
                        {
                              if(qpid[i])   /*判断是否满足条件*/
                              {
                                    f[j1][q]=min(f[j2][j],f[j1][q]); /*更新*/
                              }
                        }
                        else
                        {
                              if(q>0)        /*若未到地面*/
                              {
                                    f[j1][q]=min(f[j2][j],f[j1][q]);/*更新*/                        
                              }
                        }
                  }      
            }
      //      cout<

方法二:动归+优化 预计得分:100

1)f[i][j]表示在横坐标为i,纵坐标为j时,最小的跳跃次数。(因担心MLE,所以实际代码由滚动数组处理),初始化f[0][j]全部为零。

2)依次枚举每个纵坐标,,判断其是否在本轮可以到达,方法:判断j-up[i]本轮和上轮是否有有效值。(注意不要超过上下限)

3)单独判断m-up[i]m之间,本轮和上轮的可用值中的最小值。

4)最后将有管道的地方标注为不可行。

5)每轮纵坐标循环后,将未更新的点标注为-1(不可到达),方便下轮判断。

6)若检测到某轮结束全部点位为-1,输出0,计算已过管道并输出,结束程序。

7)最后一轮成功进行完毕,比较f[n][j],得到不等于-1,且最小的一个,输出1,输出最小值,结束程序。


Source 

Source :
#include
#include
#include
#include
#include
 
using namespace std;
 
int n,m,k,po,j1,j2,mi,sum,pic;
/*n:横坐标;m:纵坐标;k:管道数; po:临时位置记录; j1,j2:滚动数组推到用*/
/*mi:记录最小跳跃次数;sum:记录本轮无法到达的点位个数;pic:记录已通过管道数*/
int up[10001],down[10001];
/*up[i]:若i-1时点击屏幕,i时的上升高度*/ 
/*down[i]:若i-1时不点击屏幕,i时的下降高度*/
int pid[10001],piu[10001];
/*pid[i]:i处管道下方的最高点*/
/*piu[i]:i处管道上方的最低点*/ 
int f[2][10001];
/*滚动数组,记录当前行和上一行的最优解*/
 
inline void R(int &v)  /*读入优化*/ 
{
      v=0;
      char c=0;
      bool p=true;
      while(c>'9'||c<'0')
      {
            if(c=='-')
            {
                  p=false;
            }
            c=cin.get();
      }
      while(c<='9'&&c>='0')
      {
            v=(v<<3)+(v<<1)+c-'0';
            c=cin.get();
      }
      if(p==false)
      {
            v=-v;
      }
}
 
int main(void)
{
      ios::sync_with_stdio(false);
      cin.tie(NULL);   /*cin解绑*/
      R(n);
      R(m);
      R(k);
      for(int i=1;i<=n;++i)
      {
            R(up[i]);
            R(down[i]);
      }
      for(int i=1;i<=k;++i)
      {
            R(po);
            R(pid[po]);
            R(piu[po]);
      }
 
      for(int i=1;i<=m;++i) /*初始化为0*/
      {
            f[0][i]=0;
      }
      j1=0;
      j2=1;                /*滚动数组的坐标初始化*/
      for(int i=1;i<=n;++i)   /*枚举横坐标*/
      {
            if(piu[i]>0)       /*若当前列存在管道*/
            {
                  pic++;         /*管道计数加1*/
            }
            j1=(j1+1)%2;       /*改变滚动数组坐标*/
            j2=(j2+1)%2;       /*改变滚动数组坐标*/ 
            memset(f[j1],127,sizeof(f[j1])); /*初始化当前行最优解*/
            for(int j=1+up[i];j<=m;++j)  /*枚举当前列跳跃高度以上的点*/
            {
                  if(j!=m)
                  {
                        if(f[j2][j-up[i]]!=-1) /*判断上次起点能否达到*/
                        {
                              f[j1][j]=min(f[j1][j],f[j2][j-up[i]]+1); /*更新最优解*/
                        }
                        if(f[j1][j-up[i]]!=f[j1][0]) /*本轮之前位置可以到达*/
                        {
                              f[j1][j]=min(f[j1][j],f[j1][j-up[i]]+1); /*更新最优解*/
                        }
                  }
                  else
                  {
                        for(k=m-up[i];k<=m;++k)  /*单独处理最顶点*/
                        {
                              if(f[j2][k]!=-1)    /*若上轮位置可用*/
                              {
                                    f[j1][m]=min(f[j2][k]+1,f[j1][m]); /*更新最优解*/
                              }
                              if(f[j1][k]!=f[j1][0])  /*本轮有位置可用*/
                              {
                                  f[j1][m]=min(f[j1][k]+1,f[j1][m]); /*更新最优解*/
                              }
                        }
                  }
            }
            for(int j=1;j<=m-down[i];++j) /*枚举向下落点*/
            {
                  if(f[j2][j+down[i]]!=-1) /*若上轮位置可用*/
                  {
                        f[j1][j]=min(f[j1][j],f[j2][j+down[i]]); /*更新最优解*/
                  } 
            } 
            if(piu[i]>0) /*最后判断管道*/
            {
                  for(int k=1;k<=pid[i];++k) /*处理下方管道*/
                  {
                        f[j1][k]=-1;
                        sum++;
                  }
                  for(int k=piu[i];k<=m;++k) /*处理上方管道*/
                  {
                        f[j1][k]=-1;
                        sum++;
                  }
            }      
            for(int j=1;j<=m;++j) /*处理不能到达的位置*/
          {
                if(f[j1][j]==f[j1][0])
                {
                      f[j1][j]=-1; 
                      sum++; /*计数*/ 
                }
          }
            if(sum==m) /*全部不能到达*/
          {
                cout<<"0"<


Summary:

动态规划不像一般算法存在着使用的模板,每道题都有其不同的特点,只有认真揣摩分析每一道题的本质,再辅以所知道的算法,找到规划的方向才能够正确完成。当然,在考试中如果实在没有找到规划方向,就可以尝试用搜索或暴力模拟等极端方法,尽量得分。


阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/scar_lyw/article/details/53027941
文章标签: NOIP提高组2014
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭