2017-5-14 湘潭市赛 Longest Common Subsequence 想法题

Longest Common Subsequence
Accepted : 7           Submit : 66
Time Limit : 3000 MS           Memory Limit : 65536 KB

Longest Common Subsequence

Bobo has a sequence A=(a1,a2,…,an) of length n. He would like to know f(0),f(1),f(2) and f(3) where f(k) denotes the number of integer sequences X=(x1,x2,x3) where:

1≤x1,x2,x3≤m;
The length of longest common subsequence of A and X is exactly k.

Note:

u is a subsequence of v if and only if u can be obtained by removing some of the entries from v (possibly none).
u is common subsequence of v and w if and only if u is subsequence of v and w.

Input

The input contains zero or more test cases and is terminated by end-of-file. For each case,

The first line contains two integers n,m. The second line contains n integers a1,a2,…,an.

1≤n≤200
1≤m,a1,a2,…,an≤106
The number of tests cases does not exceed 10.

Output

For each case, output four integers which denote f(0),f(1),f(2),f(3).
Sample Input

3 3
1 2 2
5 3
1 2 3 2 1

Sample Output

1 14 11 1
0 1 17 9

Note

For the second sample, X=(3,3,3) is the only sequence that the length of longest common subsequence of A and X is 1. Thus, f(1)=1.

Source
XTU OnlineJudge

/**
题目：Longest Common Subsequence
链接：http://202.197.224.59/OnlineJudge2/index.php/Problem/read/id/1265
题意：给定序列A，含n个数。和一个数m；
有一个X序列{x1,x2,x3}，x1,x2,x3来自[1,m]区间内的数。

设：f(k)表示两个序列的最长公共子序列为k；

求序列X和A满足f(0),f(1),f(2),f(3)的X各有多少种。

思路：f(0)易求。计算出n个数中在m范围内的不同数的数量为cnt，然后计算(m-cnt)^3即可。

对n个数中<=m的数，离散化。

要求f(1),f(2),f(3);
f(3)的X序列内的数一定是n个数中获得。
f(2)的X序列内的数有两种来源，一种是三个数从n个数中获得，然后Longest Common Subsequence为2；
另一种是其中两个是n个数中获得，然后Longest Common Subsequence为2，另外一个是<=m的不包含n个数的数中获得。
f(1)的X序列内的数有三种来源，一种是3个数从n个数中获得，然后Longest Common Subsequence为1；
另一种是两个数从n个数中获得，然后Longest Common Subsequence为1；另外一个是是<=m的不包含n个数的数中获得。
另一种是其中一个是n个数中获得，然后Longest Common Subsequence为1，另外二个是<=m的不包含n个数的数中获得。

设：cnt表示n个数中<=m的数。kind表示n个数中<=m的不同数的种类。m-kind表示不包含n个数的数的种数。

枚举x1,x2,x3全是n个数组成的X序列，所有xi都枚举所有的n个数。

这些序列包含f(3),f(2)第一种来源，f(1)第一种来源的情况数。计算方法：一种是常规的Longest Common Subsequence 的dp求法，但是总时间复杂度为O(N^4);
更好的做法是：预处理next[i][j]表示i这个位置右边第一次出现j这个数的位置。那么可以O(1)判断X序列的Longest Common Subsequence为k。把它们更新到f(k)中。
flag[a[i]][a[j]][a[k]]表示这个序列可以匹配的最大LCS；取最值，最后遍历计算即可。

剩下要求f(2)的第二种来源,f(1)的第二种来源和第三种来源。
f(2)第二种来源：三种可能(x1,x2),(x2,x3),(x1,x3)位置，Longest Common Subsequence为2，另一个位置为m-kind中取。 其实情况数是一样的。f(2) += 3*Q(cnt)*(m-kind);
Q(cnt)表示cnt个数中找到与A序列的Longest Common Subsequence为2的序列数量。暴力枚举两个位置，同上面说的方法。

f(1)第二种来源：三种可能(x1,x2),(x2,x3),(x1,x3)位置,但是Longest Common Subsequence为1；另外一个位置从m-kind中取。 f(1) += 3*P(cnt)*(m-kind);
f(1)第三种来源：三种可能x1,x2,x3位置相同，另外两个位置为m-kind中取。f(1) += 3*kind*(m-kind)*(m-kind);

思考：为什么要用next[i][j]表示i这个位置右边第一次出现j这个数的位置。而不是直接next[i][j]表示j这个数是否在i的右边。
假设： 2 2
那么枚举出来2 2 2. 如果用后者所述定义，那么答案就是3了。实际上只能是2.
*/

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> P;
const int maxn = 1e5+100;
int flag[202][202][202];
int sign[202][202];
int mark[1000005];
int n, m;
int cnt , kind;
LL f[4];
int a[202], z;
int Next[202][202];
set<int> se;
void NextInit()
{
for(int i = 0; i < z; i++){
for(int j = i+1; j < z; j++){
if(Next[i][a[j]]==-1){
Next[i][a[j]] = j;
}
}
}
}
void lisan()
{
int cnt = 1;
set<int>::iterator it;
for(it = se.begin(); it!=se.end(); it++){
mark[*it] = cnt;
cnt++;
}
for(int i = 0; i < z; i++){
a[i] = mark[a[i]];
}
}
void init()
{
memset(f, 0, sizeof f);
memset(Next, -1, sizeof Next);
memset(flag, 0, sizeof flag);
memset(sign, 0, sizeof sign);
se.clear();
}
int cal(int i,int j,int k)
{
if(Next[i][a[j]]==j&&Next[j][a[k]]==k) return 3;
if(Next[i][a[j]]==j) return 2;
if(Next[j][a[k]]==k) return 2;
if(Next[i][a[k]]==k) return 2;
return 1;
}
void solve()
{
kind = se.size();
cnt = z;
LL temp = m-kind;
f[0] = 1LL*temp*temp*temp;
///枚举三层循环所有序列。
for(int i = 0; i < z; i++){
for(int j = 0; j < z; j++){
for(int k = 0; k < z; k++){
int len = cal(i,j,k);
flag[a[i]][a[j]][a[k]] = max(flag[a[i]][a[j]][a[k]],len);
}
}
}

se.clear();///清空原先没有离散的数据。
for(int i = 0; i < z; i++){
se.insert(a[i]);
}
set<int>::iterator it, it1, it2;
for(it = se.begin(); it!=se.end(); it++){
for(it1 = se.begin(); it1!=se.end(); it1++){
for(it2 = se.begin(); it2!=se.end(); it2++){
f[flag[*it][*it1][*it2]]++;
}
}

}

///枚举两层循环.
int cnt2, cnt1;
for(int i = 0; i < z; i++){
for(int j = 0; j < z; j++){
int len;
if(Next[i][a[j]]==j) len = 2;
else len = 1;
sign[a[i]][a[j]]= max(sign[a[i]][a[j]],len);
}
}
cnt1 = cnt2 = 0;
for(it = se.begin(); it!=se.end(); it++){
for(it1 = se.begin(); it1!=se.end(); it1++){
if(sign[*it][*it1]==2){
cnt2++;
}else cnt1++;
}
}

f[2] += 1LL*3*cnt2*(m-kind);
f[1] += 1LL*3*cnt1*(m-kind);
///f(1)第三种来源;
f[1] += 1LL*3*kind*(m-kind)*(m-kind);
}
int main()
{
while(scanf("%d%d",&n,&m)==2)
{
z = 0;
for(int i = 0; i < n; i++) {
scanf("%d",&a[z]);
if(a[z]<=m) z++;
}
init();
for(int i = 0; i < z; i++){
se.insert(a[i]);
}
lisan();
NextInit();
solve();
printf("%I64d %I64d %I64d %I64d\n",f[0], f[1], f[2], f[3]);
}
return 0;
}