제출 #596562

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
596562		SlavicG	통행료 (IOI18_highway)	C++17	51 / 100	779 ms	54424 KiB

highway

#include "highway.h"
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()

void dfs(int u, int par, vector<vector<int>>& adj, vector<int>& p, vector<int>& depth) {
    p[u] = par;
    for(int v: adj[u]) {
        if(v == par) continue;
        depth[v] = depth[u] + 1;
        dfs(v, u, adj, p, depth);
    }
}
void bfsTree(int start, vector<vector<int>>& adj, vector<vector<int>>& g, vector<bool>& use) {
    queue<int> q; q.push(start);
    vector<bool> vis(sz(g), 0);
    vis[start] = 1;
    while(!q.empty()) {
        int u = q.front();
        assert(use[u] == true);
        q.pop();
        for(int v: g[u]) {
            if(!vis[v] && use[v]) {
                adj[u].push_back(v);
                adj[v].push_back(u);
                vis[v] = true;
                q.push(v);
            }
        }
    }
}
ll init;
ll paiu;
map<vector<int>, ll> mp;
ll query(vector<int>& c) {
    if(!mp.count(c)) mp[c] = ask(c);
    return mp[c];
}
int find(int start, int n, vector<int>& u, vector<int>& v, vector<bool>& use) {
    map<pair<int, int>, int> idx;
    vector<vector<int>> adj(n), g(n);
    vector<int> p(n, 0), depth(n, 0);

    int m = u.size();
    for(int i = 0; i < m; ++i) {
        g[u[i]].push_back(v[i]);
        g[v[i]].push_back(u[i]);
        idx[{u[i], v[i]}] = idx[{v[i], u[i]}] = i;
    }
    bfsTree(start, adj, g, use);
    dfs(start, -1, adj, p, depth);
    vector<int> c(m, 1);
    for(int i = 0; i < n; ++i) {
        if(p[i] != -1 && use[i]) c[idx[{i, p[i]}]] = 0;
    }
    init = query(c);
    vector<pair<int, int>> bruh;
    for(int i = 0; i < n; ++i) {
        if(p[i] != -1 && use[i])
            bruh.push_back({depth[i], i});
    }
    sort(rall(bruh));
    vector<int> nodes;
    for(int i = 0; i < sz(bruh); ++i) {
        nodes.push_back(bruh[i].second);
    }
    if(sz(nodes) == 0) {
        return start;
    }
    assert(sz(nodes) > 0);

    vector<int> rem = c;
    vector<int> ids(sz(nodes), -1);
    for(int i = 0; i < sz(nodes); ++i) {
        ids[i] = idx[{nodes[i], p[nodes[i]]}];
    }
    int l = 0, r = sz(nodes) - 1, pp = -1;
    while(l <= r) {
        int mid = (l + r) >> 1;
        for(int i = 0; i <= mid; ++i) {
            if(p[nodes[i]] == -1) continue;
            c[ids[i]] = 1;
        }
        if(query(c) > init) {
            pp = mid;
            r = mid - 1;
        } else l = mid + 1;
        c = rem;
    }
    if(pp == -1) return start;
    return nodes[pp];
}
void get_distances(int s, vector<vector<int>>& adj, vector<int>& d) {
    d.assign((int)adj.size(), INT_MAX);
    d[s] = 0;
    queue<int> q;
    q.push(s);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int v: adj[u]) {
            if(d[v] == INT_MAX) {
                d[v] = d[u] + 1;
                q.push(v);
            }
        }
    }
}

void find_pair(int n, vector<int> u, vector<int> v, int a, int b) {
    vector<int> noo(sz(u), 0);
    init = query(noo);
    paiu = init;
    vector<vector<int>> adj(n);
    for(int i = 0; i < (int)u.size(); ++i) adj[u[i]].push_back(v[i]), adj[v[i]].push_back(u[i]);
    int pos = -1, l = 0, r = sz(u) - 1;
    while(l <= r) {
        int mid = (l + r) >> 1;
        for(int i = 0; i <= mid; ++i) noo[i] = 1;
        if(query(noo) > init) {
            pos = mid;
            r = mid - 1;
        } else l = mid + 1;

        for(int i = 0; i <= mid; ++i) noo[i] = 0;
    }
    vector<int> du(n), dv(n);
    get_distances(u[pos], adj, du);
    get_distances(v[pos], adj, dv);
    vector<bool> use(n, false);
    for(int i = 0; i < n; ++i) {
        if(du[i] <= dv[i]) use[i] = true;
    }
    int s = find(u[pos], n, u, v, use);
    use.assign(n, false);
    for(int i = 0; i < n; ++i) {
        if(dv[i] <= du[i]) use[i] = true;
    }
    int t = find(v[pos], n, u, v, use);
    answer(t, s);
}

• Subtask 1: 5 / 5
• Subtask 2: 7 / 7
• Subtask 3: 6 / 6
• Subtask 4: 33 / 33
• Subtask 5: 0 / 18
• Subtask 6: 0 / 31