uva 10635Prince and Princess (LCS转LIS)

最新推荐文章于 2018-05-20 13:38:40 发布

原创最新推荐文章于 2018-05-20 13:38:40 发布 · 1.9k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#LIS

动态规划专栏收录该内容

27 篇文章

订阅专栏

在一个n×n棋盘上，王子和公主分别从1号格出发，通过一系列跳跃到达n*n号格。目标是找到两人能共同行走的最长路径。通过重新编号并利用最长递增子序列算法(LIS)，可以在O(n log n)的时间复杂度内解决问题。

B - Prince and Princess

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

Submit Status

Description

Problem D
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

3 6 7

1 7 5 4 8 3 9

1 4 3 5 6 2 8 9

Case 1: 4

Problemsetter: Rujia Liu, Member of Elite Problemsetters' Panel

Pictures drawn by Shahriar Manzoor, Member of Elite Problemsetters' Panel

"What was lost was found; what was found was never lost."

题目大意：给你两个数字串，让你求最长公共子序列，当然很容易想到的就是O（n*n）的经典LCS解法，但是这个题目的n最大为250*250=6*10^4，显然使用这种方法会TLE。

题目中交代了所有的数字不会相同，这是一个信号，我们可以重新对第一个数字串编号，然后根据第一个串的编号对第二个串进行转换。比如

1 7 5 4 8 3 9，这是第一个串，我们对串进行重新编号,mq[1]=1,mq[7]=2。。。。依次处理。

然后处理第二个串1 4 3 5 6 2 8 9，处理之后变成了1 4 6 3 0 0 5 7，当然我们是不需要0的，我们可以直接写成1 4 6 3 5 7，然后求这个串的最长递增子序列LIS即可。

LIS普通的解法也是O（n*n）的。

当然也有O（n*log(n)）的算法，每次插入值得时候，可以采用二分查找的方式找到插入点，具体见代码：

题目地址：Prince and Princess

AC代码：

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
using namespace std;
const int maxn=100000;

map<int,int> mq;
int a[maxn];

int main()
{
    int tes,cas;
    cin>>tes;
    int n,p,q;
    int i,x;
    for(cas=1;cas<=tes;cas++)
    {
        mq.clear();
        cin>>n>>p>>q;
        p++,q++;
        for(i=1;i<=p;i++)
        {
            scanf("%d",&x);
            mq[x]=i;
        }

        for(i=1;i<=1e5-1;i++)
            a[i]=1e5;
        for(i=1;i<=q;i++)
        {
            scanf("%d",&x);
            if(mq[x])
            {
                x=mq[x];
                int l,r,mid;
                l=0,r=n*n;
                while(r>l+1)   //一定介于l与r之间
                {
                    mid=(r+l)>>1;
                    if(a[mid]<x) l=mid;
                    else r=mid;
                }
                a[l+1]=x;
            }
        }

        int res;
        for(i=n*n;i>=1;i--)
            if(a[i]<=n*n)
            {
                res=i;
                break;
            }

        printf("Case %d: %d\n",cas,res);
    }
    return 0;
}

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