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

原题链接

思路：

• 不难看出是完全背包类问题，只是要明确一点，“花钱”买债券所花的钱并没有真正的花出去，关键就在于随时都可以卖出任何所持有的债券。那么，实际上我们可以认为每一年都先把所有持有的债券变卖套现，然后拿着全部的现金重新购买债券（重新打背包），寻找能够获得的最多的金钱。
• 明白了这一点，就可以写出最简单的一版答案。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;
}​