DP动态规划入门（数字三角形、破坏的楼梯、安全序列） ...

一、动态规划（DP）简介

动态规划（Dynamic Programming，简称DP）是运筹学的一个分支，它是一种通过将复杂问题分解成多个重叠的子问题，并通过子问题的解来构建整个问题的解的算法。在动态规划中，有几个核心概念需要明确：

• 状态：状态通常表示为形如dp[j] = val的取值，其中i和j是用于描述和确定状态所需的变量（下标），而val则是该状态对应的值。
  
• 状态转移：状态转移描述了不同状态之间如何相互转化。这通常可以表示为一个数学表达式，而转移的方向则决定了算法是迭代还是递归地进行。
  
• 最终状态：最终状态即题目所要求解的状态，也是我们通过动态规划算法最终要得到的答案。
  

动态规划的关键在于找到子问题之间的重叠关系，并存储这些子问题的解以避免重复盘算。通过这种方式，动态规划能够在多项式时间内办理一些看似复杂的问题，如背包问题、最短路径问题等。在实际应用中，动态规划被广泛用于优化和控制问题，以及盘算机视觉、生物信息学等领域。
二、动态规划的解题步骤

步骤一：确定状态

首先，需要明确问题的状态表示。在动态规划问题中，状态通常界说为“到第i个为止，xx为j（xx为k）的方案数/最小代价/最大价值”等。这里，“i”、“j”和大概的“k”是状态的参数，它们根据具体问题而定。状态的确切界说取决于问题的性质和所需优化的目的（如最小代价、最大价值或方案数）。
步骤二：确定状态转移方程

状态转移方程是动态规划的核心，确定状态转移方程，即从已知状态得到新状态的方法，并确保按照这个方向一定可以精确地得到最终状态。根据状态转移的方向来决定使用迭代法还是递归法（影象化）。状态转移方程的确立通常基于问题的特定条件和约束。
步骤三：确定最终状态并输出

最终状态通常是问题的解所对应的状态。在确定了状态转移方程后，我们需要按照这个方程迭代或递归土地算出全部大概的状态，直到到达最终状态。最终状态大概是通过迭代法渐渐累积得到，也大概是通过递归法（联合影象化以避免重复盘算）渐渐回溯得到。一旦到达最终状态，我们就可以根据问题的要求输出相应的解，如最小代价、最大价值或特定条件下的方案数。
综上所述，这三个步骤——确定状态、确定状态转移方程和确定最终状态并输出——构成了动态规划求解问题的一般框架。在实际应用中，根据具体问题的不同，这些步骤的具体实现方式也会有所不同。
三、线性DP例题

（一）数字三角形（最大路径）

上图给出了一个数字三角形。从三角形的顶部到底部有许多条不同的路径对于每条路径，把路径上面的数加起来可以得到一个和，你的使命就是找到最大的和(路径上的每一步只可沿左斜线向下或右斜线向下走)。
输入描述
输入的第一行包含一个整数 N(1 ≤ N < 100)，表示三角形的行数。
下面的 N 行给出数字三角形。数字三角形上的数都是 0 至 99 之间的整数。
输出描述
输出一个整数，表示答案。
输入样例
   5 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5
  输出样例
   30
  思路：

• 从末了一层向上，取最大值累加。
  
• 确定状态：设状态dp[ i ][ j ] = a[ i ][ j ] + max(dp[ i + 1 ][ j ], dp[ i + 1 ][ j + 1 ])；
  
• 状态转移方程为dp[j]=max(dp[i+1][j]，dp[i +1][j + 1]) ；
  
• 由于这里需要用下面的状态更新上面的，以是我们应该从下往上进行状态转移。末了输出dp[1][1]
  

解法一：自下而上 

1. #include<bits/stdc++.h>
2. using namespace std;
3. using ll = long long;
4. const int N = 105;
5. ll a[N][N], dp[N][N];
7. int main()
8. {
9.         int n; cin >> n;
10.         for (int i = 1; i <= n; ++i)
11.                 for (int j = 1; j <= i; j++)
12.                         cin >> a[i][j];
13.         for (int i = n; i >= 1; i--)
14.                 for (int j = 1; j <= i; j++)
15.                         dp[i][j] = a[i][j] + max(dp[i + 1][j], dp[i + 1][j + 1]);
16.         cout << dp[1][1] << '\n';
17.         return 0;
18. }

复制代码

解法二：自上而下

1. #include<bits/stdc++.h>  
2. using namespace std;
3. const int N = 105;
4. int a[N][N], f[N][N];
5. int n, INF = 1e9;
7. int main()
8. {
9.         cin >> n;
10.         for (int i = 1; i <= n; i++)
11.                 for (int j = 1; j <= i; j++)cin >> a[i][j];
12.         for (int i = 0; i <= n; i++)
13.                 for (int j = 0; j <= i; j++)f[i][j] = -INF;
14.         f[1][1] = a[1][1];
16.         for (int i = 2; i <= n; ++i)
17.                 for (int j = 1; j <= i; ++j)
18.                         f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + a[i][j];
19.         int res = -INF;
20.         for (int i = 1; i <= n; i++)res = max(res, f[n][i]);
22.         cout << res;
23.         return 0;
24. }

复制代码

（二）破坏的楼梯（方案数）

问题描述：
小蓝来到了一座楼梯前，楼梯共有N级台阶。从第0级台阶出发，小蓝每次可以迈上1级或2级台阶。但是，楼梯上的第a1级、第a2级、第a3级，以此类推，共M级台阶的台阶面已经坏了，不能踩。
小蓝想要到达楼梯的顶端，即第N级台阶，且不能踩到坏台阶。请问他有多少种到达顶端的方案数？由于方案数大概很大，请输出结果对

取模的值。

样例输入
   6 1 3
  样例输出
   4
  思路：

• 确定状态：状态dp[ i ]表示走到第 i 级台阶的方案数。
  
• 确定状态转移方程：在正常的楼梯上，我们可以从第i - 1级台阶或第i - 2级台阶走到第 i 级台阶，因此状态转移方程为dp[ i ] = dp[ i－1 ]+dp[ i - 2 ]。
  
• 然而，如果第 i 级台阶是破坏的，则不能走到该台阶，此时我们需要将dp[ i ]设为0。
  
• 末了我们输出dp[ n ]，表示走到第 n 级台阶的方案数
  

1. #include<bits/stdc++.h>
2. using namespace std;
3. const int p = 1e9 + 7;
4. int n, m;
5. int main()
6. {
7.         cin >> n >> m;
8.         vector<int>dp(n + 1, 1);int temp = 0;
9.         for (int i = 1; i <= m; i++)
10.         {
11.                 cin >> temp;
12.                 dp[temp] = 0;
13.         }
14.         for (int i = 2; i <= n; i++)
15.         {
16.                 if (!dp[i])continue;
17.                 dp[i] = (dp[i - 1] + dp[i - 2]) % p;
18.         }
19.         cout << dp[n] << '\n';
20.        
21.         return 0;
22. }

复制代码

（三）安全序列（方案数）

   问题描述
  小蓝是工厂里的安全工程师，他负责在工厂里安全地放置危险品油桶。工厂的空位排列成一条直线，共有n个空位。小蓝需要按照特定的规则在这些空位上放置油桶：每两个油桶之间至少需要k个空位隔开。现在，小蓝想知道有多少种不同的放置方案可以满足这些条件。由于大概的方案数非常大，输出结果需要对10^9 + 7取模。
  输入格式
  输入包含两个正整数n和k，分别表示空位的数量和每两个油桶之间至少需要的空位数。
  输特别式
  输出一个整数，表示满足条件的放置方案数对10^9 + 7取模的结果。
  样例输入
  4 1
  样例输出
  6
  说明
  在样例中，有4个空位，每两个油桶之间至少需要1个空位。大概的放置方案有6种，分别是：0000（不放任何油桶），1000，0100，0010，0001和1001（其中1表示放置油桶，0表示不放）。注意，这里的方案数已经对10^9 + 7取模。
  评测数据规模
  对于全部评测数据，1 ≤ n ≤ 10^9，1 ≤ k ≤ n-1。
  思路：
首先，我们界说dp为在前i个空位中放置油桶的方案数。然后，我们需要盘算前缀和数组prefix。对于每个位置i，prefix表示从位置0到位置i为止的全部放置方案数的总和。

1. ll dp[N], prefix[N];

复制代码

循环遍历判断每个位置之前没有足够的空间放置另一个油桶 。
如果当前位置减去k再减1小于1，则dp[ i ]为1。
否则，dp[ i ]的值等于前缀和数组在( i - 1 - k )位置的值。

1. if (i - k - 1 < 1)dp[i] = 1;
2. else dp[i] = prefix[i - 1 - k];

复制代码

设状态dp[ i ]表示以位置i结尾的方案总数，状态转移方程：

但是直接去求和肯定会超时，以是我们需要使用前缀和来优化时间复杂度（注意取模）。

1. prefix[i] = (prefix[i - 1] + dp[i]) % p;

复制代码

盘算到当前位置为止，包括全部符合条件的放置方案数的总和。 

1. #include<bits/stdc++.h>using namespace std;using ll = long long;const ll N = 1e6 + 9, p = 1e9 + 7;ll dp[N], prefix[N];
2. int main(){        int n, k; cin >> n >> k;        dp[0] = prefix[0] = 1;// 初始化dp和prefix数组的第0项为1，表示空序列的方案数为1        for (int i = 1; i <= n; ++i)// 遍历1到n，盘算每个位置的dp值和前缀和        {                if (i - k - 1 < 1)dp[i] = 1;                // 如果当前位置减去k再减1小于1，则dp[i]为1                // 说明在当前位置之前没有足够的空间放置另一个油桶，                // 因此在这种情况下，只能选择不放置油桶，以是'dp[i]'被设为'1'。                else dp[i] = prefix[i - 1 - k];                // 否则，dp[i]的值等于前缀和数组在(i-1-k)位置的值                // 这表示从位置'0'到位置'i-k-1'的全部放置方案数。                // 这样做是由于每两个油桶之间需要至少'k'个空位，                // 因此'dp[i]'实际上继续了在'i-k-1'位置及之前能放置油桶的全部方案。                prefix[i] = (prefix[i - 1] + dp[i]) % p;                // 盘算到当前位置为止，包括全部符合条件的放置方案数的总和，并将结果模上'p'以防溢出。        }        cout << prefix[n] << '\n';        return 0;}

复制代码

今天就先到这了！！！

看到这里了还不给博主扣个：
⛳️ 点赞☀️收藏 ⭐️ 关注！
你们的点赞就是博主更新最大的动力！
有问题可以批评大概私信呢秒回哦。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。