NOIP 2002普及组 过河卒 题解

luogu P1002 过河卒

---

 

一道dp题 (一开始当成搜索做了半天)

这道题可以根据样例模拟一下 , 就可以求出状态转移方程了

步骤大概是这样的

A 是 A 点 , B 是 B 点, M 是马的位置,

X 是被马拦着不能走的点

(别告诉我你们连马走"日"字都不知道)

 A 0 0 0 0 0 0
 0 0 X 0 X 0 0
 0 X 0 0 0 X 0
 0 0 0 M 0 0 0
 0 X 0 0 0 X 0
 0 0 X 0 X 0 0
 0 0 0 0 0 0 B

 其中每个点的值代表的是从 A 点走到这个位置需要用多少步

1 1 1 1 1 1 1
1 2 X 1 X 1 2
1 X 0 1 1 X 2
1 1 1 M 1 1 3
1 X 1 1 0 X 3
1 1 X 1 X 0 3
1 2 2 3 3 3 6

这样很容易能看出来

关于 f[i][j] 这个点 , 从 (0,0) 位置到 B 点 , 会经过他这个点的路线有

f[1][1]=1

f[i][j]=f[i−1][j]+f[i][j−1] 

但是这个方程是推不出结果的 , 因为这样 A 点会在一开始的时候被覆盖成 0

所以修改以后的方程就是

f[1][1]=1

f[i][j]=max⁡(f[i−1][j]+f[i][j−1],f[i][j]) 

当然还有不用 max 的转移方程

f[1][0]=1

f[i][j]=f[i−1][j]+f[i][j−1]

f[1][1] 这个点通过从 f[1][0] 这个点直接转移过来

因为转移方程的时候需要 i−1 和 j−1 所以如果不从 1 开始就会因数组越界而 WA 一个点

从 1 开始就是把每个点的坐标都加了 1 而已

另外这道题的标签里有 高精

题目说明也写着

结果可能很大！

但是 unsigned long long 就可以过去

代码 :

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define ull unsigned long long
 6 using namespace std;
 7 const int fx[]={0,-2,-1,1,2,2,1,-1,-2};
 8 const int fy[]={0,1,2,2,1,-1,-2,-2,-1};
 9 //马可以走到的位置
10 int bx,by,mx,my;
11 ull ans;
12 ull f[30][30];//f[i][j]代表从A点到(i,j)会经过的线路数
13 bool s[30][30];//判断这个点有没有马盯着
14 int main(){
15     scanf("%d%d%d%d",&bx,&by,&mx,&my);
16     ++bx; ++by; ++mx; ++my;
17     //坐标+1以防越界
18     f[1][1]=1;//初始化
19     s[mx][my]=1;//标记马的位置
20     for(int i=1;i<=8;i++)
21         s[ mx + fx[i] ][ my + fy[i] ]=1;
22     for(int i=1;i<=bx;i++){
23         for(int j=1;j<=by;j++){
24             if(s[i][j])continue;
25             f[i][j]=max( f[i][j] , f[i-1][j] + f[i][j-1] ); 
26             //状态转移方程
27         }
28     }
29     printf("%llu\n",f[bx][by]);
30     return 0;
31 } 

---

既然做出来那让我们想想怎么压缩空间吧

当然是用滚动数组啦 qwq

观察这个转移方程 :

f[i][j]=f[i−1][j]+f[i][j−1]

好像每一次转移只需要提供 f[i−1][j],f[i][j−1]

即当前位置上面的一个数与他左边的一个数

那么新的转移方程就变成了

f[0][1]=1 f[0][1]=1 f[0][1]=1

f[i&1][j]=f[(i−1)&1][j]+f[i&1][j−1]

& :位运算 按位与 , 都知道吧

f[(i−1)&1][j]就是当前元素上面的那个元素

f[i&1][j−1] 就是当前元素左边的那个元素

这样 , 数组第一维是不是就可以压成 2 了呐 ???

另外 , 因为是滚动数组 , 所以如果当前位置被马拦住了无法通行一定要记住清零

代码 :

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define ull unsigned long long
 6 using namespace std;
 7 
 8 const int fx[]={0,-2,-1,1,2,2,1,-1,-2};
 9 const int fy[]={0,1,2,2,1,-1,-2,-2,-1};
10 int bx,by,mx,my;
11 ull ans;
12 ull f[2][30];//第一维大小为 2 就好
13 bool s[30][30];
14 
15 int main(){
16     scanf("%d%d%d%d",&bx,&by,&mx,&my);
17     ++bx; ++by; ++mx; ++my;
18     f[0][1]=1;//初始化
19     s[mx][my]=1;
20     for(int i=1;i<=8;i++)
21         s[ mx + fx[i] ][ my + fy[i] ]=1;
22     for(int i=1;i<=bx;i++){
23         for(int j=1;j<=by;j++){
24             if(s[i][j]){
25                 f[i&1][j]=0;//被马拦住了记住清零
26                 continue;
27             }
28             f[i&1][j]=f[(i-1)&1][j] + f[i&1][j-1]; 
29             //新的状态转移方程
30         }
31     }
32     printf("%llu\n",f[bx&1][by]);
33     //输出的时候第一维也要 按位与 一下,即 bx&1
34     return 0;
35 } 

---

 

好的那继续来看看能不能再压

二维数组第一维为什么要开成 2 呐 ? 能不能使之变成一位数组呐 ?

因为状态转移的时候需要一个 f[i−1][j] 来提供数 , 所以必须要多开一维

那岂不是把这个条件优化掉就不需要开成二维数组了呐

观察我们能发现 , 这个 f[i−1][j] 与当前位置的 f[i][j] 的第二维一样 , 都是 j , 而第一维只是差了 1

那么来看这个状态转移方程 :

f[i]=f[i]+f[i−1]

是不是就奇技淫巧的把数组变成一维了呢 ???

f[i]+f[i−1]里面

f[i−1] 就是前面方程里的 f[i][j−1]

至于 f[i] , 因为还没有被更新过 , 所以数据仍然保存的是当前位置上一个位置的元素 , 即 f[i−1][j]

这样 , 就把二维数组成功变成了一维数组

代码 :

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define debug 1
 6 #define inf 100010
 7 #define ll long long
 8 #define INF 0x7fffffff
 9 #define INF_T 9223372036854775807
10 #define ull unsigned long long
11 using namespace std;
12 
13 const int fx[]={0,-2,-1,1,2,2,1,-1,-2};
14 const int fy[]={0,1,2,2,1,-1,-2,-2,-1};
15 
16 inline int read(){//快速读入
17     char c=getchar();int num=0;bool b=0;
18     for(;c<'0'||c>'9';b=(c=='-'?1:0),c=getchar());
19     for(;c>='0'&&c<='9';num=(num<<3)+(num<<1)+(c^'0'),c=getchar());
20     return b?-num:num;
21 }
22 
23 int bx,by,mx,my;
24 ull ans;
25 ull f[30];//这次只需要一维数组啦!qwq
26 bool s[30][30];
27 
28 int main(){
29     bx=read();
30     by=read();
31     mx=read();
32     my=read();
33     ++bx; ++by; ++mx; ++my;
34     f[1]=1;//初始化呐
35     s[mx][my]=1;
36     for(int i=1;i<=8;i++)
37         s[ mx + fx[i] ][ my + fy[i] ]=1;
38     for(int i=1;i<=bx;i++){
39         for(int j=1;j<=by;j++){
40             if(s[i][j]){
41                 f[j]=0;//还是别忘了清零哦
42                 continue;
43             }
44             f[j]+=f[j-1];
45             //全新的简洁的状态转移方程
46         }
47     }
48     printf("%llu\n",f[by]);
49     return 0;
50 } 

---

Chiaro的luogu blog

转载于:https://www.cnblogs.com/chiarochinoful/p/problem-noip-2002-pj-T4.html