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 <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≤109) ，判斷n 是否是直角三角形中的一條邊，如果是的話輸出另外兩條邊，多解輸出任意一解，否則輸出-1。
當n≤2 時顯然無解。
當n>2 時，我們把n恆看成一條直角邊那麼問題變成解方程a2−b2=n2 。
當n 爲奇數時，令n2=2∗k+1 ，可以構造：(k+1)2−k2=2∗k+1 。
當n 爲偶數時，令n2=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 ：如果第i 排的第j 個位置是空的，就放一本書上去。
• 2 i j ：如果第i 排的第j 個位置上有書，那就把這本書取下來。
• 3 i ：將第i 排的所有位置狀態顛倒：有書的位置把書取下，沒書的位置放上書。
• 4 i ：回到第i 個操作時的狀態，初始狀態是第0 操作。

對於每次操作輸出書架上書的總數量。
數據範圍：n,m≤1000,Q≤105

最基本的for循環就是最簡單、最顯式的dfs
如果沒有第四種操作，直接按照題意for循環下去即可。對於第四種操作可以記錄每個操作的兒子（後繼操作），然後dfs下去並還原即可，注意細節。
藉助set 存儲每個書架上的狀態。
時間複雜度：O(Q∗n∗logn)

#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≤2000 ，每個花環的花總數≤2000 ，Q≤106 ，但是第二種操作：≤2000 。

這也太暴力了。
直接上二維樹狀數組，對於每種花環的狀態記錄類似於D 題的第三種操作。
時間複雜度:O(2000∗n2∗logn)

#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;
}