f(m,n)=       n      (m=1)

                     m     (n=1)

                     f(m-1,n)+f(m,n-1)  (m>1,n>1)

用简单 递归求类杨辉三角形的问题

到了n,m=15的时候就不能算了，就爆了

但如果利用记忆动态规划可以算到  m,n=1000以上，只是到了那么大数的时候代表的数太大，如果用基本类型装不下那就只能开空间进行字符串类型来表示了，另外的极限那就是一下子开的a[][]数组太大，栈容不下，那如果要更大，只能用生成堆内存的方法进行动态申请了。

另一个优势是记忆法用时很少，这个方法在空间和时间上控制得很好。

#include <stdio.h>
  2 #include <string.h>
  3 #include <time.h>
  4 #define N 1000
  5 #define Rec 0
  6 #define Norec 1
  7 //#if Rec
  8 int f(int,int,unsigned long  a[N][N]);/./利用递归和动态规格相结合 即是记忆动态规划
  9 //#endif
 10 //#if Norec
 11 int f2(int,int);//简单递归
 12 //#endif
 13 void main(){
 14         int i=0;
 15         unsigned long  a[N][N];
 16         clock_t s_time,e_time;
 17         s_time=clock();
 18         //printf(“%d %d %d”,sizeof(unsigned long),sizeof(unsigned long int));
 19         memset(a,0,sizeof(a));
 20         printf(“%d\n”,f(600,600,a));
 21         e_time=clock();
 22         printf(“mutliply time=%f(s)\n”,(double)(e_time-s_time)/CLOCKS_PER_SEC);
 23
 24 }

 25 int f2(int m,int n){
 26 if(1==m) return n;
 27 if(1==n)  return m;
 28 return f2(m-1,n)+f2(m,n-1);
 29 }

 30 int f(int m,int n,unsigned long a[N][N]){
 31         if(1==m){
 32                 if(a[m,n]==0){a[m][n]=n;}
 33                 return n;
 34         }
 35         if(1==n){
 36                 if(a[m,n]==0){a[m][n]=m;}
 37                 return m;
 38         }
 39         if(a[m-1][n]==0)  a[m-1][n]=f(m-1,n,a);
 40         if(a[m][n-1]==0)  a[m][n-1]=f(m,n-1,a);
 41         return a[m-1][n]+a[m][n-1];
 42
 43 }
~                                                                                            9,8          顶端