动态规划 LCS + 完全背包

1. 问题

• 动态规划中关于最长公共子序列 $LCS$ 、完全背包的问题

2. 解析

• 动态规划问题，一般都会涉及到状态的转移，最佳的状态值必然是由前一个最佳状态值递推而来，所以可以我们直接将问题抽象为一个整体，考虑当前最佳状态值是由什么状态转移而来。

• 最长公共子序列 $LCS$ 问题 ：

  • 这里要区分子序列 $subsequence$ 和子串 $substring$ 的区别， 前者是可以不连续的，后者必须是连续的，并且每个元素都要在主串出现

  • 我们假设当前最优状态值为 $dp[i][j]$，也就是取得主串 $A,B$ 最长的子序列 $C$ 的长度

    • 即主串 $A=<A_1,A_2,A_3....A_i>,B=<B_1,B_2,B_3....B_j>$
    • 可得到最长子序列 $C=<C1,C2,C3....Ck>,dp[i][j]=k$

  • 考虑当前最佳状态为 $dp[i][j]$，那么 $dp[i][j]$ 可以由三个状态转移而来

    • 分别是$dp[i-1][j-1]$， $dp[i][j-1]$， $dp[i-1][j]$
    • 当$A_i=B_j$， $C_{k-1}$ 必然是 $C_k$ 的最长公共子序列​，故 $dp[i][j]=dp[i-1][j-1]+1$
    • 当 $A_i\ne B_j$， $C_k\ne A_i$，$C_k$ 必然是 $A_{i-1}$ 和 $B_j$ 的最长公共子序列
    • 当 $A_i\ne B_j$， $C_k\ne B_j$，$C_k$ 必然是 $A_i$ 和 $B_{j-1}$ 的最长公共子序列

  • 综上所述，可得状态转移式：

    • $A_i=B_j$， $dp[i][j]=dp[i-1][j-1]+1$

    • $A_i\ne B_j$， $dp[i][j]=max(dp[i-1][j],dp[i][j-1])$

• 根据公式推导

  • 假设例子为 $A=<C,B,D,A,C,C>$ ， $B=<C,A,D>$
  • $i=1$
    • $j=1,A_i=B_j,C[1][1]=C[0][0]+1=1$
    • $j=2,A_i\ne B_j,C[1][2]=max(C[1,1],C[0,2])=max(1,0)=1$
    • $j=3,A_i\ne B_j,C[1][3]=max(C[1,2],C[0,3])=max(1,0)=1$
  • $i=2$
    • $j=1,A_i\ne B_j,C[2][1]=max(C[2,0],C[1,1])=max(0,1)=1$
    • $j=2,A_i\ne B_j,C[2][2]=max(C[2,1],C[1,2])=max(1,1)=1$
    • $j=3,A_i\ne B_j,C[2][3]=max(C[2,2],C[1,3])=max(1,1)=1$
  • $i=3$
    • $j=1,A_i\ne B_j,C[3][1]=max(C[3,0],C[2,1])=max(0,1)=1$
    • $j=2,A_i\ne B_j,C[3][2]=max(C[3,1],C[2,2])=max(1,1)=1$
    • $j=3,A_i=B_j,C[3][3]=C[2][2]+1=2$
  • $i=4$
    • $j=1,A_i\ne B_j,C[4][1]=max(C[4,0],C[3,1])=max(0,1)=1$
    • $j=2,A_i=B_j,C[4][2]=C[3][1]+1=2$
    • $j=3,A_i\ne B_j,C[4][3]=max(C[4,2],C[3,3])=max(2,2)=2$
  • $i=5$
    • $j=1,A_i=B_j,C[5][1]=C[4][0]+1=1$
    • $j=2,A_i\ne B_j,C[5][2]=max(C[5,1],C[4,2])=max(1,2)=2$
    • $j=3,A_i\ne B_j,C[5][3]=max(C[5,2],C[4,3])=max(2,2)=2$
  • $i=6$
    • $j=1,A_i=B_j,C[6][1]=c[5][0]+1=1$
    • $j=2,A_i\ne B_j,C[6][2]=max(C[6,1],C[5,2])=max(1,2)=2$
    • $j=3,A_i\ne B_j,C[6][3]=max(C[6,2],C[5,3])=max(2,2)=2$

• 求 $LCS$ 方案

  • 我们可以根据状态转移方程倒过来递推得到最长公共子序列
  • $i=6,j=3,A=<C,B,D,A,C,C>,B=<C,A,D>$
  • $i=6,j=2,A=<C,B,D,A,C,C>,B=<C,A>$
  • $i=5,j=2,A=<C,B,D,A,C>,B=<C,A>$
  • $i=4,j=2,A=<C,B,D,A>,B=<C,A>$
  • $i=3,j=1,A=<C,B,D>,B=<C>$
  • $i=2,j=1,A=<C,B>,B=<C>$
  • $i=1,j=1,A=<C>,B=<C>$
  • 可得 $C=<C,A>$

• 完全背包问题

  • 这里要区分背包问题，01背包是每种物品只能取0次或1次，而完全背包问题是每个物品取无限次

  • 我们假设当前最优状态值为 $dp[i][j]$，即可选择前 $i$ 个物品，背包大小为 $j$ 时的最优状态值

    • 考虑当前最佳状态为 $dp[i][j]$，那么 $dp[i][j]$ 可以由两个状态转移而来
      • 是不选择第 $i$ 个物品装入背包，那么 $dp[i][j]=dp[i-1][j]$
      • 选择第 $i$ 个物品装入背包，那么 $dp[i][j]=dp[i-1][j-k\ast weight[i]]+k\ast val[i]$
    • 这样的话我们就需要三重循环枚举物品的数量和物品的种类和背包的大小
    • 所以我们可以通过滚动数组进行优化，减少循环次数和 $dp$ 维度

  • 根据公式推导

  • 假设有 $n=5$ 个物品， $m=10$ 的背包大小，物品的价值为 $<1,2,3,4,5>$，重量为 $<5,4,3,2,1>$

  • i/j	1	2	3	4	5	6	7	8	9	10
    1	0	0	0	0	1	1	1	1	1	2
    2	0	0	0	2	2	2	2	4	4	4
    3	0	0	3	3	3	6	6	6	9	9
    4	0	4	4	8	8	12	12	16	16	20
    5	5	10	15	20	25	30	35	40	45	50

3. 设计

最长公共子序列算法：

#include<bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e3+10;

char a[N],b[N];
int dp[N][N];


//输出LCS方案
void print(int l,int r) {
    if (l<=0 || r<=0) return;
    if (a[l] == b[r]) {
        print(l-1,r-1);
        cout<<a[l];
    } else if (dp[l-1][r]>dp[l][r-1]) {
        print(l-1,r);
    } else {
        print(l,r-1);
    }
}

void run() {
	cin>>a+1>>b+1;
	int lena = strlen(a+1);
	int lenb = strlen(b+1);
	for (int i=1;i<=lena;i++) {
		for (int j=1;j<=lenb;j++) {
			if (a[i] == b[j]) {
				dp[i][j] = dp[i-1][j-1] + 1;
			} else {
				dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
			}
		}
	}
	cout<<dp[lena][lenb]<<endl;
    print(lena,lenb);
}

int main() {
	run();
	return 0;
}

完全背包算法：

#include<bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e3+10;

int n,m,k;
int weight[N];
int val[N];
int dp[N];

void run() {
	cin>>n>>m;
	for (int i=1;i<=n;i++) {
		cin>>weight[i]>>val[i];
	}
	for (int i=1;i<=n;i++) {
		for (int j=weight[i];j<=m;j++) {
			dp[j] = max(dp[j],dp[j-weight[i]]+val[i]);
		}
	}
	cout<<dp[m]<<endl;
}

int main() {
	run();
	return 0;
}

4. 分析

• $LCS$ 时间复杂度为两重循环为 $O(n\ast m)$

• 完全背包的时间复杂度为两重循环为 $O(n\ast m)$

5. 源码

https://github.com/a894985555/Algorithm/tree/main/LCS%E7%AE%97%E6%B3%95%2B%E5%AE%8C%E5%85%A8%E8%83%8C%E5%8C%85%E7%AE%97%E6%B3%95