Codeforces Round 971 (Div. 4)（A,B,C,D,E,F,G1）

邪神与厨二病

已于 2024-09-05 17:27:42 修改

阅读量540

点赞数 4

分类专栏： CodeForces 文章标签：算法 c++ 数学二分滑动窗口数据结构

于 2024-09-05 17:25:42 首次发布

本文链接：https://blog.csdn.net/qq_45809243/article/details/141932572

版权

CodeForces 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

比赛链接

讲解

$q u e u e f orces$ 了属于是，根本加载不进去。

这场纯纯的数学场，前面比较简单，后面 $EF$ 比较难， $G 23$ 题太难了。 $G 2$ 听别人讲听明白了，但是代码实在是太难写了，写不出来，主要是最近吃药吃的没法静下心来敲代码，一直感觉心里痒痒的，全身好像有蚂蚁在爬，压制不住的狂躁。

A. Minimize!

题面：

给你两个整数 $a$ 和 $b$ ( $\leq b$ )。在 $c$ ( $\leq c \leq b$ ) 的所有可能整数值中，求 $(c - a) + (b - c)$ 的最小值。

思路：

签到， $(c - a) + (b - c) = c - a + b - c = b - a$ 。

code：

#include <iostream>
#include <cstdio>
using namespace std;

int T,a,b;

int main(){
	cin>>T;
	while(T--){
		cin>>a>>b;
		cout<<b-a<<endl;
	}
	return 0;
}

B. osu!mania

题面：

您正在玩您最喜欢的节奏游戏 osu!mania。您的节拍图布局包括 $n$ 行和 $4$ 列。由于最下面的音符距离较近，因此您将先处理最下面的一行，最后处理最上面的一行。每一行将包含一个音符，用 "#"表示。

对于每个音符 $\dots, n$ ，按照处理顺序，输出该音符所在的列。

思路：

每行就四列，而且有且只有一个 “#”，读入每一行，然后找到第一个 “#” 的下标位置，最后倒序输出（因为题目要求从下到上）即可。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;

int T,n;

int main(){
	cin>>T;
	while(T--){
		string s;
		vector<int> a;
		cin>>n;
		for(int i=1;i<=n;i++){
			cin>>s;
			a.push_back(s.find('#')+1);
		}
		for(auto it=a.rbegin();it!=a.rend();it++)
			cout<<*it<<" ";
		cout<<endl;
	}
}

C. The Legend of Freya the Frog

题面：

青蛙弗莱娅正在二维坐标平面上旅行。她目前在点 $(0, 0)$ ，想去点 $(x, y)$ 。在一次移动中，她选择了 $\leq d \leq k$ 这样的整数 $d$ ，并沿着她面对的方向向前跳跃了 $d$ 个点。

最初，她面向的是正方向 $x$ 。每次移动后，她将交替朝向正 $x$ 方向和正 $y$ 方向(即第二次移动时朝向正 $y$ 方向，第三次移动时朝向正 $x$ 方向，以此类推)。

她最少要走多少步才能落在点 $(x, y)$ 上？

思路：

$x$ 轴上的移动至少需要 $\left\lceil\dfrac{x}{k}\right\rceil$ 次，同理 $y$ 轴上的移动至少需要 $\left\lceil\dfrac{y}{k}\right\rceil$ 次。但是因为是增加 $x$ 值和增加 $y$ 值是轮着来的，所以当一边移动次数比较多的时候，另一边可能已经走完了，但是这边就是不走，也得过轮数。

因为先走 $x$ 方向，所以 $x$ 方向走 $m$ 次， $y$ 方向至少会走 $m - 1$ 次，因此一共至少要过 $2 m - 1$ 轮。同理， $y$ 方向走 $m$ 次， $x$ 方向至少会走 $m$ 次，因此一共至少要过 $2 m$ 轮。

分别算出 $x$ 轴上和 $y$ 轴上分别至少要走多少次，然后取 $min\{\left\lceil\dfrac{x}{k}\right\rceil*2-1,\left\lceil\dfrac{y}{k}\right\rceil*2\}$ 即可。

code：

#include <iostream>
#include <cstdio>
using namespace std;

int T,x,y,k;

int main(){
	cin>>T;
	while(T--){
		cin>>x>>y>>k;
		cout<<max((x+k-1)/k*2-1,(y+k-1)/k*2)<<endl;
	}
	return 0;
}

D. Satyam and Counting

题面：

萨提亚姆在二维坐标平面上给定了 $n$ 个不同的点。对于所有给定点 $x_i, y_i)$ ，保证 $\leq y_i \leq 1$ 。选择三个不同的点作为顶点，可以形成多少个不同的非退化直角三角形 $^{\text{∗}}$ ？

如果存在一个点 $v$ ，使得 $v$ 是 $a$ 的顶点而不是 $b$ 的顶点，则两个三角形 $a$ 和 $b$ 是不同的。

$^{\text{∗}}$ 非退化直角三角形是指面积为正，一个内角为 $90^{\circ}$ 的三角形。

思路：

这挠滩翻译给我整出个非世代直角三角形给我cpu干烧了，非退化直角三角形其实就是我们常识里的直角三角形。

这个题非常贴心地保证 $\leq y_i \leq 1$ ，因此发现直角三角形只有两种可能的形成方式，一个是一个直角边是竖直的，另一个点随便取，另一个就是三个点的分布形如 $(i, 0), (i + 1, 1), (i + 2, 0)$ 或 $(i, 1), (i + 1, 0), (i + 2, 1)$ 的斜边水平的三角形。图形画出来大概如下：
在这里插入图片描述
注意点可能是重合的，选取不同的点画出来的三角形算作不同的三角形。

第一种三角形假设竖直的边的两个点坐标分别为 $(i, 0), (i, 1)$ ，在这个坐标上的点的个数分别为 $a, b$ ，一共有 $n$ 个点，那么可以组成的三角形个数为 $a * b * (n - a - b)$ 个。

第二种三角形假设三个点坐标为 $(i, 0), (i + 1, 1), (i + 2, 0)$ 或 $(i, 1), (i + 1, 0), (i + 2, 1)$ ，点的个数分别为 $a, b, c$ 个，那么三角形个数就是 $a * b * c$ 个。

枚举 $i$ ，一个一个算，累加起来即可。注意点的横坐标可以是 $0$ ，所以 $i$ 可以取 $0$ 。横坐标小于等于 $n$ ，所以不用离散化。

code：

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long ll;

int T,n;

int main(){
	cin>>T;
	while(T--){
		cin>>n;
		vector<vector<int> > pt(n+1,vector<int>(2));
		for(int i=1,x,y;i<=n;i++){
			cin>>x>>y;
			pt[x][y]++;
		}
		ll ans=0;
		for(int i=0;i<=n;i++){
			int a=pt[i][0],b=pt[i][1];
			ans+=1ll*a*b*(n-a-b);
		}
		for(int i=0;i<=n-2;i++){
			ans+=1ll*pt[i][0]*pt[i+2][0]*pt[i+1][1];
			ans+=1ll*pt[i][1]*pt[i+2][1]*pt[i+1][0];
		}
		cout<<ans<<endl;
	}
	return 0;
}

E. Klee’s SUPER DUPER LARGE Array!!!

题面：

Klee 有一个长度为 $n$ 的数组 $a$ ，其中包含按顺序排列的整数 $[k, k + 1, ..., k + n - 1]$ 。克利希望选择一个索引 $i$ ( $\leq i \leq n$ )，使得 $|a_1 + a_2 + \dots + a_i - a_{i+1} - \dots - a_n|$ 最小。请注意，对于任意整数 $z$ 而言， $∣ z ∣$ 表示 $z$ 的绝对值。

输出 $x$ 的最小可能值。

思路：

说白了就是取前 $i$ 个数为正，后 $n - i$ 个数为负，然后求和。两段分别为一个等差数列，求和后分别为 $\dfrac{(2k+i-1)*i}{2}$ 和 $\dfrac{(2k+n+i-1)*(n-i)}{2}$ ，因此前一段减后一段的结果就是 $\dfrac{(2k+i-1)*i}{2}-\dfrac{(2k+n+i-1)*(n-i)}{2}=\dfrac{(-2kn+4ki-n^2+n+2i^2-2i)}2$ 。它是一个关于 $i$ 的一个函数，看式子或者根据实际意义很容易看出它是一个单调递增的函数。

我们要找取绝对值后最小的值，其实就是找最接近 $0$ 的值，不难想到就是最后一个负值和第一个正值，我们分别取绝对值再取两者较小值即可。因为它是单调函数所以可以二分来找答案。

我们可以二分找到第一个大于等于 $0$ 的值，它的上一个位置就是最后一个负值。根据实际意义可以想到这个函数一定会存在至少一个负值和至少一个正值，所以不用担心找不到导致越界的问题。

code：

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;

ll T,n,k;
ll calc(ll i){
	return (-2*k*n+4*k*i-n*n+n+2*i*i-2*i)/2;
}
bool check(ll i){
	return calc(i)>=0;
}

int main(){
	cin>>T;
	while(T--){
		cin>>n>>k;
		ll l=1,r=n;
		while(l<r){
			ll mid=(l+r)>>1;
			if(check(mid))r=mid;
			else l=mid+1;
		}
		cout<<min(abs(calc(l-1)),abs(calc(l)))<<endl;
	}
	return 0;
}

F. Firefly’s Queries

题面：

萤火虫是一个给定长度为 $n$ 的数组 $a$ 。让 $c_i$ 表示 $a$ 数组的第 $i$ 次循环移动 $^{\text{∗}}$ 。她创建了一个新数组 $b$ ，使得 $c_1 + c_2 + \dots + c_n$ 其中 $+$ 表示连接操作 $^{\text{†}}$ 。

然后，她会向你提出 $q$ 个查询。对于每一个查询，输出从第 $l$ 个元素开始，到第 $r$ 个元素结束的 $b$ 子数组中所有元素的总和，包括两端的元素。

$^{\text{∗}}$ 数组 $a$ 的第 $x$ ( $\leq x \leq n$ ) 次循环移位是 $a_x, a_{x+1} \ldots a_n, a_1, a_2 \ldots a_{x - 1}$ 。请注意，第 $1$ 次移位就是最初的 $a$ 。

$^{\text{†}}$ 长度为 $n$ 的两个数组 $p$ 和 $q$ (换句话说， $p + q$ )的连接操作是 $p_1, p_2, ..., p_n, q_1, q_2, ..., q_n$ 。

思路：

不难想到假设第 $l$ 个元素落在第 $L$ 次循环移动里，第 $r$ 个元素落在第 $R$ 次循环移动里的话，那么 $L+1\sim R-1$ 中间的循环移动就是完整的循环移动，一次完整的循环移动的元素没有变化，它的所有元素的和就是原本所有元素的和。

所以我们可以对中间完整的循环移动快速地用所有元素的和乘上完整的循环移动数组的个数直接算出，而对于前面和后面分别计算。前面的部分在 $l$ 所在的循环移动数组中相当于求个后缀的和，后面的部分在 $r$ 所在的循环移动数组中相当于求个前缀的和。

我们分别找出 $l, r$ 相当于在第几次循环移动数组中的什么位置上，然后分别找出循环移动后的前后缀元素在原本数组中的位置，然后对它们进行求和即可。

$l, r$ 在第几次循环移动数组中的什么位置上好算。以 $l$ 距离，它在第 $\left\lceil\dfrac{l}{n}\right\rceil$ 个循环移动数组，减去前 $\left\lceil\dfrac{l}{n}\right\rceil-1$ 个循环移动数组的长度就是在这个循环移动数组中的位置，也就是 $l-(\left\lceil\dfrac{l}{n}\right\rceil-1)*n$ 。同理 $r$ 也是这么算。

为了迅速求和，我们先处理出 $a$ 数组的前缀和数组 $s$ 。

算第 $i d$ 个循环移动数组的 $i$ 位置以前的前缀和：不妨先给 $i d$ 减 $1$ ，让初始的循环移动（也就是原数组）对应 $0$ ，这样第 $i d$ 次循环移动的数组的后 $i d$ 个元素就是循环移动过来的最后 $i d$ 个元素。这个循环移动数组列出来就是 $a_{id+1},a_{id+2},\dots,a_n,a_1,a_2,\dots,a_{id}$ 。

假设 $i$ 没有超出前 $n - i d$ 个元素，即 $i\le n-id$ 。那么前缀和就是 $a_{id+1}+a_{id+2}+\dots+a_{id+i}=s_{id+i}-s_{id}$ 。如果 $i\gt n-id$ ，那么前缀和就是 $a_{id+1}+a_{id+2}+\dots+a_{n}+a_1+a_{i-(n-id)}=s_n-s_{id}+s_{i+id-n}$

同理算后缀和，如果 $i\gt n-id$ ，那么后缀和就是 $a_{i-(n-id)}+\dots+a_{id}=s_{id}-s_{i+id-n-1}$ 。如果 $i\le n-id$ ，那么后缀和就是 $a_{id+i}+\dots+a_{n}+a_1+\dots+a_{id}=s_{n}-s_{id+i-1}+s_{id}$ 。

然后列式算即可。

code：

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn=2e5+5;
typedef long long ll;

int T,n,q;
ll a[maxn],s[maxn];

ll pre(ll id,ll i){
	id--;
	ll ans=0;
	if(i<=n-id){
		ans=s[id+i]-s[id];
	}
	else {
		ans=s[n]-s[id];
		ans+=s[i-n+id];
	}
	return ans;
}
ll suf(ll id,ll i){
	id--;
	ll ans=0;
	if(i>n-id){
		ans=s[id]-s[i-n+id-1];
	}
	else {
		ans=s[id];
		ans+=s[n]-s[i+id-1];
	}
	return ans;
}

int main(){
	cin>>T;
	while(T--){
		cin>>n>>q;
		for(int i=1;i<=n;i++)cin>>a[i],s[i]=s[i-1]+a[i];
		for(ll _=1,l,r;_<=q;_++){
			cin>>l>>r;
			ll L=(l+n-1)/n+1,R=(r-1)/n;
			ll ans=s[n]*(R-L+1);
			ans+=suf((l+n-1)/n,l-(l-1)/n*n);
			ans+=pre((r+n-1)/n,r-(r-1)/n*n);
			cout<<ans<<endl;
		}
	}
	return 0;
}

G1. Yunli’s Subarray Queries (easy version)

题面：

这是问题的简单版本。在这个版本中，可以保证 $r = l + k - 1$ 适用于所有查询。

对于任意数组 $b$ ，云里可以执行任意多次下面的操作：

选择索引 $i$ 。设置 $b_i = x$ ，其中 $x$ 是她想要的任意整数( $x$ 不限于区间 $[1, n]$ )。

将 $f (b)$ 记为她需要执行的最小操作次数，直到 $b$ 中存在一个长度至少为 $k$ 的连续子数组 $^{\text{∗}}$ 。

给云莉一个大小为 $n$ 的数组 $a$ 并向你提出 $q$ 个查询。在每个查询中，你必须输出 $\sum _{j=l+k-1}^{r} f([a_l, a_{l+1}, \ldots, a_j])$ 。请注意，在这个版本中，你只需要输出 $f([a_l, a_{l+1}, \ldots, a_{l+k-1}])$ 。

$^{\text{∗}}$ 如果存在一个从索引 $i$ ( $\leq i \leq |b|-k+1$ )开始的长度为 $k$ 的连续子数组，那么对于所有的 $\leq i+k-1$ 都是 $b_j = b_{j-1} + 1$ 。

思路：

对这种找公差为 $1$ 的等差数列，有个技巧就是给每个位置上的数减去 $i$ ，这样转化后的数组如果连续的数相等，在原本的数组里这连续的数就是等差数列。

转化后对一个 $l$ 其实就是找 $l\sim l+k-1$ 这 $k$ 个数里相等的数最多有多少个。而且这样的 $l$ 最多也就是 $n - k + 1$ 个，我们直接用个滑动窗口一样的东西滑一遍，算出所有 $l$ 的答案，然后直接查即可。

这个滑动窗口，需要用一个 $ma p$ 存储一个数到这个数的个数的映射，为了查找某一时刻下最多的数的个数，我们还需要一个 $m u lt i se t$ 存储所有数的个数每次更新一个数的个数时，把这个数旧的个数删掉，再加入新的个数即可。

code：

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#define pii pair<int,int>
using namespace std;
const int maxn=2e5+5;

int T,n,k,q;
int a[maxn],ans[maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n>>k>>q;
		for(int i=1;i<=n;i++)cin>>a[i],a[i]-=i;
//		for(int i=1;i<=n;i++)cout<<a[i]<<" ";
//		cout<<endl;
		map<int,int> mp;
		multiset<int> S;
		for(int i=1;i<k;i++){
			if(mp.find(a[i])!=mp.end())S.erase(S.find(mp[a[i]]));
			mp[a[i]]++;
			S.insert(mp[a[i]]);
			
		}
		for(int l=1,r=k;l<=n;l++,r++){
			if(r<=n){
				if(mp.find(a[r])!=mp.end())S.erase(S.find(mp[a[r]]));
				mp[a[r]]++;
				S.insert(mp[a[r]]);
			}
			
			ans[l]=k-*S.rbegin();
			
			S.erase(S.find(mp[a[l]]));
			mp[a[l]]--;
			if(mp[a[l]]==0)mp.erase(a[l]);
			else S.insert(mp[a[l]]);
		}
		
		for(int i=1,l,r;i<=q;i++){
			cin>>l>>r;
			cout<<ans[l]<<endl;
		}
	}
	return 0;
}