Codeforces Round #368 (Div 2) A,B,C,D,E

最新推荐文章于 2022-10-30 16:33:21 发布

ramay7

最新推荐文章于 2022-10-30 16:33:21 发布

阅读量455

点赞数

分类专栏： Codeforces 深度优先搜索（DFS） +++模拟/构造线段树、树状数组文章标签： Codeforces 构造 dfs 二维树状数组

本文链接：https://blog.csdn.net/Ramay7/article/details/52276035

版权

Codeforces 同时被 3 个专栏收录

41 篇文章 0 订阅

订阅专栏

线段树、树状数组

21 篇文章 0 订阅

订阅专栏

深度优先搜索（DFS）

14 篇文章 0 订阅

订阅专栏

比赛题目链接

A、Brain’s Photos

给一个 $n*m$ 的方格，判断是黑白色还是彩色：只要含有字母’C’,’M’,’Y’中任意一个就认为是彩色的。
暴力判断，时间复杂度： $O(n*m)$ 。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX_N = 110;

int n, m;

int main()
{
    while (~scanf("%d%d", &n, &m)) {
        int flag = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                char s[5];
                scanf("%s", s);
                if (s[0] == 'C' || s[0] == 'M' || s[0] == 'Y'){
                    flag = 1;
                }
            }
        }
        if (flag) printf("#Color\n");
        else printf("#Black&White\n");
    }
    return 0;
}

B、Bakery

给 $n$ 个城市和 $m$ 条边以及 $k$ 个被标记的城市，要求找到被标记城市和没被标记的城市的最短距离。
如果存在最短距离的话，一定是一条边的两个端点，只要判断是否存在这样的边然后取最短即可。
也可以不用先 $sort$ ，这样复杂度就是 $O(m)$ 了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX_N = 100010;

int n, m, k;
int vis[MAX_N];

struct Edge {
    int u, v, w;

    bool operator < (const Edge& rhs) const {
        return w < rhs.w;
    }
} edge[MAX_N];

int main()
{
    while (~scanf("%d%d%d", &n, &m, &k)) {
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < m; ++i) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            edge[i].u = u, edge[i].v = v;
            edge[i].w = w;
        }
        sort(edge, edge + m);
        for (int i = 0; i < k; ++i) {
            int u;
            scanf("%d", &u);
            vis[u] = 1;
        }
        int ans = -1;
        for (int i = 0; i < m; ++i) {
            int u = edge[i].u, v = edge[i].v, w = edge[i].w;
            if (vis[u] && !vis[v]) ans = w;
            if (vis[v] && !vis[u]) ans = w;
            if (ans != -1) break;
        }
        printf("%d\n", ans);
    }
    return 0;
}

C、Pythagorean Triples

给一个 $n(n\leq 10^9)$ ，判断 $n$ 是否是直角三角形中的一条边，如果是的话输出另外两条边，多解输出任意一解，否则输出-1。
当 $n\leq 2$ 时显然无解。
当 $n>2$ 时，我们把 $n$ 恒看成一条直角边那么问题变成解方程 $a^2-b^2=n^2$ 。
当 $n$ 为奇数时，令 $n^2=2*k+1$ ，可以构造： $(k+1)^2-k^2=2*k+1$ 。
当 $n$ 为偶数时，令 $n^2=4*k$ ，可以构造： $(k+1)^2-(k-1)^2=4*k$ 。
时间复杂度： $O(1)$ 。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;

int n;
ll m;

void solve()
{
    m = 1ll * n * n;
    if (n == 1 || n == 2) printf("-1\n");
    else if (m % 4 == 0) printf("%I64d %I64d\n", m / 4 - 1, m / 4 + 1);
    else if (m & 1) printf("%I64d %I64d\n", (m - 1) / 2, (m - 1) / 2 + 1);
}

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

D、Persistent Bookcase

给一个 $n$ 排的书架，每排有 $m$ 个位置，初始时所有位置为空。有 $Q$ 次操作，每次有四种操作：

1 i j $1\ i\ j$ ：如果第

i $i$ 排的第

j $j$ 个位置是空的，就放一本书上去。

$2\ i\ j$ ：如果第 $i$ 排的第 $j$ 个位置上有书，那就把这本书取下来。
$3\ i$ ：将第 $i$ 排的所有位置状态颠倒：有书的位置把书取下，没书的位置放上书。
$4\ i$ ：回到第 $i$ 个操作时的状态，初始状态是第 $0$ 操作。

对于每次操作输出书架上书的总数量。
数据范围： $n,m\leq 1000,Q\leq 10^5$

最基本的for循环就是最简单、最显式的dfs
如果没有第四种操作，直接按照题意for循环下去即可。对于第四种操作可以记录每个操作的儿子（后继操作），然后dfs下去并还原即可，注意细节。
借助 $set$ 存储每个书架上的状态。
时间复杂度： $O(Q*n*\log n)$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#include <vector>
#include <set>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX_Q = 100010;
const int MAX_N = 1010;

int n, m, Q;
vector<int> children[MAX_Q];
set<int> s[MAX_N];
int cnt[MAX_N];

struct Query {
    int type, x, y, ans;
} query[MAX_Q];

void init()
{
    for (int i = 0; i <= n; ++i) {
        children[i].clear();
        s[i].clear();
        cnt[i] = 0;
    }
}

// cnt[x] 为奇：s[x]是不存在的；cnt[x]为偶：s[x]是存在的
void dfs(int cur, int sum)
{
    int type = query[cur].type, x = query[cur].x, y = query[cur].y, flag = 0;
    if (type == 1) {
        if (cnt[x] % 2 == 0 && s[x].find(y) == s[x].end()) {
            s[x].insert(y);
            sum++;
            flag = 1;
        } else if (cnt[x] % 2 && s[x].find(y) != s[x].end()) {
            s[x].erase(y);
            sum++;
            flag = 1;
        }
    } else if (type == 2) {
        if (cnt[x] % 2 == 0 && s[x].find(y) != s[x].end()) {
            s[x].erase(y);
            sum--;
            flag = 1;
        } else if (cnt[x] % 2 && s[x].find(y) == s[x].end()) {
            s[x].insert(y);
            sum--;
            flag = 1;
        }
    } else if (type == 3) {
        if (cnt[x] % 2 == 0) {
            sum -= s[x].size();
            sum += (m - s[x].size());
        } else {
            sum -= (m - s[x].size());
            sum += s[x].size();
        }
        cnt[x]++;
        flag = 1;
    }
//  printf("cur = %d x = %d y = %d sum = %d\n", cur, x, y, sum);
    query[cur].ans = sum;
    for (int i = 0; i < children[cur].size(); ++i) {
        dfs(children[cur][i], sum);
    }
    if (flag) {
        if (type == 1) {
            if (cnt[x] % 2 == 0) s[x].erase(y);
            else s[x].insert(y);
            sum--;
        } else if (type == 2) {
            if (cnt[x] % 2 == 0) s[x].insert(y);
            else s[x].erase(y);
            sum++;
        } else { // type = 3
            if (cnt[x] % 2 == 0) {
                sum -= s[x].size();
                sum += (m - s[x].size());
            } else {
                sum -= (m - s[x].size());
                sum += s[x].size();
            }
            cnt[x]--;
        }
    }
}

int main()
{
    while (~scanf("%d%d%d", &n, &m, &Q)) {
        init();
        for (int i = 1; i <= Q; ++i) {
            query[i].y = -1;
            scanf("%d%d", &query[i].type, &query[i].x);
            if (query[i].type < 3) {
                scanf("%d", &query[i].y);
            }
            if (query[i].type == 4) {
                children[query[i].x].push_back(i);
            } else {
                children[i - 1].push_back(i);
            }
        }
        for (int i = 0; i < children[0].size(); ++i) {
            dfs(children[0][i], 0);
        }
        for (int i = 1; i <= Q; ++i) {
            printf("%d\n", query[i].ans);
        }
    }
    return 0;
}

E、Garlands

给一个 $n*m$ 的方格和 $K$ 个花环，花环都是依次相邻放置的，会给出每个花环的每朵花的位置，每朵花会有相应的价值，初始时每个花环都是“开”状态。然后有 $Q$ 次操作，操作分两种：

改变第 $i$ 个花环：开变关，关变开
求左上角下标为 $(a,b)$ ，右下角下标为 $(c,d)$ 的矩形内所有开着的花的价值之和。

对于每个第二种操作，输出相应价值和。
数据范围： $n,m,K\leq 2000$ ，每个花环的花总数 $\leq 2000$ ， $Q\leq 10^6$ ，但是第二种操作： $\leq 2000$ 。

这也太暴力了。
直接上二维树状数组，对于每种花环的状态记录类似于 $D$ 题的第三种操作。
时间复杂度: $O(2000*n^2*\log n)$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX_N = 2010;

int n, m, K, Q;
int num[MAX_N], cur[MAX_N], state[MAX_N];
ll C[MAX_N][MAX_N];

struct Garland {
    int x, y, w;
} garland[MAX_N][MAX_N];

inline int lowbit(int x)
{
    return x & (-x);
}

void update(int x, int y, int w)
{
    for(int i = x; i <= n; i += lowbit(i)) {
        for (int j = y; j <= m; j += (lowbit(j))) {
            C[i][j] += w;
        }
    }
}

ll sum(int x, int y)
{
    ll res = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        for (int j = y; j > 0; j -= lowbit(j)) {
            res += C[i][j];
        }
    }
    return res;
}

int main()
{
    while (~scanf("%d%d%d", &n, &m, &K)) {
        memset(state, 0, sizeof(state));
        memset(cur, 0, sizeof(cur));
        memset(C, 0, sizeof(C));
        for (int i = 0; i < K; ++i) {
            scanf("%d", &num[i]);
            for (int j = 0; j < num[i]; ++j) {
                int x, y, w;
                scanf("%d%d%d", &x, &y, &w);
                garland[i][j].x = x, garland[i][j].y = y, garland[i][j].w = w;
                update(x, y, w);
            }
        }
        scanf("%d", &Q);
        for (int i = 0; i < Q; ++i) {
            char s[10];
            scanf("%s", s);
            if (s[0] == 'S') {
                int id;
                scanf("%d", &id);
                id--;
                state[id] ^= 1; // 细节！
                cur[id] ^= 1;
            } else {
                int a, b, c, d;
                scanf("%d%d%d%d", &a, &b, &c, &d);
                for (int i = 0; i < K; ++i) {
                    if (state[i] == 0) continue;
                    int flag = 1;
                    if (cur[i] == 1) flag = -1;
                    state[i] = 0;
                    for (int j = 0; j < num[i]; ++j) {
                        int x = garland[i][j].x, y = garland[i][j].y, w = garland[i][j].w;
                        update(x, y, flag * w);
                    }
                }
                ll ans = sum(c, d) + sum(a - 1, b - 1) - sum(c, b - 1) - sum(a - 1, d);
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}

ramay7

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round #368 (Div 2) A,B,C,D,E

比赛题目链接A.Brain’s Photos给一个$n*m$的方格，判断是黑白色还是彩色：只要含有字母’C’,’M’,’Y’中任意一个就认为是彩色的。暴力判断，时间复杂度：$O(n*m)$。#include <iostream>#include <cstdio>#include <cstring>#include <string>#include <algorithm>#include
复制链接

扫一扫