动态规划（DP）

已于 2022-03-06 20:04:47 修改
阅读量924 收藏 2
点赞数 1
文章标签： 动态规划 蓝桥杯 p2p
于 2022-02-26 20:52:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61531066/article/details/123155759
版权
本文通过洛谷和LeetCode上的典型问题，展示了动态规划在解决01背包问题、最短路径、最大面积、斐波那契数列等问题中的应用。代码实例涵盖从基本到高级的动态规划技巧，如一维和二维数组优化、分组背包问题等。
摘要由CSDN通过智能技术生成

洛谷 P.1359

输入说明 ：

3

5 （1->2) 15 (1->3)

7 (2 -> 3)

#include<iostream>
#include<vector>
#include<climits>
using namespace std;

vector<int> dp(201);
int  main(){
	int n ;
	cin>>n;
	vector<vector<int>> ori(201,vector<int>(201));
	for(int i = 1; i < n;i++ ){
		for(int j = i + 1; j <= n;j++){
			cin>>ori[i][j];
		}
		dp[i] = INT_MAX;
	}
	for(int i = n - 1;i > 0;i--){
		for(int j = i + 1; j <= n;j++  ){
			dp[i] = min(dp[i] , dp[j] + ori[i][j]);
		}
	}
	cout<<dp[1];
	return 0;
}

状态转移关系 ： 我们要用i把n上流的中转站从大到小跑一遍。我们先记录中转站2到中转站3的最小价钱，我们要用jj跑一遍中转站2下流的所有中转站，记录ori[i][j]+dp[j]的最小价钱,记录到dp[i]里面。

 

细节  ： 因为dp[i}是每次min来的，但dp各项初始化为0，因此我们要让除了最后一个中转站外设为INT_MAX（用头文件#include<climits>)

洛谷 P.1060

 

 01背包问题！

无优化代码

for(int i=1;i<=n;i++)
{
    for(int c=0;c<=m;c++)
    {
        f[i][c]=f[i-1][c];
        if(c>=w[i])
        f[i][c]=max(f[i][c],f[i-1][c-w[i]]+v[i]);
    }
}

 一维数组优化 ：

for(int i=1;i<=n;i++)
{
    for(int c=m;c>=0;c--)
    {
        if(c>=w[i])
        f[c]=max(f[c],f[c-w[i]]+v[i]);
    }
}
#include<iostream>
using namespace std;
int w[30],v[30],dp[30][100000];
int main(){
	int m, n;//m为总价，n为数量
	cin>>m>>n;
	 for(int i = 1;i <=n;i++){
	 	cin>>v[i]>>w[i];
	 	w[i] *= v[i];//w[i]变为总收获 
	 }
	 for(int i = 1;i <= n;i++ ){
	 	for(int j = 0;j <= m;j++){
	 		dp[i][j] = dp[i - 1][j];
	 		if(j >= v[i]){
	 			dp[i][j] = max(dp[i][j] , dp[i - 1][j - v[i]] + w[i]);
			 }
		 }
	 }
	 cout<<dp[n][m];
	 return 0;
}
//优化版
#include<iostream>
using namespace std;
int w[30],v[30],dp[100000];
int main(){
	int m, n;//m为总价，n为数量
	cin>>m>>n;
	 for(int i = 1;i <= n;i++){
	 	cin>>v[i]>>w[i];
	 	w[i] *= v[i];//w[i]变为总收获 
	 }
	 for(int i = 1;i <= n;i++ ){
	 	for(int j = m;j >= v[i];j--){
	 			dp[j] = max(dp[j] , dp[j - v[i]] + w[i]);
			 
		 }
	 }
	 cout<<dp[m];
	 return 0;
}

洛谷P.1802

与上题相似 直接上代码‘

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
int lose[1001],win[1001],use[1001];
long long f[1001][1001];
int main(){
    int n,x;
    cin>>n>>x;
    for (int i=1;i<=n;i++)
      cin>>lose[i]>>win[i]>>use[i];
    for (int i=1;i<=n;i++)
      for (int j=0;j<=x;j++)
        if (j>=use[i]) f[i][j]=max(f[i-1][j-use[i]]+win[i],f[i-1][j]+lose[i]);
 else f[i][j]=f[i-1][j]+lose[i];
    cout<<f[n][x]*5;
    return 0;
}

 

#include <cstdio>
#include <iostream>
using namespace std;
int dp[1100];
int win[1100],lose[1100],use[1100];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
     scanf("%d%d%d",lose+i,win+i,use+i);
    for(int i=1;i<=n;i++)
     {
         for(int j=m;j>=use[i];j--)
          dp[j]=max(dp[j]+lose[i],dp[j-use[i]]+win[i]);
         for(int j=use[i]-1;j>=0;j--)
          dp[j]+=lose[i];//其余情况不是0而要加lose[i]
     }
     printf("%lld",5ll*dp[m]);
}

洛谷P.1049

 

看似与01背包不同，但我们可以看作它价值与容量相等（v[i] = w[i])，即与1060一致

状态转移关系 ： dp（x）为在x的最大容积下（对应1060的最大价格）最多能装下多少容积（对应1060最多价值），最后将m - dp（m）即为最小剩余容量 。。

#include<iostream>
using namespace std;

int a[31],dp[20001];

int main(){
	int m , n;
	cin>>m>>n;
	for(int i = 1;i <= n;i++){
		cin>>a[i];
	}
	for(int i = 1;i <=n;i++){
		for(int j = m; j >= a[i];j--){
			dp[j] = max(dp[j] , dp[j -a[i]] + a[i]);  
		}
	}
	cout<<m - dp[m];
	return 0;
}

 来题几何

LeetCode.221

 

 设dp（i，j）为以（i，j）为右下角的正方形边长的最大值

边界情况 ：i = 0或 j = 0并且matrix[i][j]==1时dp[i][j]为1（无法向左上角延申）

动态转移关系 ：dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;（取决于左边，坐上，上面）最小的dp（画图理解，这种题主要背）


class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        int maxSide = 0;
        int rows = matrix.size(), columns = matrix[0].size();
        vector<vector<int>> dp(rows, vector<int>(columns));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1;
                    } else {
                        dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                    }
                    maxSide = max(maxSide, dp[i][j]);
                }
            }
        }
        int maxSquare = maxSide * maxSide;
        return maxSquare;
    }
};

LeetCode : 118

弄成二维数组看更直观 ：

1 

1   1

1    2   1

1    3   3   1

1    4   6    4   1

很容易看出边界情况 ：dp[m][0] = dp[m][m] = 1，

状态转移关系 ： dp[m][n] = dp[m - 1][n - 1] + dp[m - 1][n]，&&n > 0&&n < m

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows);
        for(int i = 0; i < numRows;i++ ){
            dp[i].resize(i + 1);//每行变成i + 1列
            dp[i][0] = 1;
            dp[i][i] = 1;
            for(int j = 1;j < i;j++){
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
            }
        }
        return dp;
    }
};

LeetCode : 119

 水题放松下，和118一致

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<vector<int>> dp(rowIndex + 1);
        for(int i = 0; i < rowIndex + 1;i++ ){
            dp[i].resize(i + 1);//每行变成i + 1列
            dp[i][0] = 1;
            dp[i][i] = 1;
            for(int j = 1;j < i;j++){
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
            }
        }
        return dp[rowIndex];
    }
};

洛谷P.1757

 重点 ：他的物品大致可分为 k 组，每组中的物品相互冲突（分组背包问题）

思路 ：不同于普通01背包，第一层for循环是以小组为元素，第二层对于一个dp[j]第三层for循环要遍历一组的所有元素，以便每组中物品不冲突

#include<iostream>
using namespace std;
int v[1001],w[1001],dp[1001],level[1001],g[1001][1001];
int main(){
	int m , n , x , t;
	cin>>m>>n;
	for(int i = 1; i <= n;i++){
		cin>>v[i]>>w[i]>>x;
		t = max(t , x);
		level[x]++;
		g[x][level[x]] = i;//存储每组第几个元素的值 
	}
	for(int i = 1;i <= t; i++){//对于每个小组 
		for(int j = m ;j >=0;j--){
			for(int k = 1;k <=level[i];k++){//一组的所有元素 
				if(j >= v[g[i][k]]){
					dp[j] = max(dp[j] , dp[j - v[g[i][k]]] + w[g[i][k]]); //不让组内元素互动
				}
			}
		}
	}
	cout<<dp[m];
	return 0;
}

LeetCode.509

class Solution {
public:
    int fib(int n) {
        if(n == 0) return 0;
        if(n == 1) return 1;//特殊情况
        int begin = 0, end = 1 , res ;
        for(int i =  2;i <= n;i++){
            res = begin + end;
            begin = end;
            end = res;//依次后移
        }
        return res;
    }
};

洛谷 P.1507

 太过简单，不做阐释

#include<iostream>
using namespace std;
int a[401],b[401],c[501];
int dp[401][401];

int main(){
	int v,m,n;
	cin>>v>>m>>n;
	for(int i = 1;i <= n;i++){
		cin>>a[i]>>b[i]>>c[i];
	} 
	for(int i = 1;i <= n;i++){
		for(int j = v;j >= a[i];j--){
			for(int k = m;k >= b[i];k--){
				dp[j][k] = max(dp[j][k] , dp[j - a[i]][k - b[i]] + c[i]);
			}
		}
	}
	cout<<dp[v][m];
	return 0;
}

洛谷 P.2858

 题目特色 ： 入口有两个并且物品价值随着每次选择改变

用二维数组dp[left][right]表示从left 到right获得的最多钱

边界情况 ： dp[i][i] = s[i] * m(只剩一份零食肯定是在最后一天)

#include<iostream>
using namespace std;
int s[2001],dp[2001][2001];

int main(){
	int m ;
	cin>>m;
	for(int i = 1; i <= m;i++ ){
		cin>>s[i];
	}
	for(int i = 1;i <= m;i++){
		dp[i][i] = m * s[i];
	}
	for(int i = 1;i <= m;i++){
		for(int left = 1;left <= m;left++){
			int right = left + i;
			if(right > m) break;
			dp[left][right] = max(dp[left + 1][right] + s[left] * (m - i),dp[left][right - 1] + s[right] * (m - i));
		}
	}
	cout<<dp[1][m];
	return 0;
}

洛谷 P .1091

 

 思路 ： 找到一个数据点让它左边的递增元素数量与它右边的递减元素数量最多

#include<iostream>
using namespace std;
int a[105],b[105],c[105];

int main(){
	int n;
	cin>>n;
	for(int i = 1;i <= n;i++){
		cin>>a[i];
	}
	for(int i = 1;i <= n;i++){//细节是从第一个数开始而第二层超出第一个数以便让i = =1时候b[i] = 1 
		for(int j = 0;j < i;j++){
			if(a[i] > a[j])
			b[i] = max(b[i],b[j] + 1);//b[i]记录i左边有几个从低到高的数 （包括自己） 
		}
	}
	for(int i = n; i>= 0;i--){
		for(int j = n + 1;j > i;j--){
			if(a[i] > a[j] ){
				c[i] = max(c[i],c[j] + 1);//c[i]记录i右边有几个从高到低的数 (包括自己） 
			}
		}
	}
	int res = 0;
	for(int i = 1;i <= n;i++){
		res = max(res,b[i] + c[i] - 1);	
	} 
	cout<< n - res;
	return 0; 
}

洛谷 P.1077

 边界情况 ：dp[0] = 1(摆0盆花有1种方案)

#include<iostream>
using namespace std;
const int mod = 1000007;
int a[105],dp[105];

int main(){
	int m,n;
	cin>>m>>n;
	for(int i = 1 ; i <= m;i++){
		cin>>a[i];
	}
	dp[0] = 1;
	for(int i = 1; i <= m;i++){//枚举每个品种 
		for(int j = n;j >= 1;j--){
			for(int k = 1; k <= a[i] && k <= j;k++){//相同品种的所有花 
				dp[j] = (dp[j] + dp[j - k]) % mod;
			}
		}
	}
	cout<<dp[n];
	return 0;
}

PTA . 1020 - 月饼

2022.3.6

 特点 ： 销售时允许取出一部分库存

意味着可以选择一点数据而非全选，解决方法 ：结构体

//N 表示月饼的种类数
//D 表示市场最大需求量
//每种月饼的库存量 每种月饼的总售价
//贪心问题
#include<bits/stdc++.h>
using namespace std;
struct item{
	double cap;//容量 
	double price;//单价 
}moon[1001];

bool cmp(item a,item b){
	return a.price > b.price; 
}

int main(){
	int n,d;
	double res = 0.0;
	cin>>n>>d;
	for(int i = 1; i <= n;i++){
		cin>>moon[i].cap;
	}
	for(int i = 1;i <= n;i++){
		cin>>moon[i].price;
		moon[i].price /= moon[i].cap;//转化为单价
	}
	sort(moon + 1,moon + n + 1,cmp);
	for(int i = 1; i <= n;i++){
		if(d <= moon[i].cap){//供大于求
			res += moon[i].price * d;
			break;
		}
		else{//求大于供
			res += moon[i].price * moon[i].cap;
			d -= moon[i].cap;
		}
	}
	printf("%.2f",res);
	return 0;
}

 

愿风吹散愿心静远
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划（dp）
miaohongxuan的博客
11-21 364
动态规划，就是把原问题分解成相对简单的子问题的方法。 我们先看一下例题： 斐波那契数列 根据以前学习的知识，我们可以快速写出一个函数： long long F(int n) { if (n == 1 || n == 2) return 1; else return F(n – 1) + F(n – 2); } 尽管这个函数可以准确得完成斐波那契数列问题，但是，它真的高效吗？ 首先，111和222直接手动自定义，在333的时候，往前枚举1和2，四的时候枚举2和3，而枚举到3时又要枚举1和.
动态规划(DP)
CSDN
10-24 1846
什么是动态规划，我们要如何描述它? 动态规划算法通常基于状态转移式及初始状态。 当前子问题的解将由上一次子问题的解推出,是一种典型的化整为零,分而治之的思维方式。使用动态规划来解题只需要多项式时间复杂度， 因此它比回溯法、暴力法等要快许多,但是也付出了一定的空间代价,这在大多数情况下都是值得的。 现在让我们通过一个例子来了解一下DP的基本原理。 首先，我们要找到某个状态的最优解，然后在它的帮
Leetcode第64题计算最小路径和，动态规划
hdsHDS6的博客
07-23 174
给定一个包含非负整数的mxn网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：每次只能向下或者向右移动一步。 示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。 int minPathSum(vector<vector<int>>& grid) { if (grid.size() == 0 || grid[0]....
算法套路十三——动态规划DP入门
Pistachiout的学习博客
04-27 1332
动态规划和递归都是通过将大问题分解为较小的子问题来解决问题。它们都可以用来解决具有重叠子问题和最优子结构特性的问题。在很多情况下，。
【算法优选】 动态规划之两个数组dp——壹
最新发布
m0_71731682的博客
05-30 845
动态规划相关题目都可以参考以下五个步骤进行解答：状态表示状态转移⽅程初始化填表顺序返回值后面题的解答思路也将按照这五个步骤进行讲解。给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。 🚩算法思路 状态表⽰： 对于两个数组的动态
动态规划——一维dp数组与二维dp数组
热门推荐
凌汐凡的博客
03-01 1万+
动态规划——一维dp数组与二维dp数组 对于二维dp数组，递推公式为：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]); 于其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 998
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
动态规划课堂7-----两个数组的dp问题（等价代换）
2301_80035594的博客
03-21 2174
详细介绍了动态规划中的两数组问题，先给出常见分析思路和解题过程，再给出例题和详细解析帮助理解这类问题，文中所有例题分析思路均采用模板，代码均经过检验，希望能帮助到你。
动态规划DP资料
09-25
动态规划（Dynamic Programming，简称DP）是计算机科学中一种强大的算法思想，主要应用于解决最优化问题，通过将复杂问题分解成子问题来求解。它在编程竞赛（如ACM/ICPC）和实际工程中都有广泛的应用。下面将详细...
动态规划dp（常用算法）
07-29
动态规划dp（常用算法） 动态规划是一种非常重要的算法思想，它可以解决具有重叠子问题和最优子结构性质的问题。动态规划的关键是将原问题划分为若干个子问题，然后通过解决子问题来获得原问题的解。 在解决动态...
动态规划 dp 状态转移方程
11-03
动态规划 dp 状态转移方程。 ACM\信息学奥赛精品资料。
动态规划dp
02-27
动态规划是一种解决最优化问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。本文将深入探讨动态规划的概念、原理及其在实际问题中的应用。 动态规划的核心在于通过分解问题为一系列相互关联的子...
斜率优化动态规划DP
01-11
### 斜率优化动态规划（DP）解析 #### 一、引言 斜率优化是一种特殊的动态规划优化技术，主要用于解决那些原本具有较高时间复杂度（如\(O(n^2)\)）的问题，并将其降至线性时间复杂度\(O(n)\)。这种优化方法主要应用...
动态规划 dp ppt
07-12
动态规划（Dynamic Programming，简称DP）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相互重叠的子问题来求解复杂问题的方法。动态规划的主要思想是将一个问题分解成多个阶段，每个阶段都有一个...
动态规划DP结题报告
08-10
动态规划DP题解 POJ HDU 动态规划解题报告
动态规划DP.rar_matlab中dp算法_matlab编程a算法_动态规划_动态规划 MATLAB_动态规划MATLAB
07-15
matlab编程实现动态规划算法，适合初学者使用
算法沉淀——动态规划之两个数组的 dp（上）（leetcode真题剖析）
立志做一个高产且细节博主
02-29 1237
如果我们希望确保两条直线不相交，我们可以将问题转化为在两个整数数组中寻找最长的公共子序列。这是因为，如果两条直线不相交，它们在同一列上对应的两个元素在两个数组中的顺序关系应该保持一致。是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。题目链接：https://leetcode.cn/problems/longest-common-subsequence/以这种方法绘制线条，并返回可以绘制的最大连线数。是这两个字符串所共同拥有的子序列。
从01背包开始动态规划：暴力解法 + dp + 滚动数组 + dp优化
Villanelle_w的博客
03-22 1127
如何直接将滚动数组的g删去，会导致 f 的更新错误，因为在更新 f [ j ] 时，f [ j - v [ i ] ] 已经更新过，也就是他在第 i 层，而更新时需要的是第 i - 1 层的数据，如下图：（下两图来源于b站up，一只会code的小金鱼）本题用两个数组来存储，其中 f 在更新前（memcpy(f , g , sizeof f)）表示第 i - 1层的数，而 g 表示第i层的数，每一层完成后，对 f 进行更新。不选时，f [ i ] [ j ] 不变。方法四：dp优化，用一个数组存储。
动态规划dp算法原理
07-29
动态规划（Dynamic Programming，简称DP）是一种用来解决多阶段决策最优化问题的算法思想。其原理可以概括为"将一个问题拆分成多个子问题，并保存子问题的解，以便重复利用"。 动态规划通常适用于具有重叠子问题和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值