Submission #906232

#	Time	Username	Problem	Language	Result	Execution time	Memory
906232		efedmrlr	Road Closures (APIO21_roads)	C++17	71 / 100	967 ms	1048576 KiB

roads

#include "roads.h"
// #pragma GCC optimize("O3,Ofast,unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#include <bits/stdc++.h>

using namespace std;


#define lli long long int
#define MP make_pair
#define pb push_back
#define REP(i,n) for(int i = 0; (i) < (n); (i)++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

void fastio() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
}


const double EPS = 0.00001;
const lli INF = 1e17;
const lli MX = 1e9 + 500;
const int M = 3e5+5;
const int ALPH = 26;
const int LGN = 25;
constexpr int MOD = 1e9+7;
int n,m,q,k;

vector<int> deg(M, 0);
vector<array<lli,2> > p(M);
vector<vector<array<lli,2> > > adj(M, vector<array<lli,2> >());
vector<array<int,2> > deg_nodes;
vector<int> tin(M, 0), vis(M, -1);
int timer = 0;
set<array<int,2> > roots;

struct Node {
    lli sz, sum;
    Node *lc, *rc;
    Node() : sz(0), sum(0), lc(NULL), rc(NULL) {};
    void extend() {
        if(!lc) lc = new Node();
        if(!rc) rc = new Node();
    }
    void update(lli tl, lli tr, lli ind, int val) {
        if(tl == tr) {
            sz+= val; sum += ind;
            return;
        }
        lli tm = (tl + tr) >> 1ll;
        extend();
        if(ind <= tm) {
            lc->update(tl, tm, ind, val);
        }
        else {
            rc->update(tm + 1, tr, ind, val);
        }
        sz = lc->sz + rc->sz; 
        sum = lc->sum + rc->sum;
    }
    lli query(lli tl, lli tr, lli els, lli add = 0) {
        if(tl == tr) {
            if(add + sz < els) return INF;
            return (els - add) * tl;
        }
        lli tm = (tl + tr) >> 1ll;
        extend();
        if(els <= add + lc->sz) {
            return lc->query(tl, tm, els, add);
        }
        else {
            return lc->sum + rc->query(tm + 1, tr, els, add + lc->sz);
        }
    }
    
};

struct SegT {
    Node root;
    int sz;
    SegT() : root(), sz(MX) {};
    
    void insert(lli val) {
        // cout<<"insert:"<<val<<"\n";
        root.update(0, sz, val, 1);
    }
    lli k_sum(int sm) {
        return min(INF, root.query(0, sz, sm));
    }
};

vector<SegT> st;
void prec(int node, int par, int cst) {
    p[node] = {par, cst};
    tin[node] = timer++;
    roots.insert({tin[node], node});
    for(auto itr = adj[node].begin(); itr != adj[node].end(); ) {
        auto c = (*itr)[0];
        if(c == par) {
            itr = adj[node].erase(itr);
            continue;
        }
        prec((int)c, node, (int)(*itr)[1]);
        itr++;
    }
}
array<lli, 2> dfs(int node) {
    vis[node] = k;
    // cout<<"dfs : " << node << endl;
    int csz = 0;
    vector<lli> A1, A2, srt;
    array<lli,2> ret = {INF, INF};
    lli sum = 0;
    for(auto &c : adj[node]) {
        if(deg[c[0]] <= k) {
            break;
        }
        srt.pb(csz);
        csz++;
        auto tmp = dfs((int)c[0]);
        A1.pb(tmp[1] + c[1]); A2.pb(tmp[0]);
        sum += min(tmp[0], tmp[1] + c[1]);
    }
    auto comp = [&](const lli &x, const lli &y) {
        return A1[x] - A2[x] < A1[y] - A2[y];
    };
    int cnt = deg[node] - k;
    assert(cnt > 0);
    sort(all(srt), comp);
    vector<lli> cev(csz + 1);
    cev[0] = sum;
    
    for(int i = 1; i <= csz; i++) {
        cev[i] = cev[i - 1] - min(A1[srt[i - 1] ], A2[srt[i - 1]]) + A1[srt[i - 1]];
    }
    for(int i = 0; i <= min(cnt, csz); i++) {
        ret[0] = min(ret[0], cev[i] + st[node].k_sum(cnt - i));
        if(i < cnt) ret[1] = min(ret[1], cev[i] + st[node].k_sum(cnt - i - 1));
    }
    // cout << "node:"<<node<<" normal:"<<ret[0]<<" del par:"<<ret[1]<<"\n";
    // cout<<"cnt:"<<cnt<<"csz:"<<csz<<"\n";
    return ret;

}
lli solve_k() {
    // cout<<"k:"<<k<<"\n\n";
    while(deg_nodes.size() && deg_nodes.back()[0] == k) {
        auto cur = deg_nodes.back();
        // cout<<"erase:"<<cur[1]<<"\n";
        roots.erase({tin[cur[1]], cur[1]});
        st[p[cur[1]][0]].insert(p[cur[1]][1]);
        for(auto &c : adj[cur[1]]) {
            st[c[0]].insert(c[1]);
        }
        deg_nodes.pop_back();
    }
    // cout<<"zort"<<endl;
    lli ret = 0;
    for(auto &c : roots) {
        if(vis[c[1]] == k) continue;
        
        ret += dfs(c[1])[0];
    }
    return ret;
}


std::vector<long long> minimum_closure_costs(int N, std::vector<int> U,
  std::vector<int> V,
  std::vector<int> W) {
    n = N;
    lli sum = 0ll;
    for(int i = 0; i<n - 1; i++) {
      V[i]++; U[i]++;
      adj[U[i]].pb({V[i], W[i]});
      adj[V[i]].pb({U[i], W[i]});
      sum += W[i]; 
    }
    vector<lli> ans(n);
    deg_nodes.resize(n);
    for(int i = 1; i<=n; i++) {
        deg[i] = (int)adj[i].size();
        deg_nodes[i - 1] = {deg[i], i};
    }
    sort(rall(deg_nodes));
    auto comp = [](const array<lli,2> &x, const array<lli,2> &y) { return deg[x[0]] < deg[y[0]]; }; 
    for(int i = 1; i<=n; i++) {
        sort(rall(adj[i]), comp);
    }
    prec(1, 0, 0);
    ans[0] = sum;
    st.assign(n + 3, SegT());
    for(int i = 1; i<=n - 1; i++) {
        // cout<<"i:"<<i<<endl;
        k = i;
        ans[i] = solve_k();

    }
    return ans;
}

• Subtask 1: 5 / 5
• Subtask 2: 0 / 7
• Subtask 3: 14 / 14
• Subtask 4: 10 / 10
• Subtask 5: 17 / 17
• Subtask 6: 25 / 25
• Subtask 7: 0 / 22