Submission #1057561

#	Time	Username	Problem	Language	Result	Execution time	Memory
1057561		Zicrus	Fountain Parks (IOI21_parks)	C++17	70 / 100	3551 ms	101396 KiB

parks

#include <bits/stdc++.h>
#include "parks.h"
using namespace std;
 
typedef long long ll;
 
ll n;
 
vector<ll> uflnk;
vector<ll> sz;
 
ll find(ll a) {
    if (a != uflnk[a]) uflnk[a] = find(uflnk[a]);
    return uflnk[a];
}

bool same(ll a, ll b) {
    return find(a) == find(b);
}
 
bool unite(ll a, ll b) {
    a = find(a); b = find(b);
    if (a == b) return false;
    if (sz[a] > sz[b]) swap(a, b);
    uflnk[a] = b;
    sz[b] += sz[a];
    return true;
}
 
int construct_roads(vector<int> x, vector<int> y) {
    n = x.size();
    vector<pair<pair<ll, ll>, ll>> coords(n);
    for (int i = 0; i < n; i++) coords[i] = {{x[i], y[i]}, i};
    sort(coords.begin(), coords.end());
    for (int i = 0; i < n; i++) {
        x[i] = coords[i].first.first;
        y[i] = coords[i].first.second;
    }
    uflnk = vector<ll>(n);
    sz = vector<ll>(n, 1);
    for (int i = 0; i < n; i++) uflnk[i] = i;
    unordered_map<ll, ll> pts;
    vector<pair<ll, ll>> edges;
    unordered_set<ll> hasEdge;
    for (int i = 0; i < n; i++) {
        ll hash = ((ll)x[i] << 31) | (ll)y[i];
        pts[hash] = i;
    }
    for (ll i = 0; i < n; i++) {
        ll hashL = (((ll)x[i]-2) << 31) | ((ll)y[i]);
        if (pts.count(hashL)) {
            if (!same(i, pts[hashL])) {
                edges.push_back({i, pts[hashL]});
                unite(i, pts[hashL]);
            }
        }
        ll hashR = (((ll)x[i]+2) << 31) | ((ll)y[i]);
        if (pts.count(hashR)) {
            if (!same(i, pts[hashR])) {
                edges.push_back({i, pts[hashR]});
                unite(i, pts[hashR]);
            }
        }
        ll hashD = (((ll)x[i]) << 31) | ((ll)y[i]-2);
        if (pts.count(hashD)) {
            if (!same(i, pts[hashD])) {
                edges.push_back({i, pts[hashD]});
                unite(i, pts[hashD]);
            }
        }
        ll hashU = (((ll)x[i]) << 31) | ((ll)y[i]+2);
        if (pts.count(hashU)) {
            if (!same(i, pts[hashU])) {
                edges.push_back({i, pts[hashU]});
                unite(i, pts[hashU]);
            }
        }
    }
 
    unordered_map<ll, ll> poss;
    unordered_set<ll> twos;
    unordered_map<ll, ll> lnk, lnkU;
    vector<pair<ll, ll>> edgeHashes(edges.size());
    mt19937 mt(67234);
    shuffle(edges.begin(), edges.end(), mt);
    for (int i = 0; i < edges.size(); i++) {
        auto e = edges[i];
        ll midX = (x[e.first] + x[e.second]) / 2;
        ll midY = (y[e.first] + y[e.second]) / 2;
        ll leftX = midX - (midY - y[e.second]);
        ll leftY = midY + (midX - x[e.second]);
        ll rightX = midX + (midY - y[e.second]);
        ll rightY = midY - (midX - x[e.second]);
        ll hashL = (leftX << 31) | leftY;
        ll hashR = (rightX << 31) | rightY;
        if (twos.count(hashL)) twos.erase(hashL);
        poss[hashL]++;
        if (poss[hashL] >= 2) twos.insert(hashL);
        if (twos.count(hashR)) twos.erase(hashR);
        poss[hashR]++;
        if (poss[hashR] >= 2) twos.insert(hashR);
        lnk[hashL] ^= i;
        lnk[hashR] ^= i;
        lnkU[hashL] = i;
        lnkU[hashR] = i;
        edgeHashes[i] = {hashL, hashR};
    }
 
    vector<int> a(edges.size()), b(edges.size());
    queue<ll> q;
    for (auto &e : poss) {
        if (e.second != 1) continue;
        q.push(e.first);
    }
    unordered_set<ll> used;
    while (used.size() < edges.size()) {
        while (!q.empty()) {
            ll hash = q.front(); q.pop();
            if (poss[hash] != 1 || used.count(hash)) continue;
            ll id = lnk[hash];
            a[id] = hash >> 31;
            b[id] = hash & ~(1 << 31);
            used.insert(id);
            if (twos.count(edgeHashes[id].first)) twos.erase(edgeHashes[id].first);
            if (--poss[edgeHashes[id].first] == 1) q.push(edgeHashes[id].first);
            if (poss[edgeHashes[id].first] >= 2) twos.insert(edgeHashes[id].first);
            if (twos.count(edgeHashes[id].second)) twos.erase(edgeHashes[id].second);
            if (--poss[edgeHashes[id].second] == 1) q.push(edgeHashes[id].second);
            if (poss[edgeHashes[id].second] >= 2) twos.insert(edgeHashes[id].second);
            lnk[edgeHashes[id].first] ^= id;
            lnk[edgeHashes[id].second] ^= id;
        }
        if (used.size() < edges.size() && twos.empty()) {
            for (auto &e : poss) {
                if (e.second == 1) q.push(e.first);
                if (e.second >= 2) twos.insert(e.first);
            }
            if (q.empty() && twos.empty()) throw;
        }
        else if (used.size() < edges.size() && !twos.empty()) {
            ll v = *twos.begin();
            twos.erase(v);
            ll i = lnkU[v];
            if (used.count(i)) continue;
            auto e = edges[i];
            ll midX = (x[e.first] + x[e.second]) / 2;
            ll midY = (y[e.first] + y[e.second]) / 2;
            if (abs(midX - (v >> 31)) + abs(midY - (v & ~(1 << 31))) > 1) continue;
            a[i] = v >> 31;
            b[i] = v & ~(1 << 31);
            poss[v] = 0;
            ll otherX = a[i] + 2 * (midX - a[i]);
            ll otherY = b[i] + 2 * (midY - b[i]);
            ll otherHash = (otherX << 31) | otherY;
            if (twos.count(otherHash)) twos.erase(otherHash);
            poss[otherHash]--;
            if (poss[otherHash] >= 2) twos.insert(otherHash);
            lnk[otherHash] ^= i;
            while (poss[otherHash] == 1) {
                ll edge = lnk[otherHash];
                auto e = edges[edge];
                ll midX = (x[e.first] + x[e.second]) / 2;
                ll midY = (y[e.first] + y[e.second]) / 2;
                a[edge] = otherHash >> 31;
                b[edge] = otherHash & ~(1 << 31);
                ll otherX = a[edge] + 2 * (midX - a[edge]);
                ll otherY = b[edge] + 2 * (midY - b[edge]);
                otherHash = (otherX << 31) | otherY;
                if (twos.count(otherHash)) twos.erase(otherHash);
                poss[otherHash]--;
                if (poss[otherHash] >= 2) twos.insert(otherHash);
                lnk[otherHash] ^= edge;
                used.insert(edge);
            }
            used.insert(i);
        }
    }
 
    uflnk = vector<ll>(n);
    sz = vector<ll>(n, 1);
    for (int i = 0; i < n; i++) uflnk[i] = i;
    vector<int> u, v;
    for (int i = 0; i < edges.size(); i++) {
        u.push_back(coords[edges[i].first].second);
        v.push_back(coords[edges[i].second].second);
        unite(edges[i].first, edges[i].second);
    }
 
    if (sz[find(0)] < n) return 0;
 
    build(u, v, a, b);
    return 1;
}

Compilation message (stderr)

parks.cpp: In function 'int construct_roads(std::vector<int>, std::vector<int>)':
parks.cpp:86:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<long long int, long long int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   86 |     for (int i = 0; i < edges.size(); i++) {
      |                     ~~^~~~~~~~~~~~~~
parks.cpp:183:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<long long int, long long int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  183 |     for (int i = 0; i < edges.size(); i++) {
      |                     ~~^~~~~~~~~~~~~~

• Subtask 1: 5 / 5
• Subtask 2: 10 / 10
• Subtask 3: 15 / 15
• Subtask 4: 20 / 20
• Subtask 5: 20 / 20
• Subtask 6: 0 / 30