数字三角形
5
1 4
12 34 56
在上面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或 右下走。只需要求出这个最大和即可，不必给出具体路径。 三角形的行数大于1小于等于100，数字为 0 - 99
输入格式：
3
5
1 4
12 34 56
递归方法：
#include <iostream>
using namespace std;
int Maxsum(int i,int j,int **p,int n)
{
if(i==n-1)
return p[i][j];
int x=Maxsum(i+1,j,p,n);
int y=Maxsum(i+1,j+1,p,n);
return max(x,y)+p[i][j];
}
int main()
{
int n;
cin>>n;
int **a=new int *[n];
for(int i=0;i<n;i++)
a[i]=new int[n];
for(int i=0;i<n;i++)
for(int j=0;j<=i;j++)
cin>>a[i][j];
cout<<Maxsum(0,0,a,n);
}
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX];
int n;
int maxSum[MAX][MAX];//作为算出来的每一个最大值，保存起来，可避免重复计算
int MaxSum(int i, int j){
if( maxSum[i][j] != -1 ) //刚开始初始化均为-1；
return maxSum[i][j];
if(i==n)
maxSum[i][j] = D[i][j];
else{
int x = MaxSum(i+1,j); 向下和右下角进行搜索，选最大的一个
int y = MaxSum(i+1,j+1);
maxSum[i][j] = max(x,y)+ D[i][j];
}
return maxSum[i][j];
}
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++) {
cin >> D[i][j];
maxSum[i][j] = -1;
}
cout << MaxSum(1,1) << endl;
}对于上面的递归，需要占用大量的空间，容易造成溢出，可再进行改进；
用递推的方法：
从倒数第二行开始，对应于第二行的数字与下一行下边和右下边相邻的数字的最大和，以此向上循环；
12 --------------------------------12
1 3 ---------------------------------13 15
12 4 12 ----------------------------------- 12 4 12
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX];
int n;
int maxSum[MAX][MAX];
int main(){
cin>>n;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=1;j++)
{
cin>>D[i][j];
}
}
for(int i=1;i<=N;i++)
{
maxSum[N][i]=D[N][i];
}
for(int i=N-1;i>=1;i--){
{
for(int j=1;j<=i;j++)
maxSum[i][j]=max(maxSum[i+1][j],maxSum[i+1,j+1])+D[i][j]；
｝
cout<<max(i,j);
}
递归到动规的一般转化方法
递归函数有n个参数，就定义一个n维的数组，数组的下标是递归函数参数的取值范围，数组元素的值是递归函数的返回值，这样就可以从边界值开始， 逐步填充数组，相当于计算递归函数值的逆过程。
动规解题的一般思路
1. 将原问题分解为子问题
- 把原问题分解为若干个子问题，子问题和原问题形式相同或类似，只不过规模变小了。子问题都解决，原问题即解决(数字三角形例）。
- 子问题的解一旦求出就会被保存，所以每个子问题只需求 解一次。
2.确定状态
- 在用动态规划解题时，我们往往将和子问题相关的各个变量的一组取值，称之为一个“状 态”。一个“状态”对应于一个或多个子问题， 所谓某个“状态”下的“值”，就是这个“状 态”所对应的子问题的解。
- 所有“状态”的集合，构成问题的“状态空间”。“状态空间”的大小，与用动态规划解决问题的时间复杂度直接相关。 在数字三角形的例子里，一共有N×(N+1)/2个数字，所以这个问题的状态空间里一共就有N×(N+1)/2个状态。
整个问题的时间复杂度是状态数目乘以计算每个状态所需时间。在数字三角形里每个“状态”只需要经过一次，且在每个状态上作计算所花的时间都是和N无关的常数。
3.确定一些初始状态（边界状态）的值
以“数字三角形”为例，初始状态就是底边数字，值就是底边数字值。
4. 确定状态转移方程
定义出什么是“状态”，以及在该“状态”下的“值”后，就要找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的 “状态”，求出另一个“状态”的“值”(递推型)。状态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方程”。
数字三角形的状态转移方程:
maxSum[r][j]={ D[r][j] r==n;
max( maxSum[r+1][j],maxSum[r+1][j+1])+D[r][j]; r!=n;
可以用动规解决的问题的特点：
1) 问题具有最优子结构性质。如果问题的最优解所包含的 子问题的解也是最优的，我们就称该问题具有最优子结 构性质。
2) 无后效性。当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态，没有关系。
给定数组 arr, arr中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim代表要找的钱数，求组成aim的最少货币数。
arr=[5, 2, 3] , aim = 20. 4张5元可以组成20元。返回 4
arr=[5, 2, 3] , aim = 0 不使用货币，返回 0
arr=[3, 5], aim = 2 找不开，返回 -1
这是经典的动态规划问题，如果数组arr的长度为N，生成行数为N，列数为aim+1的动态规划表dp. dp[i][j]的含义是：可以使用任意的arr[0...i]面值的（i+1）种货币的情况下，组成总钱数 j 所需的最少张数。
对于动态规划问题，首先需要考虑边界问题。
1. 第一列：dp[0...N-1][0] 表示组成钱数0时不需要任何货币，全设为0。 dp[0...N-1][0] = 0
2. 第一行：dp[0][0...aim]的值表示只使用arr[0]时，需要的最少张数。比如arr[0] = 5 ,则dp[0][5] = 1, dp[0][10] = 2,...., 其他位置设为一个最大值。
3.剩下的位置依次从左到右，再从上到下，依次计算dp[i][j]
--不使用 arr[i] 的情况下，即dp[i-1][j]的值
--使用1张arr[i]的情况下，即dp[i-1][ j-arr[i] ] + 1 （j - arr[i] >=0） -
-使用2张arr[i]的情况下，即dp[i-1][ j-2*arr[i] ] + 2 （j - 2*arr[i] >=0）
--使用k张arr[i]的情况下，即dp[i-1][ j-k*arr[i] ] + k （j - k*arr[i] >=0）
对于以上的选择，我们需要选取张数之和最小的。
dp[i][j] = min{ dp[i-1][ j - k*arr[i] ] + k } (k>=0)
=min{ dp[i-1][j] , min{ dp[i-1][ j - d*arr[i] ] +d } } (d>=1)
=min{ dp[i-1][j] , min{ dp[i-1][ j - arr[i] - m*arr[i] ] +m+1 } } (m>=0)
我们在计算dp[i][ j - arr[i] ]时观察到其与dp[i][j]有重复的计算部分： dp[i][ j - arr[i] ] = min{ dp[i-1][ j - arr[i] - m*arr[i] ] +m} } (m>=0) 则 dp[i][j] = min{ dp[i-1][j] , dp[i][ j -arr[i] ] +1 } } (j - arr[i] >=0) 整个过程的时间复杂度O(N.aim), 额外空间复杂度O(N.aim)
<复杂度0(N*aim)>
// 空间换时间，按顺序进行输出
// dp[i][j] = min{dp[i-1][j] ,dp[i][j-arr[i]]+1};
#include<bits/stdc++.h>
using namespace std;
int mincoins(vector<int> &arr, int aim){
int n = arr.size();
int max1 = 1000;
vector<vector<int>> dp(n, vector<int>(aim+1, 0));
dp[0][0] = 0;
for(int j = 1; j <= aim; j++){
dp[0][j] = max1;
if(j - arr[0] >= 0 && dp[0][j - arr[0]] != max1){
dp[0][j] = dp[0][j - arr[0]] + 1;
}
}
int left = 0;
for(int i = 1; i < n; i++){
for(int j = 1; j <= aim; j++){
left = max1;
if(j - arr[i] >= 0 && dp[i][j - arr[i]] != max1){
left = dp[i][j - arr[i]] + 1;
}
dp[i][j] = min(left, dp[i - 1][j]);
}
}
return dp[n-1][aim] != max1 ? dp[n-1][aim] : -1;
}
int main(){
int aim;
cin >> aim;
vector<int> arr;
int temp;
while(cin >> temp){
arr.push_back(temp);
}
int result = mincoins(arr, aim);
cout << result;
return 0;
}
/* input
24
5 2 3
/*
/* output
6
*/
01背包
有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大 特点 这是最简单的背包问题 特点是每个物品只有一件供你选择放还是不放 对于这个问题一般有两种解法 下
面分别来介绍一下 ① 二维解法 设f[i][j]表示前i件物品 总重量不超过j的最大价值 可得出状态转移方程 f[i][j]=max{f[i-1][j-a[i]]+b[i],f[i-1][j]}
#include<iostream>
using namespace std;
int main()
{
int m,n;
cin>>n>>m;
int a[50001],b[50001];
int f[5001][5001];
for(int i=1;i<=n;i++)cin>>a[i]>>b[i];
for(int i=1;i<=n;i++)
for(int j=m;j>0;j--){
if(a[i]<=j)f[i][j]=max(f[i-1][j],f[i-1][j-a[i]]+b[i]);
else f[i][j]=f[i-1][j];
}
cout<<f[n][m]<<endl; //最优解
//COYG
}
②一维解法 设f[j]表示重量不超过j公斤的最大价值 可得出状态转移方程
fj=maxj{fj,f[j−a[i]]+b[i]}
#include<iostream>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
int a[50001],b[50001];
for(int i=1;i<=n;i++)
cin>>a[i]>>b[i];
int f[50001]={0};
for(int i=1;i<=n;i++){
for(int j=m;j>=a[i];j--) //对于每个只选一次的是j>a[i]，对于每个可以选很多次的是
j=a[i];j<=m;
if(f[j-a[i]]+b[i]>f[j])
f[j]=f[j-a[i]]+b[i];
}
cout<<f[m]<<endl; //最优解
}
完全背包
有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大 特点
题干看似与01一样 但它的特点是每个物品可以无限选用 其实这个题也可以写二维和一维两种 但之前已经说过了二维的有一定局限 所以在此之介绍一维
设f[j]表示重量不超过j公斤的最大价值 可得出状态转移方程
fj=maxj{fj,f[j−a[i]]+b[i]}
#include<iostream>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
int a[50001],b[50001];
int f[50001]={0};
for(int i=1;i<=n;i++){
cin>>a[i]>>b[i];
}
for(int i=1;i<=n;i++)
for(int j=a[i];j<=m;j++){//对于每个只选一次的是j>a[i]，对于每个可以选很多次的是
j=a[i];j<=m;
if(f[j-a[i]]+b[i]>f[j])
f[j]=f[j-a[i]]+b[i];
}
cout<<f[m]<<endl;//最优解
}
【题目描述】收益
“你有一笔钱，你要将这笔钱去投资债券，现在有d种债券，每种债券都有一个价值和年收益，债券的价值是1000的倍数，问你如何投资在n年后的获得最大收益。
【输入格式】 第一个为一个整数M，表示有M组数据。 每组数据第一行有两个整数，表示初始资金(不超过50000)和年数n。
每组数据第二行为一个整数d(1 ≤ d≤10)，表示债券种类。 随后d行每行有两个整数，表示该债券的价值和年收益。年收益不会超过债券价值的10%。 所有数据不超过整型取值范围。
【输出格式】 每组数据，输出n年后获得的最大收益。
【输入样例】 1 10000 4 2 4000 400 3000 250
【输出样例】 14050
#include<iostream>
#include<cstring>
using namespace std;
int main()
{
int m,y,n,d,ans=0,a[100001],b[100001];
int f[100001]={0};
cin>>m;
while(m--){
cin>>y>>n;
cin>>d;
for(int i=1;i<=d;i++){
cin>>a[i]>>b[i];
}
for(int o=1;o<=n;o++){
for(int i=1;i<=d;i++)
for(int j=a[i];j<=y;j++){
f[j]=max(f[j-a[i]]+b[i],f[j]);
}
y+=f[y]; //每次都要累计
memset(f,0,sizeof(f));
}
cout<<y<<endl;
}
return 0;
} 多重背包
有n件物品和容量为m的背包
给出i件物品的重量以及价值 还有数量 求解让装入背包的物品重量不超过背包容量 且价值最大
特点 它与完全背包有类似点 特点是每个物品都有了一定的数量
状态转移方程为： f[j]=max{f[j],f[j−k∗a[i]]+k∗b[i]}
f[j]=max{f[j],f[j−k∗a[i]]+k∗b[i]}
【输入样例】 8 2 2 100 4 4 100 2
【输出样例】 400
#include<iostream>
using namespace std;
int main()
{
int m,n;
cin>>m>>n;
int a[10001],b[10001],c[10001];
for(int i=1;i<=n;i++){
cin>>a[i]>>b[i]>>c[i];
}
int f[10001];
for(int i=1;i<=n;i++)
for(int j=m;j>=0;j--)
for(int k=0;k<=c[i];k++){//对于可重复放入的，k<=c[i];
if(j-k*a[i]<0)
break;
f[j]=max(f[j],f[j-k*a[i]]+k*b[i]);
}
cout<<f[m]<<endl;//最优解
}
2349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
