洛谷 P1853【投资的最大效益】

本文探讨了利用动态规划解决债券投资问题的方法,通过四种不同的代码实现,逐步优化算法,降低时间与空间复杂度,实现了从4099ms到35ms的性能提升。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

原题链接

思路:

  • 不难看出是完全背包类问题,只是要明确一点,“花钱”买债券所花的钱并没有真正的花出去,关键就在于随时都可以卖出任何所持有的债券。那么,实际上我们可以认为每一年都先把所有持有的债券变卖套现,然后拿着全部的现金重新购买债券(重新打背包),寻找能够获得的最多的金钱。
  • 明白了这一点,就可以写出最简单的一版答案。dp【】记录 j 金钱能够获得的最多的本金+利润。注意答案是最后能到达的最大背包容量。

代码+讲解:

一:

  • 状态转移方程:
while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W;j++){
                dp[j] = max(dp[j] , dp[j-w[i]] + w[i] + v[i]);
            }
        }
        W = dp[W];
}
  • 完整代码1(无优化,记录本金加利息:4099ms,39956KB)
//4099ms, 39956KB 


#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int maxn = 15;
const int maxw = 10000005;

int w[maxn],v[maxn];
int dp[maxw];

int main(){
    int W,m,n;
    cin>>W>>m>>n;//m years
    for(int i=1;i<=maxw;i++)
        dp[i] = i;
    for(int i=1;i<=n;i++)
        cin>>w[i]>>v[i];
    while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W;j++){
                dp[j] = max(dp[j] , dp[j-w[i]] + w[i] + v[i]);
            }
        }
        W = dp[W];
    }
    cout<<W<<endl;
    return 0;
}
  • 核心:

    因为 dp[j] 表示花 j 金钱能够获得的本金+最大利润,所以初始化条件有些特殊。
for(int i=1;i<=maxw;i++)
        dp[i] = i;

二:

  • 状态转移方程:
    在这版代码中,由于 dp[j] 仅代表所获利润,因此每次更新的 W 也只做循环边界使用。
while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W;j++){
                dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
            }
        }
        W += dp[W];
}
  • 完整代码2(只记录利息,略微简化计算:3508ms,39864KB)
//3508ms, 39864KB 


#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int maxn = 15;
const int maxw = 10000005;

int w[maxn],v[maxn];
int dp[maxw];

int main(){
    int W,m,n;
    cin>>W>>m>>n;//m years
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
        cin>>w[i]>>v[i];
    while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W;j++){
                dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
            }
        }
        W += dp[W];
    }
    cout<<W<<endl;
    return 0;
}

三:

  • 状态转移方程:
    因为债券售价千元起步,所以当我们拥有 j 金钱时,实际能够起作用的只有 j/1000*1000 这么多。故使用 dp[j] 记录当我们拥有的金钱在 [ j,j+1000 ) 区间时,能够获得的最大利润。其实质就是减少了打表时多达几千次的冗余操作。
while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W/1000*1000;j+=1000){
                dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
            }
        }
        W += dp[W/1000*1000];
}
  • 完整代码3(减少打表次数:268ms,39944KB)
//268ms, 39944KB 


#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int maxn = 15;
const int maxw = 10000005;

int w[maxn],v[maxn];
int dp[maxw];

int main(){
    int W,m,n;
    cin>>W>>m>>n;//m years
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
        cin>>w[i]>>v[i];
    while(m--){
        for(int i=1;i<=n;i++){
            for(int j=w[i];j<=W/1000*1000;j+=1000){
                dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
            }
        }
        W += dp[W/1000*1000];
    }
    cout<<W<<endl;
    return 0;
}

四:

  • 状态转移方程:
    既然我们知道只需要打整千钱数的背包,何不删去无用空间的背包,减少空间复杂度。我们可以使用 dp[j] 表示钱数仅大于 j*1000 时所能获得的最大利润。
while(m--){
	for(int i=1;i<=n;i++){
		for(int j=w[i];j<=W/1000;j++){
			//int t = j + dp[j]/1000;
			dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
		}
	}
	W += dp[W/1000];
}
  • 注意代码中的注释行,这里我陷入了动态规划问题初学者常触的误区,是对动态规划算法的时间性还不够敏感所致。这里写出为什么算法中没有 t 的参与。首先, dp[j] 代表在前一年结束后,j 本金(前一年的本金)所能获得的最大利润。其次,在完全背包的循环条件下,dp[ j - w[i] ] 代表今年结束后,使用 j 本金(今年的本金)所能获得的最大利润。若将 dp[ j - w[i] ] 改成 dp[ t - w[i] ],显然是不对的,因为 t 实际上是默认完全执行上一年的方案,这不符合动态规划思想。
  • 完整代码4(时空复杂度均得到优化:35ms,1052KB)
//35ms, 1052KB 


#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int maxn = 15;
const int maxw = 10005;

int w[maxn],v[maxn];
int dp[maxw];

int main(){
	int W,m,n;
	cin>>W>>m>>n;//m years
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++){
		cin>>w[i]>>v[i];
		w[i]/=1000;
	}
	while(m--){
		for(int i=1;i<=n;i++){
			for(int j=w[i];j<=W/1000;j++){
				//int t = j + dp[j]/1000;
				dp[j] = max(dp[j] , dp[j-w[i]] + v[i]);
			}
		}
		W += dp[W/1000];
	}
	cout<<W<<endl;
	return 0;
}
### 关于洛谷 P1249 最大乘积问题的 C++ 解题思路 对于给定的一个正整数 `n` 和分割次数 `k`,目标是将 `n` 分割成 `k` 个部分使得这些部分的乘积最大化。这个问题可以通过动态规划来解决。 #### 动态规划的状态定义 设 `dp[i][j]` 表示前 `i` 位数字分成 `j` 段所能得到的最大乘积[^3]。 #### 初始化 - 对于只有一段的情况,即 `dp[i][1]` 就是从第1位到第i位组成的整个数值。 #### 状态转移方程 为了求解 `dp[i][j]` 的值,可以考虑最后一个切割位置 `p` (其中 `1 ≤ p < i`),则状态转移方程为: \[ dp[i][j]=\max(dp[p][j-1]*num(p+1,i)) \] 这里 `num(p+1,i)` 是指从第 `p+1` 到第 `i` 位所表示的子串对应的十进制数值。 #### 边界条件 当 `j=1` 或者 `i=j` 时,显然不需要进一步划分,因此可以直接赋初值;其他情况下通过上述公式计算得出结果。 下面是具体的代码实现: ```cpp #include<iostream> #include<string> using namespace std; const int MAX_N = 50; string s; long long f[MAX_N][MAX_N], num[MAX_N][MAX_N]; // 计算字符串s中从l到r之间的数字转换成long long型 void calc_num() { for (int l = 0; l < s.size(); ++l) for (int r = l; r < s.size(); ++r) { if (!l && !r) num[l][r] = s[l]-'0'; else num[l][r] = num[l][r-1]*10+s[r]-'0'; } } int main(){ int N, K; cin >> N >> K >> s; // 预处理每一段的数值 calc_num(); // 初始化边界情况 for(int i = 0; i<s.length();++i){ f[i+1][1]=num[0][i]; f[i+1][i+1]=f[i][i]*10+(s[i]-'0'); } // 填表过程 for(int j = 2;j<=K;++j)//枚举段数 for(int i = j;i<N;++i)//枚举终点 for(int k = j-1;k<i;++k)// 枚举上一次切分的位置 f[i][j]=max(f[i][j],f[k][j-1]*num[k][i]); cout << f[N-1][K]<<endl; } ``` 这段代码实现了基于动态规划的方法来寻找最优解,并且能够有效地处理高精度运算的需求。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值