动态规划

原理剖析

动态规划算法与分治法类似，基本思想都是将问题分解成为若干子问题，分而治之。
因此，实际上动态规划大部分情况下都可以用递归解决

斐波那契数列定义：F(N) = F(N -1) + F(N - 2)

很明显，斐波那契数列就是一个用递归解决的典型问题。
其存在的弊端是，当N特别大时，会因为子问题指数增长重复计算而导致堆栈溢出，程序崩溃。（当N == 4时，C(1)== 3， C(2) == 2， C(3)== 1， C(4) == 1， C(N)表示F(N)计算次数）

因此，引入了动态规划，实际就是以空间换时间，在计算过程采用“打表”的方式进行“剪枝”，避免子问题重复计算。

---

最小路径和

题目：给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

1	3	1
1	5	1
4	2	1

代码实现如下：

int minPathSum(vector<vector<int>>& grid) {
        if (grid.empty()) {
            return 0;
        }

        int m = grid.size();
        int n = grid[0].size();
        int dp[200][200] = {0};
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i == 0 && j == 0) {
                    dp[i][j] = grid[i][j];
                    continue;
                }

                if (j == 0) {
                    dp[i][j] = dp[i - 1][j] + grid[i][j];
                    continue;
                }

                if (i == 0) {
                    dp[i][j] = dp[i][j - 1] + grid[i][j];
                    continue;
                }

                dp[i][j] = min(dp[i - 1][j] + grid[i][j], dp[i][j - 1] + grid[i][j]); // 状态转移方程
            }
        }

        return dp[m - 1][n - 1];
    }

但是实际上，每次计算当前格的最优解依赖的前置最优解(即左边或者上边)都均已被保存，理论上我们不需要采用二维的dp数组，只需要一维数组记录，并遍历实时刷新便可。

因此，可对编码进行优化，对dp数组进行降维处理

int minPathSum(vector<vector<int>>& grid) {
        if (grid.empty()) {
            return 0;
        }

        int colSize = grid[0].size();
        vector<int> dp(colSize + 1, 0);

        for (int i = 0; i < colSize; ++i) {
            dp[i + 1] = dp[i] + grid[0][i];
        }

        dp[0] = INT_MAX;

        for (int i = 1; i < grid.size(); ++i) {
            for (int j = 0; j < colSize; ++j) {
                dp[j + 1] = min(dp[j], dp[j + 1]) + grid[i][j];
            }
        }

        return dp[colSize];
    }

---

背包问题

背包问题作为动态规划的典型，不可不提

0 - 1背包

题目：有n块物品，每块有不同的价值v和重量w，现有一个容量上限为m的背包，如何使得装入的物品价值最大？

状态转移方程：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i])

怎么理解状态转移方程呢？

1. dp[i][j]表示将前i块物品装入容量为j的背包中的最大价值；
2. 如上述所言，动态规划实际上就是减少子问题的计算量，将中间量保存下来，因此需要计算从0开始到n每个物品的动作，即装入或者不装入两种选择(0 <= i <= n)；
3. 另外，还需要记录从1开始，到背包容量m的每个容量的最大价值，满足前置条件最优化，需要另一层循环(1 <= j <= m)；
4. 综上所述，0 - 1背包的时间复杂度就是O(n * m)；
5. 0 - 1背包依然可以采取滚动数组的处理方式，对空间进行降维处理，即空间复杂度为O(m)；

代码如下：

int maxValue(vector<int>& weights, vector<int>& values, int m)
{
    if (weights.empty() || values.empty()) {
        return 0;
    }
    
    vector<int> dp(m + 1, 0);
    int n = weights.size();
    for (int i = 0; i < n; ++i) {
        for (int j = m; j >= weights[i]; --j) { // 注意j的遍历顺序
            dp[j] = max(dp[j], dp[j - weights[i]] + values[i]);
        }
    }
    
    return dp[m];
}

为什么j的遍历顺序要从后往前推呢？

1. 首先这是空间优化的结果，因为每个物品的装入状态计算，依赖于上一个物品的计算结果，从二维数组形式上看，每个dp[i][j]，都依赖于上一层(i - 1)的计算结果；
2. 比如dp[i - 1][j - w[i]]，而优化后的数组仅有一维，若从左往右计算，会将dp[i - 1][j - w[i]]的值覆盖，造成计算结果错误；
3. 通俗的理解，可参照上述题目最短路径和，从表的形式上看，每个数组元素的计算都依赖于上方元素和上一层“靠左”的元素，若从左往右遍历，会先刷新左边的元素(优化成一维)，造成后续计算错误；

多重背包

未完待续。。。