HDU 1978 How many ways(记忆化)

How many ways

这道题可以用如果用动态规划做，那就是初始化起始点方案数为1，每次枚举某一点能到达的位置，目标位置方案为能到达它的点方案数和。

如果是记忆化就是反过来做，终点位置方案数目为1，搜索过程记录搜到的每一点的方案数就好了。思路很清晰。

动态规划：

1. #include"stdio.h"  
2. #include"string.h"  
3. #define M 10000  
4. #define N 110  
5. int main()  
6. {  
7.     int T,i,j,n,m,x,y,di,dj,t;  
8.     int a[N][N],dp[N][N];  
9.     scanf("%d",&T);  
10.     while(T--)  
11.     {  
12.         scanf("%d%d",&n,&m);  
13.         for(i=1;i<=n;i++)  
14.         {  
15.             for(j=1;j<=m;j++)  
16.             {  
17.                 scanf("%d",&a[i][j]);  
18.             }  
19.         }  
20.         memset(dp,0,sizeof(dp));  
21.         dp[1][1]=1;  
22.         for(i=1;i<=n;i++)  
23.         {  
24.             for(j=1;j<=m;j++)  
25.             {  
26.                 if(dp[i][j])  
27.                 {  
28.                     t=a[i][j];  
29.                     for(x=0;x<=t;x++)  
30.                     {  
31.                         for(y=0;y<=t;y++)  
32.                         {  
33.                             if(x+y==0)  
34.                                 continue;  
35.                             if(x+y>t)  
36.                                 break;  
37.                             di=x+i;  
38.                             dj=y+j;  
39.                             if(di<=n&&dj<=m)  
40.                                 dp[di][dj]+=dp[i][j];  
41.                             dp[di][dj]%=M;  
42.                         }  
43.                     }  
44.                 }  
45.             }  
46.         }  
47.         printf("%d\n",dp[n][m]%M);  
48.     }      
49.     return 0;  
50. }  

记忆化搜索：

[cpp]  view plain  copy

1. #include<iostream>  
2. #include<stdio.h>  
3. #include<string.h>  
4. #include<algorithm>  
5. #include<queue>  
6. #include<vector>  
7. using namespace std;  
8. #define N 105  
9. const int mod=10000;  
10. int n,m;  
11. int a[N][N];  
12. int mark[N][N];  
13. int dfs(int x,int y)  
14. {  
15.     if(mark[x][y]!=-1)  
16.         return mark[x][y];  
17.     int t,x1,y1,tmp;  
18.     tmp=0;  
19.     t=a[x][y];  
20.     for(x1=0;x1<=t;x1++)  
21.     {  
22.         if(x+x1>=n)  
23.             break;  
24.         for(y1=0;x1+y1<=t;y1++)  
25.         {  
26.             if(y+y1>=m)  
27.                 break;  
28.             if(x1+y1!=0)          //不能原地走  
29.                 tmp+=dfs(x+x1,y+y1);  
30.         }  
31.     }  
32.     tmp%=mod;  
33.     return mark[x][y]=tmp;  
34. }  
35. int main()  
36. {  
37.     int i,j,T;  
38.     scanf("%d",&T);  
39.     while(T--)  
40.     {  
41.         scanf("%d%d",&n,&m);  
42.         for(i=0;i<n;i++)  
43.         {  
44.             for(j=0;j<m;j++)  
45.             {  
46.                 scanf("%d",&a[i][j]);  
47.                 mark[i][j]=-1;  
48.             }  
49.         }  
50.         mark[n-1][m-1]=1;  
51.         printf("%d\n",dfs(0,0));  
52.     }  
53.     return 0;  
54. }