动态规划算法思想讲解

总裁余(余登武)

已于 2023-12-26 21:23:13 修改

阅读量1k

点赞数 24

分类专栏：算法笔记文章标签：算法动态规划

于 2023-12-26 19:54:50 首次发布

本文链接：https://blog.csdn.net/kobeyu652453/article/details/135229541

版权

算法笔记专栏收录该内容

18 篇文章 8 订阅

订阅专栏

系列文章目录

文章目录

系列文章目录
什么是动态规划？
核心思想
从解斐波那契数列看动态规划
- 普通递归求解（自顶向下+自底向上+重复计算）
- 备忘录算法求解（自顶向下+自底向上）
- 动态规划法（自底向上）
- 优化（减少空间复杂度）
动态规划中的状态转移方程和最优子结构
动态规划性质和一般步骤
- 性质
- 一般步骤

什么是动态规划？

动态规划（Dynamic Programming，简称DP）是一种解决问题的算法思想，它将一个大问题拆分成多个相互重叠的子问题，并且通过解决这些子问题来求解原始问题。

核心思想

拆分大问题为子问题，记住已经解决的子问题，减少重复计算。

从解斐波那契数列看动态规划

这里我们将告诉小伙伴们怎么理解动态规划中的“重复计算”和“记住”，并逐步引出动态规划。
斐波那契数列的特点是数列中的每个数都是由前面两个数相加得到的。例如：1, 1, 2, 3, 5, 8, 13, …

普通递归求解（自顶向下+自底向上+重复计算）

用递归函数来求解就是：

int Fib(int n) { //递归算法1
  if (n==1 || n==2){ 
      return 1;
  }else{ 
    return Fib(n-1)+Fib(n-2);
  }
}

对于这个递归函数，求解第五个斐波那契数就是调用Fib(5)。递归过程如下图：

这个普通递归调用Fib(5)采用自顶向下，然后直到调用Fib(2)和Fib(1)后触底反弹，自底向上的执行过程，如上图。
可以看到计算过程中存在大量的重复计算，例如求Fib(5)的过程，如上图蓝色部分存在两次重复计算Fib(3)值的情况，这个就是重复计算，需要我们避免。

备忘录算法求解（自顶向下+自底向上）

我们可以设计一个一维dp数组，用dp[i]存放Fib(i)的值，初始化时数组中所有元素都是-1。对应的算法Fib如下所示：

int Fib(int n) {//带备忘的递归算法
  if(n == 0||n == 1) return 1; //递归边界
  if(dp[n]!= -1) return dp[n]; //备忘录中有值
  else{
    dp[n] = Fib1(n-1) + Fib1(n-2); //求得的值存入备忘录
    return dp[n];
  }
}

用数组（或者其他的什么东西）保存已经计算过的子问题，这个过程就叫记忆。是不是很像人常用的备忘录呀
所以！已经计算过的、得到结果的子问题我们不能忘记！而是要用某种东西保存，让程序“记住”它。这样下次还要用的时候就不用重新计算一下，直接调用即可，节约时间。

动态规划法（自底向上）

      使用备忘录算法可以避免大量的重复计算。但是我每次使用都需要先从上到下，触底，然后再自底向上返回。这样感觉好累呀😩我能不能就跑一趟呀？本大学生动不了一点。
      这就是动态规划！省略自顶向下的过程，直接自底向上！好！就喜欢这种简洁的想法👍
      执行过程改变为自底向上，即先求出子问题解，将计算结果存放在一张表中，而且相同的子问题只计算一次，在后面需要时只是简单查表（访问数组，这个数组也叫动态规划数组），以避免重复计算。
      算法伪代码如下：

int dp[MAX]; //所有元素初始化为0
int Fib(int n) { //迭代实现
  dp[0]=dp[1]=1;
  for (int i=2;i<n;i++){ 
    dp[i]=dp[i-1]+dp[i-2]; //计算子问题
  }
  return dp[n];
}

很简单，例如求解Fib(5)：

当i=2，dp[2]=dp[1]+dp[0]=2；
当i=4，dp[4]=dp[3]+dp[2]。此时dp[2]，也就是第三个斐波那契数之前已经被计算过，被保存在了dp[2]，直接查表（访问dp[2]）就可以了。

优化（减少空间复杂度）

我们观察到对于每一个斐波那契数，它的数值其实只与它的前两个数的数值有关，我们不需要记录除了这两个数之外的数。因此，用不上那么大的一个数组，只需要两个变量。

int Fib(int n){  //优化动态规划数组，使用两个变量
  if(n==1) return 1;
  else if(n==2) return 2;
  else{ 
    int a=1,b=2,c;
    for (int i=3;i<=n;i++){ 
      c=a+b;
      a=b; 
      b=c;
    }
    return c;
  }
}

动态规划中的状态转移方程和最优子结构

本篇将以一个路径题目 LeetCode 64 引出动态规划中的状态转移方程。

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

这个问题的本质其实是一个背包问题。
把从(0，0)走到(i，j)的最小路径总和置为f[i][j]。那么我们是怎么走到(i，j)的呢？有三种可能。

当前位置只能通过往下移动而来，即有f[i][j] = f[i-1][j] + grid[i][j]
当前位置只能通过往右移动而来，即有f[i][j] = f[i][j-1] + grid[i][j]
当前位置既能通过往下也能往右移动，为了使路径上的数字总和为最小，需要在向下和向右走之前取一个最小值，既有f[i][j] = min(f[i][j-1],f[i-1][j]) + grid[i][j]

像这样，当前阶段的状态往往是上一阶段状态和相应决策的结果，采用指标函数来表示它们之间的关系称为状态转移方程。

public static int minPathSum(int[][] grid) {
    int m = grid.length, n = grid[0].length;
    int[][] f = new int[m][n];
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) {
                f[i][j] = grid[i][j];
            } else {
                //如果是第一行或第一列只需要考虑left或者top值
                //其余位置则需要选取left和top比较后较小的值
                int top = i - 1 >= 0 ? f[i - 1][j] + grid[i][j] : Integer.MAX_VALUE;
                int left = j - 1 >= 0 ? f[i][j - 1] + grid[i][j] : Integer.MAX_VALUE;
                f[i][j] = Math.min(top, left);
            }
        }
    }
    return f[m - 1][n - 1];
}

这道题中，有一个最小路径总和，也就是有一个最优解。像这样，我们可以通过计算子问题的最优解可以来构建整个问题的最优解，我们就说这个问题具有最优子结构，即满足最优性原理。
你甚至不需要看懂这道题答案的具体代码，只需要你能理解啥是状态转移方程和最优子结构。