UVA 10635 Prince and Princess lcs--》lis

A - Prince and Princess

Time Limit:3000MS     Memory Limit:0KB     64bit IO Format:%lld & %llu

Submit Status Practice UVA 10635

Appoint description:

Description

 

 

Problem E
Prince and Princess
Input: Standard Input

Output: Standard Output

Time Limit: 3 Seconds

 

In an n x n chessboard, Prince and Princess plays a game. The squares in the chessboard are numbered 1, 2, 3 ... n*n, as shown below:

Prince stands in square 1, make p jumps and finally reach square n*n. He enters a square at most once. So if we use x_p to denote the p-th square he enters, then x₁, x₂, ... x_p+1 are all different. Note that x₁ = 1 and x_p+1 = n*n. Princess does the similar thing - stands in square 1, make q jumps and finally reach square n*n. We use y₁, y₂, ... y_q+1 to denote the sequence, and all q+1 numbers are different.

 

Figure 2 belows show a 3x3 square, a possible route for Prince and a different route for Princess.

The Prince moves along the sequence: 1 --> 7 --> 5 --> 4 --> 8 --> 3 --> 9 (Black arrows), while the Princess moves along this sequence: 1 --> 4 --> 3 --> 5 --> 6 --> 2 --> 8 --> 9 (White arrow).

The King -- their father, has just come. "Why move separately? You are brother and sister!" said the King, "Ignore some jumps and make sure that you're always together."

 

For example, if the Prince ignores his 2nd, 3rd, 6th jump, he'll follow the route: 1 --> 4 --> 8 --> 9. If the Princess ignores her 3rd, 4th, 5th, 6th jump, she'll follow the same route: 1 --> 4 --> 8 --> 9, (The common route is shown in figure 3) thus satisfies the King, shown above. The King wants to know the longest route they can move together, could you tell him?

 

Input 

The first line of the input contains a single integer t(1 <= t <= 10), the number of test cases followed. For each case, the first line contains three integers n, p, q(2 <= n <= 250, 1 <= p, q < n*n). The second line contains p+1 different integers in the range [1..n*n], the sequence of the Prince. The third line contains q+1 different integers in the range [1..n*n], the sequence of the Princess.

 

Output 

For each test case, print the case number and the length of longest route. Look at the output for sample input for details.

 

Sample Input                           Output for Sample Input

1 3 6 7 1 7 5 4 8 3 9 1 4 3 5 6 2 8 9

Case 1: 4

求2个串的最长公共子序列

因为数据范围是250*250 朴素算法会t

又因为每个串的每个数字出现的次数都为一

所以可以转为求lis

如何转换？

对于a数组{1,7,5,4,8,3,9}记录每个数字出现的先后顺序{1（1）,7（2）,5（3）,4（4）,8（5）,3（6）,9（7）}

然后在对b数组给出其数据在a数组出现的位置 b{1（a[1]=1),4(a[4]=4),3(a[3]=6),5(a[5]=3),6(a[6]=0),2(a[2]=0),8(a[8]=5),9(a[9]=7)}

然后对得到数组求lis {1,4,6,3,0,0,5,7} 可以看出是 1,3,5,7 长度是4

最长上升子序列（LIS），熟悉的n^2的动归会超时。LIS问题可以优化为nlogn的算法。
定义d[k]:长度为k的上升子序列的最末元素，若有多个长度为k的上升子序列，则记录最小的那个最末元素。
注意d中元素是单调递增的，下面要用到这个性质。
首先len = 1,d[1] = a[1],然后对a[i]:若a[i]>d[len]，那么len++，d[len] = a[i];
否则，我们要从d[1]到d[len-1]中找到一个j，满足d[j-1]<a[i]<d[j],则根据D的定义，我们需要更新长度为j的上升子序列的最末元素（使之为最小的）即 d[j] = a[i];
最终答案就是len
利用d的单调性，在查找j的时候可以二分查找，从而时间复杂度为nlogn。

ACcode：

#include <map>
#include <queue>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#define maxn 70000
using namespace std;
int a[maxn],b[maxn],dp[maxn];
int find_it(int x,int len){
    int l,r,m;
    l=0,r=len;
    while(l<r){
        m=(l+r)>>1;
        if(dp[m]>=b[x])r=m;
        else l=m+1;
    }
    return l;
}
int main(){
    int t,n,la,lb,cnt=1,tmp;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&n,&la,&lb);
        la++,lb++;
        for(int i=1;i<=la;++i){
            scanf("%d",&tmp);
            a[tmp]=i;
        }
        for(int i=1;i<=lb;++i){
            scanf("%d",&tmp);
            b[i]=a[tmp];
        }
        tmp=1;
        dp[1]=b[1];
        for(int i=2;i<=lb;++i)
            if(b[i]>dp[tmp])
                dp[++tmp]=b[i];
            else{
                int pos=find_it(i,tmp);
                dp[pos]=b[i];
            }
        printf("Case %d: %d\n",cnt++,tmp);
    }
    return 0;
}
/*
1
3 6 7
1 7 5 4 8 3 9
1 4 3 5 6 2 8 9
*/