Submission #1049850

#	Time	Username	Problem	Language	Result	Execution time	Memory
1049850		avighna	Relay Marathon (NOI20_relaymarathon)	C++17	25 / 100	972 ms	228804 KiB

RelayMarathon

#include <bits/stdc++.h>

typedef long long ll;

const ll inf = 1e15;

struct Edge {
  ll u, v, w;
};

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);

  ll n, m, k;
  std::cin >> n >> m >> k;
  std::vector<std::vector<std::pair<ll, ll>>> adj(n + 1);
  std::vector<Edge> edges;
  for (ll i = 0, u, v, w; i < m; ++i) {
    std::cin >> u >> v >> w;
    adj[u].push_back({v, w});
    adj[v].push_back({u, w});
    edges.push_back({u, v, w});
  }
  std::vector<ll> A(k);
  std::vector<bool> special(n + 1);
  for (auto &i : A) {
    std::cin >> i;
    special[i] = true;
  }

  auto get_best = [&]() {
    std::priority_queue<std::pair<ll, std::pair<ll, ll>>> pq;
    std::vector<ll> d(n + 1, inf);
    for (auto &i : A) {
      pq.push({0, {i, i}});
      d[i] = 0;
    }
    std::vector<std::pair<ll, ll>> closest_special(n + 1);
    std::vector<bool> vis(n + 1);
    while (!pq.empty()) {
      ll node = pq.top().second.first, source = pq.top().second.second,
         dist = -pq.top().first;
      pq.pop();
      if (vis[node]) {
        continue;
      }
      vis[node] = true;
      closest_special[node] = {source, dist};
      for (auto &[i, i_d] : adj[node]) {
        if (dist + i_d < d[i]) {
          d[i] = dist + i_d;
          pq.push({-d[i], {i, source}});
        }
      }
    }

    std::pair<ll, std::pair<ll, ll>> ans = {inf, {0, 0}};
    for (auto &[u, v, w] : edges) {
      if (special[u] and special[v]) {
        ans = std::min(ans, {w, {u, v}});
      }
    }
    for (auto &[u, v, w] : edges) {
      if (closest_special[u].first != closest_special[v].first) {
        ans = std::min(
            ans, {closest_special[u].second + w + closest_special[v].second,
                  {closest_special[u].first, closest_special[v].first}});
      }
    }
    return ans;
  };

  auto sssp = [&](ll x) {
    std::priority_queue<std::pair<ll, ll>> pq;
    pq.push({0, x});
    std::vector<ll> ans(n + 1, inf);
    std::vector<bool> vis(n + 1);
    ans[x] = 0;
    while (!pq.empty()) {
      ll node = pq.top().second, d = -pq.top().first;
      pq.pop();
      if (vis[node]) {
        continue;
      }
      vis[node] = true;
      for (auto &[i, dist] : adj[node]) {
        if (d + dist < ans[i]) {
          ans[i] = d + dist;
          pq.push({-ans[i], i});
        }
      }
    }
    return ans;
  };

  auto best = get_best();
  auto &[u, v] = best.second;
  special[u] = special[v] = false;
  A.erase(std::remove(A.begin(), A.end(), u), A.end());
  A.erase(std::remove(A.begin(), A.end(), v), A.end());
  auto second_best = get_best();
  ll ans = best.first + second_best.first;
  auto sssp1 = sssp(u);
  std::vector<std::pair<ll, ll>> best1;
  for (ll x = 1; x <= n; ++x) {
    if (x != v and special[x]) {
      best1.push_back({sssp1[x], x});
    }
  }
  auto sssp2 = sssp(v);
  std::vector<std::pair<ll, ll>> best2;
  for (ll y = 1; y <= n; ++y) {
    if (y != u and special[y]) {
      best2.push_back({sssp1[y], y});
    }
  }
  std::sort(best1.begin(), best1.end());
  std::sort(best2.begin(), best2.end());
  if (!best1.empty() and !best2.empty()) {
    if (best1[0].second != best2[0].second) {
      ans = std::min(ans, best1[0].first + best2[0].second);
    } else {
      if (best2.size() >= 2) {
        ans = std::min(ans, best1[0].first + best2[1].second);
      }
      if (best1.size() >= 2) {
        ans = std::min(ans, best1[1].first + best2[0].second);
      }
    }
  }
  std::cout << ans << '\n';
}

• Subtask 1: 0 / 5
• Subtask 2: 0 / 12
• Subtask 3: 25 / 25
• Subtask 4: 0 / 58