[DP_LIS] UVA10635

因为LCS是O(n^2)所以TLE
所以转移成O(n*logn)的LIS

LCS–>LIS

王子和公主 UVa10635

这种题目的一个特定就是其中一个序列的所有元素均不相同。首先，我们可以对A数组重新编号为{1,2,3,…n}，接下来对于B数组的每个元素，替换为A中那个元素的编号，若没有在A中出现，那么直接置0，这样，B数组也变为一个由编号构成的数组，此时我们发现，A数组是一个自然序列，那么只要在B中找到最长上升的子序列，就是和A的最长公共子序列！这就是本题的巧妙之处！而LIS问题有O(N*logN)的解法，因此可以通过本题的数据规模。

UVa 10635 Prince and Princess（LCS N*logN）

比如现在我们要找A、B的最长公共子序列，其中
A：1 3 9 2 3
B：3 2 1 7 2 3
我们要在A中找到B中的各个字符出现的位置，
3：2 5
2：4
1：1
7：没有
2：4
3：2 5
然后依次把右边的数写出来，但是对于每个“：”后面的一组数要逆序输出，因为在B中那个位置只有一个元素，所以要避免在做最长上升子序列的时候在那一个位置选择了多于一个的元素。
这样我们就得到了5 2 4 1 4 5 2，对这个序列求最长上升子序列即可。

这里因为没有重复的数，所以不会出现一个数字对应两个位置的情况，所以只需要用数组来储存位置就可以了。

LIS–O( n*logn )的求解方法

最长上升子序列nlogn算法
简单说就是通过一个数组，记录长度为len时能搜索到的最小值
如果比所有的都大，则放在最末，长度加一;
如果比前面其中一个小，则更新前面的最小值;

最后是代码

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>

#define N 63000

using namespace std;

int n, p, q;
int prince[ N ], princess[ N ];
//储存prince里值的indx，储存新建的要求LIS的序列，储存长度为len时的最末位数字
int Hash[ N ], lis[ N ], mn[ N ];

int main () {
        int t;
        scanf ( "%d", &t );
        for ( int T = 1; T <= t; T++ ) {
                scanf ( "%d%d%d", &n, &p, &q );

                memset ( Hash, 0, sizeof ( Hash ) );
                memset ( mn, 0, sizeof ( mn ) );

                //将prince的indx储存起来
                for ( int i = 1; i <= p + 1; i++ ) {
                        scanf ( "%d", &prince[ i ] );
                        Hash[ prince[ i ] ] = i;
                }

                int k = 0; // lis表的末尾
                //建立新的搜索序列
                for ( int i = 1; i <= q + 1; i++ ) {
                        scanf ( "%d", &princess[ i ] );
                        if ( Hash[ princess[ i ] ] )
                                lis[ ++k ] = Hash[ princess[ i ] ];
                }

                // O( n*logn )时间的LIS
                int len = 0;
                for ( int i = 1; i <= k; i++ ) {
                        if ( lis[ i ] > mn[ len ] )
                                mn[ ++len ] = lis[ i ];
                        else {
                                int pos = lower_bound ( mn, mn + len, lis[ i ] ) - mn;
                                mn[ pos ] = lis[ i ];
                        }
                }

                printf ( "Case %d: %d\n", T, len );
        }
        return 0;
}