CF 1654E - Arithmetic Operations（GOOD-2300）

思路

• 看到数据范围，应该想到$n\sqrt{n}$的算法。
• 多变换出一些等价形式
• 首先，逆向过程，考虑没被修改的元素个数，由于一定大于等于2，因此数列最终公差一定产生于两个元素之间。
• 考虑枚举所有正数公差，当$d>=0$时（d<0只需要将数组反转按大于0求解）
• 对于每个给定的d，可以$O(n)$求解数组中等差数列最长长度。对于等差数列的$a_i,a_j,i<j$，一定有
  $$a_i-id=a_j-jd$$
  因此维护键值为$a_i-id,\forall i$的桶，每遇到一个对应键值就将桶中的值加上1.最终桶中数量最大值就是答案
• 但如果枚举所有d，由于$d<=1e5$最终$O(nd)$会超时，有无其他方法？当d较大时，考察数组中最终没变化的两个元素，其下标差距应该较小，因为d很大时，由于等式两侧的$id$和$jd$占据主导地位，如果下标差距较大，那么等式不等的概率就很大！
• 考虑时间复杂度$n\sqrt{n}$的形式，设m为数组中元素最大值，这也是$d$的上界。如果$d>\sqrt{m}$，考察最终没被改变的$a_i,a_j,i<j$，$j-i$至多为$\sqrt{m}$
• 这意味着当$d>\sqrt{m}$时，对于每个元素,只需最多向后查看$\sqrt{m}$个元素，使用DP的思路确定当前公差下最多的个数。

DAG抽象

• 使用图更为直观
• 结点表示每个输入的数字，$a_i$与$a_j$之间有边相连当且仅当$i<j$,边权重为$\frac{a_i-a_j}{i-j}$，为整数才有边
• 等价于找一个最长相等边权的路径
• 利用边权的取值（即公差）划分解空间，不同边权范围采用不同方式。在固定d（或d的范围）的前提下可以滤除图中的一些边，且d越大，图中边数量越少，特别的，当$d>\sqrt{m}$时从$a_i$至多可以发出$\sqrt{m}$条边指向后继，因此图中边数$n\sqrt{m}$故可以采用DP。反之，d较小，还要注意d的计算即$\frac{a_i-a_j}{i-j}=d$，可对于每个d利用哈希表求解。

代码

#include <bits/stdc++.h>
using namespace std;
 
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
 
// struct splitmix64 {
//     size_t operator()(size_t x) const {
//         static const size_t fixed = chrono::steady_clock::now().time_since_epoch().count();
//         x += 0x9e3779b97f4a7c15 + fixed;
//         x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
//         x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
//         return x ^ (x >> 31);
//     }
// };
 
// const int N = 1e5+5, S = 300;
// int n, a[N];
 
// // for small d case: b[i] = number of elements in bucket i
// int b[N*S];
 
// // for large d case: dp[i][j] = maximum length of a path ending
// // at index i, such that all edges in the path have label j
// unordered_map<int, int, splitmix64> dp[N];
 
// // solve under the assumption that d >= 0
// int solve() {
 
//     int ans = 0;
 
//     // d < S
//     for (int d = 0; d < S; d++) {
//         for (int i = 0; i < n; i++)
//             ans = max(ans, ++b[a[i]+(n-i)*d]);
//         for (int i = 0; i < n; i++)
//             b[a[i]+(n-i)*d] = 0;
//     }
 
//     // S <= d < N
//     for (int i = 0; i < n; i++) {
//         for (int j = max(0, i-N/S); j < i; j++) {
//             int d = (a[i]-a[j])/(i-j);
//             int r = (a[i]-a[j])%(i-j);
//             if (r == 0 && d >= S) {
//                 dp[i][d] = max(dp[i][d], dp[j][d]+1);
//                 ans = max(ans, dp[i][d]+1);
//             }
//         }
//     }
 
//     for (int i = 0; i < n; i++)
//         dp[i].clear();
 
//     return ans;
// }
 
// int main() {
//     ios_base::sync_with_stdio(0); cin.tie(0);
//     cin >> n;
//     for (int i = 0; i < n; i++)
//         cin >> a[i];
//     int ans = solve();
//     reverse(a, a+n);
//     ans = max(ans, solve());
//     cout << n-ans << "\n";
// }



#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<algorithm>
#include<map>
#include<queue>
#include <chrono>
#include<math.h>
#include<unordered_map>
using namespace std;
const int N = 1e5+5;
const int S =  500;
int m[N*S];

struct splitmix64 {
    size_t operator()(size_t x) const {
        static const size_t fixed = chrono::steady_clock::now().time_since_epoch().count();
        x += 0x9e3779b97f4a7c15 + fixed;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
};


int solve(int a[],int n,int m_s)
{
    int remain = 1;
    
    for(int d = 0;d<=m_s;d++)
    {
        unordered_map<int,int,splitmix64> b;
        for(int i = 0;i<n;i++)  //公差为d的值
        {
            remain = max(++m[n*d + a[i]-i*d],remain);
        }
        for(int i = 0;i<n;i++) m[n*d + a[i]-i*d] = 0;
    }
    unordered_map<int,int,splitmix64> b[n]; m_s++;
    for(int i = n-2;i>=0;i--)
    {
        for(int j = i+1;j<n&&(j-i)<=m_s;j++)
        {
            int d = (a[j]-a[i])/(j-i);
            if((a[j]-a[i])%(j-i)==0 && d>=m_s)
            {
                b[i][d] = max(b[j][d]+1,b[i][d]);
                remain = max(remain,b[i][d]+1);
            }
        }
    }
    return remain;
}


int main()
{
    int n; cin >> n;
    int a[n];
    int maximal = -1;
    for(int i = 0;i<n;i++) {cin >> a[i];maximal = max(maximal,a[i]);}
    // d <= sqrt(maximal)，使用
    int m_s = (int)sqrt((double)maximal);
    int ans_1 = solve(a,n,m_s);
    reverse(a,a+n);
    ans_1 = max(ans_1,solve(a,n,m_s));
    cout << n - ans_1 << endl;
    system("pause");
    return 0;
}