Codeforces Round 816 (Div. 2)

基本情況

A秒了,B错一次之后也过了,C没思路。

B. Beautiful Array

Problem - B - Codeforces

void solve()
{
	long long n, k, b, s;
	memset(ans, 0, sizeof(ans));
	std::cin >> n >> k >> b >> s;
	if (s < b * k) {std::cout << "-1\n"; return ;}
	s -= b * k;
	ans[1] = b * k;
	for (int i = 2; i <= n; i++)
	{
		if (s - k > 0)
		{
			s -= k; ans[i] = k;
		}
		else
		{
			ans[i] = s; s = 0; break;
		}
	}
	if (s != 0) {std::cout << "-1\n"; return ;}
	for (int i = 1; i <= n; i++) std::cout << ans[i] << " ";
	std::cout << std::endl;
}

这个贪心大体上好像很对,但是又是细节问题。

  • 我把剩下的 \(ans_i\) 都赋成 \(k\) ,然而 \(\left \lfloor \frac{k}{k} \right \rfloor\)\(1\) 啊,我要搞的是等于零的最大可能的数,自然是 \(k - 1\)
  • $ans_1 = b * k $ 还不够贪,可以往上找到最大的符合 \(\left \lfloor \frac{temp}{k} \right \rfloor = b\) 的数,一开始样例跑了很久,突然发现可能会T,然后改用二分就OK。(然而这个改进并不影响正确性,似乎数据不大行)

这两个改完就AC了。

void getTemp(long long& x)
{
	long long l = b * k, r = s, mid;
	while(l <= r)
	{
		mid = l + (r - l >> 1); 
		if (mid / k == b) x = mid, l = mid + 1;
		else r = mid - 1;
	}
	return ;
}

void solve()
{
	memset(ans, 0, sizeof(ans));
	std::cin >> n >> k >> b >> s;
	if (s < b * k) {std::cout << "-1\n"; return ;}
	long long temp;
	getTemp(temp);
	s -= temp; ans[n] = temp; 
	k--;
	for (int i = n - 1; i >= 1; i--)
	{
		if (s - k > 0)
		{
			s -= k; ans[i] = k;
		}
		else
		{
			ans[i] = s; s = 0; break;
		}
	}
	if (s != 0) {std::cout << "-1\n"; return ;}
	for (int i = 1; i <= n; i++) std::cout << ans[i] << " ";
	std::cout << std::endl;
}

C. Monoblock

Problem - C - Codeforces

想了一个递推,还是错的,时间复杂度也不行。

思路

每次只变一个数,因此考虑在短时间内计算:每个位置的数产生的贡献。

容易发现以下的条件:

  • 不管 \(a_i\) 是什么,当它作为一个子串的首项时,块数一定会加一。共有 \((n - i + 1)\) 个串的首项是 \(a_i\)
  • 如果 \(a_i \ne a_{i-1}\),所有包含 \(a_i\)\(a_{i+1}\) 的子串,块数都加一。乘法原理,头有 \((i - 1)\) 个位置可以选(\(0\)\(i - 1\)),尾有 \((n - i + 1)\) 个位置可以选(\(i\)\(n\)),共 \((i - 1) \times (n - i + 1)\)

那么,我们就可以知道 \(a_{i - 1}\)\(a_i\) 间产生的贡献是多少。

LL calc(int i) //统计 a[i-1]与a[i]间产生的贡献
{
	LL k = n - i + 1; //以 a[i] 为头的所有子串,不管a[i-1]与a[i]相不相同,都要计算贡献。 
	if (a[i-1] == a[i]) return k;
	return 1ll * (i - 1) * (n - i + 1) + k; //不同才会产生贡献
}

然后,我们可以计算:原本的 \(a\) 数组有多少贡献。这非常简单。

LL sum = 0;
for (int i = 1; i <= n; i++) sum += calc(i);

那么,怎样在短时间内计算 \(a_i\) 改变后的值呢?只需要:

  1. 减去 \(a_{i-1}\)\(a_i\) 产生的贡献,减去 \(a_i\)\(a_{i + 1}\) 产生的贡献。因为它们过一会会变。
  2. 更改 \(a_i\)
  3. 重新加上 \(a_{i-1}\)\(a_i\) 产生的贡献,以及加上 \(a_i\)\(a_{i + 1}\) 产生的贡献。

然后再输出结果即可。

代码

LL calc(int ind) //统计 a[i-1]与a[i]间产生的贡献
{
	LL k = n - ind + 1;//以 a[i] 为头的所有子串,不管a[i-1]与a[i]相不相同,都要计算贡献。
	if (a[ind - 1] == a[ind]) return k;
	return 1ll * (ind - 1) * (n - ind + 1) + k;//不同才会产生贡献
}
int main()
{
 	LL sum = 0;
 	std::cin >> n >> m;
 	for (int i = 1; i <= n; i++) std::cin >> a[i];
 	for (int i = 1; i <= n; i++) sum += calc(i);//先算一遍总值
 	while(m--)
 	{
 		std::cin >> ind >> x;
 		sum -= calc(ind); sum -= calc(ind + 1);//把修改前i上的数的贡献减掉
 		a[ind] = x;
 		sum += calc(ind); sum += calc(ind + 1);//把修改后i上的数的贡献加上
 		std::cout << sum << std::endl;
	}
	return 0;
}

posted @ 2023-12-17 15:47  加固文明幻景  阅读(5)  评论(0编辑  收藏  举报