#592377 (C++17) No.1316 Maximum Minimum Spanning Tree

提出ソース

結果

問題	No.1316 Maximum Minimum Spanning Tree
ユーザー	hitonanode
提出日時	2020-12-12 02:18:17
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	34 ms / 2,000 ms
コード長	6,572 bytes
コンパイル時間	7,190 ms
コンパイル使用メモリ	274,680 KB
実行使用メモリ	5,376 KB
最終ジャッジ日時	2024-09-19 22:16:25
合計ジャッジ時間	10,092 ms
ジャッジサーバーID （参考情報）	judge4 / judge1

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	2 ms 5,376 KB
testcase_02	AC	2 ms 5,376 KB
testcase_03	AC	2 ms 5,376 KB
testcase_04	AC	2 ms 5,376 KB
testcase_05	AC	2 ms 5,376 KB
testcase_06	AC	2 ms 5,376 KB
testcase_07	AC	16 ms 5,376 KB
testcase_08	AC	19 ms 5,376 KB
testcase_09	AC	29 ms 5,376 KB
testcase_10	AC	26 ms 5,376 KB
testcase_11	AC	6 ms 5,376 KB
testcase_12	AC	5 ms 5,376 KB
testcase_13	AC	5 ms 5,376 KB
testcase_14	AC	5 ms 5,376 KB
testcase_15	AC	26 ms 5,376 KB
testcase_16	AC	28 ms 5,376 KB
testcase_17	AC	26 ms 5,376 KB
testcase_18	AC	29 ms 5,376 KB
testcase_19	AC	3 ms 5,376 KB
testcase_20	AC	3 ms 5,376 KB
testcase_21	AC	3 ms 5,376 KB
testcase_22	AC	2 ms 5,376 KB
testcase_23	AC	3 ms 5,376 KB
testcase_24	AC	3 ms 5,376 KB
testcase_25	AC	3 ms 5,376 KB
testcase_26	AC	3 ms 5,376 KB
testcase_27	AC	3 ms 5,376 KB
testcase_28	AC	3 ms 5,376 KB
testcase_29	AC	3 ms 5,376 KB
testcase_30	AC	3 ms 5,376 KB
testcase_31	AC	3 ms 5,376 KB
testcase_32	AC	4 ms 5,376 KB
testcase_33	AC	3 ms 5,376 KB
testcase_34	AC	3 ms 5,376 KB
testcase_35	AC	2 ms 5,376 KB
testcase_36	AC	3 ms 5,376 KB
testcase_37	AC	3 ms 5,376 KB
testcase_38	AC	3 ms 5,376 KB
testcase_39	AC	3 ms 5,376 KB
testcase_40	AC	4 ms 5,376 KB
testcase_41	AC	3 ms 5,376 KB
testcase_42	AC	3 ms 5,376 KB
testcase_43	AC	11 ms 5,376 KB
testcase_44	AC	12 ms 5,376 KB
testcase_45	AC	22 ms 5,376 KB
testcase_46	AC	21 ms 5,376 KB
testcase_47	AC	15 ms 5,376 KB
testcase_48	AC	14 ms 5,376 KB
testcase_49	AC	14 ms 5,376 KB
testcase_50	AC	14 ms 5,376 KB
testcase_51	AC	14 ms 5,376 KB
testcase_52	AC	12 ms 5,376 KB
testcase_53	AC	25 ms 5,376 KB
testcase_54	AC	27 ms 5,376 KB
testcase_55	AC	27 ms 5,376 KB
testcase_56	AC	24 ms 5,376 KB
testcase_57	AC	25 ms 5,376 KB
testcase_58	AC	25 ms 5,376 KB
testcase_59	AC	24 ms 5,376 KB
testcase_60	AC	26 ms 5,376 KB
testcase_61	AC	24 ms 5,376 KB
testcase_62	AC	26 ms 5,376 KB
testcase_63	AC	22 ms 5,376 KB
testcase_64	AC	25 ms 5,376 KB
testcase_65	AC	28 ms 5,376 KB
testcase_66	AC	30 ms 5,376 KB
testcase_67	AC	29 ms 5,376 KB
testcase_68	AC	27 ms 5,376 KB
testcase_69	AC	28 ms 5,376 KB
testcase_70	AC	31 ms 5,376 KB
testcase_71	AC	30 ms 5,376 KB
testcase_72	AC	30 ms 5,376 KB
testcase_73	AC	32 ms 5,376 KB
testcase_74	AC	34 ms 5,376 KB
testcase_75	AC	4 ms 5,376 KB
testcase_76	AC	4 ms 5,376 KB
testcase_77	AC	4 ms 5,376 KB
testcase_78	AC	30 ms 5,376 KB
testcase_79	AC	31 ms 5,376 KB
testcase_80	AC	31 ms 5,376 KB
testcase_81	AC	17 ms 5,376 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

// Validator
#include "testlib.h"
#include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>

// MaxFlow (Dinic algorithm)
template <typename T> struct MaxFlow {
    struct edge {
        int to;
        T cap;
        int rev;
    };
    std::vector<std::vector<edge>> edges;
    std::vector<int> level; // level[i] = distance between vertex S and i (Default: -1)
    std::vector<int> iter;  // iteration counter, used for Dinic's DFS

    void bfs(int s) {
        level.assign(edges.size(), -1);
        std::queue<int> q;
        level[s] = 0;
        q.push(s);
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (edge &e : edges[v]) {
                if (e.cap > 0 and level[e.to] < 0) {
                    level[e.to] = level[v] + 1;
                    q.push(e.to);
                }
            }
        }
    }

    T dfs_dinic(int v, int goal, T f) {
        if (v == goal) return f;
        for (int &i = iter[v]; i < (int)edges[v].size(); i++) {
            edge &e = edges[v][i];
            if (e.cap > 0 and level[v] < level[e.to]) {
                T d = dfs_dinic(e.to, goal, std::min(f, e.cap));
                if (d > 0) {
                    e.cap -= d;
                    edges[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    MaxFlow(int N) { edges.resize(N); }
    void add_edge(int from, int to, T capacity) {
        edges[from].push_back(edge{to, capacity, (int)edges[to].size()});
        edges[to].push_back(edge{from, (T)0, (int)edges[from].size() - 1});
    }
    // Dinic algorithm
    // Complexity: O(V^2 E)
    T Dinic(int s, int t, T req) {
        T flow = 0;
        while (req > 0) {
            bfs(s);
            if (level[t] < 0) break;
            iter.assign(edges.size(), 0);
            T f;
            while ((f = dfs_dinic(s, t, req)) > 0) flow += f, req -= f;
        }
        return flow;
    }
};

// LinearProgrammingOnBasePolyhedron : Maximize/minimize linear function on base polyhedron, using Edmonds' algorithm
//
// maximize/minimize cx s.t. (x on some base polyhedron)
// Reference: <https://www.amazon.co.jp/dp/B01N6G0579>, Sec. 2.4, Algorithm 2.2-2.3
//            "Submodular Functions, Matroids, and Certain Polyhedra" [Edmonds+, 1970]
template <typename Tvalue> struct LinearProgrammingOnBasePolyhedron {
    using Tfunc = std::function<Tvalue(int, const std::vector<Tvalue> &)>;
    static Tvalue EPS;
    int N;
    std::vector<Tvalue> c;
    Tfunc maximize_xi;
    Tvalue xsum;
    bool minimize;

    Tvalue fun;
    std::vector<Tvalue> x;
    bool infeasible;

    void _init(const std::vector<Tvalue> &c_, Tfunc q_, Tvalue xsum_, Tvalue xlowerlimit, bool minimize_) {
        N = c_.size();
        c = c_;
        maximize_xi = q_;
        xsum = xsum_;
        minimize = minimize_;
        fun = 0;
        x.assign(N, xlowerlimit);
        infeasible = false;
    }

    void _solve() {
        std::vector<std::pair<Tvalue, int>> c2i(N);
        for (int i = 0; i < N; i++) c2i[i] = std::make_pair(c[i], i);

        std::sort(c2i.begin(), c2i.end());
        if (!minimize) std::reverse(c2i.begin(), c2i.end());
        for (const auto &p : c2i) {
            const int i = p.second;
            x[i] = maximize_xi(i, x);
        }
        Tvalue error = std::accumulate(x.begin(), x.end(), Tvalue(0)) - xsum;
        if (error > EPS or -error > EPS) {
            infeasible = true;
        } else {
            for (int i = 0; i < N; i++) fun += x[i] * c[i];
        }
    }

    LinearProgrammingOnBasePolyhedron(const std::vector<Tvalue> &c_, Tfunc q_, Tvalue xsum_, Tvalue xlowerlimit, bool minimize_) {
        _init(c_, q_, xsum_, xlowerlimit, minimize_);
        _solve();
    }
};
template <> long long LinearProgrammingOnBasePolyhedron<long long>::EPS = 0;
template <> long double LinearProgrammingOnBasePolyhedron<long double>::EPS = 1e-10;


// UnionFind Tree (0-indexed), based on size of each disjoint set
struct UnionFind {
    std::vector<int> par, cou;
    UnionFind(int N = 0) : par(N), cou(N, 1) { iota(par.begin(), par.end(), 0); }
    int find(int x) { return (par[x] == x) ? x : (par[x] = find(par[x])); }
    bool unite(int x, int y) {
        x = find(x), y = find(y);
        if (x == y) return false;
        if (cou[x] < cou[y]) std::swap(x, y);
        par[y] = x, cou[x] += cou[y];
        return true;
    }
    int count(int x) { return cou[find(x)]; }
};

using std::cin, std::cout, std::vector;

int main(int argc, char **argv) {
    registerValidation(argc, argv);
    int N = inf.readInt(2, 50);  // N <= 50
    inf.readSpace();
    int M = inf.readInt(N - 1, 200);  // M <= 200
    inf.readSpace();
    long long K = inf.readInt(1, 100000000);
    inf.readEoln();
    vector<int> A(M), B(M);
    vector<long long> C(M), D(M);
    std::set<std::pair<int, int>> edges;

    UnionFind uf(N);

    for (int i = 0; i < M; i++) {
        A[i] = inf.readInt(1, N);
        inf.readSpace();
        B[i] = inf.readInt(1, N);
        inf.readSpace();
        C[i] = inf.readInt(1, 100000000);
        inf.readSpace();
        D[i] = inf.readInt(1, 100000000);
        inf.readEoln();
        A[i]--, B[i]--;
        assert(A[i] != B[i]);  // Graph has NO self-loop.
        if (A[i] > B[i]) std::swap(A[i], B[i]);
        assert(edges.count(std::make_pair(A[i], B[i])) == 0);  // Graph has NO multi-edge.
        edges.emplace(A[i], B[i]);
        uf.unite(A[i], B[i]);
    }
    inf.readEof();

    assert(uf.count(0) == N);  // Graph must be connected.

    auto maximize_xi = [&](int ie, const vector<long long> &xnow) -> long long {
        MaxFlow<long long> mf(N + 2);
        mf.add_edge(N, A[ie], 1LL << 60);
        mf.add_edge(N, B[ie], 1LL << 60);
        for (int je = 0; je < M; je++) {
            mf.add_edge(A[je], B[je], xnow[je]);
            mf.add_edge(B[je], A[je], xnow[je]);
            mf.add_edge(N, A[je], xnow[je]);
            mf.add_edge(N, B[je], xnow[je]);
        }
        for (int iv = 0; iv < N; iv++) mf.add_edge(iv, N + 1, 2 * K);
        long long ret = mf.Dinic(N, N + 1, 1LL << 62) / 2 - K - std::accumulate(xnow.begin(), xnow.end(), 0LL);
        return std::min(ret, D[ie]);
    };

    LinearProgrammingOnBasePolyhedron<long long> solver(C, maximize_xi, K * (N - 1), 0, true);
    if (solver.infeasible) {
        cout << "-1\n";
    } else {
        cout << solver.fun << '\n';
    }
}

yukicoder

結果

テストケース

ソースコード