結果

問題 No.1320 Two Type Min Cost Cycle
ユーザー K UK U
提出日時 2024-05-17 21:59:07
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
TLE  
実行時間 -
コード長 6,394 bytes
コンパイル時間 3,110 ms
コンパイル使用メモリ 265,000 KB
実行使用メモリ 41,376 KB
最終ジャッジ日時 2024-05-17 21:59:15
合計ジャッジ時間 6,870 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
13,764 KB
testcase_01 AC 2 ms
6,944 KB
testcase_02 AC 2 ms
6,940 KB
testcase_03 AC 2 ms
6,940 KB
testcase_04 AC 1 ms
6,940 KB
testcase_05 AC 103 ms
6,940 KB
testcase_06 AC 7 ms
6,940 KB
testcase_07 AC 88 ms
30,720 KB
testcase_08 TLE -
testcase_09 -- -
testcase_10 -- -
testcase_11 -- -
testcase_12 -- -
testcase_13 -- -
testcase_14 -- -
testcase_15 -- -
testcase_16 -- -
testcase_17 -- -
testcase_18 -- -
testcase_19 -- -
testcase_20 -- -
testcase_21 -- -
testcase_22 -- -
testcase_23 -- -
testcase_24 -- -
testcase_25 -- -
testcase_26 -- -
testcase_27 -- -
testcase_28 -- -
testcase_29 -- -
testcase_30 -- -
testcase_31 -- -
testcase_32 -- -
testcase_33 -- -
testcase_34 -- -
testcase_35 -- -
testcase_36 -- -
testcase_37 -- -
testcase_38 -- -
testcase_39 -- -
testcase_40 -- -
testcase_41 -- -
testcase_42 -- -
testcase_43 -- -
testcase_44 -- -
testcase_45 -- -
testcase_46 -- -
testcase_47 -- -
testcase_48 -- -
testcase_49 -- -
testcase_50 -- -
testcase_51 -- -
testcase_52 -- -
testcase_53 -- -
testcase_54 -- -
testcase_55 -- -
testcase_56 -- -
testcase_57 -- -
testcase_58 -- -
testcase_59 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
// #include <atcoder/all>
// using namespace atcoder;
#ifdef LOCAL
#include <debug.h>
#define dbg(...) debug::dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...) void(0)
#endif
using namespace std;

// #define int ll

#define rep(i, a, b) for(auto i=static_cast<signed>(a), i##_end__=static_cast<signed>(b); i < i##_end__; i++)
#define rep_r(i, a, b) for(auto i=static_cast<signed>(a), i##_end__=static_cast<signed>(b); i >= i##_end__; i--)
#define fore(i, a) for(auto& i: a)
#define forei(i, it, a) for(auto [i, it] = std::pair{0, std::begin(a)}; it != std::end(a); i++, it++)
#define all(x) std::begin(x), std::end(x)

using ll = long long; // __int128;
using ull = unsigned long long;
template<class T> using priority_queue_asc = priority_queue<T, vector<T>, greater<T>>;

template<class T> ostream& operator<<(ostream& os, const vector<T>& v){ rep(i, 0, v.size()){ os << (i == 0 ? "" : " ") << v[i]; } return os; }
template<class T, class S> istream& operator>>(istream& is, pair<T, S>& p) { is >> p.first >> p.second; return is; }
template<class T> istream& operator>>(istream& is, vector<T>& v) { fore(e, v){ is >> e; } return is; }

template<class C> int siz(const C& c) { return static_cast<int>(c.size()); }
template<class T, size_t N> constexpr int siz(const T (&)[N]) { return static_cast<int>(N); }
template<class A, class V> constexpr void fil(A& a, const V &v){ if constexpr(is_array_v<A>) for(auto& s: a) fil(s, v); else a = v; };
template<class V> constexpr auto vct(size_t n, const V& v){ return vector(n, v); } template <class... A> constexpr auto vct(size_t n, A... a){ return vector(n, vct(a...)); }
template<class T, class S> constexpr bool chmax(T& a, S b) { if (a < b) { a = b; return 1; } return 0; }
template<class T, class S> constexpr bool chmin(T& a, S b) { if (a > b) { a = b; return 1; } return 0; }
template<class T> constexpr T pow2(T x){ return x * x; }
template<class T, class S> constexpr T divceil(T x, S div) { return (x % div == 0) ? x / div : (x >= 0) ? (x / div) + 1 : -((-x) / div); }
template<class T, class S> constexpr T divfloor(T x, S div){ return (x % div == 0) ? x / div : (x >= 0) ? (x / div) : -((-x) / div) - 1; }
template<class T, class S> inline void outif(bool c, T t, S f){ if(c) cout << t << endl; else cout << f << endl; }
inline void yesno(bool x){ cout << (x ? "Yes" : "No") << endl; }
constexpr long long INF = 1LL << 60; // 1.15e18
constexpr int MOD = (int)1e9 + 7;

// 最短路木 - 密グラフバージョン O(N^2)
// 戻り値: d[v]=最短距離(重み), p[v]=親頂点(rootの場合、-1), l[v]=通る経路の色分け。最初の頂点(root直下の頂点番号) 
template<class T> tuple<vector<T>, vector<int>, vector<int>> shortest_path_tree(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);
    vector<T> d(n, inf);
    vector<int> p(n, -1), l(n, -1);
    vector<bool> done(n);
    d[root] = 0;
    while(true){
        int v = -1;
        T mn = inf;
        rep(i, 0, n) if(!done[i] && d[i] < mn) v = i, mn = d[i];
        if(v == -1) break;
        done[v] = true;
        rep(i, 0, n){
            auto w = g[v][i];
            if(done[i] || i == v || w >= inf) continue;
            if(d[i] <= mn + w) continue;
            d[i] = mn + w;
            p[i] = v;
            l[i] = v == root ? i : l[v];
        }
    }
    return {d, p, l};
}

// 無向グラフ 最小サイクル - 密グラフバージョン O(N^2)
template<class T> pair<T, vector<int>> shortest_cycle_undirected(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);

    auto [d, p, l] = shortest_path_tree(g, root, inf);

    T mn = inf;
    int mu = -1, mv = -1;
    rep(u, 0, n) rep(v, u + 1, n){
        auto w = g[u][v];
        if(u == p[v] || v == p[u] || l[u] == l[v] || d[u] >= inf || d[v] >= inf || w >= inf) continue;
        if(chmin(mn, d[u] + d[v] + w)) mu = u, mv = v;
    }
    if(mn == inf) return {inf, {}};

    vector<int> path;
    int v = mu;
    while(v != root) path.push_back(v), v = p[v];
    path.push_back(root);
    reverse(all(path));
    v = mv;
    while(v != root) path.push_back(v), v = p[v];

    // ---- test ----
    // {
    //     ll len = 0;
    //     rep(i, 0, siz(path)) len += g[path[i]][path[(i + 1) % siz(path)]];
    //     assert(len == mn && path[0] == root);
    // }

    return {mn, path};
}
template<class T> pair<T, vector<int>> shortest_cycle_undirected_all(const vector<vector<T>>& g, T inf = numeric_limits<T>::max()){
    T mn = inf;
    vector<int> path;
    rep(i, 0, siz(g)){
        auto [m, p] = shortest_cycle_undirected(g, i, inf);
        if(mn > m) mn = m, path = p;
    }
    return {mn, path};
}

// 有向グラフ 最小サイクル - 密グラフバージョン O(N^2)
template<class T> pair<T, vector<int>> shortest_cycle_directed(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);

    auto [d, p, l] = shortest_path_tree(g, root, inf);

    T mn = inf;
    int v = -1;
    rep(i, 0, n){
        auto w = g[i][root];
        if(i == root || d[i] >= inf || w >= inf) continue;
        if(chmin(mn, d[i] + w)) v = i;
    }
    if(mn == inf) return {inf, {}};

    vector<int> path;
    while(v != root) path.push_back(v), v = p[v];
    path.push_back(root);
    reverse(all(path));

    return {mn, path};
}
template<class T> pair<T, vector<int>> shortest_cycle_directed_all(const vector<vector<T>>& g, T inf = numeric_limits<T>::max()){
    T mn = inf;
    vector<int> path;
    rep(i, 0, siz(g)){
        auto [m, p] = shortest_cycle_directed(g, i, inf);
        if(mn > m) mn = m, path = p;
    }
    return {mn, path};
}

void _main() {
    int T, N, M;
    cin >> T >> N >> M;
    constexpr auto inf = numeric_limits<ll>::max();
    vector g(N, vector(N, inf));
    rep(i, 0, M){
        int u, v, w;
        cin >> u >> v >> w;
        u--; v--;
        g[u][v] = w;
        if(T == 0) g[v][u] = w;
    }

    if(T == 0){
        auto [mn, path] = shortest_cycle_undirected_all(g, inf);
        outif(mn < inf, mn, -1);
    }
    else{
        auto [mn, path] = shortest_cycle_directed_all(g, inf);
        outif(mn < inf, mn, -1);
    }
}

signed main() { 
    cin.tie(nullptr); ios::sync_with_stdio(false);
    cout << fixed << setprecision(15); cerr << fixed << setprecision(15);
    _main();
}
0