Submission #1161162

#	Time	Username	Problem	Language	Result	Execution time	Memory
1161162		just	Road Closures (APIO21_roads)	C++20	26 / 100	30 ms	15504 KiB

roads

#include "bits/stdc++.h"
using namespace std;

#define all(x) (x).begin(), (x).end()
#define int long long
#define vec vector
#define pii pair<int, int>

#define X first
#define Y second

int DATA[1000][2];
bool SEEN[1000][2];
int dfs(int u, int p, int k, bool conn, const vec<vec<pii>> &adj) {
    if (SEEN[u][conn]) return DATA[u][conn];

    vec<pii> vals; vals.reserve(adj[u].size());

    for(auto [v, w]: adj[u]) {
        if (v == p) continue;
        vals.push_back({
            dfs(v, u, k, 1, adj) + w,
            dfs(v, u, k, 0, adj)
        });
    }

    sort(all(vals), [](pii a, pii b) {
        return a.X - a.Y > b.X - b.Y;
    });

    int res = 0, l = k - conn;
    for (auto [a, b]: vals) {
        if (l > 0 && a > b) {
            res += a;
            l--;
        } else {
            res += b;
        }
    }

    SEEN[u][conn] = 1;
    return DATA[u][conn] = res;
}

vec<int> calc(int n, vec<pii> edges, vec<int> costs) {

    if (n == 2) {
        return {costs[0], 0};
    }


    bool is_star = true;
    for(auto [u, _]: edges) is_star &= u == 0;

    if (is_star) {
        sort(all(costs));
        partial_sum(all(costs), costs.begin());
        reverse(all(costs));
        costs.push_back(0);
        return costs;
    }

    assert(!is_star);

    bool is_line = true;
    for (int i = 0; i < n - 1; i++) {
        is_line &= edges[i].X == i && edges[i].Y == i + 1;
    }

    if (is_line) {
        vec<int> ans(n, 0);

        int sum = 0;
        for(auto x: costs) sum += x;
        ans[0] = sum;

        vec<vec<int>> dp(n, vec<int>(2, 0));

        dp[0][0] = 0;
        dp[0][1] = 0;

        dp[1][0] = costs[0];
        dp[1][1] = 0;

        dp[2][0] = min(dp[1][0], dp[1][1]) + costs[1];
        dp[2][1] = dp[1][0];

        for (int i = 3; i < n; i++) {
            dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i - 1];
            dp[i][1] = dp[i - 1][0];
        }

        ans[1] = min(dp[n - 1][0], dp[n - 1][1]);
        return ans;
    }

    assert(!is_line);

    int sum = 0;
    for(auto x: costs) sum += x;

    
    vec<vec<pii>> adj(n);
    for (int i = 0; i < n - 1; i++) {
        adj[edges[i].X].push_back({edges[i].Y, costs[i]});
        adj[edges[i].Y].push_back({edges[i].X, costs[i]});
    }

    for(auto &x: adj) sort(all(x));

    // kind of inversing the inversing the question
    vec<int> ans(n, sum);
    for(int k = 1; k < n; k++) {
        memset(SEEN, 0, sizeof(SEEN));
        ans[k] -= dfs(0, -1, k, 0, adj);
    }

    return ans;
}

vec<int> minimum_closure_costs(
    signed N, 
    vec<signed> U, 
    vec<signed> V, 
    vec<signed> W
) {
    vec<pii> edges(N - 1);
    vec<int> costs(N - 1);

    for (int i = 0; i < N - 1; i++) {
        edges[i] = {min(U[i], V[i]), max(U[i], V[i])};
        costs[i] = W[i];
    }

    return calc(N, edges, costs);
}


#ifdef debug
signed main() {
    freopen("input.txt", "r", stdin);

    int n; cin >> n;
    vec<signed> u(n - 1), v(n - 1), w(n -1 );
    for (int i = 0; i < n - 1; i++) {
        cin >> u[i] >> v[i] >> w[i];
    }

    vec<int> ans = minimum_closure_costs(n, u, v, w);
    for (int i = 0; i < n; i++) {
        cout << ans[i] << " ";
    }
    cout << endl;

}
#endif

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