제출 #1117150

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
1117150		ortsac	도로 폐쇄 (APIO21_roads)	C++17	7 / 100	2098 ms	41864 KiB

roads

#include "roads.h"
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define pii pair<long long, long long>
#define fr first
#define se second

struct State {
  int cimaL, node, re;
  State(int a = 0, int b = 0, int c = 0) : cimaL(a), node(b), re(c) {}

  bool operator < (const State& a) const {
    return (make_pair(node, make_pair(cimaL, re)) < make_pair(a.node, make_pair(a.cimaL, a.re)));
  }
};

const int MAXN = 1e5 + 10;
const int INF = 0x3f3f3f3f3f3f3f3f;
vector<pii> adj[MAXN];
array<vector<int>, 2> dp[MAXN];
int deg[MAXN];
vector<int> ans;

void calc(int node, int dad) {
  int pdad = INF;
  for (auto [u, w] : adj[node]) {
    if (u != dad) calc(u, node);
    else pdad = w;
  }
  for (int k = 0; k <= deg[node]; k++) {
    // calc dp[0][node] -> edge {node, dad} isn't removed
    if ((k > 0) || (node == 0)) {
      int r = (((int) adj[node].size()) - k);
      vector<int> mini;
      int sum0 = 0;
      for (auto [u, w] : adj[node]) {
        if (u == dad) continue;
        if (deg[u] <= k) {
          if (dp[u][0][deg[u]] < dp[u][1][deg[u]]) {
            sum0 += dp[u][0][deg[u]];
            mini.push_back(dp[u][1][deg[u]] - dp[u][0][deg[u]]);
          } else {
            sum0 += dp[u][1][deg[u]];
            r--;
          }
        } else {
          if (dp[u][0][k] < dp[u][1][k]) {
            sum0 += dp[u][0][k];
            mini.push_back(dp[u][1][k] - dp[u][0][k]);
          } else {
            sum0 += dp[u][1][k];
            r--;
          }
        }
      }
      sort(mini.begin(), mini.end());
      int i = 0;
      while (r > 0) {
        sum0 += mini[i];
        r--;
        i++;
      }
      dp[node][0][k] = sum0;
    } else {
      dp[node][0][k] = INF; 
    }
    // calc dp[1][node] -> edge {node, dad} is removed
    if (node != 0) {
      int r = (((int) adj[node].size()) - k - 1);
      vector<int> mini;
      int sum0 = pdad;
      for (auto [u, w] : adj[node]) {
        if (u == dad) continue;
        if (deg[u] <= k) {
          if (dp[u][0][deg[u]] < dp[u][1][deg[u]]) {
            sum0 += dp[u][0][deg[u]];
            mini.push_back(dp[u][1][deg[u]] - dp[u][0][deg[u]]);
          } else {
            sum0 += dp[u][1][deg[u]];
            r--;
          }
        } else {
          if (dp[u][0][k] < dp[u][1][k]) {
            sum0 += dp[u][0][k];
            mini.push_back(dp[u][1][k] - dp[u][0][k]);
          } else {
            sum0 += dp[u][1][k];
            r--;
          }
        }
      }
      sort(mini.begin(), mini.end());
      int i = 0;
      while (r > 0) {
        sum0 += mini[i];
        r--;
        i++;
      }
      dp[node][1][k] = sum0;
    } else dp[node][1][k] = INF;
  }
}

void dfs(int node, int dad, int mx) {
  if (deg[node] <= mx) {
    for (auto [u, w] : adj[node]) {
      if (u != dad) dfs(u, node, mx); 
    }
    return;
  }
  for (int i = mx + 1; i <= deg[node]; i++) {
    ans[i] += min(dp[node][0][i], dp[node][1][i]);
  }
  mx = deg[node];
  for (auto [u, w] : adj[node]) {
    if (u != dad) dfs(u, node, mx); 
  }
}

vector<int> minimum_closure_costs(int32_t n, vector<int32_t> a, vector<int32_t> b, vector<int32_t> w) {
  for (int i = 0; i < (n - 1); i++) {
    adj[a[i]].push_back({b[i], w[i]});
    adj[b[i]].push_back({a[i], w[i]});
    deg[a[i]]++;
    deg[b[i]]++;
  }
  for (int i = 0; i < n; i++) {
    dp[i][0].resize(deg[i] + 1);
    dp[i][1].resize(deg[i] + 1);
  }
  calc(0, -1);
  ans.resize(n);
  dfs(0, -1, -1);
  return ans;
}

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