PAT甲级——A1045 Favorite Color Stripe

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 (≤) 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 (≤) followed by M Eva's favorite color numbers given in her favorite order. Finally the third line starts with a positive integer L (≤) 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:

LIS——最长不下降子序列：
算法设计
定义一个长度为N的order数组，将Eva喜欢的颜色编号作为下标，对应元素为次序编号，例如给定喜欢的颜色为2 3 1 5 6，那么order[2]=1,order[3]=2……定义数组A存储给定的珠子序列，定义一个数组dp，其中dp[i]表示以 A[i]结尾的符合要求的子序列最长长度。那么对于0<=i<N，找出0<=j<i之间满足order[i]>=order[j]的最大的dp元素值MAX，则dp[i]=max(MAX,1)。遍历dp数组找出最大的值即为所求。

 #include <iostream>
 using namespace std;
 int like[], color[], dp[];
 int main()
 {
     int n, m, k, res = , x, nums = ;
     cin >> n >> m;
     for(int i=;i<=m;++i)//给自己喜欢颜色排序标号
     {
         cin >> x;
         like[x] = i;
     }
     cin >> k;
     for (int i = ; i < k; ++i)
     {
         cin >> x;
         if (like[x] > )//删除不是喜欢颜色的变量
             color[nums++] = like[x];//记住该颜色的标号
     }
     for (int i = ; i < nums; ++i)
     {
         dp[i] = ;//每种颜色单独拼接的长度为1
         for (int j = ; j < i; ++j)
             if (color[j] <= color[i])//只要前面的颜色的序号比自己小，那么就可以和直接拼接
                 dp[i] = dp[i] > (dp[j] + ) ? dp[i] : (dp[j] + );
         res = res > dp[i] ? res : dp[i];
     }
     cout << res;
     return ;
 }

LCS——最长公共子序列
算法设计
定义一个数组A储存喜欢的颜色编号序列，定义一个数组B存储给定的一串珠子序列，找出A、B之间的最长公共子序列即可。由于颜色可以重复，即子序列中可以有重复元素，状态转移方程为：

如果A[i]==B[j]，

如果A[i]!=B[j]，

边界情况为：

dp[i][0]=dp[0][j]=0(0<=i<=M,0<=j<=L)

 using namespace std;
 int dp[][];
 int main(){
     int N,M,L;
     scanf("%d%d",&N,&M);
     int A[M+]={};
     for(int i=;i<=M;++i)
         scanf("%d",&A[i]);
     scanf("%d",&L);
     int B[L+]={};
     for(int i=;i<=L;++i)
         scanf("%d",&B[i]);
     for(int i=;i<=M;++i)
         for(int j=;j<=L;++j)
             if(A[i]==B[j])
                 dp[i][j]=max(dp[i][j-],dp[i-][j-])+;
             else
                 dp[i][j]=max(dp[i][j-],dp[i-][j]);
     printf("%d",dp[M][L]);
     return ;
 }