动态规划的个人记录

一般解题流程:
分析原问题找出子问题 --> 状态转移方程 --> 决策

背包问题

01背包问题

物品只有一个 选或者不选两种结构

二维存储的 需要正序遍历背包容量  dp[i][j] = max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
一维存储的 需要倒叙遍历背包容量  dp[j] = max(dp[j] ,dp[j-v[i]]+w[i]);

为什么可以空间优化 ： 因为求dp[i][j]的时候 只需要上一层的内容
为什么空间优化后，需要倒序遍历背包容量 ： 因为dp[j]需要比他下标小的地方更新。

完全背包问题

物品有无数个 正序遍历容量
dp[j] = max(dp[j],dp[j-v[i]]+w[i]);

多重背包问题

指定了物品有多少个 需要将s个物品拆分成一个个的物品

• 普通拆分
• 二进制优化
• 单调队列优化

---

混合背包问题

将以上背包混合
把多重背包适当的优化拆分为01背包，完全背包不变(做标记)
分别for处理

二维费用背包

背包的限制不仅有体积，还有承重，直接01背包思想，多加一层for限制承重就行

分组背包问题

每个组有s个物品，只能从一个组中拿一个，求背包的最大价值
v和w要用二维记录 第i组的第j个物品的体积

每一组只能选一个 所以第一层循环是组数
每一组 那或者不拿
循环组内物品

有依赖的背包问题

需要用数组模拟邻接表。讲问题转化为树，记录起来。
由于选子节点必须选择父节点
可将dp数组设计为 dp[i][j] 以i为根节点 花费为j的****
acwing10.有依赖的背包问题

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int n , m;
int v[N] , w[N] , f[N][N];
int e[N] , ne[N] , h[N] , idx;
void add(int a,int b){
    e[idx] = b , ne[idx] = h[a] , h[a] = idx++;
}
void dfs(int u){
    for(int i = h[u]; ~i; i = ne[i]){
        int son = e[i];
        dfs(son); 
        for(int j = m-v[u]; j >= 0; j -- )
            for(int k = 0; k <= j; k ++ )
                f[u][j] = max(f[u][j] , f[u][j-k]+f[son][k]);
    }
    for(int i = m; i >= v[u]; i -- )
        f[u][i] = f[u][i-v[u]]+w[u];
    for(int i = 0; i < v[u]; i ++ )
        f[u][i] = 0;
}
int main()
{
    memset(h , -1,sizeof h);
    cin>>n>>m;
    int head;
    for(int i = 1; i <= n; i ++ ){
        int p;
        cin>>v[i]>>w[i]>>p;
        if(p==-1)head=i;
        else add(p , i); //从p指向i
    }
    dfs(head);
    cout<<f[head][m]<<endl;
    return 0;
}

---

线性DP

最长上升子序列：

• n^2作法
  • dp[i]表示以第i个元素结尾的最长公共子序列长度

//dp[i]表示以第i个元素结尾的最长公共子序列长度
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n;
int num[maxn];
int dp[maxn];

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>num[i];
		dp[i]=1; //初始化 
		for(int j=1;j<i;j++){
			if(num[j]<num[i]&&dp[i]<dp[j]+1)
				dp[i]=dp[j]+1;
		}
	}
	cout<<dp[n]<<endl;
	return 0;
} 

• nlogn做法
  • dp[i]表示长度为i的最长上升子序列末尾最小值

#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n;
int dp[maxn];
int num[maxn];

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){
		scanf("%d",&num[i]);
		dp[i]=0x3f3f3f3f; //初始化 
	}
	int len=1; //记录长度 
	dp[1]=num[1];
	//二分思想 
	for(int i=2;i<=n;i++){
		int l=0,r=len,mid;
		if(num[i]>dp[len])dp[++len]=num[i];
		else{
			while(l<r){
				mid=(l+r)/2;
				if(dp[mid]>num[i])r=mid;
				else l=mid+1;
			}
			dp[l]=min(dp[l],num[i]);
		}
	} 
	printf("%d\n",len);
	return 0;
}

我的博客-导弹拦截问题

回文串问题(暂无)

ps：如果需要记录路径 再加一个数组就行

最长公共子序列：

两个字符串的最长公共子序列：

• dp[i][j]表示A串前i位和B串前j位组成的最长公共子序列长度
  • if(a[i]==b[j]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
  • else dp[i][j]=max(dp[i-1][j] , dp[i][j-1]);
• 转化为LIS问题
  • 用map思想将A串改为abcd…，再判断B串的LIS

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 55;
int a[maxn],b[maxn],map[maxn];
int dp[maxn];
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){scanf("%d",&a[i]);map[a[i]]=i;}
	for(int i=1;i<=n;i++){scanf("%d",&b[i]);dp[i]=0x3f3f3f3f;}
	int len=0;
	dp[0]=0; //b串LIS 
	for(int i=1;i<=n;i++){
		int l=0,r=len,mid;
		if(map[b[i]]>dp[len])dp[++len]=map[b[i]];
		else{
			while(l<r){
				mid=(l+r)/2;
				if(dp[mid]>map[b[i]])r=mid;
				else l=mid+1;
			}
			dp[l]=min(dp[l],map[b[i]]);
		}
	}
	cout<<len<<endl;
	return 0;
} 

背包DP

// 逆序 01 背包
for(int i=1;i<=n;i++)
		for(int j=T;j>=v[i];j--)
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
// 正序 完全 背包
for(int i=1;i<=n;i++)
	for(int j=v[i];j<=T;j++)
		dp[j]=max(dp[j],dp[j-v[i]]+w[i]);

多重背包：我的上一篇

区间DP

区间dp

区间DP要从短区间扩展到长区间，所以如果你不是使用记忆化搜索的话，就需要按区间长短来枚举而不是直接枚举首末端点！