P5397 [Ynoi2018] 天降之物 题解

蒟蒻做的第一道黑色的 $\text{Ynoi}$，写一篇题解纪念一下。

题意#

第四分块。

你需要实现 $m$ 个操作，操作有两种：

1. 把序列中所有值为 $x$ 的数的值变成 $y$。
2. 找出一个位置 $i$ 满足 $a_i=x$，找出一个位置 $j$ 满足 $a_j=y$，使得 $|i-j|$ 最小，并输出 $|i-j|$。

思路#

考虑如何写一个暴力。

用一个 $\text{vector}$ 把所有位置记录下来，然后每次查询用类似归并的写法暴力查询。

我们发现，这个东西可以用根号分治进行优化。

我们对每一个数的出现次数进行根号分治。

大体思路是对于出现次数大于阀值的预处理答案，查询时直接查。

对于出现次数小于阀值的直接暴力归并。

修改

首先有一个小的 $\text{trick}$，就是我们发现 $x$ 和 $y$ 其实是等价的，所以我们可以直接交换他们。

考虑让 $si{z}_x<si{z}_y$。

1. 若两个都大于阀值。

我们直接 $O(n)$ 暴力合并，由于每一次合并都会减少一个出现次数大于阀值的数，所以时间复杂度为 $O(n\sqrt{n})$

2. 若一个大于阀值，一个小于阀值。

我们考虑对每一个大于阀值的维护一个附加集合。

我们将小于阀值的加入到附加集合中，在这里，再次考虑根号分治。

如果附加集合的大小小于阀值，那么，此部分复杂度为 $O(m\sqrt{n})$。

如果附加集合的大小大于阀值，我们就全部暴力 $O(n)$ 统计答案，这里最多会暴力重构 $O(\sqrt{n})$ 次。

所以，此部分复杂度为 $O(m\sqrt{n})$。

3. 若两个都小于阀值

我们将两个集合合并，在这里，如第二点一样考虑根号分治。

如果集合的大小小于阀值，那么，此部分复杂度为 $O(m\sqrt{n})$。

如果集合的大小大于阀值，我们就全部暴力 $O(n)$ 统计答案，这里最多会暴力重构 $O(\sqrt{n})$ 次。

所以，此部分复杂度为 $O(m\sqrt{n})$。

查询

查询比上面的修改有简单多了，毕竟答案什么都预处理完了。

1. 若两个都大于阀值。

则查询预处理的答案，并且将两个附加集合进行归并计算，时间复杂度 $O(m\sqrt{n})$。

2. 若一个大于阀值，一个小于阀值。

同样查询预处理的答案，并且将附加集合和集合进行归并计算，时间复杂度 $O(m\sqrt{n})$。

3. 若两个都小于阀值

直接归并计算即可，时间复杂度 $O(m\sqrt{n})$。

由于 $m,n$ 同阶，所以综上，时间复杂度为 $O(n\sqrt{n})$

代码实测阀值取 $500$ 跑得最快。

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;
const int base = 320;

int n , m , top , len , lastans , a[N] , stk[N] , siz[N] , rel[N] , sum[base][N];

vector<int> f[N];

inline int read()
{
    int asd = 0 , qwe = 1; char zxc;
    while(!isdigit(zxc = getchar())) if(zxc == '-') qwe = -1;
    while(isdigit(zxc)) asd = asd * 10 + zxc - '0' , zxc = getchar();
    return asd * qwe;
}

inline void cl(vector<int> &now)
{
    vector<int> ne;
    now.swap(ne);
}

inline int calc(vector<int> x , vector<int> y)
{
    int len1 = x.size() , len2 = y.size() , ans = 100010;
    for(int i = 0 , j = 0;i < len1;i++)
    {
        if(j < len2) ans = min(ans , abs(y[j] - x[i]));
        while(j < len2 && y[j] < x[i]) ans = min(ans , x[i] - y[j++]);
        if(j < len2) ans = min(ans , abs(y[j] - x[i]));
    }
    return ans;
}

inline void solve(vector<int> &x , vector<int> &y)
{
    vector<int> ne;
    int i , j , len1 = x.size() , len2 = y.size() , ans = 100010;
    for(i = 0 , j = 0;i < len1;i++)
    {
        while(j < len2 && y[j] < x[i]) ne.push_back(y[j++]);
        ne.push_back(x[i]);
    }
    while(j < len2) ne.push_back(y[j++]);
    y = ne , cl(x);
}

inline void update(int r , int id = 0)
{
    stk[r] = stk[r] ? stk[r] : ++top; int x = stk[r];
    memset(sum[x] , 0x3f , sizeof sum[x]);
    for(int i = 1 , j = N;i <= n;i++)
        if(a[i] == r) j = 0; else sum[x][a[i]] = min(sum[x][a[i]] , ++j);
    for(int i = n , j = N;i >= 1;i--)
        if(a[i] == r) j = 0; else sum[x][a[i]] = min(sum[x][a[i]] , ++j);
    cl(f[r]);
}

int main()
{
    n = read() , m = read() , memset(sum , 0x3f , sizeof sum) , len = 500;
    for(int i = 1;i <= n;i++) a[i] = read() , rel[i] = i;
    for(int i = 1;i <= n;i++) f[a[i]].push_back(i) , siz[a[i]]++;
    for(int i = 1;i <= n;i++) if(f[i].size() > len) update(i);
    
    for(int i = 1;i <= m;i++)
    {
        int opt = read() , x = read() ^ lastans , y = read() ^ lastans;
        if(opt == 1)
        {
            int l = rel[x] , r = rel[y];
            if(siz[l] == 0 || l == r) continue;
            if(siz[l] > siz[r]) rel[y] = l , swap(l , r) , rel[x] = n + 1;
            else rel[x] = n + 1; if(l > n || r > n) continue;
            
            if(siz[r] <= len)
            {
                if(siz[l] + siz[r] <= len)
                {
                    for(int j : f[l]) a[j] = r;
                    for(int j = 1;j <= top;j++) sum[j][r] = min(sum[j][r] , sum[j][l]);
                    solve(f[l] , f[r]);
                }
                else
                {
                    for(int i = 1;i <= n;i++) if(a[i] == l) a[i] = r;
                    update(r);
                }
            }
            else if(siz[l] <= len)
            {
                if(siz[l] + f[r].size() <= len)
                {
                    for(int j : f[l]) a[j] = r;
                    for(int j = 1;j <= top;j++) sum[j][r] = min(sum[j][r] , sum[j][l]);
                    solve(f[l] , f[r]);
                }
                else
                {
                    for(int i = 1;i <= n;i++) if(a[i] == l) a[i] = r;
                    update(r);
                }
            }
            else
            {
                for(int i = 1;i <= n;i++) if(a[i] == l) a[i] = r;
                update(r);
            }

            cl(f[l]) , siz[r] += siz[l] , siz[l] = 0;
        }
        else
        {
            int l = rel[x] , r = rel[y];
            if(!siz[l] || !siz[r]) lastans = -1;
            else if(l == r) lastans = 0;
            else
            {
                if(siz[l] > siz[r]) swap(l , r);
                if(siz[r] <= len) lastans = calc(f[l] , f[r]);
                else if(siz[l] <= len) lastans = min(sum[stk[r]][l] , calc(f[l] , f[r]));
                else lastans = min({sum[stk[r]][l] , sum[stk[l]][r] , calc(f[l] , f[r])});
            }
            if(lastans == -1) puts("Ikaros") , lastans = 0;
            else printf("%d\n" , lastans);
        }
    }
    return 0;
}