Codeforces Round #544 (Div. 3)简单题解

时间 2020-11-11

标签 node ios c++ 数组 spa 指针 code 队列内存栏目 CSS 繁體版

原文原文链接

复健，时间有限题解比较简陋node

A. Middle of the Contest

将小时转成分钟，获得起止时间在一天中的分钟数，取平均值便可，复杂度O(1)。平均值转换会时间的时候注意前导0。ios

void solve(int x) {
    x /= 2;
    printf("%02d:%02d\n", x / 60, x % 60);
}
int main() {
    // freopen("in.txt", "r", stdin);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)cpp;
    int h1, h2, m1, m2;
    char c;
    cin >> h1 >> c >> m1;
    cin >> h2 >> c >> m2;
    solve(h1 * 60 + m1 + h2 * 60 + m2);
}

B. Preparation for International Women’s Day

要加起来能被k整除, 只须要看模k的余数便可。余数为i的与余数为k-i的互补能够被k整除，经过计数看有多少对能互补。须要注意的是，为余数为0和k/2（k为偶数）时，只能同余数的互补，此时计数是偶数个时都能配对，奇数个时能配对的数量是计数 - 1。复杂度O(n + k)。c++

int main() {
    // freopen("in.txt", "r", stdin);
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int n, k, x, cnt = 0;
    cin >> n >> k;
    int d[k] = {0};
    for (int i = 0; i < n; ++i) cin >> x, d[x % k]++;
    for (int i = 0; i < (k + 1) / 2; ++i) {
        if (i == 0)
            cnt += d[i] / 2;
        else {
            cnt += min(d[i], d[k - i]);
        }
    }
    if (k % 2 == 0) cnt += d[k / 2] / 2;
    cout << cnt * 2;
}

C. Balanced Team

单调队列，从小到大添加元素，保证队首和队尾差不超过5，超过了则出队，不然用当前队列大小更新最优解。若是元素x < y则x必定比y先入队，并且能与x共存的最小值sx和能与y共存的最小值sy有sx <= sy。使用单调队列，每次入队后进行出队操做，出队完成后队首就是能与入队元素共存的最小值，队列内的元素就是以入队元素为最大值时全部能存在的元素。复杂度O(n)数组

int main() {
    // freopen("in.txt", "r", stdin);
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    ll a[n + 1];
    for (int i = 1; i <= n; ++i) cin >> a[i];
    sort(a + 1, a + 1 + n);
    int cnt = 0, l = 1, r = 2;
    while (l <= r && r <= n) {
        if (a[r] - a[l] > 5) cnt = max(cnt, r - l), l++;
        r++;
    }
    cnt = max(cnt, r - l);
    cout << cnt;
}

d * a[i] + b[i] = 0可得d = - b[i] / a[i]，统计每种d取值的个数，取最大便可。对于a[i]为0的状况须要特殊讨论，若是b[i]也为0则此时d能够取任意值；不然，d的取值为0。另外，为了不浮点偏差，不能直接统计d，而是要统计<a, b>这个配对；同时，为了归一化，须要将a与b同时除以他们的最大公约数，并保证a是正数。复杂度O(nlog(n)),log是由于用了map来计数。spa

// Author : RioTian
// Time : 20/11/10
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
int main() {
    // freopen("in.txt", "r", stdin);
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    ll a[n + 1], b[n + 1];
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> b[i];
    }
    int zeroBCnt = 0, zeroBothCnt = 0;
    map<pair<int, int>, int> hash;
    for (int i = 0; i < n; ++i) {
        if (a[i] == 0) {
            if (b[i] == 0) ++zeroBothCnt;
            continue;
        }
        if (b[i] == 0) {
            ++zeroBCnt;
        }
        int divisor = gcd(abs(a[i]), abs(b[i]));
        a[i] /= divisor;
        b[i] /= divisor;
        if (a[i] < 0) {
            a[i] = -a[i];
            b[i] = -b[i];
        }
        if (hash[make_pair(a[i], b[i])])
            ++hash[make_pair(a[i], b[i])];
        else
            hash[make_pair(a[i], b[i])] = 1;
    }
    int ans = zeroBCnt;
    for (auto item : hash) {
        if (item.second > ans) ans = item.second;
    }
    cout << ans + zeroBothCnt << endl;
    return 0;
}

E. K Balanced Teams

与C题思路相似，先获得取每一个元素为最大值，能共存的元素有哪些（排过序的数组保留首位指针便可），好比位置为i的元素最小可共存元素的位置是maxStart[i]，这样数组里面maxStart[i]到i都是可共存元素。问题就转成如何在里面选k个，让元素尽可能多，这样dp便可。dp[i][j]表示前i个元素选j队的最优值，则若是选maxStart[i]到i，最优值为dp[maxStart[i] - 1], j - 1] + i - maxStart[i] + 1；若是不选，最优值为dp[i - 1][j]；二者取最优获得状态转移方程。另外因为j只会从j - 1转移，所以能够用滚动数组节约内存。复杂度O(nk)。指针

// Author : RioTian
// Time : 20/11/10
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
int a[N], maxStart[N], dp[N][2];
int n, k;
int main() {
    cin >> n >> k;
    for (int i = 0; i < n; ++i) cin >> a[i];
    sort(a, a + n);
    int l = 0, r = 0;
    while (r < n) {
        if (a[r] - a[l] <= 5) {
            maxStart[r] = l, ++r;
            continue;
        }
        ++l;
    }
    for (int i = 1; i <= k; ++i) {
        for (int j = 0; j < n; ++j) {
            if (maxStart[j]) {
                dp[j][i % 2] =
                    max(dp[j - 1][i % 2],
                        dp[maxStart[j] - 1][(i - 1) % 2] + j - maxStart[j] + 1);
                continue;
            }
            dp[j][i % 2] = max(dp[j - 1][i % 2], j - maxStart[j] + 1);
        }
    }
    cout << dp[n - 1][k % 2] << endl;
    return 0;
}

F1. Spanning Tree with Maximum Degree

直接找到度最大的节点bfs便可，复杂度O(n + m)。code

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

vector<int> node[200010];
bool visited[200010];

void bfs(int start) {
    queue<int> qu;
    qu.push(start);
    visited[start] = true;
    while (qu.size()) {
        int cur = qu.front();
        qu.pop();
        for (auto next : node[cur]) {
            if (visited[next]) continue;
            visited[next] = true;
            qu.push(next);
            cout << cur + 1 << ' ' << next + 1 << endl;
        }
    }
}

int main() {
    int n, m, x, y, tmp, maxCnt = 0, maxNode = -1;
    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        cin >> x >> y;
        --x;
        --y;
        node[x].push_back(y);
        node[y].push_back(x);
        tmp = node[x].size() > node[y].size() ? x : y;
        if (node[tmp].size() > maxCnt) {
            maxCnt = node[tmp].size();
            maxNode = tmp;
        }
    }
    bfs(maxNode);
    return 0;
}

F2. Spanning Tree with One Fixed Degree

若是从1的一个分支出发能从另外一个分支回到1，则这些分支划分为同一组，dfs便可获得这些分组。若是一组里面全部分支都被去掉了，则这组里面的节点就没法出如今树里面，所以至少要保留一个。dfs获得有多少这样的组，每组里面取一个分支，剩下还能够取则任意取。这些分支做为bfs的第一步，继续搜下去，按搜索顺序输出便可。非法的状况有：dfs时存在节点没有走到；须要的度数比组数少（此时至少有一组全部分支都被去掉）；须要的度数比1连接的分支多。复杂度O(n + m)。队列

#include <cstring>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;
bool visited[200010];
vector<int> node[200010];
vector<int> group[200010];
queue<int> qu;
int n, m, d, g;

void dfs(int cur, int parent) {
    visited[cur] = true;
    for (auto next : node[cur]) {
        if (visited[next]) {
            if (parent == -1) group[g - 1].push_back(next);
            continue;
        }
        if (parent == -1) {
            group[g++].push_back(next);
        }
        dfs(next, cur);
    }
}

void bfs() {
    while (qu.size()) {
        int cur = qu.front();
        qu.pop();
        for (auto next : node[cur]) {
            if (!visited[next]) {
                visited[next] = true;
                cout << cur + 1 << ' ' << next + 1 << endl;
                qu.push(next);
            }
        }
    }
}

int main() {
    int x, y;
    cin >> n >> m >> d;
    for (int i = 0; i < m; ++i) {
        cin >> x >> y;
        --x;
        --y;
        node[x].push_back(y);
        node[y].push_back(x);
    }
    memset(visited, 0, sizeof(visited));
    dfs(0, -1);
    for (int i = 0; i < n; ++i) {
        if (!visited[i]) {
            cout << "NO" << endl;
            return 0;
        }
    }
    if (g > d || node[0].size() < d) {
        cout << "NO" << endl;
        return 0;
    }
    cout << "YES" << endl;
    memset(visited, 0, sizeof(visited));
    visited[0] = true;
    d -= g;
    for (int i = 0; i < g; ++i) {
        cout << '1' << ' ' << group[i][0] + 1 << endl;
        visited[group[i][0]] = true;
        qu.push(group[i][0]);
        for (int j = 1; d && j < group[i].size(); ++j) {
            cout << '1' << ' ' << group[i][j] + 1 << endl;
            visited[group[i][j]] = true;
            qu.push(group[i][j]);
            --d;
        }
    }
    bfs();
    return 0;
}