【Algorithm】2021 RoboCom 世界机器人开发者大赛-本科组（初赛）

本文链接：https://blog.youkuaiyun.com/y__a__o/article/details/124538625

懂的都懂 (20分)

给定n个数，再给定k组数，要求判断每一组内的任意一个数，是否存在n个数内任取四个数的平均值等于它本身。

四层循环去枚举取数的过程。由于下标会出现小数，所有用 map 来存。

为了避免精度问题，bool 数组下标存下四个数之和而不是平均值，最后判断每一组数的四倍是否在 bool 数组内。

#include <iostream>
#include <map>

using namespace std;

int n, k;
int a[55];
map<double, bool> st;

int main()
{
    scanf("%d%d", &n, &k);
    
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);
    
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            for (int k = j + 1; k < n; k++)
                for (int p = k + 1; p < n; p++)
                    st[(a[i] + a[j] + a[k] + a[p]) / 4.0] = true;
    
    while (k--) {
        int m;
        scanf("%d", &m);
        
        bool f = true;
        while (m--) {
            double x;
            scanf("%lf", &x);
            if (!st[x]) f = false;
        }
        
        if (f) puts("Yes");
        else puts("No");
    }
    
    return 0;
}

芬兰木棋 (25分)

如果要获得最大分数，那可以把所有木棋都击倒，最大分数就是所有木棋得分之和

为了尽量减少击打次数，那么需要把同一方向的得分为 1 的连续的木棋一次性击倒，其余的木棋都是一个木棋击打一次。

同一方向可以用斜率表示，由于 y / x 存在精度问题，我们可以考虑用一个 pair<int, int> 去表示一个斜率，注意这里需要对y和x进行约分

我们用map去映射每一个方向上的所有点，同一个方向上的点根据与原点的位置（两点之间距离公式）进行排序，每次取出一个方向上的所有点，对于连续的得分为1的点进行一次击打，其余的点每个都击打一次

#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>

#define int long long

using namespace std;

typedef pair<int, int> PII;

int n, cnt, sum;

map<PII, vector<PII> > mp;

int gcd (int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

signed main()
{
    cin >> n;

    while (n--) {
        int x, y, v;
        cin >> x >> y >> v;
        sum += v;
        
        int d = x * x + y * y;
        if (x && y) {
            
            int p = gcd(abs(x), abs(y));
            x /= p, y /= p;
            mp[{x, y}].push_back({d , v});
        }
        else if (!x && y > 0) mp[{0, 1}].push_back({d, v});
        else if (!y && x > 0) mp[{1, 0}].push_back({d, v});
        else if (!x && y < 0) mp[{0, -1}].push_back({d, v});
        else if (!y && x < 0) mp[{-1, 0}].push_back({d, v});

    }
    
    for (auto k : mp) {
        auto t = k.second;
        sort(t.begin(), t.end());
        
        for (int i = 0; i < t.size(); i++) {
            if (t[i].second != 1) cnt++;
            else {
                if ((i + 1 < t.size() && t[i + 1].second != 1) || i + 1 == t.size()) cnt++;
            }
        }
    }
    
    cout << sum << " " << cnt << "\n";
    
    return 0;
}

Floyd + dijktra

首先题目很长，归纳题意就是一个无向图，其中每条边都有两个权值，距离和价值

任务一：找一个起点，从这个点出发，到离它最远的点的距离最小。（Floyd）先用Floyd计算多源最短路，再枚举起点，暴力算出每种情况下的最远距离，取最小值；

任务二：Dijkstra算法，按照距离优先，价值其次的原则进行更新。记录路径。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <stack>

using namespace std;

const int N = 1010, INF = 0x3f3f3f3f;

int n, m;
int d[N][N], v[N][N];
int g[N][N], dist[N], val[N], pre[N];
bool st[N];

void floyd()
{
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
               for (int j = 1; j <= n; j++)
                   d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

void dijktra(int s)
{
    memset(dist, 0x3f, sizeof dist);
    dist[s] = 0;
    
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        
        st[t] = true;
        
        for (int j = 1; j <= n; j++) {
            if ((dist[j] > dist[t] + g[t][j]) || (dist[j] == dist[t] + g[t][j] && val[j] < val[t] + v[t][j])) {
                dist[j] = dist[t] + g[t][j];
                val[j] = val[t] + v[t][j];
                pre[j] = t;
            }
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    
    memset(d, 0x3f, sizeof d);
    for (int i = 1; i <= n; i++) d[i][i] = 0;
    
    memset(g, 0x3f, sizeof g);
    
    while (m -- ) {
        int a, b, c, x;
        scanf("%d%d%d%d", &a, &b, &c, &x);
        d[a][b] = d[b][a] = c;
        g[a][b] = g[b][a] = c;
        v[a][b] = v[b][a] = x;
    }
    
    floyd();
    
    int B0, t = INF;
    for (int i = 1; i <= n; i++) {
        int maxd = 0;
        for (int j = 1; j <= n; j++)
            maxd = max(maxd, d[i][j]);
        
        if (maxd < t) {
            B0 = i; t = maxd;
        }
    }
    
    printf("%d\n", B0);
    
    dijktra(B0);
    
    int q, xx;
    scanf("%d", &q);
    
    while (q -- ) {
        stack<int> res;
        
        int ed;
        scanf("%d", &ed);
        
        int edt = ed;
        
        while (ed != B0) {
            res.push(ed);
            ed = pre[ed];
        }
        
        printf("%d", B0);
        while (res.size()) {
            printf("->%d", res.top());
            res.pop();
        }
        puts("");
        
        printf("%d %d\n", dist[edt], val[edt]);
    }
    
    return 0;
}

疫情防控 (30分)

归纳题意就是给出一张图

支持两种操作

删除一个点
询问两个点是否联通

询问两个点是否联通：并查集。但是并查集并不支持删点操作，如果一定要的话需要在删点后重新建立并查集，这样必然会超时的。
对于依次删除图中的结点，启发我们将顺序删除操作变为逆序添加操作进行处理。所以我们可以把每个查询都存下来，反过来去处理，处理完之后再把当前查询要删除的点添加回去，即把这个点有关的所有边添加入并查集。

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

using namespace std;

const int N = 5e4 + 10;
const int M = 4e5 + 10;
const int D = 1e3 + 10;

typedef pair<int, int> PII;

int n, m, d;
int h[N], e[M],ne[M], idx;
int p[N];
int c[D], ans[D];
vector<PII> route, path[D];
bool vis[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    scanf("%d%d%d", &n, &m, &d);
    
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        route.push_back({a, b});
        add(a, b), add(b, a);
    }
    
    for (int i = 1; i <= d; i++) {
        int q;
        scanf("%d%d", &c[i], &q);
        vis[c[i]] = true;
        
        while (q--) {
            int x, y;
            scanf("%d%d", &x, &y);
            
            path[i].push_back({x, y});
        }
    }
    
    for (int i = 1; i <= n; i++) p[i] = i;
    
    
    for (auto k : route) {
        if (!vis[k.first] && !vis[k.second]) {
            p[find(k.first)] = p[find(k.second)];
        }
    }
    
    for (int i = d; i; i--) {
        int res = 0;
        for (auto k : path[i]) {
            if (find(k.first) != find(k.second)) res++;
        }
        ans[i] = res;
        
        vis[c[i]] = false;
        
        for (int k = h[c[i]]; k != -1; k = ne[k]) {
            if (!vis[e[k]]) {
                p[find(c[i])] = find(e[k]);
            }
        }
    }
    
    for (int i = 1; i <= d; i++)
        printf ("%d\n", ans[i]);
    
    return 0;
}