Codeforces Global Round 21

努力码字中...

已于 2022-06-26 18:43:04 修改

阅读量399

点赞数

文章标签：算法 c++ 数据结构贪心算法

于 2022-06-26 18:35:47 首次发布

本文链接：https://blog.csdn.net/weixin_52255583/article/details/125467831

版权

这个比赛一共 8 道题,AC 3 道,补题 2 道

文章目录

一、A - NIT orz!
二、B - NIT Destroys the Universe
三、C - Fishingprince Plays With Array
四、补:D - Permutation Graph
五、补:E - Placing Jinas

一、A - NIT orz!

题目:
给你一个数组A,里面有n个数字,再给你一个数字Z,你可以从数组A中选择一个索引为i的元素A[i],使得A[i] = A[i] | Z 和 Z = A[i] & Z,两者是同时进行的,不存在先后顺序,你可以执行上面的操作无限次数,如何操作可以使得A数组中元素的最大值最大.
思路:
每个元素最多可以执行一次,多执行并不会使得元素的值变大,考虑贪心,对每个数字都执行一遍最初的Z,取最大值就好
比如,A[1] = A[1] | Z 和 Z1 = A[1] & Z,然后A[2] = A[2] | Z1 和 Z2 = A[2] & Z1, 如果此时的A[2] > A[1],那这时候还不如直接执行A[2] = A[2] | Z,因为 Z >= Z1.所以直接执行 Z 会比直接执行 Z2 的值更大
代码:

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define PII pair<int,int>
#define int long long 
#define ios ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
using namespace std;
const int N = 2e5 + 100;
int a[N];
void solve()
{ 
	int n,z; cin >> n >> z;
	for(int i = 1;i <= n;i ++ ) cin >> a[i]; 
	int ans = 0;
	
	for(int i = 1;i <= n;i ++ )
	{
		int w = a[i] | z;
		ans = max(ans,w);
	}
	
	cout << ans << endl;
	
	
}
signed main() 
{
	ios;int T; cin >> T;
	while(T -- ) solve();

    return 0;
}

二、B - NIT Destroys the Universe

题目:
给一个数组A,可以执行操作选两个索引 L,R 让索引在L,R之间的所有元素都变成mex(A[L],A[L + 1]…A[R]) 问最少几次可以使得数组中所有的元素变为0.
mex()是括号里面没有出现的最小非负整数
思路:
1 如果A数组全是0的话,需要0次,
2 如果所有非0的元素的索引都是连续的,就只需要一次
3 不管数组A里面的元素是什么最多只需要两次操作就可以把整个数组变成0,两次都是L = 1,R = n,
4 这里我写复杂了,我都判断了一遍.
代码:

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define PII pair<int,int>
#define int long long 
#define ios ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
using namespace std;
const int N = 2e5 + 100;
int a[N];
void solve()
{ 
	int n; cin >> n;
	for(int i = 1;i <= n;i ++ ) cin >> a[i]; 
	
	int ans = 0;
	for(int i = 1;i <= n;i ++ )
	{
		if(a[i] != 0)
		{
			ans++;
			int j = i;
			while(a[j] != 0 && j <= n) j++;
			
			i = j - 1;
		}
	}
	if(ans > 2) ans = 2;
	
	cout << ans << endl;
	
	
}
signed main() 
{
	ios;int T; cin >> T;
	while(T -- ) solve();

    return 0;
}

三、C - Fishingprince Plays With Array

题目:
给你一个数组S,一个数组T,一个数字m,问S执行以下操作后能不能变成T
操作1:选择一个元素S[i],如果S[i] % m 等于 0 ,就把S[i]分成m个元素,每个元素都是 S[i] / m;
操作2:选择一个索引 i ,如果S[i] = S[i +1] = S[i + 2]… = S[i + m - 1]那就可以将这m个元素合并成一个元素,这个元素的值为m * S[i]
思路:
暴力的话时间复杂度为O(n²),而且很复杂,这里呢我就把 S 和 T 都一直执行操作1,把它们全部分解到不能再分解,然后统计每个位置的数字和个数,然后从前往后比较,因为m >= 2的所以最多分解的话不超过30次,所以时间复杂度最多就是O(n * 30 * 2),平均来看是O(n)的
代码:

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define PII pair<int,int>
#define int long long 
#define ios ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
using namespace std;
const int N = 2e5 + 100;
int a[N],b[N];
struct node
{
	int num,id;
}e[N],q[N];

void solve()
{ 
	int n,m; cin >> n >> m;
	for(int i = 1;i <= n;i ++ ) cin >> a[i]; 
	int k; cin >> k;
	for(int i = 1;i <= k;i ++ ) cin >> b[i];
	
	int cnt = 0,cnt2 = 0;
	for(int i = 1;i <= n;i ++ )
	{
		int ans = 1;
		while(a[i] % m == 0)
		{
			ans *= m;
			a[i] /= m;
		}
		if(a[i] != e[cnt].id)
		{
		e[++cnt].id = a[i];
		e[cnt].num += ans;
		}
		else
		{
			e[cnt].num += ans;
		}
	
	}
	
	for(int i = 1;i <= k;i ++ )
	{
		int ans = 1;
		while(b[i] % m == 0)
		{
			ans *= m;
			b[i] /= m;
		}
		if(b[i] != q[cnt2].id)
		{
		q[++cnt2].id = b[i];
		q[cnt2].num += ans;
		}
		else
		{
			q[cnt2].num += ans;
		}
	
	}
	int f = 0;
	if(cnt != cnt2) f = 1;
	else
	{
		for(int i = 1;i <= cnt;i ++ )
		{
			if(e[i].id != q[i].id)
			{
				f = 1;
				break;
			}
			
			if(e[i].num != q[i].num)
			{
				 f = 1;
				 break;
			}
		}
	}
	
	if(f)
	{
		cout << "No" << endl;
	}
	else
	{
		cout << "Yes" << endl;
	}
	
	for(int i = 1;i <= cnt;i ++ )
	{
		e[i].num = 0;
		e[i].id = -1;
	}
	
	
	for(int i = 1;i <= cnt2;i ++ )
	{
		q[i].num = 0;
		q[i].id = -1;
	}
	
	
}
signed main() 
{
	ios;int T; cin >> T;
	while(T -- ) solve();

    return 0;
}

四、补:D - Permutation Graph

思路:
观察图像发现，某个点走的时候走的越远越好，符合贪心策略，如果从L走，能走的最远的位置为R,，那在【L，R】范围里面的数走的最远的位置一定不超过R
假设数组A有5个元素一定存在一个走的策略是 1 -> 2 -> 3 -> 4 -> 5，这时候假设1最远只能走到4，在索引为[1,2,3,4]里面，a[1]和a[4]都是最值
假设a[1]是最小值,a[4]是最大值,因为1最远只能走到4，所以 a[5] < a[4]，那在【1，4】的范围内就不存在能走的比1更远的数字，比如2,假设2能走到5，那在【2，5】的范围内
应该是a[2]和a[5]都是最值,但是a[5] < a[4]，并且 a[2] < a[4]所以这个范围里面的最大值一定是a[4]，同理假设a[1]是最小值也一样，所以在【1，4】这个范围内一定不存在能比1走的更远的数字
思路和代码来自这个题解
代码:

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define PII pair<int,int>
#define int long long 
#define ios ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
using namespace std;
const int N = 3e5 + 100;
int a[N],q[N];
struct node
{
	int l,r;
	int mx;
	int mi;
}tr[N * 4];

void pushup(int u,int l,int r)
{
	tr[u].mi = min(tr[u << 1].mi,tr[u << 1 | 1].mi);
	tr[u].mx = max(tr[u << 1].mx,tr[u << 1 | 1].mx);
}

void build(int u,int l,int r)
{
	tr[u].l = l,tr[u].r = r;
	if(l == r)
	{
		tr[u].mi = a[l];
		tr[u].mx = a[l];
		return;
	}
	
	int mid = l + r >> 1;
	
	build(u << 1,l,mid);
	build(u << 1 | 1,mid + 1,r);
	pushup(u,l,r);
}
int query_max(int u,int l,int r)
{
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].mx;
	
	int mid = tr[u].l + tr[u].r >> 1;
	int mx = 0;
	if(l <= mid) mx = max(mx,query_max(u << 1,l,r));
	if(r > mid) mx = max(mx,query_max(u << 1 | 1,l,r));
	
	return mx;
}
int query_min(int u,int l,int r)
{
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].mi;
	
	int mid = tr[u].l + tr[u].r >> 1;
	int mi = 0x3f3f3f3f;
	if(l <= mid) mi = min(mi,query_min(u << 1,l,r));
	if(r > mid) mi = min(mi,query_min(u << 1 | 1,l,r));
	
	return mi;
}

int dfs(int l,int r)
{
	if(l + 1 == r) return 1;
	if(l >= r) return 0;
	int Max = query_max(1,l,r);
	int Min = query_min(1,l,r);
	int L = q[Max],R = q[Min];
	if(L > R) swap(L,R);
	return 1 + dfs(l,L) + dfs(R,r);
}
void solve()
{ 
	int n; cin >> n;
	for(int i = 1;i <= n;i ++ )
	{
		 cin >> a[i];
		 q[a[i]] = i;
	}
	if(n == 1) 
	{
		cout << "0" << endl;
		return;
	}
	build(1,1,n);
	cout << dfs(1,n) << endl;
}
signed main() 
{
	ios;int T; cin >> T;
	while(T -- ) solve();

    return 0;
}

五、补:E - Placing Jinas

题目:
给你一个非递增数组A，和一个表格，只要是y < A【x】，那（x,y）就是白色的，否则为黑色的，初始只有一个木偶在（0，0）处,若(x,y)处的木偶消失，那（x,y + 1）处和(x + 1,y)处就会出现新的木偶，把白格子里面的木偶全部消除掉最少需要多少次操作
思路:
这道题是一个找规律题，先打表，可以看出来，每一个格子被消除需要的操作次数是一个组合数，而且从(0,0)到（x,y）的和的答案是格子(x + 1，y + 1) 的组合数 - 1,所以我们求前缀，遍历每列，把每列的和加起来
代码：

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define PII pair<int,int>
#define LL long long 
#define ios ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
using namespace std;
const int N = 1e6  + 1,mod = 1e9 + 7;
int w[N];
LL f[N];
LL inf[N];

LL qsm(LL a,LL b)
{
    LL res = 1;
    LL k = a;
    
    while(b)
    {
        if(b & 1)
        {
            res =  res * k % mod;
        }
        
        b = b >> 1;
        k = k * k % mod; 
    }
    
    return res;
    
}

void init()
{
    f[0] = 1;
    inf[0] = 1;
    
    for(int i = 1;i <= N;i ++ )
    {
        f[i] = f[i - 1] * i % mod;
        inf[i] = inf[i - 1] * qsm(i,mod - 2) % mod;
    }
    
}

LL zhuhe(int a,int b)
{
	LL res = f[a] * inf[b] % mod;
	LL ans = inf[a - b] % mod;
	LL y = res * ans % mod;
	return y;
}
void solve()
{ 
	int n; cin >> n;
	for(int i = 0;i <= n;i ++ ) cin >> w[i];
	init();
	LL ans = zhuhe(w[0] + 1,1);
	
	for(int i = 1;i <= n;i ++ )
	{
		if(w[i] != 0)
		ans = (ans + zhuhe(i + w[i] + 1,i + 1) - zhuhe(w[i] + i,i) + mod) % mod;
		else
		break;
	}
	
	if(ans != 0) 
	cout << ans - 1 << endl;
	else
	cout << "0" << endl;
}
int main() 
{
	ios;int T = 1;
	while(T -- ) solve();

    return 0;
}