數字三角形
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;//最優解
}