王道机试 第十二章 动态规划 12.3 最长递增子序列(LIS) 12.4 最长公共子序列(LCS)

王道机试 第十二章 动态规划

12.3 最长递增子序列(LIS)

例题12.3 拦截导弹（北京大学复试上机题）

• 动态规划解读
• 设变量
  设$dp[k]$表示以$a_k$为结尾的子序列（可以不连续）的最大程度。（求什么设什么）
• 递推方程
  对于每个$i$ ($1\le i\le n$)，考察其前方的导弹$j$($j\le i$)。按照题目要求，前面的导弹高度$dp[j]\ge dp[i]$，否则二者无法构成非递减子序列。若能够构成，显然加入第$j$个导弹后，以$a_i$为结尾的子序列又增加一个元素$a_j$。则递推方程为：$dp[i]=$ {$max(1,dp[j]+1)|i>j\&a[j]\ge a[i]$}
• 初值
  显然，初始时单个元素均构成LIS，则$dp[i]=1(1\le i\le n)$.

C++代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 10005;
int dp[maxn]; // 以a_k结尾的最长不下降子序列的最大长度
int a[maxn]; // 导弹高度

int main()
{
	int n;
	while (cin >> n){
		memset(a, 0, sizeof(a));
		for (int i = 1; i <= n; i++){
			cin >> a[i];
		}

		fill(dp, dp + maxn, 1); // dp初始值
		for (int i = 1; i <= n; i++){ // dp[i] = {max(1, dp[j] + 1) | i > j && a[j] >= a[i]}
			for (int j = 1; j < i; j++){
				if (i > j && a[j] >= a[i]){
					dp[i] = max(dp[i], dp[j] + 1);
				}
			}
		}

		int maxx = dp[1];
		for (int i = 2; i <= n; i++){
			if (maxx < dp[i]) maxx = dp[i];
		}
		cout << maxx << endl;
	}
	return 0;
}

例题12.5 最大上升子序列和（北京大学复试上机题）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 1005;
int dp[maxn]; // 以a_k元素结尾的上升子序列的最大值
int a[maxn]; // input element

int main()
{
	int n;
	while (cin >> n){
		memset(a, 0, sizeof(a));
		for (int i = 1; i <= n; i++){
			cin >> a[i];
		}
		for (int i = 1; i <= n; i++){
			dp[i] = a[i];
		}
		for (int i = 1; i <= n; i++){
			for (int j = 1; j < i; j++){
				if (a[j] < a[i]){
					dp[i] = max(dp[i], dp[j] + a[i]);
				}
			}
		}

		int maxx = dp[1];
		for (int i = 2; i <= n; i++){
			if (maxx < dp[i]) maxx = dp[i];
		}
		cout << maxx << endl;
	}
	return 0;
}

习题12.3 合唱队形

• 思路
• 枚举所有的最中间的位置($1-n$)，对这$n$种情况分别以中间位置为分界点求最长递增子序列和最长下降子序列，再将二者求和减去1，即得到队伍中的人数。再用总人数减去它们，即得出队人数，取最小值即可。时间复杂度为$O(n^3)$

C++代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 105;
int dp1[maxn], dp2[maxn];
int a[maxn];

int main()
{
	int n;
	while (cin >> n){
		memset(a, 0, sizeof(a));
		for (int i = 1; i <= n; i++){
			cin >> a[i];
		}

		int ans = 105;
		for (int k = 1; k <= n; k++){
			int ans1 = 0, ans2 = 0;

			fill(dp1, dp1 + maxn, 1);
			for (int i = 1; i <= k; i++){
				for (int j = 1; j < i; j++){
					if (a[i] > a[j]) dp1[i] = max(dp1[i], dp1[j] + 1);
				}
				ans1 = max(ans1, dp1[i]);
			}

			fill(dp2, dp2 + maxn, 1);
			for (int i = k; i <= n; i++){
				for (int j = k; j < i; j++){
					if (a[i] < a[j]) dp2[i] = max(dp2[i], dp2[j] + 1);
				}
				ans2 = max(ans2, dp2[i]);
			}
			ans = min(ans, n - (ans1 + ans2) + 1);
		}
		cout << ans << endl;
	}
	return 0;
}

12.4 最长公共子序列(LCS)

例题12.6 Common Subsequence

• 注意事项
• 初始值：当两个子串任意一个长度为0时，公共子序列长度为0.
• 从1开始输入字符串：

scanf("%s%s", s1 + 1, s2 + 1) != EOF) // input
int n = strlen(s1 + 1), m = strlen(s2 + 1); // length

C++代码如下：

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 1005;
int dp[maxn][maxn];
char s1[maxn], s2[maxn];

int main()
{
	while (scanf("%s%s", s1 + 1, s2 + 1) != EOF){
		int n = strlen(s1 + 1), m = strlen(s2 + 1);
		memset(dp, 0, sizeof(dp));

		for (int i = 0; i <= n; i++){
			for (int j = 0; j <= m; j++){
				if (i == 0 || j == 0){
					dp[i][j] = 0; continue;
				}
				if (s1[i] == s2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
				else dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
			}
		}
		cout << dp[n][m] << endl;
	}
	return 0;
}

习题12.4 Coincidence

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
using namespace std;

const int maxn = 105;
int dp[maxn][maxn];
char s1[maxn], s2[maxn];

int main()
{
	while (scanf("%s%s", s1 + 1, s2 + 1) != EOF){
		int n = strlen(s1 + 1), m = strlen(s2 + 1);
		memset(dp, 0, sizeof(dp));
		for (int i = 0; i <= n; i++){
			for (int j = 0; j <= m; j++){
				if (i == 0 || j == 0) dp[i][j] = 0;
				else if (s1[i] == s2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
				else dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
			}
		}
		cout << dp[n][m] << endl;
	}
	return 0;
}