动态规划&备忘录方法&递归方法

动态规划的基本思想是，将原问题拆分为若干子问题，自底向上的求解。其总是充分利用重叠子问题，即通过每个子问题只解一次，把解保存在一个表中，巧妙的避免了子问题的重复求解。

递归方法，采用的是自顶向下的思想，拆分为若干子问题，但是造成了子问题的重复求解。

备忘录方法，采用的也是自顶向下的思想，但是该方法维护了一个记录子问题解的表，虽然填表动作的控制结构更像递归方法，但是的确避免了子问题的重复求解。

下面以字符串的相似度来展示一下各方法的特点：

动态规划

递归：略

备忘录：

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string>  
3. #include <vector>  
4. using namespace std;  
5.   
6. const int N = 100;  
7.   
8. int dist[N][N];  
9.   
10. int minValue(int va, int vb, int vc)  
11. {  
12.     int temp = va;  
13.   
14.     if(vb < temp)  
15.         temp = vb;  
16.     if(vc < temp)  
17.         temp = vc;  
18.   
19.     return temp;  
20. }  
21.   
22. int distance(string strA, int pABegin, int pAEnd, string strB, int pBBegin, int pBEnd)  
23. {  
24.     if(dist[pABegin][pBBegin]>=0)  
25.         return dist[pABegin][pBBegin];  
26.   
27.     if (pABegin > pAEnd)  
28.     {  
29.         if(pBBegin > pBEnd)  
30.             dist[pABegin][pBBegin] = 0;  
31.         else  
32.             dist[pABegin][pBBegin] = pBEnd - pBBegin + 1;  
33.   
34.         return dist[pABegin][pBBegin];  
35.     }  
36.   
37.     if (pBBegin > pBEnd)  
38.     {  
39.         if(pABegin > pAEnd)  
40.             dist[pABegin][pBBegin] = 0;  
41.         else  
42.             dist[pABegin][pBBegin] = pAEnd - pBBegin + 1;  
43.   
44.         return dist[pABegin][pBBegin];  
45.     }  
46.   
47.     if (strA[pABegin]==strB[pBBegin])  
48.     {  
49.         dist[pABegin][pBBegin] = distance(strA, pABegin+1, pAEnd, strB, pBBegin+1, pBEnd);  
50.   
51.         return dist[pABegin][pBBegin];  
52.     }  
53.     else  
54.     {  
55.         int t1 = distance(strA, pABegin, pAEnd, strB, pBBegin+1, pBEnd);  
56.         int t2 = distance(strA, pABegin+1, pAEnd, strB, pBBegin, pBEnd);  
57.         int t3 = distance(strA, pABegin+1, pAEnd, strB, pBBegin+1, pBEnd);  
58.   
59.         dist[pABegin][pBBegin] = minValue(t1, t2, t3)+1;  
60.   
61.         return dist[pABegin][pBBegin];  
62.     }  
63.       
64. }  
65.   
66. int main()  
67. {  
68.     string A;  
69.     string B;  
70.   
71.     cin>>A;  
72.     cin>>B;  
73.   
74.     for (int i=0; i<N; i++)  
75.         for(int j=0; j<N; j++)  
76.             dist[i][j] = -1;  
77.   
78.     cout<<distance(A, 0, A.length()-1, B, 0, B.length()-1);  
79.     return 0;  
80. }  

当n=0时，f(n) = 0     

当n=1时，f(n) = 1

当n>1时，f(n) = f(n-1) + f(n-2)

递归算法：

[cpp]  view plain copy

1. int fun(int n)  
2. {  
3.     if(n <= 0)  
4.         return 0;  
5.     if(n == 1)  
6.         return 1;  
7.   
8.     return fun(n-1)+fun(n-2);  
9. }  

备忘录方法：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. const int N = 100;  
5. int f[N];  
6.   
7. int fun(int n)  
8. {  
9.     if(f[n]>=0)  
10.         return f[n];  
11.   
12.     if(n == 0)  
13.     {  
14.         f[0] = 0;  
15.         cout<<"0"<<endl;  
16.         return f[0];  
17.     }  
18.   
19.     if(n == 1)  
20.     {  
21.         f[1] = 1;  
22.         cout<<"1"<<endl;  
23.         return f[1];  
24.     }  
25.   
26.     cout<<n<<endl;  
27.     f[n] = fun(n-1) + fun(n-2);  
28.     return f[n];  
29. }  
30.   
31. int main()  
32. {  
33.     for (int i=0; i<N; i++)  
34.         f[i] = -1;  
35.   
36.     cout<<fun(4);  
37.     return 0;  
38. }  

由于计算的时候只需要前两个数即可，所以代码还可以继续优化。但是对于上述的备忘录方法貌似不能继续进行空间优化了(不知道对否，如果理解的不对请不吝赐教~)。

但是对于下面的方法（就称为遍历方法吧）,还是可以继续优化的。

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. const int N = 100;  
5. int f[N];  
6.   
7. int main()  
8. {  
9.       
10.     int n;  
11.     cin>>n;  
12.   
13.     for (int i=0; i<=n; i++)  
14.     {  
15.         if(i==0)  
16.             f[i] = 0;  
17.         else if(i==1)  
18.             f[i] = 1;  
19.         else  
20.             f[i] = f[i-1] + f[i-2];  
21.     }  
22.   
23.     cout<<f[n];  
24.   
25.     return 0;  
26. }  

由于计算的时候只用了前两个数，所以没有必要使用数组。

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. int main()  
5. {  
6.     int n;  
7.     cin>>n;  
8.   
9.     int temp1, temp2, temp;  
10.     for (int i=0; i<=n; i++)  
11.     {  
12.         if(i==0)  
13.             temp1 = 0;  
14.         else if(i==1)  
15.             temp2 = 1;  
16.         else  
17.         {  
18.             temp = temp1 + temp2;  
19.             temp1 = temp2;  
20.             temp2 = temp;  
21.               
22.         }  
23.     }  
24.   
25.     cout<<temp;  
26.   
27.     return 0;  
28. }  

总结：从代码中可以看出来，遍历方法实际上是一种自底向上的方法，而备忘录方法是一种自顶向下的方法，也许正由于这个原因造成了备忘录方法无法进行空间优化。(待证)

 动态规划算法的基本要素： 
1  最优子结构性质
当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。
2  重叠子问题性质   
动态规划算法对每个问题只解一次，将其解保存在一个表格中，当再次需要解此问题时，用常数时间查看一下结果。因此，用动态规划算法通常只需要多项式时间。

备忘录方法：
•用一个表格来保存已解决的子问题的答案，用的时候查表即可。 
•采用的递归方式是自顶向下。
•控制结构与直接递归相同，区别在于备忘录方式为每个解过的子问题建立备忘录。 
•初始化为每个子问题的记录存入一个特殊的值，表示并未求解。在求解过程中，查看相应记录如果是特殊值，表示未求解，否则只要取出该子问题的解答即可。

备忘录方法与动态规划和递归的区别：

1、动态规划是自低向上 ，备忘录方法是自顶向下，递归是自顶向下

2、动态规划每个子问题都要解一次，但不会求解重复子问题；备忘录方法只解哪些确实需要解的子问题；递归方法每个子问题都要解一次，包括重复子问题• 。

动态规划解矩阵连乘问题

#include<iostream>
using namespace std;
void metrixchain(int n,int p[],int **s,int **m)
{
 for(int i=0;i<n;i++)
  m[i][i]=0;
 for(i=2;i<=n;i++)    //小于等于n
 {
  for(int j=0;j<n-i+1;j++) //横坐标
  { int k=j+i-1;   //纵坐标
  m[j][k]=m[j+1][k]+p[j]*p[k+1]*p[j+1];s[j][k]=j;
  for(int t=j+1;t<k;t++)
  {
   int u=m[j][t]+m[t+1][k]+p[j]*p[t+1]*p[k+1];
   if(u<m[j][k])
   {
    m[j][k]=u;s[j][k]=t;
   }
  }
  }
 }
}
void Traceback(int i, int j, int ** s)
{
 if (i==j||i==j-1) return;
 cout<<"divide after metrix "<<s[i][j]<<endl;
 Traceback(i, s[i][j],  s);
 Traceback(s[i][j]+1,j ,  s);
}

int main()
{
 int p[]={30,35,15,5,10,20,25};
 int **s=new int*[6];
 for(int i=0;i<6;i++)
  s[i]=new int[6];
 int **m=new int*[6];
 for( i=0;i<6;i++)
  m[i]=new int[6];
 metrixchain(6,p,s,m);
 for( i=0;i<6;i++)
 { for( int j=i;j<6;j++)
 cout<<m[i][j]<<" ";
 cout<<endl;
 }
 Traceback(0,5,s);
 return 0;

}