NC218035 小L的数列

题目链接：小L的数列 (nowcoder.com)

 样例输入：

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

 样例输出：

4
4

题意：需要在a数组挑选数字组成一个最长上升子序列b，并且子序列还要满足相邻两个数的最大公约数 > 1，计算子序列b的长度。

思路1：会超时，可以获得80分，n比较小的时候可以试着用。套用最长上升子序列的板子，在判断条件中加上两者的最大公约数大于1.

代码1：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N], dp[N];
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int tt;  cin >> tt;
    while(tt--){
        cin >> n;
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i++)  cin >> a[i];
        sort(a + 1, a + n + 1);
        int ans = 0;
        for(int i = 1; i <= n; i++){
            dp[i] = 1;
            for(int j = 1; j < i; j++){
                if(__gcd(a[i], a[j]) > 1)  dp[i] = max(dp[i], dp[j] + 1);
            }
            ans = max(ans, dp[i]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

思路2：动态规划。gcd(bi​, bi + 1​) > 1说明在b数组中，相邻的两个数需要有相同的质因子，而且这仅限于相邻的两个数，b[i]和b[i - 2]是不用有相同的质因子，例如：2 6 9。

因此我们设置dp[i][j]表示a的前i位数，质因子为j时b数组长度的最大值。每次都枚举a[i]的质因子，并将这些质因子存起来，然后将依次dp[i][质因子]更新为所有dp[i - 1][质因子]的最大值 + 1，第一维可以被优化掉。

代码2：

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 5;
int a[N], dp[N], vis[N], pri[N], cnt;

void get_prime(){
    for(int i = 2; i <= N - 5; i++){
        if(!vis[i])  pri[cnt++] = i;
        for(int j = 0; j < cnt && i * pri[j] <= N - 5; j++){
            vis[i * pri[j]] = 1;
            if(i % pri[j] == 0)  break;
        }
    }
}

int32_t main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int tt;  cin >> tt;
    get_prime();
    while(tt--){
        memset(dp, 0, sizeof(dp));
        int n;  cin >> n;
        for(int i = 1; i <= n; i++)  cin >> a[i];
        sort(a + 1, a + 1 + n);
        vector<int> v;
        int ans = 0;
        for(int i = 1; i <= n; i++){
            int d = a[i], maxn = 0;
            for(int j = 0; j < cnt && pri[j] * pri[j] <= d; j++){
                if(d % pri[j] == 0){
                    v.push_back(pri[j]);
                    maxn = max(maxn, dp[pri[j]]);
                }
                while(d % pri[j] == 0)  d /= pri[j];
            }
            if(d > 1){
                v.push_back(d);
                maxn = max(maxn, dp[d]);
            }
            for(int j = 0; j < v.size(); j++){
                dp[v[j]] = maxn + 1;
            }
            ans = max(ans, maxn + 1);
            v.clear();
        }
        printf("%lld\n", ans);
    }
}