【寒假复健Day1】Codeforces 894题解

Codeforces Round 894 (Div. 3) - 题解

Codeforces Round 894 (Div. 3)

题目集

官方题解

A - Gift Carpet

模拟

​ 从左到右依次扫描每列，依次寻找***v,i,k,a***即可。

• 时间复杂度：$O(nm)$
• 空间复杂度：$O(nm)$

#include <bits/stdc++.h>

using namespace std;
const int N = 20;
string arr[N];
const string T = "vika";

int main() {
	int t;
	cin >> t;
	while (t--) {
		int n, m, i = -1, f = 1;
		cin >> n >> m;
		for (int y = 0; y < n; y++) cin >> arr[y];
		for (int x = 0; x < T.size(); x++, f = 1)
			while (f && ++i < m)
				for (int j = 0; j < n && f; j++) 
					if (arr[j][i] == T[x]) f = 0;
		cout << (i < m ? "YES\n" : "NO\n");
	}
}

B - Sequence Game

模拟

​ 当$a_{i-1}\le a_i$时，$a_i$会被填入数组$b$中，我们观察可以得知，一段（最长）连续上升序列时，处第一个元素外，剩余元素均被添加入$b$中，如$[3,1,2,3,1,2,3]$中，数组$b$为$[3,2,3,2,3]$。

​ 故我们将$b$数组遍历一遍，发现出现“断层”，即$b_{i-1}>b_i$，则可知在对应$a$数组中，二者之间必须存在一元素$x$满足$1\le x\le b_i$。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

#include <bits/stdc++.h>
 
using namespace std;
const int N = 2e5 + 1;
int arr[N], res[N * 2];
 
int main() {
	int t;
	cin >> t;
	while (t--) {
		int n, len = 1;
		cin >> n >> arr[0];
		res[0] = arr[0];
		for (int i = 1; i < n; i++) {
			cin >> arr[i];
			if (arr[i] < arr[i - 1]) res[len++] = 1;//[1,arr[i]]
			res[len++] = arr[i];
		}
		cout << len << '\n';
		for (int i = 0; i < len; i++) cout << res[i] << ' ';
		cout << '\n';
	}
} 

C - Flower City Fence

模拟

​ 根据题意，将木板反置，下标$i$处对应板高$h$，反置后的意义为下标$h$处对应板高$i$，并且是从开始连续至下标为$h$处的板高最高可知$i$，由于板高高度递减，答案也必然是递减的，我们记录下标$idx$，依次推动下标$idx$至$i$，并且将$(id{x}^{\prime },i]$的部分赋为$h$即可。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 1;
int arr[N], res[N];

int main() {
	int t;
	cin >> t;
	while (t--) {
		int n, idx = 0, f = 1;
		cin >> n;
		for (int i = 0; i < n; i++) cin >> arr[i];
		for (int i = n - 1; i >= 0; i--)
			while (idx < arr[i] && idx < n) res[idx++] = i + 1;
		for (int i = 0; i < n && f; i++)
			if (arr[i] != res[i]) f = 0;
		cout << (f ? "YES\n" : "NO\n");
	}
} 

D - Ice Cream Balls

二分

• 所有的都是不同的${}^1$：假设有$n$个不同口味，可以组合出 { x , y } ( x ≠ y ) \lbrace x,y\rbrace (x\neq y) {x,y}(x​=y)类型共$C_2^n=\frac{n(n-1)}{2}$种；
• 考虑两个相同的的${}^2$：每有两个相同口味，可以组合出 { x , x } \lbrace x,x\rbrace {x,x}，答案$+1$。

​ 所以我们先考虑第一类情况，得到 C 2 a = m a x { C 2 x ≤ n } C^a_2=max\lbrace C^x_2\leq n\rbrace C2a​=max{C2x​≤n}种种类，消耗$x$种口味；剩下的$n-C_2^a$种种类，使用第二类情况，消耗$n-C_2^a$种口味；答案即$a+n-C_2^a$。

​ 对于 m a x { C 2 x ≤ n } max\lbrace C^x_2\leq n\rbrace max{C2x​≤n}可以使用二分求得。

​ $C_2^x\le n<C_2^{x+1}$时，$n-C_2^x\le C_2^x$成立$(x\ge 2)$，故第二类情况总是满足。

​ $n\le 10^{18}$，二分时，初始右边界$r$直接取值$n$可能导致溢出，因为$C_2^x=\frac{x(x-1)}{2}\le n\Rightarrow x<2\sqrt{n}$，故取$r=min(n,2\times 10^9)$

• 时间复杂度：$O(\log n)$
• 空间复杂度：$O(n)$

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL MAX = 2e9;

int main() {
	int t;
	cin >> t;
	while (t--) {
		LL n;
		cin >> n;
		LL l = 2;
		LL r = min(MAX, n);
		while (l < r) {
			LL mid = (l + r + 1) / 2;
			LL t = mid * (mid - 1) / 2;
			if (t == n) l = r = mid;
			else if (t > n) r = mid - 1;
			else l = mid;
		}
		cout << l + (n - l * (l - 1) / 2) << '\n';
	}
}

E - Kolya and Movie Theatre

思维, STL(priority_queue)

​ 每次看电影，其娱乐值的衰退值$d\cdot cnt$的$cnt$并非间隔天数，而是绝对天数差(相邻两天也算作一天)，故衰退值之和，可以视为与最后一场电影的选取有关，$\sum d\cdot cn{t}_i=d\cdot id{x}_{last}$，其中$id{x}_{last}$为最后一次看电影的天数下标。

​ 我们依次考虑每一天看最后一场电影的情况，得到$a_i-di$；再从前$i-1$场电影中，选择最多$m-1$场以获得尽量大的娱乐值 m a x 1 ≤ j < i { ∑ a j } \mathop{max}\limits_{1\leq j< i}\lbrace \sum a_j\rbrace 1≤j<imax​{∑aj​}，用 a i − d i + m a x 1 ≤ j < i { ∑ a j } a_i-di+\mathop{max}\limits_{1\leq j< i}\lbrace \sum a_j\rbrace ai​−di+1≤j<imax​{∑aj​}更新答案即可。

​ 对于选择$i$前面最多$m-1$场电影的最优选择，可以用优先队列(小根堆)维护前最多$m-1$场电影的最小值，我们采取以下策略：

• 若$a_i\le 0$则当前电影无意义，直接跳过考虑；

• 若尚未选$m-1$场电影，则选择观看该场电影，并入堆。

• 若已选满$m-1$场电影，则用$a_i$与堆顶元素$q_{min}$比较，若$q_{min}<a_i$，则用$a_i$更新$q_{min}$：$q_{min}$出堆，$a_i$入堆，和$+a_i-q_{min}$。

• 时间复杂度：$O(n\log n)$

  • priority_queue(优先队列)，由二叉堆实现，插入、查询堆顶元素的时间复杂度均为$\log n$；

• 空间复杂度：$O()n$

#include <bits/stdc++.h>
 
using namespace std;
typedef long long LL;
const int N = 2e5 + 1;
 
int main() {
	int t;
	cin >> t;
	while (t--) {
		LL sum = 0, res = 0;
		LL n, m, d;
		cin >> n >> m >> d;
		priority_queue<int, vector<int>, greater<int>> q;
		for (int i = 1, x; i <= n; i++) {
			cin >> x;
			if (x > 0) {
				res = max(res, sum + x - d * i);
				if (q.size() < m - 1) q.push(x), sum += x;
				else if (m > 1 && q.top() < x) {
					sum += x - q.top();
					q.pop();
					q.push(x);
				}
			}
		}
		cout << res << '\n';
	}
} 

F - Magic Will Save the World

DP, bitset

​ 显然，应该将怪物按照使用的魔法类型分为两类——水魔法消灭和冰魔法消灭。使用水魔法消灭的怪兽的强度之和记为$X$，火魔法则记为$Y$，则至少需要$max(\lceil \frac{X}{w}\rceil ,\lceil \frac{Y}{f}\rceil )$。

​ 讨论划分方法，如果直接搜索枚举所有可能划分方法，枚举可达$2^n$种，由于$n\le 100$，喜提***TLE***。由此我们尝试非常经典的***0/1背包DP***，以怪物强度作为“体积”，求方案可行性；对于每一个可行的划分$X$，其$Y=\sum s_i-X$，故直接对所有的$s_i$进行***DP***，计算$max(\lceil \frac{X}{w}\rceil ,\lceil \frac{\sum s_i-X}{f}\rceil )$。

​ 由于 s i ≤ 1 0 4 , ∑ s i ≤ n ⋅ m a x { s i } = 1 0 6 s_i\leq10^4,\sum s_i\leq n\cdot max\lbrace s_i\rbrace=10^6 si​≤104,∑si​≤n⋅max{si​}=106，空间上允许；对于单个测试数据，的时间复杂度为$O(n\sum s_i)$方案可行，但是因为多测($t\le 100$)的存在，难以接受，故需要进一步优化。

​ 由于我们只关心方案的可行性，故可以采用经典的位运算优化——bitset，其运算操作常数极小，我们暂且视为$O(1)$。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(\sum s_i)$

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 1e6 + 1;
bitset<N> dp;

int main() {
	int t;
	cin >> t;
	while (t--) {
		int n, w, f, res = INT_MAX, sum = 0;
		cin >> w >> f >> n;
		dp.reset();
		dp[0] = 1;
		for (int i = 0, x; i < n; i++) {
			cin >> x;
			sum += x;
			dp |= (dp << x);
		}
		for (int i = 0; i <= sum; i++) 
			if (dp[i]) res = min(res, max((i + w - 1) / w, (sum - i + f - 1) / f));
		cout << res << '\n';
	}
} 

G - The Great Equalizer

STL(multiset)

思维

​ 每次操作都会将数组非递减排序${}^1$，并且删除重复元素${}^2$。经过这两步操作后，数组为严格升序，即$a_{i-1}<a_i$。

​ 在第三步时，将每个元素赋为$a_i=a_i+n-i+1$；此时我们换一个视角，每相邻两项，前一项比后一项多$加1$，即相邻两项的差($a_i-a_{i-1}$)减$1$；而当相邻两项相等时，则会合并。

​ 那每次操作可视为“追逐”，相邻两项之差减$1$，直至相同并合并，整体上直到只剩下一个数字为止。显然，本场“游戏”进行的次数为 m a x { a i − a i − 1 } max\lbrace a_i-a_{i-1}\rbrace max{ai​−ai−1​}，因为相邻两项相同时会合并，并且每次差仅减$1$，所以后一项总是大于前一项，“游戏”开始时排序后的最后一项(即最大的数组)会保留到最后，并且每次操作仅加$1$，故“游戏”最终剩下的数字为：
m a x { a i } + m a x { a i − a i − 1 } max\lbrace a_i\rbrace+max\lbrace a_i-a_{i-1}\rbrace max{ai​}+max{ai​−ai−1​}

维护

​ 如果我们根据思维来“暴力”解决这题——每次修改数组，对修改后的数组排序，$for$循环找出最大的相邻差分，与排序后的最后一项相加，得出答案。显然，时间复杂度为$O(qn\log n)$，喜提***TLE***的好成绩。

​ 此时我们应该使用STL***，来维护差值与快速查找最大差值与最大元素。其允许重复元素的按序查询、修改等，故使用**multiset***。

• 时间复杂度：$O(q\log n)$

  • multiset(多集)由***红黑树***实现，查询、删除、插入操作的时间复杂度均为$O(\log n)$，$n$为集合大小；

• 空间复杂度：$O(n)$

解题代码

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 1;
int arr[N];

int main() {
	cin.tie(0)->sync_with_stdio(false);
	int t;
	cin >> t;
	while (t--) {
		int n, q, idx, val;
		cin >> n;
		for (int i = 0; i < n; i++) cin >> arr[i];
		if (n == 1) {
			cin >> q;
			while (q--) {
				cin >> idx >> val;
				cout << val << ' ';
			}
			cout << '\n';
			continue;
		}
		multiset<int> a, s;//数组; 差值
		for (int i = 0; i < n; i++) a.insert(arr[i]);
		for (auto p = a.begin(), pr = a.begin(); ++p != a.end(); pr = p) s.insert(*p - *pr);
		cin >> q;
		while (q--) {
			cin >> idx >> val;
			//删除原idx下标的元素
			auto p = a.find(arr[idx - 1]);
			auto prve = p, next = p;
			prve--, next++;
			if (p == a.begin()) s.erase(s.find (*next - *p));//头
			else if (p == --a.end()) s.erase(s.find (*p - *prve));//尾
			else {//中间
				s.erase(s.find(*next - *p));//使用.find()防止删除多个相同值的元素
				s.erase(s.find(*p - *prve));
				s.insert(*next - *prve);
			}
			a.erase(p);
			//添加val
			prve = next = p = a.insert(val);
			prve--, next++;
			if (p == a.begin()) s.insert(*next - *p);//头
			else if (p == --a.end()) s.insert(*p - *prve);//尾
			else {//中间
				s.insert(*next - *p);
				s.insert(*p - *prve);
				s.erase(s.find (*next - *prve));
			}
			arr[idx - 1] = val;
			cout << *--a.end() + *--s.end() << ' ';
		}
		cout << '\n';
	}
}

后记

复健第一天，随便拿个题解糊弄下~