Codeforces Round #738 (Div. 2) A,B,C,D1_森林加多少新边-优快云博客

本文探讨了几个涉及图论、位运算和字符串处理的算法问题。A题中，通过分析位运算的性质，找出使序列最大值最小的操作策略；B题通过填充字符串使得相邻字符相等的数量最少；C题是关于有向图的路径构造，证明了总是存在遍历所有点的路径；D题是森林的边连接问题，寻找最多能添加的边且保持森林属性。这些问题都展示了在限制条件下优化问题的解决方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A. Mocha and Math

题目大意：
给定n个数，对这些数可以做以下操作

选取一个区间[l ， r]
翻转这个区间，然后再与原来的区间的数进行 & 操作,从而改变原来区间的数
操作可以做无限次

问，经过上面操作，这个序列的最大值最小是多少?

例如:
1,2
选取[1,2]这个区间把区间中的数变为,1 & 2 , 2 & 1,
也就是 0， 0

所以最小的最大值就是0

思路：
1.进行 & 操作的话，原来的数一定是 >= &之后的数，也就是进行操作，被操作的数一定不会变大

2.假设现在对x进行操作，因为操作可以做无限次，所以通过区间的选取，x可以和序列中其他所有的数，进行 & 操作
所以每个数，都可以和其他所有的数进行 & 操作

然后x想变小就要尽可能 & 上所有能够 & 的数，最后的值就是最小值,又因为所有数的 & 操作结果是唯一的，所以答案就是这个序列所有数的 &。

#include <iostream>
 
using namespace std;
 
const int N = 110;
int a[N];
 
int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        int n;
        cin >> n;
        for(int i = 1;i <= n;i ++) cin >> a[i];
        int res = a[1];
        for(int i = 1;i <= n;i ++) res &= a[i];
        
        cout << res << endl;
    }
}

B. Mocha and Red and Blue

题目大意：
给定一个字符串，其中只包含 ? ，B，R

现在要填充 ‘?’，并要求填充的方案，要使最后的字符串，相邻的字符相等的数量最少，输出这个字符串（输出任意一种最优）

例如
?R???BR

填充后
BRRBRBR
相邻相等的数量为 1

思路：
由已经被填充了的字符，来填充他相邻的 ?，让与它相邻的 ?，与它不相等

#include <iostream>
#include <string>
 
using namespace std;
 
int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        int n;
        string s;
        cin >> n >> s;
        s +='B';//特殊情况，全是??????
        int i = 0;
        while(i < n && s[i] == '?') i ++;
        for(int j = i - 1;j >= 0;j --) s[j] = s[j + 1] == 'B' ? 'R':'B';
        for(int j = i + 1;j < n;j ++) if(s[j] == '?') s[j] = s[j - 1] == 'B' ? 'R':'B';
            
        cout << s.substr(0,n) << endl;
    }
    return 0;
}

C. Mocha and Hiking

题目大意：
有一个有向图，有n + 1个点，2n - 1 条边
其中n - 1条边，是i 到 i + 1 (1 <= i <= n -1)的有向边

另外的n条边，由一个序列决定
序列中的元素 ai
当 ai 为 0，的时候代表i点到n + 1这个点有条有向边
当 ai 为 1，的时候代表n + 1点到 i 点有条有向边

请输出任意一条符合走过所有点恰好一次的路径，起点和终点任意,如果答案不存在输出 - 1

例如
3
0 1 0

代表有4个点边分别为
1 -> 2
2 -> 3
1 -> 4
4 -> 2
3 -> 4

思路

假设序列全是0
那么 1 ,2 …n , n + 1
就是一条路径

假设有1
那么在第一个1的位置对应的点之前就可以插入一个n + 1

所以一定是有答案的

#include <iostream>

using namespace std;

const int N  = 1e4 + 10;
int a[N];

int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        int n;
        cin >> n;
        for(int i = 1;i <= n;i ++) cin >> a[i];
        int st = 0;
        for(int i = 1;i <= n;i ++) if(a[i] == 1) {st = i;break;}
        if(st) 
        {
            for(int i = 1;i <= n;i ++) 
            if(i == st) cout << n + 1 << ' ' << i << " ";
            else cout << i << " ";
            cout << endl;
        }
        else 
        {
            for(int i = 1;i <= n + 1;i ++) cout << i << ' ';
            cout << endl;
        }
    }
    return 0;
}

D1. Mocha and Diana (Easy Version)

题目大意
现有2个森林

对这2个森林进行加边操作，加边需要符合
1.一个森林加了 (u，v) 这条边，另一个也要加上
2.加完边后，还要满足是它们是森林

问最多可以加多少条边，输出数量，和加的边

思路：

加完边后，还要满足是森林，代表着加的这条边的2个端点，一开始不能再，在加之前不能在一颗树上

所以枚举所有点对，判断在2个森林中，他们在不在一颗树上，如果这个点对，在2个森林中，都不在一颗树上，就连上

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e4 + 10;
int p1[N],p2[N];

int f(int x,int p[])
{
    if(p[x] == x) return x;
    return p[x] = f(p[x],p);
}

int main()
{
    int n,m1,m2;
    cin >> n >> m1 >> m2;
    for(int i = 1;i < N;i++) p1[i] = p2[i] = i;
    for(int i = 1;i <= m1;i ++)
    {
        int a,b;
        cin >> a >> b;
        a = f(a,p1);
        b = f(b,p2);
        p1[a] = b;
    }
    
    for(int i = 1;i <= m2;i ++)
    {
        int a,b;
        cin >> a >> b;
        a = f(a,p2);
        b = f(b,p2);
        p2[a] = b;
    }
    
    
    int res = 0;
    vector<pair<int,int>> q;
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j <= n;j ++)
            {
                int a = f(i,p1),b = f(j,p1);
                int c = f(i,p2),d = f(j,p2);
                if(a != b && c != d)
                {
                    res ++;
                    p1[a] = b;
                    p2[c] = d;
                    q.push_back({i,j});
                }
            }
            
    cout << res << endl;
    for(int i = 0;i < q.size();i ++) cout << q[i].first << " " << q[i].second << endl;
    
    return 0;
}