第三章：动态规划

1、  分治算法和动态规划算法都是通过对问题进行分解，通过对子问题的求解然后进行解重构，从而实现对原问题的求解。请指出这两种算法在对问题进行分解时各自所遵循的原则。

答：分治算法对问题进行分解时所遵循的原则是将待求解问题分解为若干个规模较小、相互独立且与原问题相同的子问题（不包含公共的子问题）。

动态规划对问题进行分解时所遵循的原则是将待求解问题分解为若干个规模较小、相互关联的与原问题类似的子问题（包含公共的子问题），采用记录表的方法来保存所有已解决问题的答案，而在需要的时候再找出已求得的答案，避免大量的重复计算。

 

2、  动态规划算法的本质是什么，请简要阐述。

答：动态规划的实质是分治思想和解决冗余，动态规划算法是将问题分解为更小的、相似的子问题，并存储子问题的解而避免计算重复的子问题，以解决最优化问题的算法策略。

 

3、  如果一个问题可以利用动态规划算法求解，那么该问题应满足什么条件？

答：该问题具有最优子结构性质（一个问题的最优解包含其子问题的最优解）和无后效性(将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态).

 

4、动态规划算法的基本思想是什么？请简述动态规划算法主要设计步骤。

答：动态规划算法的基本思想是将待求解问题分解成若干个相互关联的与原问题类似的子问题，求解这些子问题，并保存子问题的答案，避免重复计算，然后从这些子问题的解得到原问题的解。

动态规划算法主要设计步骤：

1）找出最优解的性质，并刻画其结构特征；

2）递归地定义最优值；

3）以自底向上的方式计算出最优值；

4）根据计算最优值时得到的信息，构造最优解；

5，什么是备忘录方法？它同动态规划法相比主要不同点是什么？请指出动态规划法和备忘录方法各自的适用范围。(注：平常说的“动态规划”是自底向上的动态规划，“备忘录方法”是自顶向下的动态规划。)

答：备忘录方法是动态规划算法的变形，它通过分治思想对原问题进行分解，以存储子问题的解的方式解决冗余计算，并采用自顶向下的递归方式获取问题的最终解。

与动态规划算法的不同之处是动态规划算法的递归方式是自底向上递归求解，而备忘录方法的递归方式是自顶向下递归求解。

当一个问题的所有子问题都至少要解一次时，使用动态规划算法。

当子问题空间中的部分子问题不需要求解时，使用备忘录方法。

6，矩阵相乘算法目前最好的时间复杂度是多少？

答：目前矩阵乘法最好的时间复杂度是能做到O（n2.376）

7，分治法与动态规划法之间的相同点是什么？不同之处在哪些方面？

答：与分治法类似，动态规划法 也是把问题一层一层地分解为规模逐渐减小的同类型的子问题。

动态规划法与分治法的一个重要的不同点在于，用分治法分解后得到的子问题通常都是相互独立的， 而用动态规划法分解后得到的子问题很多都是重复的。因此，对重复出现的子问题，只是在第一次遇到时才进行计算，然后把计算所得的结果保存起来；当再次遇到该子问题时，就直接引用已保存的结果，而不再重新求解。

例题：

1，

 

2，

 

3，动态0-1背包

public class  SF_Beibao_0_1{

 public static void main(String[]args){

          int []v={1,2,3,4,5,6,7};

          int []w={2,3,4,5,34,23,2};

          int []b={2,3,4,1,2,3,5};

          int c=45;

          int d=36;

          int [][][]m=new int[v.length][c+1][d+1];

          knapsack(v,w,b,c,d,m);

          System.out.println("输出最优解："+m[1][c][d]);

          }

 public static void knapsack(int[]v,int[]w,int []b,int c,int d,int[][][]m){

          int n=v.length-1;

     int jMax=Math.min(w[n]-1,c);

     int kMax=Math.min(b[n]-1,d);

     for(int j=0;j<=jMax;j++)

                   for(int k=0;k<=kMax;k++)

                             m[n][j][k]=0;

     for(int j=w[n];j<=c;j++)

     for(int k=b[n];k<=d;k++)

                             m[n][j][k]=v[n];

     for(int i=n-1;i>1;i--){

                    jMax=Math.min(w[i]-1,c);

                    kMax=Math.min(b[i]-1,d);

                    for(int j=0;j<=jMax;j++)

         for(int k=0;k<=kMax;k++)

         m[i][j][k]=m[i+1][j][k];

                    for(int j=w[i];j<=c;j++)

         for(int k=b[i];k<=d;k++)

         m[i][j][k]=Math.max(m[i+1][j][k],m[i+1][j-w[i]][k-b[i]]+v[i]);

                    }

         m[1][c][d]=m[2][c][d];

    if(c>=w[1]&&d>=b[1])m[1][c][d]=Math.max(m[1][c][d],m[2][c-w[1]][d-b[1]]+v[1]);

         }

 public static void trackback(int[][][]m,int[]b,int[]w,int c,int d,int[]x){

          int n=w.length-1;

     for(int i=1;i<n;i++)

     if(m[i][c][d]==m[i+1][c][d])x[i]=0;

     else {x[i]=1;c-=w[i];d-=b[i];}

     x[n]=(m[n][c][d]>0)?1:0;

     }

 }

4，