Submission #1345882

#TimeUsernameProblemLanguageResultExecution timeMemory
1345882pandaa73Nile (IOI24_nile)C++20
38 / 100
40 ms7732 KiB
#include <bits/stdc++.h>
using namespace std;

#define ff endl
#define lf "\n"
#define fi first
#define se second
#define _ << ' ' <<
#define all(x) begin(x),end(x)
#define rall(x) rbegin(x),rend(x)

#ifdef DEBUG

constexpr bool IS_DEBUG = 1;

#define infor(fmt, ...) do { print(stderr, fmt, ##__VA_ARGS__); } while(0)
#define infof(fmt, ...) do { println(stderr, fmt, ##__VA_ARGS__); } while(0)

#else

constexpr bool IS_DEBUG = 0;

#define infor(fmt, ...)
#define infof(fmt, ...)

#endif

using ll = long long;

using pll = pair<ll, ll>;
using pii = pair<int, int>;

template<typename... Args>
using vec = vector<Args...>;

constexpr int LOG = 20;
constexpr int MOD = 1e9+7;
constexpr int MAXN = 1e5+7;

mt19937 timmy_loves_gambling(73);

struct DSU {
    DSU(int N, const vec<ll> &V): N(N), sum(accumulate(all(V), 0LL)), mn(V),
        dsu(N, -1) {}

    ll f(int v) {
        if constexpr(IS_DEBUG) {
            assert(dsu[v] < 0);
        }

        return dsu[v]&1 ? mn[v] : 0LL;
    }

    int find(int v) {
        return dsu[v] < 0 ? v : dsu[v] = find(dsu[v]);
    }

    void join(int u, int v) {
        u = find(u);
        v = find(v);

        if(u == v) return;

        if(dsu[u] > dsu[v]) swap(u, v);

        sum -= f(u);
        sum -= f(v);

        dsu[u] += dsu[v];
        dsu[v] = u;

        mn[u] = min(mn[u], mn[v]);

        sum += f(u);
    }

    ll sum;
    vec<ll> mn;

    int N;
    vec<int> dsu;
};

vector<long long> calculate_costs(vector<int> W, vector<int> A, vector<int> B,
        vector<int> E) {
    const int N = W.size();
    const int Q = E.size();

    vec<int> ord(N); iota(all(ord), 0);
    sort(all(ord), [&](int i, int j) -> bool {
        return W[i] < W[j];
    });

    vec<int> ord_q(Q); iota(all(ord_q), 0);
    sort(all(ord_q), [&](int i, int j) -> bool {
        return E[i] < E[j];
    });

    vec<pii> events; events.reserve(N - 1);
    for(int ii = 0; ii < N - 1; ++ii) {
        int i = ord[ii + 0], j = ord[ii + 1];
        events.emplace_back(abs(W[i] - W[j]), ii);
    }

    sort(all(events));

    vec<ll> V(N);
    for(int i = 0; i < N; ++i) {
        V[i] = A[i] - B[i];
    }

    DSU dsu(N, V);
    vec<ll> ans(Q, accumulate(all(B), 0LL));

    int idx = 0;
    for(auto q: ord_q) {
        for(; idx < N - 1 && events[idx].fi <= E[q]; ++idx) {
            dsu.join(ord[events[idx].se + 0], ord[events[idx].se + 1]);
        }

        ans[q] += dsu.sum;
    }

    return ans;
}

#ifdef LOCAL
int main() {
  int N;
  assert(1 == scanf("%d", &N));
  std::vector<int> W(N), A(N), B(N);
  for (int i = 0; i < N; i++)
    assert(3 == scanf("%d%d%d", &W[i], &A[i], &B[i]));
  int Q;
  assert(1 == scanf("%d", &Q));
  std::vector<int> E(Q);
  for (int j = 0; j < Q; j++)
    assert(1 == scanf("%d", &E[j]));
  fclose(stdin);

  std::vector<long long> R = calculate_costs(W, A, B, E);

  int S = (int)R.size();
  for (int j = 0; j < S; j++)
    printf("%lld\n", R[j]);
  fclose(stdout);

  return 0;
}
#endif
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...
#Verdict Execution timeMemoryGrader output
Fetching results...