Harbour.Space Scholarship Contest 2021-2022 (open for everyone, rated, Div. 1 + Div. 2) E.F-CSDN博客

本文探讨了两个关于序列操作的算法问题。第一个问题是通过有限次操作将序列b转换为序列a右移k位后的序列，关键在于找到满足条件的序列偏移量和最小操作数。第二个问题涉及数组的模运算求和，通过分类讨论和巧妙的数学变换求解。这两个问题都需要深入理解序列操作和数学变换技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Harbour.Space Scholarship Contest 2021-2022 (open for everyone, rated, Div. 1 + Div. 2)

E. Permutation Shift

题目大意

对于一个长度为n从1到n的序列a，我们可以将它向右移动k位，例：[1,2,3,4,5]右移2位后得到[4,5,1,2,3]
给出一个操作，选择i，j，交换序列中a[i]和a[j]的值。
现在给出一个序列b，问能否通过最多m次操作后，将b变成序列a移动k位后的序列

题目思路

根据偏移可以发现偏移后序列p 中 $p i = (i - k) m o d n$
我们考虑将x序列转换成y序列的最小操作数
我们对比x序列和y序列，当 $y [i]! = x [i]$ 说明x[i]这个值要移动，并且y[i]也不再原位置，它要移回y[i]。
我们用并查集维护这个关系，我们最终的操作数就是，并查集中的数字个数-并查集中的环的个数
然后我们考虑怎么找k，题目要求我们最多m次操作恢复序列，那么b数组中至少有n-m*2个位置是满足题目条件的。又因为题目规定m<=n/3,那么满足条件的位置至少要有n/3个。
我们可以根据上面的偏移式子退出，所有点的偏移量x，并记录有多少个数的值等于x，如果这个数小于n/3，说明它一定不满足。相反的，当大于等于n/3时，我们再去计算他的操作数，如果操作数小于等于m的话，他就是我们的答案之一。

ac代码

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#define pi 3.1415926535898
#define ll long long
#define lson rt<<1
#define rson rt<<1|1
#define eps 1e-6
#define ms(a,b) memset(a,b,sizeof(a))
#define legal(a,b) a&b
#define print1 printf("111\n")
#define pb(x) push_back(x)
#define pair4 pair<pair<int,int>,pair<int,int> >
#define fi first
#define se second
using namespace std;
const int maxn = 3e5+10;
const int inf = 1e9+10;
const ll llinf =1e18+10;
const ll mod = 1e9+7;

int n,m;
int cnt[maxn];
int a[maxn],b[maxn];
int fa[maxn];

int findx(int x)
{
    return x==fa[x]?x:findx(fa[x]);
}

int check(int x)
{
    for(int i=1;i<=n;i++)
    {
        fa[i]=i;
        b[i]=i-x;
        if(b[i]<1)b[i]+=n;
    }

    int tot=0,sum=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]!=b[i])
        {
            int r1=findx(a[i]);
            int r2=findx(b[i]);
            if(r1==r2)tot++;
            else
            {
                fa[r1]=r2;
            }
            sum++;
        }
    }
    return sum-tot;
}

int main()
{
    int _;
    scanf("%d",&_);

    while(_--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            cnt[(i-a[i]+n)%n]++;
        }
        queue<int>ans;
        for(int i=0;i<n;i++)
        {
            if(cnt[i]>=n/3)
            {
                if(check(i)<=m)
                {
                    ans.push(i);
                }
                //printf("i %d %d\n",i,check(i));
            }

        }
        printf("%d ",ans.size());
        while(!ans.empty())
        {
            int x=ans.front();
            printf("%d ",x);
            ans.pop();
        }
        printf("\n");
    }
}

F. Pairwise Modulo

题目大意

给出一个长度为n的数组a，令 $Pk=∑1<=i,j<=kaimodaj\ P_k = \sum_{1<=i,j<=k} a_i mod a_j$
请输出 $p_1,p_2,……,p_n$

题目思路

题目要求的我们不好直接求，我们考虑将原式分类。
我们先分成两类： $Sk=∑1<=i,j<=k，i<jaimodaj\ S_k = \sum_{1<=i,j<=k，i<j} a_i mod a_j$ 和 $Tk=∑1<=i,j<=k，i>jaimodaj\ T_k = \sum_{1<=i,j<=k，i>j} a_i mod a_j$
我们很容易发现 $Sk=Sk−1+∑j<kakmodaj\ S_k = S_{k - 1}+\sum_{j<k} a_k mod a_j$ 和 $Tk=Tk−1+∑j<kajmodak\ T_k = T_{k - 1}+\sum_{j<k} a_j mod a_k$
那么我们只需要考虑当前位置的影响就行了，并且记录一个前缀，最后相加就是答案。
我们先分析怎么求 $∑j<kakmodaj\sum_{j<k} a_k mod a_j$
（1）当 $a_k <a_j$ 时， $a_k mod a_j$ 的答案就是 $a_k$ 本身，那么我们求出大于 $a_k$ 的值的个数cnt，这部分的答案就会使cnt* $a_k$ 。
（2）当 $a_k >a_j$ 时，我们无法像上一种情况那样直接的出答案。我们先将 $a_kmoda_j$ 转换成 $ak−aj∗⌊akaj⌋a_k -a_j* ⌊ \frac{a_k}{a_j} ⌋$ 的形式，我们发现当我们知道 $a_k$ 是 $a_j$ 的多少倍，我们就能求出答案了。我的处理方式是在加入 $a_j$ 的时候，将 $t*a_j$ 全部加上一个 $a_j$ ，最后我们求1到k的sum时，就能直接求出得出 $aj∗⌊akaj⌋a_j* ⌊ \frac{a_k}{a_j} ⌋$ 的值了，而我们每个 $a_j$ 都这样更新，求1到k的sum时得到的值就变成了 $∑j<kaj∗⌊akaj⌋\sum_{j<k} a_j* ⌊ \frac{a_k}{a_j}⌋$ ，我们只需要在求出满足条件的 $a_j$ 的个数cnt，最后答案就是cnt* $a_k$ -（1到k的sum）。
然后我们分析怎么求 $∑j<kajmodak\sum_{j<k} a_j mod a_k$
（3）当 $a_k >a_j$ 时， $a_j mod a_k$ 的答案就是 $a_j$ 本身，所以我们只要求的所有小于 $a_k$ 的值的总和，就是这部分的答案了。
（4）当 $a_k <a_j$ 时，我们按照上面的分析方法也将 $a_jmoda_k$ 转换成 $aj−ak∗⌊ajak⌋a_j -a_k* ⌊ \frac{a_j}{a_k} ⌋$ 的形式。这是我们需要知道的是 $a_j$ 是 $a_k$ 的多少倍。我们可以考虑枚举满足 $t*a_k,(t+1)*a_k-1),t>0$ 的所有区间。对于 $t*a_k,(t+1)*a_k-1),t>0$ 这样的一个区间中的数 $a_j$ 来说， $\frac{a_j}{a_k} ⌋$ 的值就等于 $t$ ，那么我们求出这个区间含有的数的个数cnt和数值的总和sum，最后这个区间的贡献就是 $sum-cnt*t*a_k$ 。算出每个区间的贡献后求个和就是这部分的值了。
我们可以通过线段树或者树状数组来求解。题解用的是树状数组，但是我不会，所以用的是线段树求解

ac代码

ll ta[maxn<<4];
ll tsum[maxn<<4];
ll tb[maxn<<4];
ll sumquery;

ll querybig(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
    {
        sumquery+=tsum[rt];
        return ta[rt];
    }
    ll sum=0;
    int mid=(l+r)>>1;
    if(mid>=L)
        sum+=querybig(lson,l,mid,L,R);
    if(R>mid)
        sum+=querybig(rson,mid+1,r,L,R);
    return sum;
}

void updatebig(int rt,int l,int r,int v)
{
    if(l==r)
    {
        tsum[rt]=v;
        ta[rt]=1;
        return;
    }
    int mid=(l+r)>>1;
    if(mid>=v)
        updatebig(lson,l,mid,v);
    else
        updatebig(rson,mid+1,r,v);
    ta[rt]=ta[lson]+ta[rson];
    tsum[rt]=tsum[lson]+tsum[rson];
}

void updatesmall(int rt,int l,int r,int v,int p)
{
    if(l==r)
    {
        tb[rt]+=(ll)p;
        return;
    }
    int mid=(l+r)>>1;
    if(mid>=v)
        updatesmall(lson,l,mid,v,p);
    else
        updatesmall(rson,mid+1,r,v,p);
    tb[rt]=tb[lson]+tb[rson];
}

void build(int rt,int l,int r)
{
    ta[rt]=tb[rt]=tsum[rt]=0;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)>>1;
    build(lson,l,mid);
    build(rson,mid+1,r);
}

ll querysmall(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
    {
        return tb[rt];
    }
    int mid=(l+r)>>1;
    ll ans=0;
    if(mid>=L)
        ans+=querysmall(lson,l,mid,L,R);
    if(mid<R)
        ans+=querysmall(rson,mid+1,r,L,R);
    return ans;
}

int main()
{
    int n;
    scanf("%d",&n);
    ll sum=0;
    ll ans=0;
    build(1,1,n);
    for(int j=1;j<=n;j++)
    {
        int x;
        scanf("%d",&x);
        //ans+=sum;

        sumquery=0;
        ll tem=querybig(1,1,maxn,x+1,maxn);// ak mod aj  aj>ak
        ans+=x*tem;

        sumquery=0;
        tem=querybig(1,1,maxn,1,x);// aj mod ak  aj<ak
        ans+=sumquery;

        sumquery=0;
        ans+=x*querybig(1,1,maxn,1,x);// ak mod aj  aj<ak
        ans-=querysmall(1,1,maxn,1,x);



        for(int i=x;i<=maxn;i+=x)
        {
            sumquery=0;
            ll temx=i*querybig(1,1,maxn,i,min(maxn,i+x-1));//aj mod ak  aj>ak
            ans+=sumquery-temx;

            updatesmall(1,1,maxn,i,x);
        }
        printf("%lld ",ans);
        updatebig(1,1,maxn,x);

    }
    printf("\n");

}