正是太蠢了，我做這道題居然做了幾天

一道經典的LCS，但也可以轉化成LIS

將A中的資料重新編排成{1,2,3,....}，然後將B中的元素與A一一對應，如果B中的元素在A中沒有出現，就直接刪除。

例：A={1,7,5,4,8,3,9},B={1,4,3,5,6,2,8,9}

=>A={1,2,3,4,5,6,7},B={1,4,6,3,0,0,5,7}==>B={1,4,6,3,5,7}（0可以直接刪除）這就轉化成B的LIS

因為資料範圍為40000，所以LIS正常的o(n^2)演算法直接超時

下面為大家講解一下o(nlogn)的演算法：

設陣列d[i]是以i為結尾的最長上升子序列的長度，易知d[i]=max(d[j],j<i,A[j]<A[i])+1;

假設已經算出兩個值a和b，且a<b，d[a]=d[b]，則對於後面的每一個i(i>b)來說，若A[i]>A[b],則A[i]一定大於A[a],但反過來卻不一定——即通過A[i]>A[a]不能推出A[i]>A[b]，所以當我們只保留d相同的最小的a時，一定不會丟失最優解。

現在設陣列g[d]表示長度為d的所以最長上升子序列的結尾值得最小值，

所以很容易得知g[1]<=g[2]<=……<=g[n-1]<=g[n]，即這是一個遞增的陣列，所以可以是用二分查詢將效率降到o(nlogn)

每次處理一個數a時，用二分查詢找到最小的g[k],使得g[k]>a，且a>g[k-1]，然後更新g[k]=a，並通過ans不斷記錄最大的長度，

下面是程式碼：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=250*250;

int a[maxn],num[maxn];

int main()
{
  int t,n,p,q,x;
  scanf("%d",&t);
  for(int kase=1;kase<=t;kase++)
  {
  	scanf("%d%d%d",&n,&p,&q);
  	memset(num,0,sizeof(num));
  	for(int i=1;i<=p+1;i++)
  	{
  	  scanf("%d",&x);
  	  num[x]=i;
	}
	int nn=0;
	for(int i=1;i<=q+1;i++)
	{
	  scanf("%d",&x);
	  if(num[x])a[nn++]=num[x];
	}
	int ans=0;
	for(int i=1;i<=nn;i++)num[i]=10000000;
	for(int i=0;i<nn;i++)
	{
	  int k=lower_bound(num+1,num+nn+1,a[i])-num;
	  num[k]=a[i];
	  ans=max(ans,k);
	}
	printf("Case %d: %d\n",kase,ans);
  }
  return 0;
}