1.21Codeforces Round 999 (part div.2)

合集 - Codeforces记录(5)

1.CF2070E(edu.175) Game with Binary String 题解03-052.CF1827B2 Range Sorting (Hard Version) 题解03-053.2025.2.12(CF.R1004.part-div.2)03-05

4.1.21Codeforces Round 999 (part div.2)03-05

5.CW寒假年前集训1.20(Codeforces Round 998 div.3)03-05

收起

前言：质量超级高的div.2

B:

题意：

给你$n$个数，问是否可以在其中选出4个使得构成一个等腰梯形，如果可以就输出方案，否则输出$-1$

思路：

考虑可以构成等腰梯形的充要条件：设此等腰梯形的两个腰长度为$c$,两个底为$a,b$，则$|a-b|<2c$

若存在至少两对相同的边长，则其一定能构成等腰梯形

若只有一对，则根据充要条件判断

否则无解

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>

const int N = 2e5 + 10;
int a[N];

void solve(){
	int n;
	std::cin >> n;
	for(int i = 1;i <= n;++i){
		std::cin >> a[i];
	}
	std::sort(a + 1,a + n + 1);
	for(int i = n;i >= 4;--i){
		if(a[i] == a[i - 3]){
			std::cout << a[i] << ' ' << a[i] << ' ' << a[i] << ' ' << a[i] << '\n';
			return;
		}
	}
	std::set<int> s;
	for(int i = n;i >= 2;--i){
		if(a[i] == a[i - 1]) s.insert(a[i]);
	}
	
	if(s.empty()) {
		std::cout << -1 << '\n';
		return;
	}
	if((int)s.size() >= 2){
		auto it = s.begin();
		int x = *it;
		++it;
		int y = *it;
		std::cout << x << ' ' << x << ' ' << y << ' ' << y << '\n';
		return;
	}
	
	int x = *s.begin();
	int p = (int)(std::lower_bound(a + 1,a + n + 1,x) - a);
	for(int i = p;i <= n - 2;++i){
		a[i] = a[i + 2];
	} 
	n -= 2;
	for(int i = 2;i <= n;++i){
		if(a[i] - a[i - 1] < 2 * x){
			std::cout << a[i - 1] << ' ' << x << ' ' << x << ' ' << a[i] << '\n';
			return;
		}
	}
	
	std::cout << -1 << '\n';
}

int main(){
	int T;
	std::cin >> T;
	while(T--) solve();
	return 0;
}

C:(小清新动态规划题)

题意：题面

转化题意：

找到一组 诚实 / 说谎 的分配, 使得没有两个说谎者可以站在一起, 并且满足所有诚实的人说的都是真的

思路：

考虑令$f_{i,0/1}$表示考虑到$i$人, 其中这个人是诚实还是说谎，考虑转移, 可以确定的是不能记录当前有多少个说谎者, 考虑找性质使其可以直接解决

重要性质：
若当前人说谎，则其左边的人一定是诚实的

那么考虑当前是诚实的人

1.$a_i=a_{i-1}$

那么若左边的人是诚实的，则满足题意；若左边的人是说谎的，那么由题意，左边的左边那个人一定是诚实的，所以若$a_{i-2}+1=a_i$ 这种情况才可以成立

2.$a_i\ne a_{i-1}$

那么若左边的人是诚实的，则一定不满足题意；若左边的人是说谎的，那么由题意，左边的左边那个人一定是诚实的，所以若$a_{i-2}+1=a_i$这种情况才可以成立

由上述条件，$f$的转移就十分简单了

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
const int MAXN = 2e5 + 20;
const int MOD = 998244353;

namespace calc {
    int add(int a, int b) { return a + b > MOD ? a + b - MOD : a + b; }
    void addon(int &a, int b) { a = add(a, b); }
} using namespace calc;

int n;
int a[MAXN];

int dp[MAXN][2];

void solve(){
	scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);

    memset(dp, 0, sizeof dp);
    dp[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        addon(dp[i][1], dp[i - 1][0]);
        if (a[i] == a[i - 1]) {
            if (a[i - 2] + 1 == a[i]) addon(dp[i][0], dp[i - 1][1]);
            addon(dp[i][0], dp[i - 1][0]);
        } else {
            if (a[i - 2] + 1 == a[i]) addon(dp[i][0], dp[i - 1][1]);
        }
    }
        
    printf("%d\n", add(dp[n][0], dp[n][1]));
}

int main()
{
    int T; 
	scanf("%d", &T);
    while (T--) solve();
    return 0;
}

D:(逆向思维好题)

题意：题面

思路：

我们发现，如果真的按题意模拟合并数组$a$，处理起来非常复杂，正难则反，若我们考虑将$b$数组中的元素拆分之后与$a$再比较会舒服很多，因为对于一个数$x$，若要满足题意限制，则一定只能拆分成$\lfloor \frac{x}{2}\rfloor$与$\lceil \frac{x}{2}\rceil$这样的形式

我们可以对$b$中的数字进行这种拆分操作，正好$n-m$次。如果$b$中的最大数字也出现在$a$中，我们可以同时将其从$a$和$b$中删除。否则，$b$中最大的数字必须拆分为两个较小的数字

为了有效地管理$a$和$b$中的数字，我们可以使用优先队列或多重集。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<set>
#include<vector>
#define int long long
const int N = 2e5 + 10;

int a[N],b[N];
void solve(){
	int n,m,sa = 0,sb = 0;
	std::cin >> n >> m;
	for(int i = 1;i <= n;++i) {
		std::cin >> a[i];
		sa += a[i];
	}
	for(int i = 1;i <= m;++i) {
		std::cin >> b[i];
		sb += b[i];
	}
	if(sa != sb){
		std::cout << "No" << '\n';
		return;
	}
	
	std::multiset<int> s;
	for(int i = 1;i <= n;++i) s.insert(a[i]);
	for(int i = 1;i <= m;++i){
		std::vector<int> stk;
		stk.push_back(b[i]);
		while(!stk.empty()){
			int y = stk.back();
			stk.pop_back();
			if(s.find(y) != s.end()){
				s.erase(s.find(y));
			}else{
				if(y == 1){
					std::cout << "No" << '\n';
					return;
				}
				stk.push_back(y / 2); 
				stk.push_back(y - y / 2);
			}
		}
	}
	std::cout << "Yes" << '\n';
}

signed main(){
	int T;
	std::cin >> T;
	while(T--) solve();
	return 0;
}

E:（数学好题）

题意：题面

思路：

这道题其实如果严谨做出来并且在考场上A掉，那么其一定具有较高的数学素养，但是很可惜，大部分人都是赌王，直接在考场上赌出贪心思路，甚至有人根本没发现自己算法的不严谨性

因为最终答案是让你求出$min\{\sum a_i\}$所以我们希望可以每次都使$a_i$尽可能减去更多的值，有人问了，你怎么确定每次$a_i$一定不会增加呢？这其实就涉及到了按位与运算的性质，很好证明

那么好，我们令$g_{i,j}$表示对于$a_i$我们执行$j$次操作后，$a_i$的最小值，所以显然的，因为$m$的范围很小，我们可以直接状态压缩集合来暴力预处理。

现在，我们给出一个非常重要的结论(很多人考场根本没有发现自己这一部分漏洞)：

首先为了方便，对于每一个$a_i$其代价函数$g$我们直接表示为$g_i(1<i\le m)$

那么一定有：

$$2g_i<g_{i-1}+g_{i+1}$$

也就是函数$g$呈凸性

proof(太妙了):

令$S$为产生$g_{i-1}$的操作集合($|S|=i-1$)，$T$为产生$g_{i+1}$的操作集合($|T|=i+1$)，令$g_{i-1}$与$g_{i+1}$的最高不同位为$w$，则由按位与操作的性质，一定有$g_{i-1}$这一位是$1$，而$g_{i+1}$是$0$,(有用且有趣的性质，想一想为什么)。

令函数$f(S)$表示对于这一个$a_i,(|S|=i)$，操作集合$S$产生的值,所以形式化的，我们可以给出下列式子：

$$g_i=mi{n}_{|S|=i}\{f(S)\}$$

所以显然注意到:

$${\mathrm{\forall }}_{S,|S|=i}f(S)\ge g_i$$

有了这些铺垫，我们又注意到一定${\mathrm{\exists }}_{y\in T-S}$（这里的$T-S$表示集合的差）使得$g_{i-1}$的第$w$位变成$0$，且$|S\bigcup \{y\}|=i$。
所以一定有:

$$g_{i-1}-f(S\bigcup \{y\})\ge 2^w$$

又因为此时$f(S\bigcup \{y\})$与$g_{i+1}$最多只在第$(w-1)$位不同所以又有：

$$f(S\bigcup \{y\})-g_{i+1}\le 2^w-1$$

联立上述两个不等式我们可以得到以下放缩：

$$2g_i\le 2f(S\bigcup \{y\})<g_{i-1}+g_{i+1}$$

即：

$$2g_i<g_{i-1}+g_{i+1}$$

Q.E.D

那么现在我们就可以继续流畅地解决这道题了我们发现对于数组$g_i$可以做差分操作，即：$g_{i,j}=g_{i,j}-g_{i,j-1}$又因为$g$刚刚证明过的凸性，可以得出对于每一个$i$，$g_i$的差分序列是单调递减的，所以我们才能放心的把所有的$g$的差分序列放在一堆，然后按倒序排序，用$\sum a_i$减去前$k$个最小的即可。

#include<iostream>
#include<algorithm>
#include<cstdio> 
#include<cstring>
#include<vector>
#define int long long
#define count_1 __builtin_popcount
using namespace std;

const int N = 1e5;
const int M = 15;
const int INF = 0x3f3f3f3f3f3f3f;
int a[N],b[M],val[N * 10 + 5],f[1 << 10],pre[N];

bool cmp(int a,int b){
	return a > b;
}

void solve(){
	int n,m,mx;
	std::cin >> n >> m >> mx;
	for(int i = 1;i <= n;++i) std::cin >> a[i];
	for(int i = 1;i <= m;++i) std::cin >> b[i];
	for(int i = 1;i <= n * m;++i) val[i] = 2e9;
	
	for(int S = 1;S < (1 << m);++S){
		pre[S] = (1ll << 31) - 1;
		for(int i = 1;i <= m;++i)if((S >> i - 1 ) & 1) pre[S] &= b[i];
	}
	
	for(int i = 1;i <= n;++i){
		f[0] = a[i];
		for(int S = 1;S < (1 << m);++S){
			f[S] = a[i] & pre[S];
			int pos = (i - 1) * m + count_1(S);
			val[pos] = min(val[pos],f[S]);
		}
		for(int j = i * m;j > (i - 1) * m + 1;--j) val[j] = val[j - 1] - val[j];
		val[(i - 1) * m + 1] = a[i] - val[(i - 1) * m + 1];
	} 
	int tot = n * m;
	std::sort(val + 1,val + 1 + tot,cmp);
	int ans = 0;
	for(int i = 1;i <= n;++i) ans += a[i];
	for(int i = 1;i <= mx;++i) ans -= val[i];
	std::cout << ans << '\n';
}

signed main(){
	std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
	int T;
	std::cin >> T;
	while(T--) solve();
	return 0;
}

F1：

这个没什么特别惊艳的，直接给代码吧。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string> 
const int N = 4e5 + 10;
int n,m1,m2,lens[N],lent[N]; 

void solve(){
	std::string s,t;
	std::cin >> s >> t;
	n = s.length();
	char u = t[0],v = t[n - 1];
	s = u + s + v,t = u + t + v,n += 2;
	int tmp_len = 0;
	m1 = m2 = 0;
	for(int i = 0;i < n;++i){
		if(i > 0 && s[i] != s[i - 1]) lens[++m1] = tmp_len,tmp_len = 1;
		else ++tmp_len;
	}
	lens[++m1] = tmp_len;
	tmp_len = 0;
	for(int i = 0;i < n;++i){
		if(i > 0 && t[i] != t[i - 1]) lent[++m2] = tmp_len,tmp_len = 1;
		else ++tmp_len;
	} 
	lent[++m2] = tmp_len;
	int i = 1,j = 1;
	while(j <= m2){
		if(i > m1) {
			std::cout << -1 << '\n';
			return;
		}
		if(lent[j] < lens[i]){
			std::cout << -1 << '\n';
			return;
		}
		if(lent[j] == lens[i]){++i,++j;continue;}
		if(i == m1){
			std::cout << -1 << '\n';
			return;
		}
		int x = lens[i],y = lens[i + 1];
		if(j + 1 <= m2){
			while(i + 3 <= m1){
				x += lens[i + 2],y += lens[i + 3],i += 2;
				if(x > lent[j]) {
					std::cout << -1 << '\n';
					return; 
				}
				if(x == lent[j]) break;
			}
			if(x == lent[j]) ++i,++j,lens[i] = y;
			else {
				std::cout << -1 << '\n';
				return;
			}
		}else{
			std::cout << -1 << '\n';
			return;
		} 
	}
	if(i > m1) std::cout << (m1 - m2) / 2 << '\n';
	else {
		std::cout << -1 << '\n';
		return;
	}
}

int main(){
	int T;
	std::cin >> T;
	while(T--) solve(); 
	return 0;
}

F2:(It's so difficult that I think I should depend on my father's power.)

题意：题面

思路: