oj.uz

Submission #746809

# Submission time Handle Problem Language Result Execution time Memory
746809 2023-05-23T06:34:03 Z GrindMachine Election Campaign (JOI15_election_campaign) C++17
20 / 100
 1000 ms 34912 KB 
// 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;

vector<ll> adj[N];

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

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

    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);

        lca_dfs(1, -1);
    }

    void lca_dfs(int node, int par) {
        trav(child, 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;

            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;
    }

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

vector<array<ll,3>> here[N];
vector<ll> dp(N), adj_dp(N);
vector<ll> tin(N), tout(N);
vector<ll> par(N,-1);
ll timer = 1;
ll n;

void dfs1(ll u, ll p){
    tin[u] = timer++;
    trav(v, adj[u]){
        if(v == p) conts;
        par[v] = u;
        dfs1(v, u);
    }
    tout[u] = timer++;
}

void dfs2(ll u, ll p){
    trav(v, adj[u]){
        if(v == p) conts;
        dfs2(v, u);
        adj_dp[u] += dp[v];
    }

    // pick 1 path passing through u
    for(auto [x, y, w] : here[u]){
        ll val = w;

        ll x2 = x;
        while(x2 != u){
            val -= dp[x2];
            val += adj_dp[x2];
            x2 = par[x2];
        }

        ll y2 = y;
        while(y2 != u){
            val -= dp[y2];
            val += adj_dp[y2];
            y2 = par[y2];
        }

        val += adj_dp[u];
        amax(dp[u], val);
    }

    // dont pick any path going through u
    amax(dp[u], adj_dp[u]);
}

void solve(int test_case)
{
    cin >> n;
    rep1(i,n-1){
        ll u,v; cin >> u >> v;
        adj[u].pb(v), adj[v].pb(u);
    }

    lca_algo LCA(n);

    ll m; cin >> m;

    rep1(i,m){
        ll u,v,w; cin >> u >> v >> w;
        ll lca = LCA.query(u,v);
        here[lca].pb({u, v, w});
    }

    dfs1(1, -1);
    dfs2(1, -1);

    ll ans = dp[1];
    cout << ans << endl;
}

int main()
{
    fastio;

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

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

    return 0;
}

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 8916 KB Output is correct
2 Correct 5 ms 8916 KB Output is correct
3 Correct 6 ms 8916 KB Output is correct
4 Correct 6 ms 9044 KB Output is correct
5 Correct 124 ms 24688 KB Output is correct
6 Correct 55 ms 29928 KB Output is correct
7 Correct 105 ms 28236 KB Output is correct
8 Correct 70 ms 24628 KB Output is correct
9 Correct 110 ms 26956 KB Output is correct
10 Correct 87 ms 24640 KB Output is correct

Subtask #2
0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 8852 KB Output is correct
2 Correct 4 ms 8916 KB Output is correct
3 Correct 5 ms 9044 KB Output is correct
4 Execution timed out 1079 ms 34820 KB Time limit exceeded
5 Halted 0 ms 0 KB -

Subtask #3
0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 8852 KB Output is correct
2 Correct 4 ms 8916 KB Output is correct
3 Correct 5 ms 9044 KB Output is correct
4 Execution timed out 1079 ms 34820 KB Time limit exceeded
5 Halted 0 ms 0 KB -

Subtask #4
0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 196 ms 28824 KB Output is correct
2 Correct 834 ms 34912 KB Output is correct
3 Execution timed out 1065 ms 32776 KB Time limit exceeded
4 Halted 0 ms 0 KB -

Subtask #5
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 8916 KB Output is correct
2 Correct 5 ms 8916 KB Output is correct
3 Correct 6 ms 8916 KB Output is correct
4 Correct 6 ms 9044 KB Output is correct
5 Correct 124 ms 24688 KB Output is correct
6 Correct 55 ms 29928 KB Output is correct
7 Correct 105 ms 28236 KB Output is correct
8 Correct 70 ms 24628 KB Output is correct
9 Correct 110 ms 26956 KB Output is correct
10 Correct 87 ms 24640 KB Output is correct
11 Correct 5 ms 9044 KB Output is correct
12 Correct 6 ms 9104 KB Output is correct
13 Correct 7 ms 9044 KB Output is correct
14 Correct 5 ms 9088 KB Output is correct
15 Correct 6 ms 9168 KB Output is correct
16 Correct 6 ms 9104 KB Output is correct
17 Correct 5 ms 9044 KB Output is correct
18 Correct 6 ms 9092 KB Output is correct
19 Correct 5 ms 9100 KB Output is correct
20 Correct 6 ms 9172 KB Output is correct

Subtask #6
0 / 40.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 8916 KB Output is correct
2 Correct 5 ms 8916 KB Output is correct
3 Correct 6 ms 8916 KB Output is correct
4 Correct 6 ms 9044 KB Output is correct
5 Correct 124 ms 24688 KB Output is correct
6 Correct 55 ms 29928 KB Output is correct
7 Correct 105 ms 28236 KB Output is correct
8 Correct 70 ms 24628 KB Output is correct
9 Correct 110 ms 26956 KB Output is correct
10 Correct 87 ms 24640 KB Output is correct
11 Correct 6 ms 8852 KB Output is correct
12 Correct 4 ms 8916 KB Output is correct
13 Correct 5 ms 9044 KB Output is correct
14 Execution timed out 1079 ms 34820 KB Time limit exceeded
15 Halted 0 ms 0 KB -