PAT 1045

题目

Eva is trying to make her own color stripe out of a given one. She would like to keep only her favorite colors in her favorite order by cutting off those unwanted pieces and sewing the remaining parts together to form her favorite color stripe.

It is said that a normal human eye can distinguish about less than 200 different colors, so Eva’s favorite colors are limited. However the original stripe could be very long, and Eva would like to have the remaining favorite stripe with the maximum length. So she needs your help to find her the best result.

Note that the solution might not be unique, but you only have to tell her the maximum length. For example, given a stripe of colors {2 2 4 1 5 5 6 3 1 1 5 6}. If Eva’s favorite colors are given in her favorite order as {2 3 1 5 6}, then she has 4 possible best solutions {2 2 1 1 1 5 6}, {2 2 1 5 5 5 6}, {2 2 1 5 5 6 6}, and {2 2 3 1 1 5 6}.

Input Specification:
Each input file contains one test case. For each case, the first line contains a positive integer N (≤200) which is the total number of colors involved (and hence the colors are numbered from 1 to N). Then the next line starts with a positive integer M (≤200) followed by M Eva’s favorite color numbers given in her favorite order. Finally the third line starts with a positive integer L (≤10
​4) which is the length of the given stripe, followed by L colors on the stripe. All the numbers in a line a separated by a space.

Output Specification:
For each test case, simply print in a line the maximum length of Eva’s favorite stripe.

Sample Input:

6
5 2 3 1 5 6
12 2 2 4 1 5 5 6 3 1 1 5 6

Sample Output:

7

给出一串已有的序列，然后再给出一串数组，要求从数组中挑出按照已有序列不下降的方式求出最长子序列长度

思路一

可以使用最长不下降子序列

1. 题目给出的顺序，我们可以映射为从0 ~ n - 1的数字，这样就按照题目的优先级得到了一串递增序列
2. 其他数字的映射处理为 -1 ，这样在读入第二串数字的时候，我们可以不读入映射为 -1 的数，因为映射为 -1 的数本质上都是一样的，因为序列可以不连续，所以他们也会被跳过，所以一开始的时候就不如读入他们
3. 得到了一串处理过的数组后，直接套用LIS的模板就可以得到答案了，具体LIS可以在动态规划的文章中找到

   #include<cstdio>
   #include<algorithm>
   using namespace std;
   const int maxc = 210;
   const int maxn = 10010;
   int Hash[maxc];
   int dp[maxn], A[maxn];
   
   int main() {
   	int n, m, temp;
   	scanf("%d %d", &n, &m);
   	fill(Hash, Hash + 210, -1);
   	for (int i = 0; i < m; i++) {
   		scanf("%d", &temp);
   		Hash[temp] = i;
   	}
   	int L, num = 0;
   	scanf("%d", &L);
   	for (int i = 0; i < L; i++) {
   		scanf("%d", &temp);
   		if (Hash[temp] >= 0) {
   			A[num++] = Hash[temp];
   		}
   	}
   	int ans = -1;
   	for (int i = 0; i < num; i++) {
   		dp[i] = 1;
   		for (int j = 0; j < i; j++) {
   			if (A[j] <= A[i] && dp[i] < dp[j] + 1) {
   				dp[i] = dp[j] + 1;
   			}
   		}
   		ans = max(ans, dp[i]);
   	}
   	printf("%d", ans);
   	return 0;
   }
   

思路二

使用最长公共子序列

1. 模板公共最长子序列中，当A[i] = B[j] 时，dp[i][j]直接由dp[i -1][j - 1] + 1得来，因为在不考虑可以产生重复元素的情况下，本质上是max (dp[i -1][j - 1] + 1, dp[i -1][j], dp[i][j - 1])，但可以确定dp[i -1][j - 1] + 1一定是最大的。
2. 但现在因为可以出现公共元素，如果A[i - 1] = B[j]或如果A[i] = B[j - 1]，此时变为了max (dp[i -1][j - 1] + 1, dp[i -1][j] +1, dp[i][j - 1] + 1) ，所以求解dp[i][j]就变为了max (dp[i -1][j] +1, dp[i][j - 1] + 1) + 1。
3. 当A[i] != B[j] 时，则仍然继承前面元素的dp值，为max (dp[i -1][j] +1, dp[i][j - 1] + 1) 。
4. dp[i][j]表示第一个字符串a的i之前和第二个字符串b的j之前的匹配长度,，所以所有的dp[i][0]和的dp[j][0]都是0，因为不可能和空串有匹配长度

   #include<cstdio>
   #include<algorithm>
   using namespace std;
   const int maxc = 210;
   const int maxn = 10010;
   int dp[maxn][maxn]; // dp[i][j]表示第一个字符串a的i之前和第二个字符串b的j之前的匹配长度
   int A[maxc], B[maxn];
   
   int main() {
   	int n, m;
   	scanf("%d %d", &n, &m);
   	for (int i = 1; i <= m; i++) {
   		scanf("%d", &A[i]);
   	}
   	int L;
   	scanf("%d", &L);
   	for (int i = 1; i <= L; i++) {
   		scanf("%d", &B[i]);
   	}
   	for (int i = 0; i <= m; i++) {
   		dp[i][0] = 0;
   	}
   	for (int i = 0; i <= L; i++) {
   		dp[0][i] = 0;
   	}
   	for (int i = 1; i <= m; i++) {
   		for (int j = 1; j <= L; j++) {
   			int h = max(dp[i - 1][j], dp[i][j - 1]);
   			if (A[i] == B[j]) {
   				dp[i][j] = h + 1;
   			}
   			else {
   				dp[i][j] = h;
   			}
   		}
   	}
   	printf("%d", dp[m][L]);
   	return 0;
   }