动态规划dp

一.动态规划五步走

一.dp数组的含义

dp[i]：i是这个位置的，而dp[i]是作用这个位置而有的值

DP数组（通常是一个一维或二维数组）用来存储子问题的解。每一个 dp[i] 表示在某个状态下的解。这个数组的意义是：通过记录之前的计算结果来避免重复计算，从而提高效率。

• 一维DP数组：当问题的状态可以通过一个变量来表示时，使用一维数组。例如，斐波那契数列就是一个经典的一维DP问题，dp[i] 表示到第 i 个位置的解。
• 二维DP数组：当问题的状态可以由两个变量来表示时，使用二维数组。例如，背包问题通常需要二维数组，dp[i][j] 表示前 i 个物品放入容量为 j 的背包中的最大价值。

二.递推公式

递推公式（或者叫状态转移方程）是求解问题的核心，它决定了如何从已知的子问题的解推导出当前问题的解。

• 类如斐波那契数列的递推公式为： dp[i]=dp[i−1]+dp[i−2]dp[i] = dp[i-1] + dp[i-2]dp[i]=dp[i−1]+dp[i−2]

三.dp数组的初始化

动态规划的初始化通常需要根据问题的边界条件来设定初值。例如：

• 斐波那契数列：初始化 dp 数组时，通常有两个基础条件： dp[0]=0,dp[1]=1dp[0] = 0, dp[1] = 1dp[0]=0,dp[1]=1
• 背包问题：通常初始化背包容量为 0 的情况为 0，即： dp[0][j]=0(表示没有物品时，背包容量 j 的最大价值为 0)dp[0][j] = 0 \quad \text{(表示没有物品时，背包容量 j 的最大价值为 0)}dp[0][j]=0(表示没有物品时，背包容量 j 的最大价值为 0)
• 最短路径问题：初始状态下，如果从起点到某一点不可达，则设为无穷大。

四.dp数组的遍历

遍历 DP 数组是根据递推公式更新状态的过程。一般来说，我们会按照某种顺序遍历数组，通常是从前到后，或者按照某种结构（例如二维数组按行或按列遍历）。

• 斐波那契数列：从 dp[2] 开始递推，直到 dp[n]。
• 背包问题：从物品的第一个到最后一个，或者从背包的最小容量到最大容量依次填充 DP 数组。
• 矩阵链乘法：通过动态规划的方式，按某个规律遍历可能的拆分点。

五.dp数组的打印

当整个动态规划过程完成后，我们通常会打印最终的结果。这个结果可能是 dp[n]（例如，斐波那契数列的最后一个结果），也可能是 dp[n][m]（例如，背包问题的最终解）。

• 斐波那契数列：最终结果是 dp[n]，表示第 n 个斐波那契数。
• 背包问题：最终结果是 dp[n][W]，表示使用前 n 个物品，背包容量为 W 时的最大价值。
   

 二.题

1.

思路：五部曲，这个基本上都给出的规律，写代码即可

class Solution {
public:
    int fib(int n) {
        vector<int>dp(n+1,0);
        dp[0] = 0;dp[1] = 1;
        for(int i=2;i<=n;i++)dp[i] = dp[i-1]+dp[i-2];
        return dp[n];
    }
};

 2.

思路：五部曲，含义，公式，初始化，遍历加打印，变版的斐波那契

class Solution {
public:
   int climbStairs(int n) {
        if (n <= 1) return n; 
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { 
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

 3.

思路：五部曲，明确dp是在i台阶上时从下往上跳所有费用；(同时，i往上跳又要cost【i】)

          费用最小的状态转移方程 dp[i] = min(dp[i-1]+cost[i-1],dp[i]+dp[i-2]+cost[i-2]);

          初始化 dp[0] = dp[1] = 0;

          遍历是前到后

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int>dp(cost.size()+1);
        dp[0] = 0;
        dp[1] = 0;
        for(int i=2;i<=cost.size();i++)dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        return dp[cost.size()];
    }
};

4.

思路：五部曲dp数组表示在某个（x，y） 位置的方法有dp[x][y]种

           状态转移方程dp[x][y] = dp[x-1][y]+dp[x][y-1];

           初始化，最上边和最左边都是只能有一种俩个for循环来初始化

           可以先先排后列遍历，也可以先列后排遍历

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>>dp(m,vector<int>(n,0));
        for(int i = 0;i < m; i++)dp[i][0] = 1;
        for(int i = 0;i < n; i++)dp[0][i] = 1;

        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

5.  

思路： 五部曲dp数组表示在某个（x，y） 位置的方法有dp[x][y]种，如果有障碍，就地图标记

           状态转移方程dp[x][y] = dp[x-1][y]+dp[x][y-1];

           初始化，最上边和最左边都是只能有一种俩个for循环来初始化

           可以先先排后列遍历，也可以先列后排遍历

 int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1)
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];

6.

 思路：五部曲dp数组是数 i 拆后乘积的最大值dp[i]

           状态转移方程dp = max(j*(i-j),max(dp[i],j * dp[i-j]));

           初始化dp[2] = 1;

           被拆的数从小开始遍历

class Solution {
public:
    int integerBreak(int n) {
        vector<int>dp(n+1,0);
        dp[2] = 1;

        for(int i = 3 ;i<=n;i++){
            for(int j = 1;j <i;j++){
               dp[i] = max(dp[i],max(j*dp[i-j],j*(i-j)));
            }
        } 
        return dp[n];
    }
};

7.

思路：五部曲明确dp数组为第 i 个数，有dp[i]种二叉搜索树

           状态转移方程 dp[i] 前有 i - 1 个数，既有 i - 1 个头节点，for循环遍历每个头节点有

           for(int j = 1 ; j < i ; j++) dp[i] += dp[j-1] * dp[i-j];

           初始化 dp[0] = 1;

           从头到尾遍历

class Solution {
public:
    int numTrees(int n) {
         vector<int>dp(n + 1);
         dp[0] = 1;

         for (int i = 1; i <= n; i++) {
             for (int j = 1; j <= i; j++) {
                  dp[i] += dp[j - 1] * dp[i - j];
             }
         }
         return dp[n];
    }
};

  8.       

思路：来了来了，经典的背包问题，依旧五部曲

dp[i][j]数组的含义：任选[0,i]的物品在背包容量为j的情况下其价值为dp[i][j]

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

初始化，dp[i][0] = 0

遍历可以先背包再物品，也可以先物品再背包

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include<climits>
#include <queue>
#include<cstring>
using namespace std;

void work(int M,int N) {
    vector<int>items(M + 1, 0); // 物品
    vector<int>values(M + 1, 0); // 价值
    vector<vector<int>>dp(M + 1, vector<int>(N + 1, 0)); // 背包

    // 物品
    for (int i = 1; i <= M; i++) {
        cin >> items[i];
    }
    // 物品价值
    for (int i = 1; i <= M; i++) {
        cin >> values[i];
    }

    // 物品装包
    for (int i = 1; i <= M; i++) {
        for (int j = 1; j <= N; j++) {
            if (j >= items[i])
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - items[i]] + values[i]);
            else
                dp[i][j] = dp[i - 1][j];
        }
    }
    cout << dp[M][N];
}
int M, N;

int main() {
    cin >> M >> N;
    work(M, N);
    return 0;
}

一维压缩背包

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include<climits>
#include <queue>
#include<cstring>
using namespace std;

void work(int M,int N) {
    vector<int>items(M + 1, 0); // 物品
    vector<int>values(M + 1, 0); // 价值
    vector<int>dp(N + 1, 0); // 背包

    // 物品
    for (int i = 1; i <= M; i++) {
        cin >> items[i];
    }
    // 物品价值
    for (int i = 1; i <= M; i++) {
        cin >> values[i];
    }

    // 物品装包
    for (int i = 1; i <= M; i++) {
        for (int j = N; j >= 1; j--) {
            if (j >= items[i])dp[j] = max(dp[j], dp[j - items[i]] + values[i]);
            else dp[j] = dp[j];
        }
    }
    cout << dp[N];
}
int M, N;

int main() {
    cin >> M >> N;
    work(M, N);
    return 0;
}