ICPC 2023 Online A D G L

A:：签到

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<string> s1, s2;
    map<string, bool> mp1, mp2;

    for (int i = 0; i < n; ++i) {
        string x;
        cin >> x;
        if (mp1[x]) continue;
        s1.push_back(x);
        mp1[x] = 1;
    }
    for (int i = 0; i < m; ++i) {
        string x;
        cin >> x;
        if (mp2[x]) continue;
        s2.push_back(x);
        mp2[x] = 1;
    }

    vector<string> v;
    map<string, bool> mp;
    
    for (int i = 0; i < max(s2.size(), s1.size()); ++i) {
        if (i < s1.size()) {
            v.push_back(s1[i]);
        }
        if (i < s2.size()) {
            v.push_back(s2[i]);
        }
    }

    for (int i = 0; i < v.size(); ++i) {
        if (!mp[v[i]]) {
            cout << v[i] << endl;
            mp[v[i]] = 1;
        }
    }
    return 0;
}

L ：签到

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n, t;
    cin >> n >> t;
    int x, k = 0;
    for (int i = 0; i < n; ++i) {
        cin >> x;
        k = max(k, x);
    }
    cout << max(2, (k + t - 1) / t) << endl;
    return 0;
}

D ：判断初始图是否满足连通性，满足则连最小的两个块，否则将图补为连通

#include<bits/stdc++.h>
using namespace std;
using ll = long long;

struct DSU {
    int n;
    vector<int> p;
    vector<ll> sz, cnt;
    
    DSU (int x) :n(x) {
        p.resize(n + 1);
        sz.resize(n + 1, 1);
        cnt.resize(n + 1);
        iota(p.begin(), p.end(), 0);
        
    }
    inline int find(int x) {
        return x == p[x] ? p[x] : p[x] = find(p[x]);
    }

    void merge(int a, int b) {
        a = find(a), b = find(b);
        if (a == b) {
            cnt[b] ++;
            return ;
        }
        p[a] = b;
        cnt[b] += cnt[a] + 1;
        sz[b] += sz[a];
    }
    
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int n, m;
    cin >> n >> m;
    DSU p(n);
    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        p.merge(u, v);
    }

    ll zen = 0;
    vector<bool> st(n + 1);
    ll edg = 0;
    vector<int> v;
    
    for (int i = 1; i <= n; ++i) {
        int u = p.find(i);
        if (!st[u]) {
            st[u] = 1;
            v.push_back(p.sz[u]);
            edg = p.sz[u] * (p.sz[u] - 1) / 2;
            if (edg > p.cnt[u]) zen += edg - p.cnt[u];
        }
    }
    sort(v.begin(), v.end());

    ll ans = 1ll * v[0] * v[1];
    if (zen == 0) cout << ans << endl;
    else 
        cout << zen << endl;
    return 0;
}

G ：启发式合并，连接两个集合时，集合间只能有一条边可连，若不符合则无法生成给定的数

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 998244353;
const int N = 1e6 + 10;

ll qpow (int a, int b) {
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        b >>= 1;
        a = a * a % mod;
    }
    return res;
}
vector<int> G[N];

struct DSU {
    int n;
    vector<int> p, sz;
    DSU (int x) : n(x) {
        p.resize(n + 1);
        iota(p.begin(), p.end(), 0);
        sz.resize(n + 1, 1);
    }

    inline int find(int x) {
        return x == p[x] ? p[x] : p[x] = find(p[x]);
    }

    void merge (int a, int b) {
        a = find(a), b = find(b);
        if (a == b) {
            return ;
        }
        p[a] = b;
        sz[b] += sz[a];
    }
};
int f[N], dep[N];

void dfs(int u, int fa) {
    f[u] = fa;
    for (auto x : G[u]) {
        if (x != fa) {
            dep[x] = dep[u] + 1;
            dfs(x, u);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> a(n), b(n);
    DSU p(n);
    
    for (int i = 0; i < n - 1; ++i) {
        cin >> a[i] >> b[i];
    }
    vector<ll> inv(n + 1);
    inv[1] = 1;
    for (int i = 2; i <= n; ++i) 
        inv[i] = inv[mod % i] * (mod - mod / i) % mod;

    for (int i = 0; i < n - 1; ++i) {
        int c, d;
        cin >> c >> d;
        G[c].push_back(d);
        G[d].push_back(c);
    }
    dfs(1, 0);
    
    ll ans = 1;
    for (int i = 0; i < n - 1; ++i) {
        int u = p.find(a[i]), v = p.find(b[i]);
        if (dep[u] < dep[v]) swap(u, v);
        if (p.find(f[u]) != v) {
            cout << 0 << endl;
            return 0;
        } 
        else {
            ans = (ans * inv[p.sz[u]] % mod) * inv[p.sz[v]] % mod;
            p.merge(u, v);
        }
    }
    cout << ans << endl;
    return 0;
}