Submission #738189

#	Time	Username	Problem	Language	Result	Execution time	Memory
738189		GrindMachine	Valley (BOI19_valley)	C++17	59 / 100	3043 ms	35204 KiB

valley

// Om Namah Shivaya

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x, y) ((x + y - 1) / (y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i, n) for(int i = 0; i < n; ++i)
#define rep1(i, n) for(int i = 1; i <= n; ++i)
#define rev(i, s, e) for(int i = s; i >= e; --i)
#define trav(i, a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a, b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a, b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(x) 42
#endif

/*



*/

const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

struct suffmx {
    // https://usaco.guide/adv/springboards?lang=cpp
    vector<pll> v;

    void insert(pll p) {
        v.pb(p);
    }

    ll query(ll x) {
        ll res = -inf2;

        trav(p, v) {
            if (p.ff >= x) {
                amax(res, p.ss);
            }
        }

        return res;
    }
};

vector<array<ll, 3>> adj[N];

struct lca_algo {
    // LCA template (for graphs with 1-based indexing)

    int LOG = 1;
    vector<int> depth;
    vector<vector<int>> up;
    vector<ll> dis;

    lca_algo() {

    }

    lca_algo(int n) {
        lca_init(n);
    }

    void lca_init(int n) {
        while ((1 << LOG) < n) LOG++;
        up = vector<vector<int>>(n + 1, vector<int>(LOG, 1));
        depth = vector<int>(n + 1);
        dis = vector<ll>(n + 1);

        lca_dfs(1, -1);
    }

    void lca_dfs(int node, int par) {
        for (auto [child, w, id] : adj[node]) {
            if (child == par) conts;

            up[child][0] = node;
            rep1(j, LOG - 1) {
                up[child][j] = up[up[child][j - 1]][j - 1];
            }

            depth[child] = depth[node] + 1;
            dis[child] = dis[node] + w;

            lca_dfs(child, node);
        }
    }

    int lift(int u, int k) {
        rep(j, LOG) {
            if (k & (1 << j)) {
                u = up[u][j];
            }
        }

        return u;
    }

    int query(int u, int v) {
        if (depth[u] < depth[v]) swap(u, v);
        int k = depth[u] - depth[v];
        u = lift(u, k);

        if (u == v) return u;

        rev(j, LOG - 1, 0) {
            if (up[u][j] != up[v][j]) {
                u = up[u][j];
                v = up[v][j];
            }
        }

        u = up[u][0];
        return u;
    }

    ll get_dis(int u, int v) {
        int lca = query(u, v);
        return dis[u] + dis[v] - 2 * dis[lca];
    }
};

vector<array<ll, 3>> edges(N);
vector<ll> edge_node(N);
vector<ll> tin(N), tout(N);
vector<ll> node_tin(N, -1);
ll timer = 1;

void dfs(ll u, ll p) {
    tin[u] = timer++;
    node_tin[tin[u]] = u;

    for (auto [v, w, id] : adj[u]) {
        if (v == p) conts;
        edge_node[id] = v;
        dfs(v, u);
    }

    tout[u] = timer - 1;
}

vector<ll> par(N, -1);
vector<bool> rem(N);
vector<ll> subsiz(N);

ll get_siz(ll u, ll p) {
    subsiz[u] = 1;

    for (auto [v, w, id] : adj[u]) {
        if (v == p or rem[v]) conts;
        subsiz[u] += get_siz(v, u);
    }

    return subsiz[u];
}

ll get_centroid(ll u, ll p, ll nodes) {
    for (auto [v, w, id] : adj[u]) {
        if (v == p or rem[v]) conts;
        if (subsiz[v] > nodes / 2) {
            return get_centroid(v, u, nodes);
        }
    }

    return u;
}

void build(ll u, ll p) {
    ll nodes = get_siz(u, -1);
    ll centroid = get_centroid(u, -1, nodes);

    par[centroid] = p;
    rem[centroid] = 1;

    for (auto [v, w, id] : adj[centroid]) {
        if (rem[v]) conts;
        build(v, centroid);
    }
}

void solve(int test_case)
{
    ll n, s, q; cin >> n >> s >> q;
    ll root; cin >> root;

    rep1(i, n - 1) {
        ll u, v, w; cin >> u >> v >> w;
        edges[i] = {u, v, w};
        adj[u].pb({v, w, i}), adj[v].pb({u, w, i});
    }

    vector<bool> spl(n + 5);
    rep1(i, s) {
        ll u; cin >> u;
        spl[u] = 1;
    }

    dfs(root, -1);
    // build(root, -1);
    lca_algo LCA(n);

    vector<array<ll, 3>> queries[n + 5];
    // vector<suffmx> smx(n + 5);

    rep1(i, q) {
        ll edge, src; cin >> edge >> src;
        ll sub = edge_node[edge];
        ll l = tin[sub], r = tout[sub];
        queries[1].pb({edge, src, i});
    }

    vector<ll> ans(q + 5);

    rep1(t, n) {
        // ll u = node_tin[t];
        // if (u != -1 and spl[u]) {
        //     ll lca = u;
        //     while (lca != -1) {
        //         ll d = LCA.get_dis(u, lca);
        //         smx[lca].insert({tin[u], -d});
        //         lca = par[lca];
        //     }
        // }

        for (auto [edge, src, qid] : queries[t]) {
            ll sub = edge_node[edge];
            ll l = tin[sub], r = tout[sub];

            if (!(tin[src] >= l and tout[src] <= r)) {
                ans[qid] = -1;
                conts;
            }

            if (spl[src]) {
                ans[qid] = 0;
                conts;
            }

            queue<ll> q;
            vector<bool> vis(n + 5);
            vector<ll> dis(n + 5, inf2);

            q.push(src);
            vis[src] = 1;
            dis[src] = 0;

            while (!q.empty()) {
                ll u = q.front();
                q.pop();

                for (auto [v, w, id] : adj[u]) {
                    if (id == edge) conts;
                    if (vis[v]) conts;

                    q.push(v);
                    vis[v] = 1;
                    dis[v] = dis[u] + w;
                }
            }

            ans[qid] = inf2;
            rep1(u, n) {
                if (spl[u]) {
                    amin(ans[qid], dis[u]);
                }
            }

            // ll lca = src;
            // ll best = inf2;

            // while (lca != -1) {
            //     if (tin[lca] >= l and tout[lca] <= r) {
            //         ll mn = -smx[lca].query(l);

            //         if (mn < inf2) {
            //             ll d = LCA.get_dis(src, lca);
            //             // pll px = {src, lca};

            //             amin(best, d + mn);
            //         }
            //     }

            //     lca = par[lca];
            // }

            // ans[qid] = best;
        }
    }

    rep1(i, q) {
        if (ans[i] == -1) {
            cout << "escaped" << endl;
        }
        else if (ans[i] >= inf2) {
            cout << "oo" << endl;
        }
        else {
            cout << ans[i] << endl;
        }
    }
}

int main()
{
    fastio;

    int t = 1;
    // cin >> t;

    rep1(i, t) {
        solve(i);
    }

    return 0;
}

Compilation message (stderr)

valley.cpp: In function 'void solve(int)':
valley.cpp:245:12: warning: unused variable 'l' [-Wunused-variable]
  245 |         ll l = tin[sub], r = tout[sub];
      |            ^
valley.cpp:245:26: warning: unused variable 'r' [-Wunused-variable]
  245 |         ll l = tin[sub], r = tout[sub];
      |                          ^

• Subtask 1: 9 / 9
• Subtask 2: 27 / 27
• Subtask 3: 23 / 23
• Subtask 4: 0 / 41