2024牛客寒假算法基础集训营5 题解 （ A,C,G,H,I,L,M ）

AlwaysBeShine
82 阅读8分钟

2024牛客寒假算法基础集训营5 题解 （ A,C,G,H,I,L,M ）

A mutsumi的质数合数

题意

有一个由 nn 个正整数组成的数组，她想知道数组中质数和合数共有几个。

思路

由质数和合数的定义可知，正整数范围内除 11 外，要么是质数要么是合数，本题直接统计不是 11 的正整数的个数即可

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
			
int main(){
			
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
			
	int n;
	cin >> n;
	int cnt = 0;
	for(int i = 0;i < n;i++){

		int a;
		cin >> a;

		if(a != 0 && a != 1)cnt++;

	}

	cout << cnt;
			
	return 0;
}

C anon的私货

题意

在一个正数数组中夹带一些 0，只要数组的除全 0 连续子数组外的每个连续子数组的平均数都大于等于 1，最多可以夹带多少个 0

思路

如果在两数之间插入 00 的话，插入的位置左右两侧的数都会受影响
所以数组的第一个元素和最后一个元素要重点考虑，在数组前插 00 ，只有第一个元素会受影响，最后一个元素同理。

除此之外，设数组第 ii 个元素为 aia_i，可以把本题看作从第 11 位开始，每次对第 ii 和 i+1i+1 位（ 1≤i<n 1 \le i \lt n），同时自减 min(ai−1,ai+1−1)min(a_i-1,a_{i+1}-1)，然后整个数组一共减去的值就是答案。

特别注意第一位和最后一位是否有剩余

代码

/*******************************
| Author:  AlwaysBeShine
| Problem: anon的私货
| Contest: NowCoder
| URL:     https://ac.nowcoder.com/acm/contest/67745/C
| When:    2024-02-21 15:48:37
| 
| Memory:  524288 MB
| Time:    2000 ms
*******************************/
#include <bits/stdc++.h>
#include <limits.h>
using namespace std;
typedef long long ll;
			
int main(){
			
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
			
	int n;	
    cin >> n;
    std::vector<ll> a(n+3,LLONG_MAX);
    for(int i = 1; i <= n;i++){

    	cin >> a[i];

    }
    ll cnt = 0;
    for(int i = 0;i <= n;i++){

    	if(a[i] >= 2 && a[i+1] >= 2){
    		
    		if(a[i] >= a[i+1]){
    			cnt += a[i+1] - 1;
    			a[i] -= (a[i+1] - 1);
    			a[i+1] = 1;


    		}else{

    			cnt += a[i] - 1;
    			a[i+1] -= (a[i] - 1);
    			a[i] = 1;

    		}

    	}

    	// for(int i = 1; i <= n;i++){

    	// 	cout << a[i] << " \n"[i==n];

    	// }

    }

    if(a[1] >= 2)cnt += a[1] - 1;
    cout << cnt;
			
	return 0;
}

G sakiko的排列构造（easy）

题意

构造一个长度为 nn 的排列 pp ，使得每一个 pi+i (1≤i≤n)p_i+i\ (1\leq i\leq n) 都是质数。

思路

通过打表可发现规律
设第 ii 位应该放的值为 aia_i，当前使用的质数为 zkz_k （第 kk 个质数）
倒着构造，提前预处理出小于等于 10310^3 以内的所有质数，用第一个大于等于 nn 的质数从最后一位开始倒着构造。

因为要构造一个排列，所以数字不能重复，也不能大于 nn
所以要求 zk−iz_k - i 必须没有出现过，并且 zk−i≤nz_k - i \le n 如果满足条件，那么 ai=zk−ia_i = z_k - i
否则 kk 自减（就是再往小找最大的满足 zk−iz_k - i 没出现过的质数）再循环这个情况

如果构造过程中 k<1k \lt 1 （也就是质数不够用了），那么就构造不出来，否则就构造的出来

代码

/*******************************
| Author:  AlwaysBeShine
| Problem: sakiko的排列构造（easy）
| Contest: NowCoder
| URL:     https://ac.nowcoder.com/acm/contest/67745/G
| When:    2024-02-21 16:49:29
| 
| Memory:  524288 MB
| Time:    2000 ms
*******************************/
/*******************************
| Author:  AlwaysBeShine
| Problem: B3716 分解质因子 3
| Contest: Luogu
| URL:     https://www.luogu.com.cn/problem/B3716
| When:    2024-02-11 15:50:18
| 
| Memory:  600 MB
| Time:    2500 ms
*******************************/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

vector<bool> isNotPrime(10100);
vector<int> prime;


int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    prime.push_back(2);
	for(int i = 2;i <= 10000;i++){

		if(isNotPrime[i] == false){

			prime.push_back(i);
			
		}
		for(int j = 1;prime[j] * i <= 10000;j++){
			int temp = prime[j] * i;
			isNotPrime[temp] = true;
			
			if(i % prime[j] == 0)break;

		}
	}

    int pos;
    int n;
    cin >> n;
    for(int i = 1;i <= prime.size();i++){

    	if(prime[i] > n){

    		pos = i;
    		break;
    	}

    }
    vector<int>ans(n+5);
    map<int,int>mp;
    for(int i = n;i >= 1;i--){ //倒着来

    	if(pos < 1){

    		cout << "-1";
    		return 0;
    	}

    	while(pos >= 1 && (prime[pos] - i > n || mp[prime[pos] - i] == 1)){

    		pos--;

    	}

    	if(mp[prime[pos] - i] == 0){ //如果没出现过这个数

    		if(prime[pos] - i <= n){ //必须要小于等于 n
    			ans[i] = prime[pos] - i;
    			mp[prime[pos] - i] = 1; 

    		}else{ //如果大于等于n了或者出现过了

    			while(pos >= 1 && (prime[pos] - i > n || mp[prime[pos] - i] == 1)){

    				pos--;

    			}

    			if(pos < 1){

    				cout << -1;

    			}else{

    				ans[i] = prime[pos] - i;
    				mp[prime[pos] - i] = 1;

    			}

    		}
    	}

    }

    for(int i = 1;i <= n;i++){

    	cout << ans[i] << " ";

    }

    return 0;
}

H sakiko的排列构造（hard）

题意

同 easy 版，只有数据范围扩大到了 10610^6

思路

同 easy 版

代码

/*******************************
| Author:  AlwaysBeShine
| Problem: sakiko的排列构造（easy）
| Contest: NowCoder
| URL:     https://ac.nowcoder.com/acm/contest/67745/G
| When:    2024-02-21 16:49:29
| 
| Memory:  524288 MB
| Time:    2000 ms
*******************************/
/*******************************
| Author:  AlwaysBeShine
| Problem: B3716 分解质因子 3
| Contest: Luogu
| URL:     https://www.luogu.com.cn/problem/B3716
| When:    2024-02-11 15:50:18
| 
| Memory:  600 MB
| Time:    2500 ms
*******************************/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

vector<bool> isNotPrime(1000010);
vector<int> prime;


int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    prime.push_back(2);
	for(int i = 2;i <= 1000010;i++){

		if(isNotPrime[i] == false){

			prime.push_back(i);
			
		}
		for(int j = 1;prime[j] * i <= 1000010;j++){
			int temp = prime[j] * i;
			isNotPrime[temp] = true;
			
			if(i % prime[j] == 0)break;

		}
	}

    int pos;
    int n;
    cin >> n;
    for(int i = 1;i <= prime.size();i++){

    	if(prime[i] > n){

    		pos = i;
    		break;
    	}

    }
    vector<int>ans(n+5);
    map<int,int>mp;
    for(int i = n;i >= 1;i--){ //倒着来

    	if(pos < 1){

    		cout << "-1";
    		return 0;
    	}

    	while(pos >= 1 && (prime[pos] - i > n || mp[prime[pos] - i] == 1)){

    		pos--;

    	}

    	if(mp[prime[pos] - i] == 0){ //如果没出现过这个数

    		if(prime[pos] - i <= n){ //必须要小于等于 n
    			ans[i] = prime[pos] - i;
    			mp[prime[pos] - i] = 1; 

    		}else{ //如果大于等于n了或者出现过了

    			while(pos >= 1 && (prime[pos] - i > n || mp[prime[pos] - i] == 1)){

    				pos--;

    			}

    			if(pos < 1){

    				cout << -1;

    			}else{

    				ans[i] = prime[pos] - i;
    				mp[prime[pos] - i] = 1;

    			}

    		}
    	}

    }

    for(int i = 1;i <= n;i++){

    	cout << ans[i] << " ";

    }

    return 0;
}

I rikki的最短路

题意

rikki 在找 anon ，她准备去找 tomorin 问一下 anon 在哪。 （以下tomorin简称 TT ，anon简称 AA ）
寻找过程：找到 AA ，将 AA 带回 TT 的位置，可以简单的理解为先找到 AA 再去找 TT 。
我们把寻找过程简化为一条数轴， rikki 在数轴上的坐标为 0 ， TT 在数轴上的坐标为 tt ， AA 在数轴上的坐标为 aa 。
初始时 rikki 只知道 TT 的坐标，而不知道 AA 的坐标，因此 rikki 会先前往 TT 的坐标。
而当 rikki 到达 TT 的坐标时，就可以知道 AA 的坐标。
rikki 的视野为 kk ，若rikki当前坐标为 uu ，则她可以看到 [u−k,u+k][u-k,u+k] 区间内的东西，即 rikki 可能可以在移动到 TT 所在坐标的过程中直接看到 AA ，去找到 AA ，省略先去找 TT 的过程。
rikki 想知道她将 AA 带回 TT 的坐标最少需要移动多少距离。

思路

分类讨论

  1. 当 AA 和 TT 同向时，如果 ∣A∣≤∣T∣\lvert A \rvert \le \lvert T \rvert，那么在找 TT 的过程中就找到了 AA 直接带走，不需要多走，答案就是 ∣T∣\lvert T \rvert
  2. 当 A 和 TT 同向时，如果 ∣A∣>∣T∣\lvert A \rvert \gt \lvert T \rvert，那就得比上面那种情况，多走 2∗(∣A∣−∣T∣)2 * (\lvert A \rvert - \lvert T \rvert)
  3. 当 AA 和 TT 反向时，如果∣A∣≤∣k∣\lvert A \rvert \le \lvert k \rvert，一开始就知道 AA 在哪，所以可以先找 AA ，再带到 TT 处
  4. 当 T=0T = 0 时，同上理。
  5. 当 AA 和 TT 反向时，如果∣A∣>∣T∣\lvert A \rvert \gt \lvert T \rvert ，得先去找 TT 再去找 AA ，再找 TT。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
			
int main(){
			
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
			
	ll t,a,k;
	cin >> t >> a >> k;
    if((t > 0 && a > 0) || (t < 0 && a < 0)){ //同向
		ll la = abs(a),lt = abs(t);
		if(la <= lt){ //去t路上能看见a

			cout << lt;

		}else{ //看不见a

			cout << la + la - lt;

		}

	}else if(a == 0){ //带着a去找t

		cout << abs(t);

	}else if(t == 0){ //直接知道a在哪 把他带回来

		cout << 2 * abs(a);

	}else{ //反向

		if(abs(a) > k){

			cout << 3*abs(t) + 2*abs(a);

		}else{

			cout << 2*abs(a) + abs(t);

		}

	}
			
	return 0;
}

L anon的星星

题意

玩一个游戏，胜利一局会获得一颗星星，失败一局会失去一颗星星，没有平局。 只知道自己玩了 nn 局游戏，共获得了 xx 颗星星。
求胜利了几局，失败了几局？

思路

设胜利了 ii 局，则输了 n−i n - i 局，判断 1≤i≤n1 \le i \le n 是否存在 i−(n−i)=xi - (n-i) = x 即可

代码

#include <iostream>
using namespace std;

int main() {
    int n, x;
    cin >> n >> x;

    for (int i = 0; i <= n; ++i) {
        int j = n - i;
        if (i - j == x) {
            cout << i << " " << j << endl;
            return 0;
        }
    }
    
    cout << -1 << endl;
    return 0;
}

M mutsumi的排列连通

题意

有两个排列，放置在一个 2×n2 \times n 的矩形中，每次你可以选择一个数字 xx ，将两个排列内的 xx 所在的单元格删除。
删除尽可能少的数字，使得矩形至少被分成两个连通块（不一定是矩形）， 请输出最小的删除次数。若无法通过删除使得矩形被分成至少两个连通块，则输出 -1。
连通块：块内任意两点（可以是同一点）都可以找到至少一条只由上下左右组成的路径相连。
长度为 nn 的排列为：1−n1-n 中，每个数字恰好出现一次。

思路

很容易思考出，答案只有 −1,1,2-1,1,2 三种可能

当 n=1n = 1 时，无解

当 n=2n = 2 时，如果两排列完全相同，无解；如果两排列不同，操作一次即可

当 n≥3n \ge 3 时，判断第 22 位到第 n−1n-1 位之间，两排列是否存在两个相同的元素在两排列种各自的下标之差为 11

​ 如果存在，则操作一次即可，否则要操作两次。

代码

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

void solve(){

    map<int,int>a;

	map<int,int>b;		
	int n,temp;
	cin >> n;
	vector<int>A(n+1,0);
	vector<int>B(n+1,0);
	for(int i = 1;i <= n;i++){

		
		cin >> temp;
		a[temp] = i;
		A[i] = temp;
	}
	bool ck = false;
	for(int i = 1;i <= n;i++){

		cin >> temp;
		b[temp] = i;
		B[i] = temp;
		if(abs(i - a[temp]) == 1 || i == a[temp] && i != n && i != 1){

			ck = true;

		}

	}

	if(n == 1){

		cout << "-1\n";

	}else if(n == 2){

		if(A[1] == B[1] && A[2] == B[2])cout << "-1\n";
		else{

			cout << "1\n";

		}
	}else{

		if(ck){

			cout << "1\n";

		}else{

			cout << "2\n";

		}

	}

}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int T;
    cin >> T;
    while(T--){

       solve();

    }

    return 0;
}
avatar
文章
阅读
粉丝