NOIP 2014 飞扬的小鸟
描述
Flappy Bird 是一款风靡一时的休闲手机游戏。玩家需要不断控制点击手机屏幕的频率来调节小鸟的飞行高度，让小鸟顺利通过画面右方的管道缝隙。如果小鸟一不小心撞到了水管或者掉在地上的话，便宣告失败。
为了简化问题，我们对游戏规则进行了简化和改编：
- 游戏界面是一个长为 n，高为 m 的二维平面，其中有k 个管道（忽略管道的宽度）。
- 小鸟始终在游戏界面内移动。小鸟从游戏界面最左边 任意整数高度位置出发，到达游戏界面最右边时，游戏完成。
- 小鸟每个单位时间沿横坐标方向右移的距离为 1，竖直移动的距离由玩家控制。如果点击屏幕，小鸟就会上升一定高度 X，每个单位时间可以点击多次，效果叠加； 如果不点击屏幕，小鸟就会下降一定高度 Y。小鸟位于横坐标方向不同位置时，上 升的高度 X 和下降的高度 Y 可能互不相同。
- 小鸟高度等于 0 或者小鸟碰到管道时，游戏失败。小鸟高度为 m 时，无法再上升。
现在，请你判断是否可以完成游戏。如果可以，输出最少点击屏幕数；否则，输出小鸟最多可以通过多少个管道缝隙。
格式
输入格式
第 1 行有 3 个整数 n，m，k，分别表示游戏界面的长度，高度和水管的数量，每两个 整数之间用一个空格隔开；
接下来的 n 行，每行 2 个用一个空格隔开的整数 X 和 Y，依次表示在横坐标位置 0~n-1 上玩家点击屏幕后，小鸟在下一位置上升的高度 X，以及在这个位置上玩家不点击屏幕时， 小鸟在下一位置下降的高度 Y。
接下来 k 行，每行 3 个整数 P，L，H，每两个整数之间用一个空格隔开。每行表示一个管道，其中 P 表示管道的横坐标，L 表示此管道缝隙的下边沿高度为 L，H 表示管道缝隙上边沿的高度（输入数据保证 P 各不相同，但不保证按照大小顺序给出）。
输出格式
共两行。
第一行，包含一个整数，如果可以成功完成游戏，则输出 1，否则输出 0。 第二行，包含一个整数，如果第一行为 1，则输出成功完成游戏需要最少点击屏幕数，否则，输出小鸟最多可以通过多少个管道缝隙。
样例1
样例2
限制
对于 30%的数据：5≤n≤10，5≤m≤10，k=0，保证存在一组最优解使得同一单位时间最多点击屏幕 3 次；
对于 50%的数据：5≤n≤20，5≤m≤10，保证存在一组最优解使得同一单位时间最多点击屏幕 3 次；
对于 70%的数据：5≤n≤1000，5≤m≤100；
对于 100%的数据：5≤n≤10000，5≤m≤1000，0≤k<n，0<X<m，0<Y<m，0<P<n，0≤L<H ≤m，L+1<H。
提示
如下图所示，蓝色直线表示小鸟的飞行轨迹，红色直线表示管道。
分析：动态规划
f[i][j]代表到达(i,j)所需点击的最少次数
要想写出状态转移方程，关键是理解这句话：“每个单位时间可以点击多次，效果叠加”。
效果叠加有两种方式，假设点两次，纵坐标由 j 到 jj 再到 jjj ，横坐标由 i 到 i+1
①f[i+1][jjj]=min(f[i+1][jjj],f[i][j]+2)
②f[i+1][jj]=min(f[i+1][jj],f[i][j]+1) f[i+1][jjj]=min(f[i+1][jjj],f[i+1][jj])
网上有不少题解是按照②来写的，我实在不明白为什么对，求大神解答。。。
AC的代码：
1 #include<iostream>
2 #include<cstdio>
3 #include<cstdlib>
4 #include<cstring>
5 #define maxn 10010
6 using namespace std;
7 const int inf =1e9;
8 int n,m,k,p,l,h;
9 int x[maxn],y[maxn],down[maxn], up[maxn];
10 int f[maxn][1001];
11 int main() {
12 scanf("%d%d%d",&n,&m,&k);
13 for (int i = 0; i < n; ++i)
14 scanf("%d %d", &x[i], &y[i]);
15 for (int i = 1; i <=n; ++i) {
16 down[i] = 0;
17 up[i] = m + 1;
18 }
19 for(int i = 1; i <= k; ++i) {
20 cin >> p >> l >> h;
21 down[p] = l;
22 up[p] = h;
23 }
24 for (int i = 1; i <= n; ++i)
25 for (int j = 0; j <= m; ++j)
26 f[i][j] = inf;
27 f[0][0] = inf;
28 int arrive = k;
29 for (int i = 1; i <= n; ++i){
30 for (int j = 1; j <= m; ++j){
31 //上升
32 if(j >= x[i-1]){
33 f[i][j] = min(f[i][j], f[i-1][j-x[i-1]] + 1);
34 f[i][j] = min(f[i][j], f[i][j-x[i-1]] + 1);//叠加
35 }
36 if(j == m) {
37 for(int k=m-x[i-1];k<=m;k++) {
38 f[i][j] = min(f[i][j], f[i-1][k] + 1);
39 f[i][j] = min(f[i][j], f[i][k] + 1);
40 }
41 }
42 }
43 //下降
44 for (int j = down[i]+1; j <= up[i]-1; ++j)
45 if( j + y[i-1] <= m)
46 f[i][j] = min(f[i][j], f[i-1][j+y[i-1]]);
47 //由于没考虑管道所以重新赋值
48 for (int j = 1; j <= down[i]; ++j) f[i][j] = inf;
49 for (int j = up[i]; j <= m; ++j) f[i][j] = inf;
50
51 }
52 int cnt = k, ans = inf;
53 for (int i = n; i >= 1; i--) {
54
55 for (int j = down[i]+1; j <= up[i]-1; ++j){
56 if (f[i][j] < inf)
57 ans = min(ans, f[i][j]);
58 }
59
60 if (ans != inf) break;
61 if (up[i] <= m)
62 cnt --;
63 }
64 if(cnt==k)
65 printf("1\n%d\n", ans);
66 else
67 printf("0\n%d\n", cnt);
68 return 0;
69 }
不过我按照①的思路也能写对，下面先给一个70分的未加优化的DP代码，复杂度O(n*m^2)
1 #include<iostream>
2 #include<cstdio>
3 #include<cstdlib>
4 #include<algorithm>
5 #include<cmath>
6 #include<cstring>
7 #include<vector>
8 #include<queue>
9 using namespace std;
10 const int maxn=100005;
11 const int maxm=1005;
12 const int inf=1e9;
13 int N,M,K;
14 int f[maxn][maxm];
15 struct node{
16 int up,down;
17 };
18 node move[maxn];
19 struct node1{
20 bool EXIST;
21 int highh,bott;
22 node1(){
23 EXIST=false;
24 highh=inf;
25 bott=0;
26 }
27 };
28 node1 map1[maxn];
29
30 int ANS=inf;
31 int h;
32 int tot;
33 int res=inf;
34 bool notallinf(int c){
35 for(int i=1;i<=M;i++){
36 if(f[c][i]!=inf)
37 return true;
38 }
39 return false;
40 }
41 int main(){
42
43 scanf("%d%d%d",&N,&M,&K);
44 for(int i=0;i<=N-1;i++)
45 scanf("%d%d",&move[i].up,&move[i].down);
46
47 for(int i=0;i<=N;i++) map1[i].highh=M+1;
48
49 for(int i=1;i<=K;i++){
50 int P,L,H;
51 scanf("%d%d%d",&P,&L,&H);
52 map1[P].bott=L;
53 map1[P].highh=H;
54 map1[P].EXIST=true;
55 }
56
57 for(int i=1;i<=N;i++)
58 for(int j=0;j<=M;j++)
59 f[i][j]=inf;
60
61 for(int i=1;i<=N;i++){
62 for(int j=map1[i].bott+1;j<=map1[i].highh-1;j++){
63
64 if((j+move[i-1].down)<map1[i-1].highh&&(j+move[i-1].down)>map1[i-1].bott)
65 f[i][j]=f[i-1][j+move[i-1].down];
66
67 for(int k=map1[i-1].bott+1;k<=map1[i-1].highh-1;k++){
68 if(k<j&&(j-k)%move[i-1].up==0)
69 f[i][j]=min(f[i][j],f[i-1][k]+(j-k)/move[i-1].up);
70 else{
71 if(k<=j&&j==M&&((j-k)%move[i-1].up!=0||j-k==0))
72 f[i][j]=min(f[i][j],f[i-1][k]+(j-k)/move[i-1].up+1);
73 else{
74 if(k>j)
75 break;
76 }
77 }
78 }
79
80 }
81 }
82 for(int i=1;i<=M;i++){
83 if(i>map1[N].bott&&i<map1[N].highh){
84 ANS=min(ANS,f[N][i]);
85 }
86 }
87
88 if(ANS!=inf){
89 cout<<"1"<<endl;
90 cout<<ANS<<endl;
91 }
92 else{
93 int nai=N-1;
94 for(;nai>0;--nai){
95 if(notallinf(nai)){
96 break;
97 }
98 }
99 res=0;
100 for(int i=0;i<nai;i++){
101 if(map1[i].EXIST==true)
102 ++res;
103 }
104 printf("0\n%d\n",res);
105 }
106 return 0;
107 }
这样的DP由于复杂度太高不能满分，这也是为什么要贴出①的解法，复杂度低啊，无需优化(难道这就是优化过的？反正不理解)，对于解法②，真正的优化是：
上述动态规划超时的原因在于转移复杂度太高，如果能将转移复杂度降为O(1)，那么就可以轻松将此题AC，仔细想想发现对于所有可以用于更新f[i][j]的状态的高度都与j同余(mod move[i-1].up)，那么在实际实现上述动态规划时，我们可以先穷举同余系，并以高度从低到高进行动态规划，在同一同余系中，记一个变量temp为已经访问的状态中可以用于更新的最小值，每穷举到一个新的状态，把temp更新为min(temp+1,f[i-1][j)，并且只用temp+1更新其他状态。
我根据上面的理解(非常肤浅的理解)，稍微降低了一下复杂度，原来我是枚举，现在用mod的方法做到跳跃更新，跳跃的距离就是move[i-1].up,因为我们可以发现，假设要更新f[i][j],用f[i][h]来更新的话(h一直在变)，那么一定存在：h%move[i-1].up==j%move[i-1].up，对任意h均存在。那么如果move[i-1].up很大或M较小，即能减少很多运算，我试了一下，，，，才多过了一个点，，，，75分。真正的优化还没看懂，，，求一大神解答。。。
75分的：
1 #include<iostream>
2 #include<cstdio>
3 #include<cstdlib>
4 #include<algorithm>
5 #include<cmath>
6 #include<cstring>
7 #include<vector>
8 #include<queue>
9 using namespace std;
10 const int maxn=100005;
11 const int maxm=1005;
12 const int inf=1e9;
13 int N,M,K;
14 int f[maxn][maxm];
15 struct node{
16 int up,down;
17 };
18 node move[maxn];
19 struct node1{
20 bool EXIST;
21 int highh,bott;
22 node1(){
23 EXIST=false;
24 highh=inf;
25 bott=0;
26 }
27 };
28 node1 map1[maxn];
29
30 int ANS=inf;
31 int h;
32 int tot;
33 int res=inf;
34 bool notallinf(int c){
35 for(int i=1;i<=M;i++){
36 if(f[c][i]!=inf)
37 return true;
38 }
39 return false;
40 }
41 int main(){
42
43 scanf("%d%d%d",&N,&M,&K);
44 for(int i=0;i<=N-1;i++)
45 scanf("%d%d",&move[i].up,&move[i].down);
46
47 for(int i=0;i<=N;i++) map1[i].highh=M+1;
48
49 for(int i=1;i<=K;i++){
50 int P,L,H;
51 scanf("%d%d%d",&P,&L,&H);
52 map1[P].bott=L;
53 map1[P].highh=H;
54 map1[P].EXIST=true;
55 }
56
57 for(int i=1;i<=N;i++)
58 for(int j=0;j<=M;j++)
59 f[i][j]=inf;
60
61 for(int i=1;i<=N;i++){
62 for(int j=map1[i].bott+1;j<=map1[i].highh-1;j++){
63
64 if((j+move[i-1].down)<map1[i-1].highh&&(j+move[i-1].down)>map1[i-1].bott)
65 f[i][j]=f[i-1][j+move[i-1].down];
66
67
68 if(j<M){
69 int base=j%move[i-1].up;
70 int g=map1[i-1].bott+1;
71 int p=g%move[i-1].up;
72 if(p==base)
73 base=g;
74 else{
75 if(p<base){
76 int delta=base-p;
77 base=g+delta;
78 }
79 else{
80 if(p>base){
81 base+=move[i-1].up;
82 int delta=base-p;
83 base=g+delta;
84 }
85 }
86 }
87
88 while(base<=map1[i-1].highh-1&&base<j){
89 f[i][j]=min(f[i][j],f[i-1][base]+(j-base)/move[i-1].up);
90 base+=move[i-1].up;
91 }
92
93 }
94 else{
95 for(int k=map1[i-1].bott+1;k<=map1[i-1].highh-1;k++){
96 if(k<j&&(j-k)%move[i-1].up==0)
97 f[i][j]=min(f[i][j],f[i-1][k]+(j-k)/move[i-1].up);
98 else{
99 if(k<=j&&j==M&&((j-k)%move[i-1].up!=0||j-k==0))
100 f[i][j]=min(f[i][j],f[i-1][k]+(j-k)/move[i-1].up+1);
101 else{
102 if(k>j)
103 break;
104 }
105 }
106 }
107 }
108 }
109 }
110 for(int i=1;i<=M;i++){
111 if(i>map1[N].bott&&i<map1[N].highh){
112 ANS=min(ANS,f[N][i]);
113 }
114 }
115
116 if(ANS!=inf){
117 cout<<"1"<<endl;
118 cout<<ANS<<endl;
119 }
120 else{
121 int nai=N-1;
122 for(;nai>0;--nai){
123 if(notallinf(nai)){
124 break;
125 }
126 }
127 res=0;
128 for(int i=0;i<nai;i++){
129 if(map1[i].EXIST==true)
130 ++res;
131 }
132 printf("0\n%d\n",res);
133 }
134 return 0;
135 }
