Codeforces Round #682 (Div. 2)

最新推荐文章于 2020-11-16 08:18:08 发布

SHOHOKUKU

最新推荐文章于 2020-11-16 08:18:08 发布

阅读量132

点赞数

分类专栏：图论数学

本文链接：https://blog.csdn.net/neweryyy/article/details/109692327

版权

图论同时被 2 个专栏收录

205 篇文章 3 订阅

订阅专栏

数学

164 篇文章 0 订阅

订阅专栏

传送门

Codeforces Round #682 (Div. 2)

A

显然元素全部为 $1$ 的数组满足要求。

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;

int main()
{
    int t, n;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 0; i < n; ++i)
            printf("%d%c", 1, i + 1 == n ? '\n' : ' ');
    }
    return 0;
}

B 补题

第一反应居然是对 $a$ 快速幂模素数求前缀和，然后暴力枚举子区间哈希处理，在 $T L E$ 的边缘冲突了…… $u n r a t e d$ 之后直接睡了

假设 $b$ 中包含两个相同的元素，那么将其作为不相交子数组；反之，考虑区间和的二进制表示，不同的 $b$ 使区间和在不同的位置为 $1$ ，显然没有满足条件的不相交子数组。

#include <bits/stdc++.h>
using namespace std;
#define maxn 1005
int B[maxn];

int main()
{
    int t, n;
    scanf("%d", &t);
    while (t--)
    {
        unordered_set<int> st;
        bool f = 0;
        scanf("%d", &n);
        for (int i = 0; i < n; ++i)
        {
            scanf("%d", B + i);
            if (st.count(B[i]))
                f = 1;
            else
                st.insert(B[i]);
        }
        puts(f ? "YES" : "NO");
    }
    return 0;
}

C 补题

2-SAT

矩阵内的任一个格子，只有保持原值或增加一两种可能，那么考虑 $2 - S A T$ 。定义布尔变量 $x_i$ ，设 $i d [i] [j]$ 为位置 $(i, j)$ 格子的索引
$x_{id[i][j]}为真\leftrightarrow 位置为(i,j)的格子保持原值$ 那么枚举每一个位置的格子，判断它与相邻的格子是否相等，进行连边。比如，若 $x_{id[i][j]}=x_{id[i'][j']}$ ，那么需要满足的布尔方程为 $\lnot(x_{id[i][j]}\land x_{id[i'][j']})$ ，即 $\lnot x_{id[i][j]} \lor \lnot x_{id[i'][j']}$ ，从 $x_{id[i][j]}$ 向 $\lnot x_{id[i'][j']}$ 连一条有向边。

分解强连通分量后，对任一拓扑序的变量赋予真值，相应的对矩阵元素进行处理。

#include <bits/stdc++.h>
using namespace std;
#define maxn 105
const int di[4] = {0, 0, -1, 1}, dj[4] = {-1, 1, 0, 0};
int t, n, m, mat[maxn][maxn], id[maxn][maxn];
vector<int> G[2 * maxn * maxn], rG[2 * maxn * maxn], vs;
bool used[2 * maxn * maxn];
int cmp[2 * maxn * maxn];

void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int v)
{
    used[v] = 1;
    for (int i = 0; i < (int)G[v].size(); ++i)
    {
        int u = G[v][i];
        if (!used[u])
            dfs(u);
    }
    vs.push_back(v);
}

void rdfs(int v, int k)
{
    used[v] = 1, cmp[v] = k;
    for (int i = 0; i < (int)rG[v].size(); ++i)
    {
        int u = rG[v][i];
        if (!used[u])
            rdfs(u, k);
    }
}

int scc(int V)
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for (int v = 0; v < V; ++v)
        if (!used[v])
            dfs(v);
    memset(used, 0, sizeof(used));
    int k = 0;
    for (int i = vs.size() - 1; i >= 0; --i)
        if (!used[vs[i]])
            rdfs(vs[i], ++k);
    return k;
}

inline bool judge(int i, int j)
{
    return 0 <= i && i < n && 0 <= j && j < m;
}

void solve()
{
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            id[i][j] = i * m + j;
    int mn = n * m, V = mn * 2;
    for (int v = 0; v < V; ++v)
    {
        G[v].clear();
        rG[v].clear();
    }
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
        {
            int u = id[i][j];
            for (int k = 0; k < 4; ++k)
            {
                int ni = i + di[k], nj = j + dj[k];
                if (judge(ni, nj))
                {
                    int v = id[ni][nj];
                    if (mat[i][j] == mat[ni][nj])
                        add_edge(u, v + mn);
                    if (mat[i][j] == mat[ni][nj] + 1)
                        add_edge(u, v);
                    if (mat[i][j] + 1 == mat[ni][nj])
                        add_edge(u + mn, v + mn);
                    if (mat[i][j] + 1 == mat[ni][nj] + 1)
                        add_edge(u + mn, v);
                }
            }
        }
    scc(V);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
        {
            int u = id[i][j];
            if (cmp[u] < cmp[u + mn])
                ++mat[i][j];
        }
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                scanf("%d", mat[i] + j);
        solve();
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                printf("%d%c", mat[i][j], j + 1 == m ? '\n' : ' ');
    }
    return 0;
}

奇偶性

$t u t o r i a l$ 的解法巧妙地利用了相邻主对角线奇偶性不同的特征。考虑将坐标和为奇数和偶数的格子分别染成黑色与白色，每一个黑/白色的格子都被白/黑色的格子包围，若黑白格子上的数字奇偶性不同，则它们一定不相等；且数字增加一改变它的奇偶性。那么将染为黑色的格子赋为奇数，将染为白色的格子赋为偶数。

#include <bits/stdc++.h>
using namespace std;
#define maxn 105
int mat[maxn][maxn];

int main()
{
    int t, n, m;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
            {
                scanf("%d", mat[i] + j);
                if ((mat[i][j] & 1) != ((i + j) & 1))
                    ++mat[i][j];
            }
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                printf("%d%c", mat[i][j], j + 1 == m ? '\n' : ' ');
    }
    return 0;
}

D 补题

论修炼构造法的重要性。

设数组所有元素的异或值为 $X$ ，考虑将所有元素处理为 $X$ 。相同元素异或为零，则对于三元组 $(x, y, y)$ ，操作后赋值为 $(x, x, x)$ 。考虑 $n$ 为奇数的情况，从前向后不断构造这样的二元组，共 $\lfloor \frac{n}{2}\rfloor$ 组；再用最后一个元素对二元组进行操作，共 $\lfloor \frac{n}{2}\rfloor$ 次，最终各元素都等于 $X$ 。操作总次数为 $2\times\lfloor \frac{n}{2}\rfloor=n-1$ 次，满足限制。

当 $n$ 为偶数，按照上述方法构造，在处理最后一个二元组时，会出现无法凑出三个元素的情况。考虑 $a_i,a_j,a_k)$ ，那么操作前后三个元素的异或值都为 $a_i\oplus a_j \oplus a_k$ ，可以观察到操作无法改变 $X$ 。因为偶数个相同元素异或值为零，假设 $X\neq 0$ ，则无法构造出这样的数组。那么处理前 $n - 1$ 个元素，此时 $a_{n-1}=X\oplus a_{n}=a_{n}$ 。

#include <bits/stdc++.h>
using namespace std;
#define maxn 100005
int A[maxn];

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d", A + i);
    if (n & 1)
    {
        puts("YES");
        printf("%d\n", n - 1);
        for (int i = 1; i + 2 <= n; i += 2)
            printf("%d %d %d\n", i, i + 1, i + 2);
        for (int i = n; i - 2 >= 1; i -= 2)
            printf("%d %d %d\n", i, i - 1, i - 2);
    }
    else
    {
        int s = 0;
        for (int i = 1; i <= n; ++i)
            s ^= A[i];
        if (s)
            puts("NO");
        else
        {
            puts("YES");
            printf("%d\n", n - 2);
            for (int i = 1; i + 2 <= n - 1; i += 2)
                printf("%d %d %d\n", i, i + 1, i + 2);
            for (int i = n - 1; i - 2 >= 1; i -= 2)
                printf("%d %d %d\n", i, i - 1, i - 2);
        }
    }
    return 0;
}

E 补题

SHOHOKUKU

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round #682 (Div. 2)

传送门Codeforces Round #682 (Div. 2)A显然元素全部为 111 的数组满足要求。#include <algorithm>#include <cmath>#include <cstdio>#include <cstring>using namespace std;int main(){ int t, n; scanf("%d", &t); while (t--) {
复制链接

扫一扫

专栏目录