Atcoder Beginner Contest 367

合集 - 赛事(59)

1.Codeforces Round 955 (Div. 2)2024-06-262.AtCoder Beginner Contest 3632024-07-213.AtCoder Regular Contest 182（A B C）2024-08-124.暑假集训CSP提高模拟12024-07-185.暑假集训CSP提高模拟22024-07-196.暑假集训CSP提高模拟72024-07-257.暑假集训CSP提高模拟52024-07-238.暑假集训 加赛12024-07-229.暑假集训CSP提高模拟42024-07-2110.暑假集训CSP提高模拟182024-08-1111.暑假集训CSP提高模拟172024-08-1012.暑假集训CSP提高模拟 162024-08-0813.暑假集训CSP提高模拟 ∫[0,6] (x^2)/6 dx2024-07-3114.暑假集训CSP提高模拟112024-07-2915.暑假集训SCP提高模拟102024-07-2816.暑假集训PVZ提高模拟92024-07-2717.暑假集训CSP提高模拟82024-07-2618.暑集假训SCP提高拟模212024-08-1519.[CL-FOOL] CLOI 愚人赛的部分官方题解与小杂谈2024-04-0220.トヨタ自動車プログラミングコンテスト2024#7（ABC 362）2024-07-1421.寒假集训测试2 题目转存2024-02-2322.HEOI2024 题目转存2024-03-0523.高一小学期22024-07-0824.张江蔡2024-06-2725.高一高考集训总结赛2024-06-1326.高一下二调题目转存2024-04-1527.CSP提高组模拟12024-07-12

28.Atcoder Beginner Contest 3672024-08-18

29.[R18][中国語翻訳]HDKのABC370赛試（ABC370）2024-09-0830.[30] CSP 加赛 12024-09-1531.[33]（CSP 集训）CSP-S 模拟 42024-09-2532.[34]（CSP 集训）CSP-S 联训模拟 12024-09-2633.[35] (CSP 集训) CSP-S 模拟 52024-09-2734.[36]（CSP 集训）CSP-S 模拟 62024-09-2835.AtCoder Beginner Contest 3732024-09-2936.[37]（CSP 集训）CSP-S 模拟 72024-09-3037.[39] (多校联训) A层冲刺NOIP2024模拟赛012024-10-0338.[40]（CSP 集训）CSP 联训模拟 22024-10-0539.[42] (多校联训) A层冲刺NOIP2024模拟赛032024-10-0740.[41] (CSP 集训) CSP-S 模拟 92024-10-0741.[44] (多校联训) A层冲刺NOIP2024模拟赛042024-10-0942.[45] (多校联训) A层冲刺NOIP2024模拟赛052024-10-1143.[46] (多校联训) A层冲刺NOIP2024模拟赛062024-10-1244.パナソニックグループ プログラミングコンテスト2024（ABC 375）2024-10-1345.[47] (CSP 集训) CSP-S 模拟 112024-10-1446.[49 & 50] (多校联训) A层冲刺NOIP2024模拟赛08 | CSP-S 模拟 122024-10-1847.[51] (多校联训) A层冲刺NOIP2024模拟赛092024-10-1948.Atcoder Beginner Contest 3762024-10-2049.Codeforces Round 980 (Div. 2)2024-10-2050.[54] (多校联训) A层冲刺NOIP2024模拟赛122024-10-2451.[57] (多校联训) A层冲刺NOIP2024模拟赛152024-10-2952.[61] (多校联训) A层冲刺NOIP2024模拟赛182024-11-0553.[62] (NOIP 集训) NOIP2024加赛 22024-11-0654.[63] (多校联训) A层冲刺NOIP2024模拟赛192024-11-0755.[68] (炼石计划) NOIP 模拟赛 #202024-11-1456.[68] (NOIP集训) NOIP2024 加赛 52024-11-2057.[72] (多校联训) A层冲刺NOIP2024模拟赛252024-11-2258.[73] (NOIP集训) NOIP2024 加赛 72024-11-2259.[75] (NOIP集训) NOIP2024 加赛 82024-11-27

收起

A.Shout Everyday $\text{Diff }43$

给你 $24$ 小时制下的 $A,B,C$ 三个时刻，问 $A$ 是否在 $[B,C]$ 范围内

考虑到先将 $B,C$ 加上一个 $24$，假如 $C$ 比 $B$ 小，将 $C$ 再加上一个 $24$，这样可以保证严格的 $A<B,C$，此时直接判断是否存在一个 $k$，使得 $A+24k\in [B,C]$ 即可

#include<bits/stdc++.h>
using namespace std;
int main(){
	int a,b,c;
	cin>>a>>b>>c;
	if(c<b) c+=24;
	while(a<=c){
//		cout<<a<<" in "<<b<<" "<<c<<endl;
		if(a>=b and a<=c){
			cout<<"No"<<endl;
			return 0;
		}
		a+=24;
	}
	cout<<"Yes"<<endl;
}

B.Cut .0 $\text{Diff }43$

给定一个小数，去除多余的后导零或小数点

比第一题水，不说了

#include<bits/stdc++.h>
using namespace std;
int main(){
	string x;
	cin>>x;
	for(int i=x.length()-1;i>=0;--i){
		if(x[i]=='.'){
			x.pop_back();
			break;
		}
		if(x[i]!='0') break;
		x.pop_back();
	}
	cout<<x<<endl;
}

C.Enumerate Sequences $\text{Diff }234$

按字典序输出所有满足条件的，长度为 $N$ 的序列 $A$

• $\mathrm{\forall }{A}_i\in [1,R_i]$
• $\sum _{i=1}^N{A}_i\mathrm{mod}K=0$

$N\le 8,K\le 10,R_i\le 5$

显然应该是爆搜

#include<bits/stdc++.h>
using namespace std;
int a[9];
int n,k;
int r[9];
void dfs(int now,int nowsum){
	if(now>n){
		if(nowsum%k==0){
			for(int i=1;i<=n;++i){
				cout<<a[i]<<" ";
			}
			cout<<endl;
		}
		return;
	}
	for(int i=1;i<=r[now];++i){
		a[now]=i;
		dfs(now+1,nowsum+i);
	}
}
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;++i){
		cin>>r[i];
	}
	dfs(1,0);
}

D.Pedometer $\text{Diff }1037$

顺时针给你一个环，告诉你环上各边的权值

定义 $dis(x,y)$ 为从 $x$ 顺时针走到 $y$ 的路径长

请你求出所有满足 $dis(u,v)\mathrm{mod}M=0$ 的点对数量

$N\le 2\times {10}^5,M\le {10}^6$

显然不能每次都改变整个 $dis$ 数组的值

首先先来模拟一下，先考虑暴力，每次枚举出发点，开一个数组 $dis$ 用来表示从出发点到各点的距离，观察当出发点从 $i$ 变成 $i+1$ 的时候，$dis$ 数组会如何变化

2 1 4 3

i   dis
1   0 2 3 7
2   8 0 1 5
3   7 9 0 4

可以发现，每当我们将 $i$ 向后移了一位，其实就相当于以下两步操作：

• 将 $di{s}_i$ 加上总路径和（其实就是绕了一圈）
• 将整个 $dis$ 数组减去 $di{s}_{i+1}$

发现第二步实际上是可以优化的，因为这道题是取模操作，方便我们优化. 注意到若 $x\mathrm{mod}M=0$，则应该有 $(x-k)\mathrm{mod}M=M-(k\mathrm{mod}M)$，因此我们可以考虑直接根据这样的性质来转移余数而不是整个 $dis$ 数组，这样这个题就做完了

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,m,sum;
int a[200001],r[1000001],pres[200002],opres[200002];
signed main(){
	scanf("%lld %lld",&n,&m);
	for(int i=1;i<=n;++i){
		scanf("%lld",&a[i]);
		sum+=a[i];
	}
	for(int i=1;i<=n-1;++i){
		pres[i]=pres[i-1]+a[i];
		opres[i]=pres[i];
		r[pres[i]%m]++;
	}
	r[0]++;
	int ans=0,rm=m,msum=0;
	for(int i=1;i<=n;++i){
		m+=opres[i]-msum;
		msum+=pres[i]-msum;
		r[pres[i==1?n:i-1]%rm]--;
		pres[i==1?n:i-1]+=sum;
		r[pres[i==1?n:i-1]%rm]++;
		ans+=r[msum%rm];
	}
	cout<<ans-n<<endl;
}

E.Permute K times $\text{Diff }1370$

给定长度为 $N$ 的序列 $X,A$，其中 $\mathrm{\forall }{x}_i\in [1,N]$，对序列 $A$ 执行 $K$ 次下列操作：

• 同时将全部 $A_i$ 赋值为 $A_{X_i}$

求最终的序列 $A$

$N\le 2\times {10}^5,K\le {10}^{18}$

好题。

この問題は、 ダブリング と呼ばれるテクニックで解くことができます

我并不知道 ダブリング 是啥算法，但是我猜大抵是倍增罢

注意到我们每次在 $A$ 数组上操作其实就相当于在 $X$ 数组上操作，因此我们暂时抛开 $A$ 数组不管

又注意到 $X$ 数组上的转移是有传递性的，比如两次操作后的 $X_i^{\prime }=X_{X_i}$

定义 $p_{i,j}$ 表示操作 $2^i$ 次以后 $X_j$ 的值，我们姑且先不考虑 $K$ 的限制，转移是显而易见的

$$p_{i,j}=p_{i-1,p_{i-1,j}}$$

初始化 $p_{0,i}=x_i$

但是有了这个东西还不够，因为它让我们求恰好 $K$ 次操作时候的 $K$ 数组值，而我们现在只有 $2^i$ 的数组值.

写到这基本就能想到了，搞一个二进制分解就行了

其实本来想暴力建图弄一个内向基环树的，因为在树上直接维护环信息，到最后直接取模 $O(1)$ 就出了. 这个思路是假的，但是如果 $K\ge N$，这个思路就是对的了. 瓶颈在这个算法只能求出走进环里的节点的末态，而对于很长的链而 $K$ 非常小的时候，存在节点无法走入环内，由于无法维护环外信息，因此复杂度会被卡成 $n^2$

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,k;
int p[61][200001],a[200001],x[200001];
signed main(){	
	cin>>n>>k;
    for(int i=1;i<=n;++i){
        cin>>p[0][i];
    }
    for(int i=1;i<=n;++i){
        cin>>a[i];
    }
    for(int i=1;i<=60;++i){
        for(int j=1;j<=n;++j){
            p[i][j]=p[i-1][p[i-1][j]];
        }
    }
    for(int i=1;i<=n;++i){
        x[i]=i;
    }
    for(int i=0;i<=60;++i){
        if(k&1){
            for(int j=1;j<=n;++j){
                x[j]=p[i][x[j]];
            }
        }
        k>>=1;
    }
    for(int i=1;i<=n;++i){
        cout<<a[x[i]]<<" ";
    }
    cout<<endl;
}

F.Rearrange Query $\text{Diff }1540$

给你两个序列 $A,B$

每次询问给定 $l,r,L,R$，判断是否满足下列条件

$A_l,A_{l+1}\cdots A_r$ 可以通过重排与 $B_L,B_{L+1}\cdots B_R$ 匹配

$N,Q\le 2\times {10}^5,\mathrm{\forall }{A}_i,B_i\in [1,N]$

当 $R-L\ne r-l$ 时显然不可能，考虑剩下的情况

设计一个哈希值，考虑每次直接 $O(n)$ 判等. 那么我们这个哈希值显然是需要无序的，即只要是 $A$ 的一个排列，其哈希值都与 $A$ 相等. 可以想到两种哈希：和哈希与异或哈希.

异或哈希做不到给每个元素都赋不同的值，因为它总共就只有 $64$ 位可用，因此考虑和哈希，即将序列元素中的值加起来之和用于判断.

假如我们真的用原数列做哈希的话，出题人随便就给卡了，因为即便是和哈希，哈希冲突的概率还是太高. 因此考虑开一个 map，把数字离散化，均匀分布到 $[1,mod-1]$ 范围内. 可以证明这样做的冲突概率是 $\frac{2^{64}}{n^2}$

此外，直接处理前缀和即可 $O(1)$ 回答询问

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int p=141592653589;
int n,q;
int a[200001],b[200001],val[200001],sum1[200001],sum2[200001];
signed main(){	
	cin>>n>>q;
    ios::sync_with_stdio(false);
    srand(time(0));
    for(int i=1;i<=n;++i){
        val[i]=(rand()*1ll*rand())%(p-1)+1;
    }
    for(int i=1;i<=n;++i){
        cin>>a[i];
        a[i]=val[a[i]];
        sum1[i]=sum1[i-1]+a[i];
    }
    for(int i=1;i<=n;++i){
        cin>>b[i];
        b[i]=val[b[i]];
        sum2[i]=sum2[i-1]+b[i];
    }
    for(int i=1;i<=q;++i){
        int l,r,L,R;
        cin>>l>>r>>L>>R;
        if((sum1[r]-sum1[l-1])%p!=(sum2[R]-sum2[L-1])%p) cout<<"No\n";
        else cout<<"Yes\n";
    }
}