第十二章-dp

动态规划策略
将原始问题拆分为多个子问题,将子问题结果记录,方便复用子问题的解
递归 记忆化 递推 是动态规划的一体两面,本质都是一样的;递推减少了调用次数,空间上还能优化,一般选择递推方式

//递归+记忆化
int memo[maxn];//将O(2^n) > O(n)
int fibonacci(int n){
    if(memo[n] != -1) return memo[n];
    if(n <= 1) memo[n] = n;
    else memo[n] = fibonacci(n - 1) + fibonacci(n - 2);
    return memo[n];
}
//递推
int fib[maxn];
int fibonacci(int n){
	for(int i = 0;i <= n;++i){
		if(i <= 1) fib[i] = i;
		else fib[i] = fib[i - 1] + fib[i - 2];
	}
	return fib[n];
}

最大连续子序列和

1,-2,3,4,-10,6
看以某个元素作为尾的最大连续子序列之和

F(j) = Max{A(j),F(j-1)+A(j)}
long long dp[maxn];
fill(dp,dp + maxn,-1);
for(int i = 0;i < n;++i){
	if(i == 0) dp[i] = arr[i];
	else dp[i] = max(dp[i - 1] + arr[i],arr[i]);
}
//最后还得遍历dp[]选出最大值

最长递增子序列

O(n^2)
for(int i = 0;i < n;++i){
	if(i == 0) dp[i] = 1;
	else{
		dp[i] = 1;
		for(int j = 0;j < i;++j){
			if(arr[j] < arr[i]) dp[i] = max(dp[i],dp[j] + 1));
	}
}

最长公共子序列

F(i,j) 表示以下标 i 结尾的序列A和下标 j 结尾的序列B 的最长公共子序列

int dp[maxn][maxm],falg[maxn][maxm];
string str1,str2;
cin >> str1 >> str2;
for(int i = 0;i <= str1.size();++i){
	for(int j = 0;j <= str2.size();++j){
		if(i == 0 || j == 0) dp[i][j] = 0;
		else{
			if(str1[i - 1] == str2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1,flag[i][j] = 0;
			else if(dp[i - 1][j] > dp[i][j - 1]) dp[i][j] = dp[i - 1][j],flag[i][j] = 1;
			else dp[i][j] = dp[i][j - 1],falg[i][j] = 2;
		}
	}
}
void Print(int i,int j){
	if(n == 0 || m == 0) return;
	if(flag[i][j] == 0) Print(i - 1,j - 1),printf("%c",str1[i - 1];
	else if(falg[i][j] == 1) Print(i - 1,j);
	else Print(i,j - 1);
}

0-1背包

题目描述
北大网络实验室经常有活动需要叫外卖，但是每次叫外卖的报销经费的总额最大为C元，有N种菜可以点，经过长时间的点菜，网络实验室对于每种菜i都有一个量化的评价分数（表示这个菜可口程度），为Vi，每种菜的价格为Pi, 问如何选择各种菜，使得在报销额度范围内能使点到的菜的总评价分数最大。 注意：由于需要营养多样化，每种菜只能点一次。
输入描述:
输入的第一行有两个整数C（1 <= C <= 1000）和N（1 <= N <= 100），C代表总共能够报销的额度，N>代表能点菜的数目。接下来的N行每行包括两个在1到100之间（包括1和100）的的整数，分别表示菜的>价格和菜的评价分数。
输出描述:
输出只包括一行，这一行只包含一个整数，表示在报销额度范围内，所点的菜得到的最大评价分数。
示例1
输入
90 4
20 25
30 20
40 50
10 18
40 2
25 30
10 8
输出
95
38

#include<iostream>
using namespace std;
const int maxn = 1000 + 10;
const int maxm = 100 + 10;
int dp[maxm][maxn];
int weigh[maxm];
int value[maxm];
int main(){
    int c,n;
    while(cin >> c >> n){
        for(int i = 1;i <= n;++i) cin >> weigh[i] >> value[i];
        for(int i = 0;i <= n;++i){
            for(int j = 0;j <= c;++j){
                if(i == 0 || j == 0) dp[i][j] = 0;//边界
                else{
                    if(j < weigh[i]) dp[i][j] = dp[i - 1][j];//放不下时
                    else dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - weigh[i]] + value[i]);//能放得下,有选和不选两种可能
                }
            }
        }
        cout << dp[n][c] << endl;
    }
}

压缩空间

for(int i = 1;i <= n;++i) cin >> w[i] >> v[i];
dp[0] = 0;
for(int i = 1;i <= n;++i){
    for(int j = c;j >= w[i];--j){
         dp[j] = max(dp[j],dp[j - w[i]] + v[i]);
    }
}

完全背包

0-1背包状态转移方程
dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - weigh[i]] + value[i]);
完全背包状态转移方程为
dp[i][j] = max(dp[i - 1][j],dp[i][j - weigh[i]] + value[i]);
由于dp[i][j]的值仅依赖于dp[i-1]和dp[i] 因此正向更新一维数组即可,因为dp[i][j] 是原本的dp[i-1][j] 
dp[i - 1][j - weigh[i]] 更新之后(j正向遍历)就是dp[i][j-weigh[i]] + value[i]);
完全背包核心代码
for(int i = 0;i <= n;++i){
	for(int j = w[i];j <= c;++j){
		dp[j] = max(dp[j],dp[j - w[i]] + v[i]);
	}
}

多重背包

将多数量的物品绑定成2de幂次个数和一个剩下的;然后构建新的weigh[] 和value[];剩下的和0-1背包一样

#include<iostream>
#define max(a,b) a > b ? a : b
using namespace std;
const int maxn = 100 + 10;
const int maxm = 100 + 10;
int w[maxm];
int v[maxm];
int num[maxm];
int newW[maxm * 20];
int newV[maxm * 20];
int dp[maxn];
int main(){
    int c,n,m;
    cin >> c;
    while(c--){
        cin >> n >> m;
        int number = 0;
        for(int i = 1;i <= m;++i){
            cin >> w[i] >> v[i] >> num[i];
            for(int j = 1;j <= num[i];j *= 2){
                number++;
                newW[number] = w[i] * j;
                newV[number] = v[i] * j;
                num[i] -= j;
            }
            if(num[i] > 0){
                number++;
                newW[number] = w[i] * num[i];
                newV[number] = v[i] * num[i];
            }
        }
        for(int i = 0;i <= n;++i) dp[i] = 0;
        for(int i = 1;i <= number;++i){//注意这里不再是m了!
            for(int j = n;j >= newW[i];--j){
                dp[j] = max(dp[j],dp[j - newW[i]] + newV[i]);
            }
        }
        cout << dp[n] << endl;
    }
}

背包问题之记录选择

输出字典序较小的那个解
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1e4 + 10;
const int maxm = 1e2 + 10;
int dp[maxm] = {0};
bool choice[maxn][maxm];
bool flag[maxn];
int w[maxn];
bool cmp(int a,int b){
    return a > b;
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;++i) scanf("%d",&w[i]);
    sort(w + 1,w + n + 1,cmp);//要从大到小排序
    for(int i = 1;i <= n;++i){
        for(int j = m;j >= w[i];--j){
            if(dp[j] <= dp[j - w[i]] + w[i]){
                dp[j] = dp[j - w[i]] + w[i];
                choice[i][j] = true;
            }else choice[i][j] = false;
        }
    }
    if(dp[m] != m) printf("No Solution");
    else{
        int i = n,j = m;
        while(i >= 0){
            if(choice[i][j]){
                flag[i] = true;
                j -= w[i];
            }else flag[i] = false;
            i--;
        }
        for(int i = n;i >= 1;--i){
            if(flag[i]){
                printf("%d ",w[i]);
            }
        }
    }
}

最长回文子串

#include<iostream>
#include<string>
using namespace std;
int main(){
    string str;
    getline(cin,str);
    int ans = 1;
    for(int i = 0;i < str.size();++i){
        int left = i - 1,right = i + 1;
        while(left >= 0 && right < str.size() && str[left] == str[right]){
            left--;
            right++;
        }
        if(right - left - 1 > ans) ans = right - left - 1;
    }
    for(int i = 0;i < str.size();++i){
        int left = i,right = i + 1;
        while(left >= 0 && right < str.size() && str[left] == str[right]){
            left--;
            right++;
        }
        if(right - left - 1 > ans) ans = right - left - 1;
    }
    cout << ans;
}