算法——动态规划

　　每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。它与分而治之都是将一个问题的实例划分为较小的实例。

　　谈到动态规划，我们首先要理解它是什么意思，这里的“规划”意味着使用一个在其中存有答案的数组。什么意思那？我们说到分而治之的方法时，例如计算斐波那契序列时，往往在递归过程中会计算很多重复的值，这样往往造成效率低下，而动态规划则是将一些已经计算过的值存下来，在需要再次使用时，直接取出，而不是重新计算。于分而治之自上而下的策略相反，动态规划采用了自下而上的方法。

适用的情况

　　能采用动态规划求解的问题的一般要具有3个性质：

　　(1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。

　　(2) 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。

　　(3）有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有　　这条性质，动态规划算法同其他算法相比就不具备优势）

　

使用方式

　　它的计算步骤如下：

　　1、确立一种递归性质，给出一个问题实例的解。（这步比较重要，直接关系到了程序的编写）

　　2、首先求解较小的实例，以自下而上的方法求解问题的原实例。

　　通过问题来详解。

　　二项式系数问题。

　　（n,k） = n!/k!(n-1)!

　　我们首先知道

　　（n,k） = { (n-1,k-1)+(n-1,k)       0<=k<=n

　　　　　　　　1　　                         k=0或k=n

　  我们很自然的想到分而治之的方法，递归而出.代码如下。

　　

int bin(int n,int k){
    if(k==0||n==k){
        return 1;
    }else{
        return bin(n-1,k-1)+bin(n-1,k);
    }
}

 

　　我们可以清楚的看出它在每次递归调用时都要求解相同的实例。这样造成效率的低下。

　　那么使用动态规划那？

　　我们先确定第一步，找到一种递归性质，并能用之前的解推出之后的解，而不是重新计算。

　　    　0　　1　　2　　3　　4

　　　　———————————————————————

　　0|   1

　　1|　1　　1

　　2|　1　　2　　1

　　3|　1　　3　　3　  1　

　　4|　1　　4　　6　  4　　1

 

　　我们可以清楚的发现这么一个递推公式

　　B[i][j] = B[i-1][j-1]+B[i-1][j]         0<j<i

　　　　　　  1　　　　　　　　　　　　　j=0或j=i

　　那么我们

　　先计算第一行：

　　　　　　　　B[0][0] = 1;

 　  第二行：

　　　　　　　　B[1][0] = 1; B[1][1] = 1;

　　等等以此类推，将结果存储起来使用。代码如下

　　

int bin2(int n,int k){
    int i,j;
    int B[30][30];
    for(i=0;i<=n;i++){
        for(j=0;j<=i<k?i:k;j++){
            if(j==0||i==i){
                B[i][j] = 1;
            }else{
                B[i][j] = B[i-1][j-1]+B[i-1][j];
            }
        }
    }
    
    return B[n][k];
}

　　通过上面的简单例子，我们大致了解了，如何使用动态规划，以及在什么情况下使用动态规划。

　　

接下来通过floyed算法求最短路径来解析一下动态规划的算法

　　我们来看为什么求最短路径能用动态规划，1、最短路径的子路径一定是最短的。2、两点之间的最短路径决定后，并不会影响得到这两点最短路径的最短子路径。3、两点的子路径会在后面多次用到。

　　一个邻接数组代表了图，我们来看W[][]

　　

　　       1　　2　　3　　4　　5

　　　　------------------------------

　　1|   0　　1　　∞　  1　　5

　　2|   9 　  0　　3　　2　　∞　　

　　3|  ∞　  ∞　　0　　4　　∞

　　4|  ∞ 　 ∞　　2　　0　　3

　　5|  3　　∞　　∞　  ∞　  0

 

　　将他们存到数组中D[][]，若求两点之间最短路径，即求D[i][j].

　　那么我们先规定D(0) = W,我们认为他是两点之间不经过任何一点直接相连的最短路径

　　for(int i=0;i<n;i++）{

　　　　for(int j=0;j<n;j++){

　　　　　　D[i][j] = D[i][j];

　　　　}

　　}

　　D(1)[i][j] ，我们认为它是两点之间经过点V1后Vi和Vj之间的最短路径，可以用公式这么看 min{{vi,vj},{vi,v1,vj}}

　　列出代码就是

　　for(int i=0;i<n;i++）{

　　　　for(int j=0;j<n;j++){

　　　　　　D[i][j] = min{D[i][j],D[i][1]+D[1][j]}

　　　　}

　　}

　　D(2)[i][j] ，我们认为它是两点之间经过点V2后Vi和Vj之间的最短路径，可以用公式这么看 min{{vi,vj},{vi,v2,vj}}

　　for(int i=1;i<=n;i++）{

　　　　for(int j=1;j<=n;j++){

　　　　　　D[i][j] = min{D[i][j],D[i][2]+D[2][j]}

　　　　}

　　}

　　以此类推

　　for(int k=1;k<=n;k++){

　　　　for(int i=0;i<n;i++）{

　　　　　　for(int j=0;j<n;j++){

　　　　　　　　D[i][j] = min{D[i][j],D[i][k]+D[k][j]}//为该问题的递归性质

　　　　　　}

　　　　}

　　}

　　那么我们就可以明白，这个数组便是存有所有两点之间最短路径。先循环一边k=1，D（1）[][]代表，直接相连和经过v1相连的最短路径。再循环k=2，D（2）[][]代表，直接相连，只经过v1，只经过v2，经过v2、v1两点的最短路径。以此类推，便能得到最后结果。

　　代码如下

　　

void floyed(int n,int w[5][5],int d[5][5]){
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            d[i][j] = w[i][j];
        }
    }

    for(int k=0;k<n;k++){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                d[i][j] = d[i][j]<(d[i][k]+d[k][j])?d[i][j]:(d[i][k]+d[k][j]);
            }
        }
    }
}