牛客IOI周赛23-普及组 D题 - LIS变形

很容易看出，将原数组从小到大排序，就可以按照LIS的DP套路来解这道题了。但是，一般情况下LIS是O(n^2)，用在这道题会被卡。LIS可以优化做到O(nlogn)，参照LIS的优化也是有可能解出这道题的，但比赛时一直想不出来。看了他人的题解后才明白的。

首先是dp状态的定义：

dp[i]: 表示以数字i为结尾的最长好序列的长度。注意，这里是指以i为结尾，而不是以b[i]为结尾(b[0 ~ n - 1]为原数组)。

转移方程：

dp[i] = max(dp[j]) + 1 for j < i && gcd(b[j], b[i]) > 1.

朴素的做法就是O(n^2)。但是，我们可以仿照LIS优化的方式，定义一个len数组：

len[i]: 表示以 因数中含有i的数 为结尾的 最长好序列的 末尾的数。

说得有点绕 (尽力了，语文水平不好) 。然后我们每次就对b[i]进行分解质因数，假设b[i]的质因数为f[0 ~ m - 1]那么状态转移方程就变成了：

dp[i] = max(dp[ len[fj] ]) + 1 for j < m.

然后还要更新len:

len[f[j]] = i for j < m.

理解好len数组的意义，再结合下面的样例解释，应该可以get到的。

n = 5
     0    1    2    3    4
b    4    6    3    2    9
初始化dp, len中的元素为0, 这里暂时先假设dp, len的长度都为10.
对b进行排序, 得到:
     0    1    2    3    4
b    2    3    4    6    9

开始更新dp和len.
1. 当i = 0时:
     0    1    2    3    4    5    6    7    8    9
dp   0    0    0    0    0    0    0    0    0    0

     0    1    2    3    4    5    6    7    8    9
len  0    0    0    0    0    0    0    0    0    0
b[0] = 2, 分解2的质因数得到: f[0] = 2
dp[b[0]] (dp[2]) = max(dp[ len[f[0]] ]) + 1 = dp[0] + 1 = 1
len[f[0]] = len[2] = b[0] = 2.

2. 当i = 1时:
     0    1    2    3    4    5    6    7    8    9
dp   0    0    1    0    0    0    0    0    0    0

     0    1    2    3    4    5    6    7    8    9
len  0    0    2    0    0    0    0    0    0    0
b[1] = 3, 分解3的质因数得到: f[0] = 3
dp[b[1]] (dp[3]) = max(dp[ len[f[0]] ]) + 1 = dp[0] + 1 = 1
len[f[0]] = len[3] = b[1] = 3

3. 当i = 2时:
     0    1    2    3    4    5    6    7    8    9
dp   0    0    1    1    0    0    0    0    0    0

     0    1    2    3    4    5    6    7    8    9
len  0    0    2    3    0    0    0    0    0    0
b[2] = 4, 分解4的质因数得到: f[0] = 2
dp[b[2]] (dp[4]) = max(dp[ len[f[0]] ]) + 1 = dp[2] + 1 = 2
len[f[0]] = len[2] = b[2] = 4

3. 当i = 3时:
     0    1    2    3    4    5    6    7    8    9
dp   0    0    1    1    2    0    0    0    0    0

     0    1    2    3    4    5    6    7    8    9
len  0    0    4    3    0    0    0    0    0    0
b[3] = 6, 分解4的质因数得到: f[0] = 2, f[1] = 3
dp[b[3]] (dp[6]) = max(dp[ len[f[0], f[1]] ]) + 1 = dp[4] + 1 = 3
len[f[0]] = len[2] = b[3] = 6
len[f[1]] = len[3] = b[3] = 6

4. 当i = 4时:
     0    1    2    3    4    5    6    7    8    9
dp   0    0    1    1    2    0    3    0    0    0

     0    1    2    3    4    5    6    7    8    9
len  0    0    6    6    0    0    0    0    0    0
b[4] = 9, 分解4的质因数得到: f[0] = 3
dp[b[4]] (dp[9]) = max(dp[ len[f[0]] ]) + 1 = dp[3] + 1 = 4
len[f[0]] = len[3] = b[4] = 9

于是最终得到最长的好序列长度就为max(dp[0 ~ n - 1]) = 4.

codes:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn = 1e5 + 5;
int b[maxn], dp[maxn], len[maxn];

int calculatePrimeFactors(int n, int *primeFactors){
	int cnt = 0, i = 2;
	for(int i = 2; i * i <= n; ++i){
		if(n % i == 0){
			while(n % i == 0)
				n /= i;
			primeFactors[cnt++] = i;
		}
	}
	if(n != 1)
		primeFactors[cnt++] = n;
	return cnt;
}

int main(){
	int T, primeFactors[105];
	calculatePrimeFactors(98756, primeFactors);
	scanf("%d", &T);
	while(T--){
		int n;
		scanf("%d", &n);
		for(int i = 0; i < n; ++i)
			scanf("%d", &b[i]);
		
		sort(b, b + n);
		memset(dp, 0, sizeof(dp));
		memset(len, 0, sizeof(len));
		for(int i = 0; i < n; ++i){
			int primeCount = calculatePrimeFactors(b[i], primeFactors);
			int temp = 0;
			for(int j = 0; j < primeCount; ++j){
				if(dp[len[primeFactors[j]]] > temp)
					temp = dp[len[primeFactors[j]]];
				len[primeFactors[j]] = b[i];
			}
			dp[b[i]] = temp + 1;
		}
		int ans = 0;
		for(int i = 0; i < maxn; ++i)
			ans = max(ans, dp[i]);
		printf("%d\n", ans);
	}
	return 0;
}