DP入门题

PATA1007

题目要求求出最大子序列的各元素之和，并且输出最大子序列的第一个元素和最后一个元素的值。使用一个dp数组，dp[i]表示以第i个元素为末尾的和最大的序列。由于需要用到序列的首元素，所以在DP时就要记录。状态转移方程如下：
$dp[0].start=0;dp[0].v=dat[0]$
$dp[i-1]<0,dp[i].start=i,dp[i].v=dat[i]$
$dp[i-1]\geq 0,dp[i].start=dp[i-1].start,dp[i].v=dat[i]+dp[i-1].v$
题目要求要求按照一定的优先级输出结果，即最大值、i、j，那么可以使用三轮遍历，也可以自定义一个比较函数使用sort(时间复杂度会增加)。
代码如下：

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
 
const int MAX = 10010;
int K = 0;
struct node {
	int start, end, v;
	node(int a,int b,int c):start(a),end(b),v(c){}
	node(){}
};
//dp数组,第i个元素储存以i为末尾的序列的最大值
struct node dp[MAX];
//原始data
int dat[MAX] = { 0 };
//全为负数？
bool flag = true;
void input() {
	cin >> K;
	for (int i = 0; i < K; i++) {
		cin >> dat[i];
		if (dat[i] >= 0)	flag = false;
	}
}
 
struct cmp {
	bool operator()(const struct node& a, const struct node& b) {
		if (a.v != b.v)	return a.v > b.v;
		if (a.start != b.start)	return a.start < b.start;
		if (a.end != b.end)	return a.end < b.end;
	}
};
 
int main(void) {
	ios::sync_with_stdio(false);
	input();
	if (flag) {
		cout << 0 << " " << dat[0] << " " << dat[K - 1] << endl;
		return 0;
	}
	
	//dp计算
	dp[0] = node(0, 0, dat[0]);
	for (int i = 1; i < K; i++) {
		int s, v;
		if (dp[i - 1].v >= 0) {
			s = dp[i - 1].start;
			v = dp[i - 1].v + dat[i];			
		}
		else {
			s = i;
			v = dat[i];
		}
		dp[i] = node(s, i, v);
	}
 
	//输出结果
	//将结果排序
	sort(dp, dp + K, cmp());
	cout << dp[0].v <<" "<< dat[dp[0].start] <<" "<< dat[dp[0].end]<<endl;
}

patA1045之LIS做法

使用最长不下降子序列做法，dp[i]储存以第i个元素结尾的所有序列的最大长度，可以写出状态转移方程：
$dp[i]=MAX\{1,dp[j]+1\},j\in \{0...i-1\} \and j的顺序先于i$
关键在于如何表示顺序的先后关系。代码1的思路是使用一个二维数组，[i][j]的意义即为数字j允许出现在数字i之前。但这样代码较为冗长。
代码1

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<unordered_map>
#include<vector>
#include<set>
using namespace std;
 
const int MAX = 10010;
const int MAX2 = 205;
int N, M, L;
//newl储存去掉所有不喜欢的颜色后的色带元素个数
int newl;
//map[i][j]表示j可以出现在i之前
bool map1[MAX2][MAX2] = { false };
//储存去掉不喜欢颜色后的色带
vector<int> dat;
//储存喜欢的颜色
vector<int> color;
set<int> colorset;
 
void input() {
	cin >> N;
	cin >> M;
	for (int i = 0; i < M; i++) {
		int c; cin >> c; color.push_back(c); colorset.insert(c);
	}
	cin >> L;
	for (int i = 0; i < L; i++) {
		int c; cin >> c;
		if (colorset.find(c) != colorset.end()) {
			dat.push_back(c);
		}
	}
}
 
//创建映射
void createmap() {
	for (int i = 0; i < color.size(); i++) {
		int key = color[i];
		for (int j = 0; j <= i; j++) {
			map1[key][color[j]] = true;
		}
	}
}
 
int dp[MAX] = { 0 };
int main(void) {
	ios::sync_with_stdio(false);
	input();
	createmap();
 
	//dp求解,dp[i]储存以色带第i个元素为末尾且满足顺序的所有序列中，序列的最大长度
	dp[0] = 1;
	for (int i = 1; i < dat.size(); i++) {
		int dpmax = 0;
		for (int j = 0; j < i; j++) {
			//元素j的顺序在i之前
			if (map1[dat[i]][dat[j]]) {
				if (dp[j] > dpmax)	dpmax = dp[j];
			}
		}
		dp[i] = (dpmax == 0 ? 1 : dpmax+1);
	}
 
	int result=*max_element(dp,dp+dat.size());
	cout << result << endl;
}

代码2借鉴了教材。使用一个数组来完成数字到顺序间的映射关系。然后在dp时直接按照映射得到相对的顺序。
代码如下：

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<unordered_map>
#include<vector>
#include<set>
using namespace std;
 
const int MAX = 10010;
const int MAX2 = 205;
int N, M, L;
//储存去掉不喜欢颜色后的色带
vector<int> dat;
//映射，将喜欢的颜色映射到0,1,2...
int myhash[MAX2];
 
void input() {
	cin >> N;
	cin >> M;
	for (int i = 0; i < M; i++) {
		int c; cin >> c;
		myhash[c] = i;
	}
	cin >> L;
	for (int i = 0; i < L; i++) {
		int c; cin >> c;
		if (myhash[c]!=-1) {
			dat.push_back(c);
		}
	}
}
 
int dp[MAX] = { 0 };
int main(void) {
	fill(myhash, myhash + MAX2, -1);
	ios::sync_with_stdio(false);
	input();
 
	//dp求解,dp[i]储存以色带第i个元素为末尾且满足顺序的所有序列中，序列的最大长度
	dp[0] = 1;
	for (int i = 1; i < dat.size(); i++) {
		int dpmax = 0;
		for (int j = 0; j < i; j++) {
			//元素j的顺序在i之前
			if (myhash[dat[i]]>=myhash[dat[j]]) {
				if (dp[j] > dpmax)	dpmax = dp[j];
			}
		}
		dp[i] = (dpmax == 0 ? 1 : dpmax+1);
	}
 
	int result=*max_element(dp,dp+dat.size());
	cout << result << endl;
}

不难看出，两种写法的时间复杂度都是$O(L^2)$，这个无疑是很大的，所以不出所料这两个版本的代码在acwing的oj中都会超时，但pat的水oj可以ac。接下来介绍可以在$O(ML)$的时间复杂度中求解的LCS做法。

patA1045之LCS做法

LCS即最长公共子串。假设有两个字符串s1和s2分别长为M和N，s1=acb，s2=abbcccc，则最长公共子串为acccc。
使用一个dp数组dp[M+2][N+2]，其中dp[i][j]表示以s1的第i位为结尾的字串和s2的第j位为结束的字串两个的最长公共子串长度。
状态转移方程为
$若s1[i]=s2[j],dp[i][j]=max\{dp[i-1][j],dp[i][j-1]\}+1$
$否则,dp[i][j]=max\{dp[i-1][j],dp[i][j-1]\}$
代码如下：

#include<cstring>
#include<cstdio>
#include<string>
#include<iostream>
#include<vector>
using namespace std;
 
const int MAX1 = 205;
const int MAX2 = 10005;
int N, M, L;
int dp[MAX1][MAX2] = { 0 };
//标记第i个颜色是否为喜欢的
bool like[MAX1] = { false };
//储存去掉不喜欢的颜色后的色带
vector<int> mydata;
//储存喜欢的色带
int order[MAX1] = { 0 };
 
void input() {
	cin >> N;
	cin >> M;
	for (int i = 1; i <= M; i++) {
		int j; cin >> j;
		like[j] = true;
		order[i] = j;
	}
	cin >> L;
	mydata.push_back(0);
	for (int i = 0; i < L; i++) {
		int j; cin >> j;
		if (like[j])	mydata.push_back(j);
	}
}
 
int main(void) {
	ios::sync_with_stdio(false);
	input();
 
	for (int i = 1; i <= M; i++) {
		for (int j = 1; j < mydata.size(); j++) {
			if (order[i] == mydata[j]) {
				dp[i][j]=max(dp[i-1][j],dp[i][j-1])+1;
			}
			else {
				dp[i][j]= max(dp[i - 1][j], dp[i][j - 1]);
			}
		}
	}
	cout << dp[M][mydata.size()-1] << endl;
}

PATA1524

这道题如果用DP的方法，就是最长回文子串模型。
使用一个bool类型的二维dp数组，其中dp[i][j]表示以i、j为首尾的字串是否为回文字串
状态转移方程：
$若str[i]=str[j]，则dp[i][j]=dp[i+1][j-1]$
边界条件：$dp[i][i]=1,dp[i][i+1]=str[i]==str[i+1]?1:0$
比较重要的是它的遍历方法，不能用之前的递增i,j的方法，而是每次对一个长度的字串进行dp，每轮结束递增该长度。
代码如下：

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
 
const int MAX = 1005;
string str;
//dp[i][j]表示字串中第i个与第j个中间的子串是否为回文
bool dp[MAX][MAX] = { 0 };
int result=1;		//最长回文子串的长度
 
int main(void) {
	ios::sync_with_stdio(false);
	//注意不能直接用cin输入给str，否则得到的是单词而不是一整行
	getline(cin, str);
	int len = str.length();
 
	//初始化dp矩阵的边界值
	for (int i = 0; i < len; i++) {
		dp[i][i] = true;
		if (str[i] == str[i + 1]) { 
			dp[i][i + 1] = true; 
			result = 2;
		}
	}
	//dp递推
	for (int l = 3; l <= len; l++) {
		for (int i = 0; i <= len - l; i++) {
			int begin = i;
			int end = i + l - 1;
			if (str[begin] == str[end]) {
				if (dp[begin + 1][end - 1]) {
					dp[begin][end] = true;
					result = l;
				}
			}
		}
	}
 
	cout << result << endl;
}