多校A层冲刺NOIP2024模拟赛09

多校A层冲刺NOIP2024模拟赛09

考试唐完了，T2、T4 都挂了 100 分，人麻了。

排列最小生成树

给定一个 $1,2,\dots ,n$ 的排列 $p_1,p_2,\dots ,p_n$。

构造一个 $n$ 个点的完全无向图，节点编号分别是 $1,2,\dots ,n$ 。

节点 i 和节点 j 之间的边边权为 $|pi-pj|\times |i-j|$，其中 $|x$ 表示 $x$ 的绝对值。

请问这个完全图的最小生成树的所有边的权值和是多少？

$n\le 5\times {10}^4$。

易发现边的长度都不大于 $n$，考虑记录一个点连向其他点的边中长度小于 $n$ 的边。

对于 $i$ 来说，这些点的满足以下之一：

• 距离在 $\sqrt{n}$ 以内，即 $|i-j|\le \sqrt{n}$。
• 大小在 $\sqrt{n}$，即 $|p_i-p_j|\le \sqrt{n}$。

把这些点枚举出来，桶排后使用 $Kruskal$ 求解。

瓶颈在 $Kruskal$ 的并查集，时间复杂度 $O(n\sqrt{n}\alpha )$。

当然由于 $Prim$ 的优先队列跑不满，所以说时间复杂度 $O(n\sqrt{n}\log n)$ $Prim$ 也可以通过本题。

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

#define ll long long
#define pii pair<int,int>
#define fi first
#define se second

const int maxn=5e4+5,maxB=255;

ll ans;

int n,B;
int p[maxn],pid[maxn],dis[maxn];

bool vis[maxn];

priority_queue<pii,vector<pii>,greater<pii>>que;

int tmp=1e9,id=0;
inline void check(int u)
{
    tmp=1e9,id=0;
    for(int i=1;i<=n;i++)
        if(i!=u)
        {
            if(1ll*tmp>1ll*abs(u-i)*abs(p[u]-p[i])) tmp=1ll*abs(u-i)*abs(p[u]-p[i]),id=i;
        }
}

int main()
{
    freopen("ex_pmst2.in","r",stdin);
    // freopen("pmst.in","r",stdin);
    freopen("pmst.out","w",stdout);
    check(1);
    scanf("%d",&n);
    B=sqrt(n);
    for(int i=1;i<=n;i++) scanf("%d",&p[i]),pid[p[i]]=i,dis[i]=n+1;
    dis[1]=0;que.push({0,1});
    int cnt=0;
    while(cnt<n)
    {
        int u=que.top().se;que.pop();
        if(vis[u]) continue;
        ans+=dis[u];vis[u]=true;cnt++;
        for(int j=max(u-B,1);j<=min(u+B,n);j++)
        {
            if(dis[j]>abs(u-j)*abs(p[u]-p[j]))
            {
                dis[j]=abs(u-j)*abs(p[u]-p[j]);
                que.push({dis[j],j});
            }
        }
        for(int j=max(p[u]-B,1);j<=min(p[u]+B,n);j++)
        {
            if(dis[pid[j]]>abs(u-pid[j])*abs(p[u]-j))
            {
                dis[pid[j]]=abs(u-pid[j])*abs(p[u]-j);
                que.push({dis[pid[j]],pid[j]});
            }
        }
    }
    printf("%lld",ans);
    // cerr<<clock()/1000;
}

卡牌游戏

形式化的，求：

$$\sum _{i=1}^n\sum _{k=0}^{m-1}[A_i>B_{i+k\times n\mathrm{mod}m}]$$

其中若 $i+k\times n\equiv 0\mathrm{mod}m$，则小于号右边为 $B_m$。

打表发现对于一个 $i$ 而言 $i+k\times n\mathrm{mod}m$ 会形成循环节，不同的循环节之间没有交集；循环节的长度等于 $gcd(n,m)$，或者说循环节一定完整；不同的 $i$ 循环节会重复。

8 12
1:
1 9 5 1 9 5 1 9 5 1 9 5 
2:
2 10 6 2 10 6 2 10 6 2 10 6 
3:
3 11 7 3 11 7 3 11 7 3 11 7 
4:
4 0 8 4 0 8 4 0 8 4 0 8 
5:
5 1 9 5 1 9 5 1 9 5 1 9 
6:
6 2 10 6 2 10 6 2 10 6 2 10 
7:
7 3 11 7 3 11 7 3 11 7 3 11 
8:
8 4 0 8 4 0 8 4 0 8 4 0

暴力跑出循环节，对于 $A$ 中的每一个元素，在循环节上查询比自己小的数的个数，然后乘循环次数即可。

对于剩下两个答案同理，是 easy 的。

然而场上没开 long long 导致溢出了（悲。

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

#define ll long long

const int maxn=2e5+5;

bool swp;

int col,n,m;
int a[maxn],b[maxn],tc[maxn],vis[maxn];

ll ans1,ans2,ans3;

vector<int>vec[maxn],vect[maxn];

struct treearray
{
    #define N 200000
    int ts[maxn];
    inline int lowbit(int x) {return x&(-x);}
    inline void updata(int x,int y) {for(;x<=N;x+=lowbit(x)) ts[x]+=y;}
    inline int getsum(int x) {int sum=0;for(;x;x-=lowbit(x)) sum+=ts[x];return sum;}
}T;

map<int,int>mp;

int main()
{
    // freopen("ex_cardgame2.in","r",stdin);
    freopen("cardgame.in","r",stdin);
    freopen("cardgame.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=m;i++) scanf("%d",&b[i]);
    if(n>m) swap(n,m),swap(a,b),swp=1;
    for(int i=1;i<=n;i++)
    {
        int flg=1;
        for(int k=0;k<=m;k++)
        {
            int v=(i+1ll*k*n)%m;
            if(v==0) v=m;
            if(vis[v]) {tc[i]=vis[v];break;}
            col+=flg;flg=0;
            vis[v]=col;vec[col].emplace_back(v);
        }
        vect[tc[i]].emplace_back(i);
    }
    for(int i=1;i<=n;i++) mp[a[i]]=1;
    for(int i=1;i<=m;i++) mp[b[i]]=1;
    auto it1=mp.begin(),it2=mp.begin();
    for(it2++;it2!=mp.end();it1++,it2++) it2->second+=it1->second;
    for(int i=1;i<=m;i++) b[i]=mp[b[i]];
    for(int i=1;i<=n;i++) a[i]=mp[a[i]];
    for(int i=1;i<=col;i++)
    {
        for(auto v:vec[i])
        {
            if(b[v]==0)
            {
                b[v]=0;
            }
            T.updata(b[v],1);
        }
        for(auto v:vect[i])
        {
            ans1+=1ll*T.getsum(a[v]-1)*(m/vec[i].size());
            ans3+=1ll*(T.getsum(N)-T.getsum(a[v]))*(m/vec[i].size());
        }
        for(auto v:vec[i]) T.updata(b[v],-1);
    }
    ans2=1ll*n*m-ans1-ans3;
    if(swp) swap(ans1,ans3);
    printf("%lld\n%lld\n%lld",ans1,ans3,ans2);
}

比特跳跃

探求位运算性质的好题，就是我不会做。

分类讨论：

1.$s=1$。

对于所有最高位不为 $1$ 的，都可以与最高位 $1$ 其他位为 $0$ 的数 $\mathrm{\&}$ 得到 $0$。对于剩下最高位为 $1$ 的数，按位取反后不为 $0$，答案为 $0$，否则为 $k$ 和连向其的边中区较小值。

2.$s=2$。

将每个点与有一位是不一样的点连边，跑最短路即可。

3.$s=3$。

先跑一次最短路，每个点 $x$ 递推的求出满足 $x|y=x$ 的最小的 $di{s}_y$，然后判断是否有 $di{s}_x>di{s}_y+x\times k$，如果有就令 $di{s}_x=di{s}_y+x\times k$。

再跑一次最短路即可求得答案。

// ubsan: undefined
// accoders
#include<bits/stdc++.h>
using namespace std;

#define int long long
#define ll long long
#define pli pair<ll,int>
#define fi first
#define se second

const int maxn=2e6+5;

int n,m,s,k;
int f[maxn];

struct Edge
{
    int tot;
    int head[maxn];
    struct edgenode{int to,nxt;ll w;}edge[maxn*2];
    inline void add(int x,int y,ll w)
    {
        tot++;
        edge[tot].to=y;
        edge[tot].w=w;
        edge[tot].nxt=head[x];
        head[x]=tot;
    }
}G;

priority_queue<pli,vector<pli>,greater<pli>>que;
ll dis[maxn];
bool vis[maxn];

int flg=0;

inline void dij()
{
    if(!flg) memset(dis,0x3f,sizeof(dis));
    else for(int i=2;i<=n;i++) que.push({dis[i],i});
    flg++;
    memset(vis,0,sizeof(vis));
    dis[1]=0;que.push({0,1});
    while(!que.empty())
    {
        int u=que.top().se;que.pop();
        if(vis[u]) continue;
        vis[u]=true;
        for(int i=G.head[u];i;i=G.edge[i].nxt)
        {
            int w=G.edge[i].w,v=G.edge[i].to;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                que.push({dis[v],v});
            }
        }
    }
}

signed main()
{
    freopen("jump.in","r",stdin);
    freopen("jump.out","w",stdout);
    scanf("%lld%lld%lld%lld",&n,&m,&s,&k);
    for(int i=1,u,v,w;i<=m;i++) scanf("%lld%lld%lld",&u,&v,&w),G.add(u,v,w),G.add(v,u,w);
    if(s==1)
    {
        for(int i=2;i<n;i++) printf("0 ");
        bool flg=0;
        for(int i=1;i<=20;i++) flg|=(n==((1<<i)-1));
        if(!flg) printf("0");
        else
        {
            ll ans=k;
            for(int i=G.head[n];i;i=G.edge[i].nxt) ans=min(ans,G.edge[i].w);
            printf("%lld ",ans);
        }
    }
    else if(s==2)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=20&&(n>>j);j++)
            {
                int st=i^(1<<j);
                if(st<=n) G.add(i,st,1ll*k*(1<<j)),G.add(st,i,1ll*k*(1<<j));
            }
        }
        dij();
        for(int i=2;i<=n;i++) printf("%lld ",dis[i]);
    }
    else
    {
        for(int i=2;i<=n;i++) G.add(1,i,(1|i)*k);
        dij();
        for(int i=1;i<=n;i++) f[i]=i;
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=20;j++)
            {
                if((i>>j)&1)
                {
                    if(dis[f[i]]>dis[f[i^(1<<j)]]) f[i]=f[i^(1<<j)];
                }
            }
            dis[i]=min(dis[f[i]]+1ll*i*k,dis[i]);
        }
        dij();
        for(int i=2;i<=n;i++) printf("%lld ",dis[i]);
    }
}

区间

固定二元组的右端点 $r$，找到一个最小的 $l$ 使得二元组 $(l,r)$ 满足条件 $2$。

观察 $(l,r)$ 中满足条件 $1$ 的左端点，发现这些点是一个从 $l$ 开始的单调递减的单调栈中小于 $B_r$ 的部分。

假设所有的查询的 $L_i=1$，离线完询问后枚举二元组右端点，同时维护单调栈，每次二分查询单调栈里有多少点小于 $B_r$ 即可。

可是 $L_i$ 并不全部等于一，那么我们设 $va{l}_i$ 表示 $i$ 这个点可以作为多少个二元组中的左端点出现，每次二分查询时，给栈内小于 $B_r$ 的部分的 $va{l}_i$ 加一，每次查询 $[L_i,R_i]$ 的 $val$ 的和即可。

由于单调栈内的节点编号并不会连续，如果暴力实现 $val$ 值的更改显然不合适，那么我们把栈内的 $val$ 值附上新的编号，维护在线段树上，如果这个点被栈弹出了，那么他的 $val$ 值存在本身编号的位置。

由于栈内的原编号是递增的，在 $R_i$ 时求出栈内原编号大于 $L_i$ 点的 $val$ 值和，以及弹出栈的 $[L_i,R_i]$ 的 $val$ 值和。

场上手残了，树状数组写挂了。

// ubsan: undefined
// accoders
#include<bits/stdc++.h>
using namespace std;

#define ll long long

const int maxn=3e5+5;

int n,m;
int a[maxn],b[maxn],l[maxn],r[maxn],flg[maxn];

vector<int>vec[maxn];

ll ans[maxn];

struct treearray
{
    #define N 300000
    ll ts[maxn];
    inline int lowbit(int x) {return x&(-x);}
    inline void updata(int x,int y) {for(;x<=N;x+=lowbit(x)) ts[x]+=y;}
    inline ll getsum(int x) {ll sum=0;for(;x;x-=lowbit(x)) sum+=ts[x];return sum;}
}Ta;

namespace linetree
{
    #define lch(p) p*2
    #define rch(p) p*2+1
    struct treenode{ll sum,lz;}tr[maxn*12];
    inline void updata(int p){tr[p].sum=tr[lch(p)].sum+tr[rch(p)].sum;}
    inline void push_down(int p,int l,int r)
    {
        if(!tr[p].lz||l==r) return ;
        int mid=(l+r)>>1;
        tr[lch(p)].sum+=tr[p].lz*(mid-l+1),tr[lch(p)].lz+=tr[p].lz;
        tr[rch(p)].sum+=tr[p].lz*(r-mid),tr[rch(p)].lz+=tr[p].lz;
        tr[p].lz=0;
    }
    inline void insert(int p,int l,int r,int lx,int rx,int v)
    {
        if(r<lx||l>rx) return ;
        if(lx<=l&&r<=rx)
        {
            tr[p].sum+=(r-l+1)*v;
            tr[p].lz+=v;
            return ;
        }
        push_down(p,l,r);
        int mid=(l+r)>>1;
        insert(lch(p),l,mid,lx,rx,v),insert(rch(p),mid+1,r,lx,rx,v);
        updata(p);
    }
    inline ll qry(int p,int l,int r,int lx,int rx)
    {
        if(r<lx||l>rx) return 0;
        if(lx<=l&&r<=rx) return tr[p].sum;
        push_down(p,l,r);
        int mid=(l+r)>>1;
        return qry(lch(p),l,mid,lx,rx)+qry(rch(p),mid+1,r,lx,rx);
    }
}

int tp;
int stk[maxn];

inline int fr(int x)
{
    int l=1,r=tp,ans=0;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(a[stk[mid]]<x) ans=mid,r=mid-1;
        else l=mid+1;
    }
    return ans;
}
inline int fr_id(int x)
{
    int l=1,r=tp,ans=0;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(stk[mid]>=x) ans=mid,r=mid-1;
        else l=mid+1;
    }
    return ans;
}

int main()
{
    // freopen("ex_interval2.in","r",stdin);
    freopen("interval.in","r",stdin);
    freopen("interval.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=2;i<=n;i++) scanf("%d",&b[i]);
    scanf("%d",&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&l[i],&r[i]);
        vec[r[i]].push_back(i);
    }
    stk[++tp]=1;
    for(int i=2;i<=n;i++)
    {
        int tmp=fr(b[i]);
        if(tmp)
        {
            linetree::insert(1,1,n,tmp,tp,1);
        }
        for(auto v:vec[i])
        {
            tmp=fr_id(l[v]);
            ans[v]=(Ta.getsum(r[v])-Ta.getsum(l[v]-1));
            if(tmp) ans[v]+=linetree::qry(1,1,n,tmp,tp);
        }
        while(tp&&a[stk[tp]]<=a[i])
        {
            ll val=linetree::qry(1,1,n,tp,tp);
            Ta.updata(stk[tp],val);
            linetree::insert(1,1,n,tp,tp,-val);
            tp--;
        }
        stk[++tp]=i;
    }
    for(int i=1;i<=m;i++) printf("%lld\n",ans[i]);
}