Codeforces Round 882 (Div. 2) A-D

最新推荐文章于 2024-05-21 20:29:42 发布

Muelsyse_

最新推荐文章于 2024-05-21 20:29:42 发布

阅读量199

点赞数 3

分类专栏： CF 文章标签：算法

本文链接：https://blog.csdn.net/Muelsyse_/article/details/131588900

版权

CF 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

写的烂，看着图个乐吧...

A. The Man who became a God

题意：

给出n，k和一个长度为n的数组A。定义一个区间Li到Ri的价值为 $\sum_{i=L}^{i=R-1}\left | A[i]-A[i+1] \right |$ 求把整个数组分为k个区间的最小价值。

题解：

贪心。先把整个数组看为一个整体然后在中间断开k-1个连接就能拆分成k个区间，要让最终价值最小只需要让断开的连接价值最大，因此只需计算出所有 $\left | A[i]-A[i+1] \right |$ ，排序之后对前n-k个求和即可。

#define _CRT_SECURE_NO_WARNINGS
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const LL N = 1e2 + 10, INF = 0x3f3f3f3f;
int a[N], b[N];
void solve()
{
	int n, k, ans = 0;
	scanf("%d%d", &n, &k);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &a[i]);
	for (int i = 1; i < n; ++i)
		b[i] = abs(a[i + 1] - a[i]);
	sort(b + 1, b + n);
	for (int i = 1; i <= n - k; ++i)
		ans += b[i];
	printf("%d\n", ans);
}
int main()
{
	int T = 1;
	scanf("%d", &T);
	while (T--)
	{
		solve();
	}
	return 0;
}

B. Hamon Odyssey

题意：

给定一个长度为n的数组，定义f(l,r)=al&al+1&al+2&…&ar.问最多能将数组拆成几个连续区间使得f(1,r1)+f(l2,r2)+...+f(lk,n)的值最小

题解：

先求出整个数组的按位与之后的值f(1,n)，f(1,n)即整个数组的所有连续区间按位与之后相加的最小值。若f(1,n)!=0说明整个数组最小的f(l,r)==f(1,n)!=0,因此最多只能把数组拆成1个连续区间（若拆成俩f(1,t)+f(t+1,r)>=2*(1,n)和不为最小值）。若f(1,n)==0，则求最多能把集合拆成几个按位与之后值为0的区间，具体方式见代码...

#define _CRT_SECURE_NO_WARNINGS
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const LL N = 2e5 + 10, INF = 0x3f3f3f3f;
int a[N];
void solve()
{
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &a[i]);
	int t = a[1];
	for (int i = 2; i <= n; ++i)
		t &= a[i];
	if (t)
		printf("1\n");
	else
	{
		int ans = 0;
		for (int i = 1, s = 0; i <= n; ++i)
		{
			if (s == 0)s = a[i];
			s &= a[i];
			if (s == 0)++ans;
		}
		printf("%d\n", ans);
	}
}
int main()
{
	int T = 1;
	scanf("%d", &T);
	while (T--)
	{
		solve();
	}
	return 0;
}

C. Vampiric Powers, anyone?

题意：

给定一个初始长度为n的数组，你可以对数组进行任意次操作：设多次操作之后数组的长度为m，选定一个下标i(1<=i<=m)，在数组末尾加入 am+1=ai⊕ai+1⊕…⊕am(亦或操作)，求任意次操作后数组中最大的元素的大小。

题解：

亦或和有类似于前缀和的特性，记Si为a1⊕a2⊕…⊕ai，i<j，Si-1⊕Sj=ai⊕ai+1⊕…⊕aj，当依次选择了x,y(x>y)后，设f(l,r)=al⊕al+1⊕…⊕ar，am-1=f(x,m-2)，am=f(y,m-1)=f(y,x-1)⊕f(x,m-2)⊕am-1=f(y,x-1)，即最终通过任意次操作后能求出所有的f(l,r)，那最终最大的元素大小及原数组中最大的某个连续区间的亦或和f(l,r)，而f(l,r)又能表示为Sl-1⊕Sr，那问题就变成了求出数组S中最大的亦或值，用贪心+tire处理。

对于求与Sj亦或后值最大的Si(i<j)只需要将前S0到Sj-1存入tire树，然后从高位往低位贪心的优先找与Sj的当前位不同的就行了...写的好垃圾感觉不如直接看代码

#define _CRT_SECURE_NO_WARNINGS
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const LL N = 1e5 + 10, INF = 0x3f3f3f3f;
int a[N], tr[8 * N][2], idx;
void updata(int x)
{
	for (int i = 7, t = 0; i >= 0; --i)
	{
		int f = x >> i & 1;
		if (!tr[t][f])
			tr[t][f] = ++idx;
		t = tr[t][f];
	}
}
int find(int x)
{
	int res = 0;
	for (int i = 7, t = 0; i >= 0; --i)
	{
		int f = x >> i & 1;
		if (tr[t][1 - f])
			res += 1 << i, t = tr[t][1 - f];
		else
			t = tr[t][f];
	}
	return res;
}
void solve()
{
	int n, ans = 0;
	scanf("%d", &n);
	for (int i = 0; i <= 8 * n; ++i)
		tr[i][0] = tr[i][1] = 0;
	idx = 0;//←初始化↑
	updata(0);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d", &a[i]);
		a[i] ^= a[i - 1];
		ans = max(ans, find(a[i]));
		updata(a[i]);
	}
	printf("%d\n", ans);
}
int main()
{
	int T = 1;
	scanf("%d", &T);
	while (T--)
	{
		solve();
	}
	return 0;
}

D. Professor Higashikata

题意：

给一个长度为n的由0或1组成的字符串S，m个ch的子串的范围Li,Ri(1<=Li,Ri<=n)（即子串为S[Li],S[Li+1],...,S[Ri]），q次反转操作xi(1<=xi<=n) (即S[xi]=!S[xi])，定义一次交换操作为swap(S[i],S[j])(1<=i,j<=n)

有一个由m个S的子串依次拼接成的字符串，问在每次反转操作之后最少经过几次交换操作能使此字符串字典序最大

题解：

贪心，树状数组。

字典序问题一般都会用到贪心，对于这个问题可以先给原字符串的所有位置定义一个优先级，在最终拼接成的字符串中越靠前的优先级越高，考虑依次遍历所有Li到Ri，若当前位置还没有赋予优先级 (f[i]==0) 则给这个位置赋予一个新的优先级(f[i]=++idx)。暴力遍历所有的Li到Ri会超时，在对同一段区间进行多次遍历的时候我们可以尝试跳过这段区间，定义一个数组p[i]为i的下一位，对每次i=p[i]的时候进行一个路径优化（并查集里的那个）

int p[N], f[N], idx;
int find(int x)
{
	if (f[p[x]])//路径优化
		p[x] = find(p[x]);
	return p[x];
}
void init(int n, int m)//初始化优先级
{
	for (int i = 1; i <= n; ++i)
		p[i] = i + 1;
	for (int i = 1; i <= m; ++i)
	{
		int l, r;
		scanf("%d%d", &l, &r);
		for (int j = l; j <= r; j = find(j))
			if (!f[j])f[j] = ++idx;
	}
}

原字符串S中并不一定每一个位置都会被用上，没用上的位置f[i]=0，记有idx个位置是有用的。

设每次反转操作之后S中‘1’的个数为s1对于每次询问时，要保证拼接成的字符串字典序最大，则要保证优先级1到min(s1,idx)的位置最终必须是1，那具体操作就是把优先级1到min(s1,idx)的位置上原来是1的不动，原来是0的移一个别的地方的1过来，那最少的交换次数就为优先级为1到s1的位置上0的数量（或为s1-1的数量）。考虑用树状数组来维护按优先级为下标的前缀和即可。

#define _CRT_SECURE_NO_WARNINGS
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const LL N = 2e5 + 10, INF = 0x3f3f3f3f;
char ch[N];
int p[N], f[N], tr[N], idx;
int find(int x)
{
	if (f[p[x]])
		p[x] = find(p[x]);
	return p[x];
}
int lowbit(int x)
{
	return x & -x;
}
void updata(int i, int x)
{
	if (i == 0)return;
	while (i <= idx)
	{
		tr[i] += x;
		i += lowbit(i);
	}
}
int get_sum(int i)
{
	int sum = 0;
	while (i >= 1)
	{
		sum += tr[i];
		i -= lowbit(i);
	}
	return sum;
}
void solve()
{
	int n, m, q, s = 0;
	scanf("%d%d%d%s", &n, &m, &q, ch + 1);
	for (int i = 1; i <= n; ++i)
		p[i] = i + 1;
	for (int i = 1; i <= m; ++i)
	{
		int l, r;
		scanf("%d%d", &l, &r);
		for (int j = l; j <= r; j = find(j))
			if (!f[j])f[j] = ++idx;
	}
	for (int i = 1; i <= n; ++i)
	{
		updata(f[i], ch[i] - '0');
		s += ch[i] - '0';
	}
	for (int i = 1, x; i <= q; ++i)
	{
		scanf("%d", &x);
		if (ch[x] == '0')
			++s, updata(f[x], 1), ch[x] = '1';
		else
			--s, updata(f[x], -1), ch[x] = '0';
		printf("%d\n", min(s, idx) - get_sum(min(s, idx)));
	}
}
int main()
{
	int T = 1;
	//scanf("%d", &T);
	while (T--)
	{
		solve();
	}
	return 0;
}