Submission #1275357

#	Time	Username	Problem	Language	Result	Execution time	Memory
1275357		MisterReaper	Olympic Bus (JOI20_ho_t4)	C++20	0 / 100	14 ms	2852 KiB

ho_t4

// File olympicbus.cpp created on 02.10.2025 at 09:58:45
#include <bits/stdc++.h>

using i64 = long long;

#ifdef DEBUG 
    #include "/home/ahmetalp/Desktop/Workplace/debug.h"
#else
    #define debug(...) void(23)
#endif

constexpr i64 inf = i64(1E15);

template<typename T>
bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

void dijkstra(int N, std::vector<std::array<int, 4>>& E, std::vector<std::vector<int>>& adj, std::vector<i64>& dis, std::vector<int>& used, int s, int t) {
    std::vector<int> chosen(N), par(N, -1);
    dis[s] = 0;
    while (true) {
        int p = -1;
        for (int i = 0; i < N; ++i) {
            if (!chosen[i] && (p == -1 || dis[i] < dis[p])) {
                p = i;
            }
        }
        if (p == -1) {
            break;
        }
        chosen[p] = true;
        for (auto e : adj[p]) {
            int u = E[e][0] ^ E[e][1] ^ p;
            if (chmin(dis[u], dis[p] + E[e][2])) {
                par[u] = e;
            }
        }
    }

    debug("ok");

    if (dis[t] != inf) {
        int u = t;
        while (u != s) {
            int e = par[u];
            int v = E[e][0] ^ E[e][1] ^ u;
            used[e] = true;
            u = v;
        }
    }

    return;
}

i64 dijkstra2(int N, std::vector<std::array<int, 4>>& E, std::vector<std::vector<int>>& adj, int id, int s, int t) {
    std::vector<i64> dis(N, inf);
    std::vector<int> chosen(N);
    dis[s] = 0;
    while (true) {
        int p = -1;
        for (int i = 0; i < N; ++i) {
            if (!chosen[i] && (p == -1 || dis[i] < dis[p])) {
                p = i;
            }
        }
        if (p == -1) {
            break;
        }
        chosen[p] = true;
        if (E[id][1] == p) {
            int u = E[id][0];
            chmin(dis[u], dis[p] + E[id][2]);
        }
        for (auto e : adj[p]) {
            if (e == id) {
                continue;
            }
            int u = E[e][0] ^ E[e][1] ^ p;
            chmin(dis[u], dis[p] + E[e][2]);
        }
    }
    return dis[t];
}

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

    int N, M;
    std::cin >> N >> M;

    std::vector<std::array<int, 4>> E(M);
    std::vector<std::vector<int>> adj(N), rdj(N);
    for (int i = 0; i < M; ++i) {
        int A, B, C, D;
        std::cin >> A >> B >> C >> D;
        --A, --B;
        E[i] = {A, B, C, D};
        adj[A].emplace_back(i);
        rdj[B].emplace_back(i);
    }

    std::vector<std::vector<i64>> dfr(2, std::vector<i64>(N, inf));
    std::vector<std::vector<i64>> dbk(2, std::vector<i64>(N, inf));
    std::vector<std::vector<int>> ufr(2, std::vector<int>(M));
    std::vector<std::vector<int>> ubk(2, std::vector<int>(M));

    dijkstra(N, E, adj, dfr[0], ufr[0], 0, N - 1);
    dijkstra(N, E, adj, dfr[1], ufr[1], N - 1, 0);
    dijkstra(N, E, rdj, dbk[0], ubk[0], N - 1, 0);
    dijkstra(N, E, rdj, dbk[1], ubk[1], 0, N - 1);

    debug(dfr[0]);
    debug(dbk[0]);

    i64 ans = dfr[0][N - 1] + dbk[0][0];
    debug(ans);
    for (int i = 0; i < M; ++i) {
        i64 tmp = E[i][3];
        if (ufr[0][i]) {
            i64 x = dijkstra2(N, E, adj, i, 0, N - 1);
            tmp += x;
        } else {
            i64 x = std::min(dfr[0][N - 1], dfr[0][E[i][1]] + dbk[0][E[i][0]] + E[i][2]);
            tmp += x;
        }
        if (ufr[1][i]) {
            i64 x = dijkstra2(N, E, adj, i, N - 1, 0);
            tmp += x;
        } else {
            i64 x = std::min(dfr[1][0], dfr[1][E[i][1]] + dbk[1][E[i][0]] + E[i][2]);
            tmp += x;
        }
        debug(i, tmp);
        chmin(ans, tmp);
    }

    if (ans >= inf) {
        ans = -1;
    }
    std::cout << ans << '\n';

    return 0;
}

• Subtask 1: 0 / 5
• Subtask 2: 0 / 11
• Subtask 3: 0 / 21
• Subtask 4: 0 / 63