dp解决子序列问题

最长公共子序列

http://acm.hdu.edu.cn/showproblem.php?pid=1159 最长公共子序列

一个给定序列的子序列是在该序列中删去若干元素后得到的序列。例如: X=(A,B,C,B, D,A,B)。

X的子序列：所有X的子集(集合中元素按原来在X中的顺序排列)，例如(A,B, D), (B,C,D,B), 等等。

给定两个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。

 

dp[i][j]表示str1前i个元素的子序列，str2前j的元素的子序列  的最长子序列的长度

if (str1[i - 1] == str2[j - 1])
	dp[i][j] = dp[i - 1][j - 1] + 1;
else 
	dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

代码很简单，枚举即可

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

const int mm = 1e3 + 5;
int dp[mm][mm];

int main()
{
	string str1, str2;
	while (cin >> str1 >> str2) {
		memset(dp, 0, sizeof(dp));
		for (int i = 1; i <= str1.length(); i++)
			for (int j = 1; j <= str2.length(); j++)
				if (str1[i - 1] == str2[j - 1])
					dp[i][j] = dp[i - 1][j - 1] + 1;
				else 
					dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

		cout << dp[str1.length()][str2.length()] << endl;
	}

	return  0;
}

还有一个叫最长公共子串的东西，注意区分

最长上升子序列

http://acm.hdu.edu.cn/showproblem.php?pid=1257 最少拦截系统

最长递增子序列问题：给定一个长度为N的数组，找出一个最长的单调递增子序列。

例：一个长度为6的序列A={5,6,7,4,2,8,3}，它最长的单调递增子序列为{5,6,7,8}，长度为4。

对于这道题第一个想法是贪心：

假设发射了很多高度无穷大的导弹。 读入第一个炮弹时，一个导弹下降来拦截。 以后每读入一个新的炮弹，就由能拦截它的最低的那个导弹来拦截。 最后，统计用到了几个导弹，就是最少的拦截系统。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
//贪心解最少拦截系统
const int inf = 0x3f3f3f3f;
const int mm = 1005;
int high[mm];
int n;
int main()
{
	while (cin >> n) {
		for (int i = 1; i <= n; i++)
			cin >> high[i];
		int cnt = 0, num = 0;
		while (num != n) {
			int minn = inf;
			for (int i = 1; i <= n; i++)
				if (high[i] < minn && high[i]) {
					minn = high[i];
					high[i] = 0;
					num++;
				}
			cnt++;
		}
		cout << cnt << endl;
	}

	return 0;
}

拦截系统这道题题目出的有点隐晦，字面意思求得是序列中  单调递减子序列的最少条数

可以直接用dp去求，其中dp[i]表示第i个敌国导弹属于哪个下降子序列，找到最大的dp[i]即为一共有几条下降子序列

转移方程为

	int maxx = 0;
	for (int j = 1; j < i; j++) 
		if (high[j]<high[i] && dp[j]>maxx) //出现上升的情况 查询前面出现了几个下降序列 
			maxx = dp[j];	
	dp[i] = maxx + 1;

求解代码：

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

const int mm = 1005;

int dp[mm];//i属于第几个下降序列 
int high[mm];
int n;

int main(){
	while (cin >> n) {
		int res = 1;
		memset(dp, 0, sizeof(dp));
		for (int i = 1; i <= n; i++)
			cin >> high[i];
		dp[1] = 1;//第一个下降序列 
		for (int i = 2; i <= n; i++) {
			int maxx = 0;
			for (int j = 1; j < i; j++) 
				if (high[j]<high[i] && dp[j]>maxx) //出现上升的情况 查询前面出现了几个下降序列 
					maxx = dp[j];
			dp[i] = maxx + 1;
			res = max(res, dp[i]);
		}
		cout << res << endl;
	}
	return 0;
}

最神奇的在这里，其实题目中要求的最少下降子序列条数其实就是这个序列里最长上升子序列的元素个数

还是有两种方法：

先将原序列排序，然后求两个序列的最长公共子序列的个数即可（神奇）

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

const int mm = 1005;
//最长上升子序列的元素数目 == 下降子序列的条数 ==  排序前后的 最长公共子序列 
int dp[mm][mm];
int high[mm];
int a[mm];
int n;
 
int main(){
	while (cin >> n) {
		memset(dp, 0, sizeof(dp));
		for (int i = 1; i <= n; i++) {
			cin >> high[i];
			a[i] = high[i];
		}
		sort(a + 1, a + n + 1);
		//求最长公共子序列  
		for (int i = 2; i <= n+1; i++)
			for (int j = 2; j <= n+1; j++)
				if (a[i - 1] == high[j - 1])
					dp[i][j] = dp[i - 1][j - 1] + 1;
				else
					dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
		cout << dp[n+1][n+1] << endl;

	}
	return 0;
}

另外一种是二分的做法非常之巧妙

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int mm = 1005;
int n;
int high[mm];
int dp[mm];

int main()
{
	while (cin >> n) {
		memset(dp, 0, sizeof(dp));
		for (int i = 1; i <= n; i++)
			cin >> high[i];
		dp[1] = high[1];
		int res = 1;
		for (int i = 2; i <= n; i++) {
			int l = 1, r = res;
			while (l <= r) {
				int mid = (l + r) >> 1;
				if (high[i] <= dp[mid])
					r = mid - 1;
				else
					l = mid + 1;
			}
			dp[l] = high[i];
			if (l > res)res++;
		}
		cout << res << endl;
	}

	return 0;
}