Codeforces Round #664 (Div. 2)

A. Boboniu Likes to Color Balls

---

首先，要由rgbw三种字符组成回文串，必定有三种字符的个数为偶数，另一种字符的个数可以是奇数，也可以是偶数。此外，根据题目的描述，每次操作后，rgb三种颜色的球减少1个，w球增加三个，这就意味着，通过一次操作之后，个数为奇数的球就变成了偶数个，个数为偶数的球就变成了奇数个。所以只要判断是否可以通过进行0次或1次操作就可以构造出回文串，就可以判断是否能形成回文串。

#include<bits/stdc++.h>
using namespace std;
int t, r, g, b, w;
bool f;

bool judge(){
    return ((r%2==0)&&(g%2==0)&&(b%2==0)&&(w%2==0)) || ((r%2==0)&&(g%2==0)&&(b%2==0)&&(w%2==1)) ||
           ((r%2==0)&&(g%2==0)&&(b%2==1)&&(w%2==0)) || ((r%2==0)&&(g%2==1)&&(b%2==0)&&(w%2==0)) ||
           ((r%2==1)&&(g%2==0)&&(b%2==0)&&(w%2==0));
}

int main(){
    scanf("%d", &t);
    while(t--){
        scanf("%d%d%d%d", &r, &g, &b, &w);

        if(judge()) printf("Yes\n");
        else{
            f = true;
            int m = min(r, g);
            m = min(m, b);

            if(m==0) printf("No\n");
            else{
                if( ((r%2==0)&&(g%2==0)&&(b%2==1)&&(w%2==1)) || ((r%2==0)&&(g%2==1)&&(b%2==0)&&(w%2==1)) ||
                    ((r%2==0)&&(g%2==1)&&(b%2==1)&&(w%2==0)) || ((r%2==1)&&(g%2==0)&&(b%2==0)&&(w%2==1)) ||
                    ((r%2==1)&&(g%2==0)&&(b%2==1)&&(w%2==0)) || ((r%2==1)&&(g%2==1)&&(b%2==0)&&(w%2==0))) printf("No\n");
                else printf("Yes\n");
            }
        }
    }
    return 0;
}

B. Boboniu Plays Chess

---

逐行遍历即可，限制是只能移动到所在行或所在列的某个单元格

#include<bits/stdc++.h>
using namespace std;
const int N = 100+5;
bool vis[N][N];
int n, m, x, y, num;
queue<int> r[N], c[N];

int main(){
    memset(vis, true, sizeof(vis));
    scanf("%d%d%d%d", &n, &m, &x, &y);
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            r[i].push(j);
        }
    }
    for(int i=1; i<=m; i++){
        for(int j=1; j<=n;j++){
            c[i].push(j);
        }
    }


    printf("%d %d\n%d %d\n%d %d\n", x, y, x, 1, 1, 1);
    vis[x][y] = vis[x][1] = vis[1][1] = false;

    int i=1, j, per;
    num += 3;
    while(num<n*m){
        while(!r[i].empty()){
            j = r[i].front();
            r[i].pop();
            if(vis[i][j]){
                printf("%d %d\n", i, j);
                vis[i][j] = false;
                num++;
                per = j;
            }
        }
//        cout<< "per:"<< per<< endl;
        j = per;
        i = c[j].front();
        c[j].pop();
        while(!vis[i][j]){
            i = c[j].front();
            c[j].pop();
        }
        if(i&&j&&vis[i][j]){
            printf("%d %d\n", i, j);
            vis[i][j] = false;
            num++;
        }
    }
    return 0;
}

C. Boboniu and Bit Operations

---

二进制枚举答案。因为a和b的最大值<2⁹ ，所以最后的结果最大是9个位置全1，数据量不是很大，直接枚举[0, 1<<9)即可。每次将枚举值和a[i]&b[j]的值进行与运算，如果有一个 j 可以使相与后枚举值不变，那么当前a[i]可以，如果没有，那么当前枚举值不满足条件。当所有a[i]都可行，当前枚举值就是答案，否则继续枚举。

关于 k|(a[i]&b[j]))==k ：
首先a|b的结果，要么保持a b中的最大值，要么更大
1.假设现在k就是最小值，k可以看成是前面i个c相或的结果，现在k|(a&b)，如果结果不是k，那么结果肯定比k大， 这样一来，前（i+1）个c相或的结果就比k大了，即使后面在进行或运算，最后结果一定比k大，也就是说k不是要找的最小值
2.假设现在k就是最小值，k可以看成是前面i个c相或的结果，现在k|(a&b)，如果结果是k，就继续往下找， 每次k|(a&b)==k,就能找到一个序列满足条件，而k是从小到大找的，所以x就是最小值

#include<bits/stdc++.h>
using namespace std;
const int MAX = 200+5;
int n, m, a[MAX], b[MAX];

int main(){
    scanf("%d%d", &n, &m);

    for(int i=0; i<n; i++) scanf("%d", &a[i]);
    for(int i=0; i<m; i++) scanf("%d", &b[i]);

    for(int k=0; k<(1<<9); k++){
        bool flag = false;
        for(int i=0; i<n; i++){
            flag = false;
            for(int j=0; j<m; j++){
            	/*
            	首先a|b的结果，要么保持a b中的最大值，要么更大
            	1.假设现在k就是最小值，k可以看成是前面i个c相或的结果，现在k|(a&b)，如果结果不是k，那么结果肯定比k大，
            	  这样一来，前（i+1）个c相或的结果就比k大了，即使后面在进行或运算，最后结果一定比k大，也就是说k不是
            	  要找的最小值
            	2.假设现在k就是最小值，k可以看成是前面i个c相或的结果，现在k|(a&b)，如果结果是k，就继续往下找，
            	  每次k|(a&b)==k,就能找到一个序列满足条件，而k是从小到大找的，所以x就是最小值
            	*/
                if((k|(a[i]&b[j]))==k){
                    flag = true;
                    break;
                }
            }
            if(!flag) break;
        }
        if(flag){
            printf("%d", k);
            break;
        }
    }
    return 0;
}

D. Boboniu Chats with Du

---

贪心。先把大于m和小于等于m的区分开存放；假设当前有x个大于m的数，那么可以选择1~x个大于m的数，并且要尽量选最大的；假设选了y个，那么其中一个可以放在第n天，用掉1天；剩下的y-1个用掉 (y-1)(d+1)天 ; 现在总共用掉 (y-1)(d+1) +1天；剩下left = n-(y-1)*(d+1) +1天；剩下的left天在小于m的数里面找，当然也是尽量找最大的；对于每一个y，都得到一个值，选择最大值作为答案。

#include<bits/stdc++.h>
using namespace std;
const int N =2e5+10;
typedef long long ll;
ll a[N], b[N];
int n, d, m;

int main()
{
	scanf("%d%d%d", &n, &d, &m);

	int aa = 0, bb = 0;
	for(int i=1; i<=n; i++)
	{
		ll tmp;
		scanf("%lld", &tmp);
		if(tmp>m) a[++aa] = tmp;
		else b[++bb] = tmp;
	}

	sort(a+1, a+1+aa, greater<int>());
	sort(b+1, b+1+bb, greater<int>());
	for(int i=1; i<=bb; i++) b[i] += b[i-1];

	ll res = 0, ans = b[bb];
	for(int i=1; i<=aa; i++)
	{
		res += a[i];
		int pos = (i-1)*(d+1)+1;
		if(pos>n) break;
		pos = n-pos;
		pos = min(pos, bb);
		ans = max(ans, res+b[pos]);
	}

	printf("%lld", ans);
	return 0;
}