动态规划基础问题 背包问题、最长公共子序问题、最长上升子序、划分数、多重集合组成数问题

01背包问题

适用于数据范围较小（eg. 1<=n<=100,1<=wi,vi<=100,1<=w<=10000）

有n个重量和价值分别为wi和vi的物品，从这些物品中挑出总重量不超过W的物品，求所挑选方案中价值的最大值。

（1=<n<=100,1<=wi,vi<=100,1<=W<=10000）

dp[i+1][j]:从0到i这i+1个物品中选出总重量不超过j的物品同时总价值最大（dp[0][j]=0）

二维数组代码：

void solve(){
    for(int i=0;i<n;i++){
        for(int j=0;j<=W;j++){
            if(j<w[i])dp[i+1][j]=dp[i][j];//能承受重量少于物品重量，则不能这个物品
            else dp[i+1][j]=max(dp[i][j],dp[i][j-w[i]]+v[i]);//要和不要求最大值
        }
    }
    printf("%d\n",dp[n][W]);
}

一维数组代码：

for(int i=0;i<n;i++){
    for(int j=W;j>=w[i];j--){
        dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
    }
}
printf("%d\n",dp[W]);

01背包问题2

适用于数据范围较大（1=<n<=100,1<=wi<=1^7,1<=vi<=100,1<=W<=1^9）

当限制条件改变时（变大），此时可以看见重量已经非常大了，相较之下，价值的范围小，所以我们可以这样定义：

dp[i+1][j]:从前i个物品中选出总价值为j时最小的重量（dp[0][0]=0,dp[0][j]=INF前0个物品中什么都挑选不了，所以初始值为INF）

此外，从前i个物品中选出总价值为j时，一定有:

1）从前i-1个物品中选择总价值为j的物品

2）从前i-1个物品中选择总价值为j-v[i]的物品，然后选中第i个物品

所以dp[i+1][j]=min(dp[i][j],dp[i][j-v[i]]+v[i]);

int dp[MAX_N+1][MAX_N*MAX_V+1]
void solve(){
    fill(dp[0],dp[0]+MAX_N*MAX_V+1,INF);
    dp[0][0]=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<=MAX_N*MAX_V;j++){
            if(j<v[i])dp[i+1][j]=dp[i][j];
            else dp[i+1][j]=min(dp[i][j],dp[i][j-v[i]]+w[i]);
        }
    }
    int res=0;
    for(int i=0;i<=MAX_N*MAX_V;i++){
        if(dp[n][i]<=W)res=i;//n个物品都选了res为价值最大且不超过W的价值
    }
    printf("%d\n",res);
}

完全背包问题

有n个重量和价值分别为wi和vi的物品，从这些物品中挑出总重量不超过W的物品，每种物品任意选多件，求所挑选方案中价值的最大值。

二维数组代码：

void solve(){
    for(int i=0;i<n;i++){
        for(int j=0;j<=W;j++){
            if(j<w[i])dp[i+1][j]=dp[i][j];
            else dp[i+1][j]=max(dp[i][j],dp[i+1][j-w[i]]+v[i]);
        }
    }
    printf("%d\n",dp[n][W]);
}

一维数组代码：

for(int i=0;i<n;i++){
    for(int j=w[i];j<=W;j++){
        dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
    }
}
printf("%d\n",dp[W]);

最长公共子序问题（LCS - Longest Common Subsequence）

给定两个字符串s1…si和t1…tj，求着两个字符串最长的公共子序列的长度。

定义dp[i][j]:=s1…si和t1…tj对应的LCS的长度

因此s1…si+1和t1…tj+1对应的公共子列可能是：

• 当si+1=tj+1时，在s1…si和t1…tj的公共子列末尾加上si+1
• s1…si和t1…tj+1的公共子列
• s1…si+1和t1…tj的公共子列

三者中的某一个

因此得到递推方程：

dp[i+1][j+1]=

• max(dp[i][j]+1,dp[i][j+1],dp[i+1][j])  (si+1=tj+1)
• max(dp[i][j+1],dp[i+1][j])  (si+1!=tj+1)

int n,m;
char s[MAX_N],t[MAX_M];
int dp[MAX_N+1][MAX_M+1];
void solve(){
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(s[i]==t[j])dp[i+1][j+1]=dp[i][j]+1;
			else dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
		}
	}
}

最长上升子序问题（LIS - Longest Increasing Subsequence）

方法一：复杂度O(n^2)

有一个长为n的数列a0,a1,…,an-1，求这个序列中最长的上升子序列（对于任意j<i都满足aj<ai）的长度。

首先建立递推关系：dp[i]:=以ai结尾的最长上升子序的列的长度

以ai结尾的上升子序列是：

1）只包含ai的子序列，即长度为1

2）在满足j<i并且aj<ai的以aj结尾的序列中，末尾加上ai，即长度大于等于1

===》得到递推关系：dp[i]=max(1,dp[j]+1)  (i<j且aj<ai)

int res=0;
for(int i=0;i<N;i++){
    dp[i]=1;//以ai结尾的序列长度至少为1
    for(int j=0;j<i;j++){
        if(a[j]<a[i])dp[i]=max(dp[i],dp[j]+1);
    }
    res=max(res,dp[i]);//res选出以a0到aN-1结尾的序列的最大值即为LIS
}
printf("%d\n",res);

方法二：复杂度O(nlogn)

最开始全部dp[i]都初始化为INF。然后由前到后逐个考虑数列的元素，对于每个aj，如果i=0或者dp[i-1]<aj的话，都用dp[i]=min(dp[i],aj)进行更新。最终找出使得dp[i]<INF的最大的i+1就是结果了

int dp[MAX_N];
void solve(){
	fill(dp,dp+n,INF);
	for(int i=0;i<n;i++){
		*lower_bound(dp,dp+n,a[i])=a[i];
	}
	printf("%d\n",lower_bound(dp,dp+n,INF)-dp);
}

多重部分和问题  

有n种不同大小的数字ai每种mi个。判断是否可以从这些数字中选出若干使他们的和恰好为k

dp[i+1][j]:=用前i种数加和得到j时第i种数最多能剩余几个

dp[i+1][j]=

• mi (dp[i][j]>=0)
• -1 (j<ai或者dp[i+1][j-ai]<=0)
• dp[i+1][j-ai]-1 (其他)

这个递归式可以在O(nK)时间内计算出结果，再将数组重复利用的话，就得到如下代码：

int dp[MAX_K+1];

void solve(){
	memset(dp,-1,sizeof(dp));
	dp[0]=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<=K;j++){
			if(dp[j]>=0){
				dp[j]=m[i];
			}
			else if(j<a[i]||dp[j-a[i]]<=0){
				dp[j]=-1;
			}
			else dp[j]=dp[j-a[i]]-1;
		}
	}
	if(dp[K]>=0)printf("Yes\n");
	else printf("No\n");
}

划分数问题

有n个无区别的物品，将他们划分成不超过m组，求出划分方法数模M的余数

eg、n=4,m=3,M=10000

划分成1组，4

划分成2组，2,2或1,3

划分成2组，1,1,2

一共4种情况。

这样的划分被成做n的m划分，特别的，m=n时称做n的划分数。dp不仅对于求解最优问题有效，对于更重排列组合的个数、概率或者期望之类的计算同样很有用。

dp[i][j]:=j的i划分数

考虑n的m划分，如果对于每个i都有ai>0,那么{ai-1}就对应了n-m的m划分。另外，如果存在ai=0，那么就对应了n的m-1划分，综上，可得以下递推关系：

dp[i][j]=dp[i][j-i]+dp[i-1][j]

int n,m;
int dp[MAX_M+1][MAX_N+1];
void solve(){
	dp[0][0]=1;
	for(int i=1;i<=m;i++){
		for(int j=0;j<=n;j++){
			if(j-i>=0){
				dp[i][j]=(dp[i-1][j]+dp[i][j-i])%M;
			}
			else dp[i][j]=dp[i-1][j];
		}
	}
	printf("%d\n",dp[m][n]);
}

多重集组合数

有n中物品，第i种物品有ai个。不同种类的物品可以相互区分但相同种类的无法区分。从这些物品中取出m个，有多少种取法？求出的方案模M。

eg、n=3,m=3,a={1,2,3},M=10000

结果：

6（0+0+3,0+1+2,0+2+1,1+0+2,1+1+1,1+2+0）

为了不重复计数，同一种物品最好一次性处理好，于是我们按照如下方式定义。

dp[i+1][j]:=从前i种物品中取出j个的组合总数

dp[i+1][j]=dp[i+1][j-1]+dp[i][j]-dp[i][j-1-ai]

复杂度：O(nm)

int n,m;
int a[MAX_N];
int dp[MAX_N][MAX_M+1];
void solve(){
	for(int i=0;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(j-1-a[i]>=0){
				//在有取余的情况下，要避免减法运算的结果出现负数 
				dp[i+1][j]=(dp[i+1][j-1]+dp[i][j]-dp[i][j-1-a[i]]+M)%M;
			}
			else dp[i+1][j]=(dp[i+1][j-1]+dp[i][j])%M;
		}
	}
	printf("%d\n",ap[n][m]);
}