第四届河南省 CCPC 大学生程序设计竞赛

F-集合之和

规定集合A和集合B的加法运算：\(A+B={x+y|x∈A，y∈B}\),设有限数集A中的元素个数为|A|,现给定n，请你构造集合A使得\(|A+A|=n\),如果A不存在，输出-1

题解：思维

首先我们经过模拟发现，\((0,1,2...k) + (0,1,2,...k) = (0,1,2...2k)\),所以很显然对于n为奇数来说，我们直接构造为\((0,1,2...(n-1)/2)\)即可

那么对于当n为偶数时我们应该如何构造呢？

实际上我们发现当我们去掉1后，当\(|A|>3\)时，\((0,2,3...k) + (0,2,3,...k) = (0,2,3...2k)\),但是当\(|A|<=2\)即\(n==4 || n==2\)时，我们发现怎么也凑不出来，所以无解，其余我们只需要构造\((0,2,3...n/2)\)即可

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define debug(x) cerr << #x << '=' << x << endl
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 2e5 + 10, M = 4e5 + 10;

int n;

void solve()
{
    cin >> n;
    if (n == 2 || n == 4)
    {
        cout << -1 << endl;
        return;
    }
    if (n % 2 == 0)
    {
        int k = n / 2;
        cout << k << endl;
        for (int i = 0; i <= k; ++i)
        {
            if (i == 1)
                continue;
            cout << i << " ";
        }
    }
    else
    {
        int k = (n + 1) / 2;
        cout << k << endl;
        while (k--)
        {
            cout << k << " ";
        }
    }
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

G - Mocha 上大班

在旭丘幼儿园大班的数学课上，Mocha 学到了位运算和概率。她认为自己已经熟练地掌握了这两个 知识点，于是她找到了同学 Arisa 来出题考考自己。 Arisa 给了 Mocha n 个长度为 m 且只包含 0 和 1 的数字串，Arisa 会对这些数字串操作 q 次。每次 Arisa 会选择两个数字串 si 和 sj，并选择两个位置 l, r，对于所有的 x ∈ [l, r]，将 sj [x] 替换为 sj [x] & si [x]， sj [x] 为第 j 个数字串的第 x 位，其中 & 为位运算中的与运算。但是对于第 i 次操作，只有 pi/100 的概 率成功。Arisa 想让 Mocha 计算出 q 次操作后，n 个数字串按. 位. 与. 运. 算. 后. 得到的数字串中 1 的个数的期 望对 998 244 353 取模的结果。

题解：思维

首先我们观察到虽然每次操作都有失败的几率，但是我们需要注意到我们进行的是与运算，也就是说尽管可能存在操作失败的情况，但是只有全部为1才会产生1，只要有0是不可能产生1的，所以也就是说每次操作或者不操作不会影响答案本身1的个数，我们直接对所有数字串进行一遍与运算即可

H-旋转水管

给你4行m列的地图，水会从(1,x)向下流出，必须从(4,y)向下流进，现在在第二行和第三行有两种水管\(I、L\)

请问能否转动水管使得水流进终点

题解：\(DFS\) : 好题目

对于\(I\)型水管，水在进入水管后方向不会发生改变，对于\(L\)型水管，如果从左或右流进，会从上或下流出，同理从上或下流进，会从左或右流出，所以我们只需要对其所有所有状态进行一遍DFS即可，我们发现每个水管最多只会被遍历到两次，所以复杂度为\(O(n)\)

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define debug(x) cerr << #x << '=' << x << endl
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 1e5 + 10, M = 4e5 + 10;

int m;
char g[5][N];
bool vis[5][N];
int sy, ey;

bool dfs(int x, int y, int dir) // 1 up , 2 down , 3 left , 4 right
{
    if (x == 4 && y == ey)
        return true;
    if (x >= 4 || x <= 1 || y > m || y < 1 || vis[x][y])
        return false;
    vis[x][y] = true;
    bool flag = false;
    if (g[x][y] == 'I')
    {
        if (dir == 1)
        {
            flag = dfs(x - 1, y, 1);
        }
        else if (dir == 2)
        {
            flag = dfs(x + 1, y, 2);
        }
        else if (dir == 3)
        {
            flag = dfs(x, y - 1, 3);
        }
        else if (dir == 4)
        {
            flag = dfs(x, y + 1, 4);
        }
    }
    else if (g[x][y] == 'L')
    {
        if (dir == 1)
        {
            if (dfs(x, y + 1, 4) || dfs(x, y - 1, 3))
                flag = true;
            else
                flag = false;
        }
        else if (dir == 2)
        {
            if (dfs(x, y + 1, 4) || dfs(x, y - 1, 3))
                flag = true;
            else
                flag = false;
        }
        else if (dir == 3)
        {
            if (dfs(x + 1, y, 2) || dfs(x - 1, y, 1))
                flag = true;
            else
                flag = false;
        }
        else if (dir == 4)
        {
            if (dfs(x + 1, y, 2) || dfs(x - 1, y, 1))
                flag = true;
            else
                flag = false;
        }
    }
    vis[x][y] = false;
    return flag;
}

void solve()
{
    cin >> m >> sy >> ey;
    for (int i = 1; i <= 4; ++i)
        for (int j = 1; j <= m; ++j)
            vis[i][j] = false;
    for (int i = 2; i <= 3; ++i)
        for (int j = 1; j <= m; ++j)
            cin >> g[i][j];
    if (dfs(2, sy, 2))
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

J - Mex Tree

给定一颗编号为1-n的树，所有点的权值为0,1,2...n-1的一个排列，现在定义\(mex(S)\)表示不属于S的最小非负数，

当\(mex(S)=k\)时，询问点数最多的非空连通子图有多少个点？

题解：思维+换根+树形DP

首先乍一看贼像树的重心，我们仔细分析以下：

首先如果一个连通图中包含了所有比\(k\)小的数，那么这个连通图就是合法的

1. 当k=0时，它的点数最多的非空连通子图就是树的重心
2. 当k=n时，它的点数就是整一颗树的所有点
3. 当\(0<k<n\)时，因为是一颗无根树，我们可以将权值为0的点作为根，如果节点u的子树中出现了比\(a[u]\)还要小的数时，就说明节点u的子树外和子树内都没有，答案为0，否则合法的连通图一定u的子树外\(n-sz[u]\),所以我们只需要树上维护最小值和维护子树内的点数即可

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define debug(x) cerr << #x << '=' << x << endl
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 1e6 + 10, M = 4e5 + 10;

int n;
int a[N];
vector<int> g[N];
int ans[N];
int sz[N], minn[N];

void dfs(int u, int par)
{
    sz[u] = 1;
    minn[u] = min(minn[u], a[u]);
    for (auto v : g[u])
    {
        if (v == par)
            continue;
        dfs(v, u);
        if (a[u] == 0)
            ans[0] = max(ans[0], sz[v]);
        sz[u] += sz[v];
        minn[u] = min(minn[u], minn[v]);
    }
    if (minn[u] == a[u] && a[u] != 0)
        ans[a[u]] = n - sz[u];
}

void solve()
{
    cin >> n;
    int rt = -1;
    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i];
        if (a[i] == 0)
            rt = i;
        minn[i] = INF;
    }
    for (int i = 2, u; i <= n; ++i)
    {
        cin >> u;
        g[u].push_back(i);
        g[i].push_back(u);
    }
    dfs(rt, 0);
    ans[n] = n;
    for (int i = 0; i <= n; ++i)
        cout << ans[i] << " ";
    cout << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}