带你入门动态规划算法

一、导论

动态规划（Dynamic Programming，DP）是算法设计思想中最难也是最有趣的部分。掌握动态规划算法，对于大厂面试是必不可少的。有接触过DP的小伙伴也许会联想到许许多多的名词，如什么状态转移方程什么的；要不就想到教材书上严谨而又晦涩难懂的对于动态规划的介绍；也有人想到高中的通项公式或数列题等等，但是左看右看都看不出动态体现在哪？哈哈，按照MIT编程导论老师的说法，就是创建人为了不让军方知道他在做什么而故意胡诌的一个名词。后续了解有关算法的实现，我们或许可以用分步规划法、分步存储法、递推存储法、数列递推法、状态转移法等等来重命名它。
其实，小编本人掌握动态规划的过程，也是一波三折，经历九九八十一难。接下来，小编借助几个例子，谈谈自己对DP算法的一点理解。

二、斐波那契数列看DP思想

斐波那契数列：0，1，1，2，3，5，8，13，21，34，55，89，144，233 ……
它遵循这样的规律：当前值为前两个值的和。那么第n个值为多少？
这其实是一个数列，学过数列的小伙伴应该知道，如果数列{a_n}的第n项与它前一项或几项的关系可以用一个式子来表示，那么这个公式叫做这个数列的递推公式。那么斐波那契数列的递推公式就是f(n)=f(n-1)+f(n-2)。我们来分析下问题的解决方法。

（一）暴力递归

我们常见的是使用暴力递归的算法来解决这个问题，代码如下：

#include
using namespace std;
int Fib(int n)//递归
{
    if(n<0)
        cout<<"n<0，data error!"<>n;
    ret=Fib(n);
    cout<<"递归值："<

 
  有关递归算法的讲解可参考小编的另一篇文章递归算法详解。
  如上所示，代码简单易懂，然而代码却极其低效。这种使用递归的方式一方面不仅造成栈空间的极大浪费，另一方面该算法的时间复杂度为O(2ⁿ)，指数级别。我们可以看下f(20)的求解过程，这其实就是一棵树。可以看到 f(18) 被计算了两次，而且你可以看到，以 f(18) 为根的这个递归树体量巨大，多算一遍，会耗费巨大的时间。更何况，还不止 f(18) 这一个节点被重复计算，随着递归的深入，计算任务不断翻倍，所以这个算法及其低效。
  
  
   
     
    
   
  
    递归树 
   
  
 
  这就是动态规划可解决的问题经常出现的情况：重叠子问题。下面，我们想办法解决这个问题。 
  
 （二）自顶向下的记忆化搜索递归 
  即然耗时的原因是重复计算，那么我们可以造一个数组，每次算出某个子问题的答案后别急着返回，先记到数组里再返回；每次遇到一个子问题先去数组里查一查，如果发现之前已经解决过这个问题了，直接把答案拿出来用，不要再耗时去计算了。
  代码如下： 
 #include
#include
using namespace std;
int helper(vector& result,int n){
    if(n==1)return 1;
    if(n==2)return 2;
    if(result[n]!=0)return result[n];
    result[n]=helper(result,n-1)+helper(result,n-2);
    return result[n];
}
int Fib(int N){
    if(N<1) return 0;//小于1，不正确 
    vector result(N+1,0);//创建长度为N+1的数组 ，初始化为0 
    return helper(result,N);
}
int main()
{
    int n,ret=0;
    cout<<"请输入下标:";
    cin>>n;
    ret=Fib(n);
    cout<<"递归值："<
 
  *"记忆化搜索"或者我们称"重叠子问题"的加缓存优化的实现，我们的思考路径是"自顶向下"。即为了解决数据规模大的问题，我们“假设”已经解决了数据规模较小的子问题。我们没有从最基本的问题开始求解，对于f(n)=f(n-1)+f(n-2)，我们假装f(n-1)和f(n-2)是已知的。现在，画出图，你就知道数组到底做了什么。
  
  
   
     
    
   
  
    记忆化搜索 
   
  
 
  实际上，带数组的递归算法，把一棵存在巨量冗余的递归树通过裁剪，改造成了一幅不存在冗余的递归图，极大减少了子问题（即递归图中节点）的个数。 
 
 
  
   
     
    
   
  
    剪枝 
   
  
 
  经过分析，本算法的时间复杂度是 O(n)。 
 
  至此，带数组的递归解法的效率已经和迭代的动态规划解法一样了。实际上，这种解法和迭代的动态规划已经差不多了，只不过这种方法叫做自顶向下，动态规划叫做自底向上。关于自顶向下和自底向上的意思这里就不做描述，不懂的可以找度娘。 
  
 （三）自底向上的动态规划思想 
  有了上一步的启发，我们可以把这个数组独立出来成为一张表。
  ① 斐波那契数列有这样的关系：f(n)=f(n-1)+f(n-2)
  ② 我们使用一个数组result[ ]，来缓存这些重复计算的值。
  因此有：result[i]= result[i-1]+ result[i-2]。采用这样的方法我们就可以对缓存的数据进行复用。
  ③ 按顺序从小往大算。使用for循环实现了从0到n的顺序求解，问题从小规模往大规模求解的顺序走。
  
  
   
     
    
   
  
    DP思想 
   
   代码如下： 
  
 #include
#include
using namespace std;
int Fib(int N){
    if(N<1) return 0;
    vector result(N+1,0);
    result[1]=1;
    result[2]=2;
    for(int i=3;i<=N;i++){
        result[i]=result[i-1]+result[i-2];
    }
    return result[N];
}
int main()
{
    int n,ret=0;
    cout<<"请输入下标:";
    cin>>n;
    ret=Fib(n);
    cout<<"递归值："<
 
  同样的，时间复杂度降为O(n)。
  其实，上述斐波那契数列就是使用了DP思想来解决这个问题。 
 （四）动态规划思想解决问题的三步骤 
  ① 建立递推公式
  ② 根据递推公式建立一个数组，用来缓存并复用以往结果
  ③ 运用循环控制结构，按顺序从小往大算，得到最终结果
  当然，这里的递推公式，在DP里称呼为状态转移方程，数组又称呼为DP表。往下看，小编稍后还会进行解释。 
 三、凑硬币问题探DP性质 
  当然，DP思想主要使用在求解最值问题这一类问题上，上述斐波那契数列只不过是用来描述下DP思想解决问题的基本的步骤及其使用价值。
  现在有面值为1，5，11的硬币若干。现在您的目标是凑出某个金额w，需要用到尽量少的硬币。 
 （一）“贪心”能解决？ 
  依据生活经验，我们每次都是先挑面值大的硬币，按这样的方法来凑够金额。这就是所谓的“贪心策略”。我们面对的局面是“需要凑出w”，贪心策略会尽快让w变得更小。能让w少11就尽量让它少11，这样我们接下来面对的局面就是凑出w-11。长期的生活经验表明，贪心策略是正确的。
  但是，如果我们要用这些面值的硬币凑出15元时，会发现：
  贪心策略：15=1×11+4×1（贪心策略使用了5个硬币）
  然而15=3×5，正确的策略只需要用3个硬币。为什么会这样呢？贪心策略错在了哪里？
  刚刚已经说过，贪心策略的纲领是：“尽量使接下来面对的w更小”。这样，贪心策略在w=15的局面时，会优先使用11来把w降到4；但是在这个问题中，凑出4的代价是很高的，必须使用4×1。如果使用了5，w会降为10，虽然没有4那么小，但是凑出10只需要两张5元。在这里我们发现，贪心是一种只考虑眼前情况的策略。也就是所谓的鼠目寸光。 
 （二）寻找递推关系 
  那么，现在我们怎样才能避免鼠目寸光呢？如果直接暴力枚举凑出w的方案，明显复杂度过高。太多种方法可以凑出w了，枚举它们的时间是不可承受的。我们现在来尝试找一下性质。
  重新分析刚刚的例子。w=15时，我们如果取11，接下来就面对w=4的情况；如果取5，则接下来面对w=10的情况。我们发现这些问题都有相同的形式：“给定w，凑出w所用的最少硬币是多少个？”
  我们用f(n)来表示“凑出n所需的最少硬币数量”。
  那么，如果我们取了11，最后的代价（凑出来的总硬币个数）是多少呢？
  明显f(15)=f(15-11)+1=f(4)+1=4+1=5，它的意义是：利用11来凑出15，付出的代价等于f(4)加上自己这一枚硬币。现在我们暂时不管f(4)怎么求出来。
  依次类推，马上可以知道：如果我们用5来凑出15，cost就是f(15)=f(15-5)+1=f(10)+1=2+1=3；
   那么，现在w=15的时候，我们该取那种硬币呢？当然是各种方案中，代价最低的那一个！
   取11：f(15)=f(15-11)+1=f(4)+1=4+1=5;
   取5 ：f(15)=f(15-5)+1=f(10)+1=2+1=3;
   取1 ：f(15)=f(15-1)+1=f(14)+1=4+1=5;
   显而易见，f(15)值最低的是取5的方案。我们通过上面三个式子，做出了正确的决策！
   这给了我们一个至关重要的启示：f(n)只与f(n-11)，f(n-5)，f(n-1)有关，也就是：f(n)=min{ f(n-11), f(n-5), f(n-1) } +1
  这个递推式子是非常激动人心的。我们要求出f(n)，只需要求出几个更小的f值；既然如此，我们从小到大把所有的f(i)求出来不就好了？注意一下边界情况即可。 
 （三）编写程序 
  代码如下： 
 #include 
using namespace std;
#define INF  99999
int min(int x, int y, int z)
{
    if (x <= y && x <= z)
        return x;
    if (y <= x && y <= z)
        return y;
    if (z <= x && z <= y)
        return z;
}
int main()
{
    int coin[3] = { 1, 5, 11 };
    int dp[16] = {0};
 
    for (int i = 1; i < 16; i++)
    {
        int tmp[3] = { INF,INF,INF };
        if (i >= 1)
            tmp[0] = dp[i - 1] + 1;
        if (i >= 5)
            tmp[1] = dp[i - 5] + 1;
        if (i >= 11)
            tmp[2] = dp[i - 11] + 1;
        dp[i] = min(tmp[0], tmp[1], tmp[2]);
        cout << "dp["< 
   
     
    
   
  
    线路网络图

#include using namespace std; int main() { int i,j,n,max; scanf("%d",&n); int a[n+1],d[n+1]; for(i=1;i<=n;++i) scanf("%d",&a[i]); d[1]=1; for(i=2;i<=n;++i) { max=d[1]; for(j=1;jmax) max=d[j]; } d[i]=max+1; } max=0; for(i=1;i<=n;++i) { if(d[i]>max) max=d[i]; } printf("%d\n",max); return 0; }

for(j=1; j<=m; j=j+1) // 第一个阶段 xn[j] = 初始值; for(i=n-1; i>=1; i=i-1)// 其他n-1个阶段 for(j=1; j>=f(i); j=j+1)//f(i)与i有关的表达式 xi[j]=j=max（或min）{g(xi-1[j1:j2]), ......, g(xi-1[jk:jk+1])}; t = g(x1[j1:j2]); // 由子问题的最优解求解整个问题的最优解的方案 print(x1[j1]); for(i=2; i<=n-1; i=i+1） { t = t-xi-1[ji]; for(j=1; j>=f(i); j=j+1) if(t=xi[ji]) break; }

带你入门动态规划算法

一、导论

二、斐波那契数列看DP思想

（一）暴力递归

（二）自顶向下的记忆化搜索递归

（三）自底向上的动态规划思想

（四）动态规划思想解决问题的三步骤

三、凑硬币问题探DP性质

（一）“贪心”能解决？

（二）寻找递推关系

（三）编写程序

五、最长上升子序列窥DP解题思路

六、DP解题的一般思路

七、算法实现的一般步骤

你可能感兴趣的:(带你入门动态规划算法)