oj.uz

Submission #1049577

# Submission time Handle Problem Language Result Execution time Memory
1049577 2024-08-08T23:56:09 Z avighna Relay Marathon (NOI20_relaymarathon) C++17
25 / 100
 832 ms 211460 KB 
#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;
  ll f = inf, s = inf;
  auto sssp1 = sssp(u);
  for (ll x = 1; x <= n; ++x) {
    if (x != v and special[x]) {
      f = std::min(f, sssp1[x]);
    }
  }
  auto sssp2 = sssp(v);
  for (ll y = 1; y <= n; ++y) {
    if (y != u and special[y]) {
      s = std::min(s, sssp2[y]);
    }
  }
  if (f != inf and s != inf) {
    ans = std::min(ans, best.first + f + s);
  }
  std::cout << ans << '\n';
}

Subtask #1
0 / 5.0

# Verdict Execution time Memory Grader output
1 Incorrect 1 ms 348 KB Output isn't correct
2 Halted 0 ms 0 KB -

Subtask #2
0 / 12.0

# Verdict Execution time Memory Grader output
1 Incorrect 1 ms 348 KB Output isn't correct
2 Halted 0 ms 0 KB -

Subtask #3
25.0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 31 ms 11504 KB Output is correct
2 Correct 5 ms 5724 KB Output is correct
3 Correct 757 ms 211460 KB Output is correct
4 Correct 349 ms 87788 KB Output is correct
5 Correct 86 ms 22520 KB Output is correct
6 Correct 68 ms 17664 KB Output is correct
7 Correct 97 ms 22660 KB Output is correct
8 Correct 37 ms 11624 KB Output is correct
9 Correct 62 ms 15620 KB Output is correct
10 Correct 48 ms 12860 KB Output is correct
11 Correct 802 ms 211168 KB Output is correct
12 Correct 49 ms 13320 KB Output is correct
13 Correct 244 ms 55012 KB Output is correct
14 Correct 94 ms 22780 KB Output is correct
15 Correct 777 ms 210908 KB Output is correct
16 Correct 25 ms 9996 KB Output is correct
17 Correct 529 ms 138732 KB Output is correct
18 Correct 4 ms 5780 KB Output is correct
19 Correct 832 ms 211368 KB Output is correct
20 Correct 90 ms 22016 KB Output is correct
21 Correct 80 ms 20888 KB Output is correct
22 Correct 42 ms 12984 KB Output is correct
23 Correct 13 ms 8460 KB Output is correct
24 Correct 537 ms 146900 KB Output is correct
25 Correct 70 ms 15872 KB Output is correct
26 Correct 39 ms 12196 KB Output is correct
27 Correct 51 ms 14092 KB Output is correct
28 Correct 8 ms 7148 KB Output is correct
29 Correct 99 ms 22472 KB Output is correct
30 Correct 186 ms 43636 KB Output is correct

Subtask #4
0 / 58.0

# Verdict Execution time Memory Grader output
1 Incorrect 1 ms 348 KB Output isn't correct
2 Halted 0 ms 0 KB -