結果

問題 No.1678 Coin Trade (Multiple)
ユーザー hitonanodehitonanode
提出日時 2021-09-10 22:37:04
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 461 ms / 5,000 ms
コード長 9,775 bytes
コンパイル時間 2,785 ms
コンパイル使用メモリ 196,200 KB
実行使用メモリ 15,368 KB
最終ジャッジ日時 2024-06-12 01:40:21
合計ジャッジ時間 10,166 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,376 KB
testcase_02 AC 1 ms
5,376 KB
testcase_03 AC 49 ms
10,516 KB
testcase_04 AC 229 ms
13,040 KB
testcase_05 AC 103 ms
14,716 KB
testcase_06 AC 80 ms
14,024 KB
testcase_07 AC 228 ms
11,016 KB
testcase_08 AC 143 ms
11,700 KB
testcase_09 AC 104 ms
14,740 KB
testcase_10 AC 63 ms
7,532 KB
testcase_11 AC 166 ms
12,556 KB
testcase_12 AC 54 ms
7,356 KB
testcase_13 AC 345 ms
14,304 KB
testcase_14 AC 134 ms
10,328 KB
testcase_15 AC 127 ms
12,608 KB
testcase_16 AC 40 ms
12,604 KB
testcase_17 AC 111 ms
15,052 KB
testcase_18 AC 2 ms
5,376 KB
testcase_19 AC 2 ms
5,376 KB
testcase_20 AC 2 ms
5,376 KB
testcase_21 AC 2 ms
5,376 KB
testcase_22 AC 2 ms
5,376 KB
testcase_23 AC 2 ms
5,376 KB
testcase_24 AC 2 ms
5,376 KB
testcase_25 AC 2 ms
5,376 KB
testcase_26 AC 2 ms
5,376 KB
testcase_27 AC 2 ms
5,376 KB
testcase_28 AC 2 ms
5,376 KB
testcase_29 AC 1 ms
5,376 KB
testcase_30 AC 2 ms
5,376 KB
testcase_31 AC 2 ms
5,376 KB
testcase_32 AC 2 ms
5,376 KB
testcase_33 AC 1 ms
5,376 KB
testcase_34 AC 1 ms
5,376 KB
testcase_35 AC 2 ms
5,376 KB
testcase_36 AC 2 ms
5,376 KB
testcase_37 AC 2 ms
5,376 KB
testcase_38 AC 2 ms
5,376 KB
testcase_39 AC 2 ms
5,376 KB
testcase_40 AC 1 ms
5,376 KB
testcase_41 AC 2 ms
5,376 KB
testcase_42 AC 2 ms
5,376 KB
testcase_43 AC 1 ms
5,376 KB
testcase_44 AC 1 ms
5,376 KB
testcase_45 AC 2 ms
5,376 KB
testcase_46 AC 2 ms
5,376 KB
testcase_47 AC 2 ms
5,376 KB
testcase_48 AC 413 ms
15,152 KB
testcase_49 AC 418 ms
15,368 KB
testcase_50 AC 418 ms
15,160 KB
testcase_51 AC 418 ms
15,200 KB
testcase_52 AC 455 ms
15,120 KB
testcase_53 AC 439 ms
15,284 KB
testcase_54 AC 461 ms
15,320 KB
testcase_55 AC 438 ms
15,232 KB
testcase_56 AC 449 ms
15,272 KB
testcase_57 AC 447 ms
15,172 KB
testcase_58 AC 170 ms
13,440 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using lint = long long;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define REP(i, n) FOR(i,0,n)

#include <array>
#include <cstddef>
#include <limits>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

// Radix heap for unsigned integer
// https://github.com/iwiwi/radix-heap
template <class Uint, class Label, typename std::enable_if<std::is_unsigned<Uint>::value>::type * = nullptr>
class radix_heap {
    int sz;
    Uint last;
    std::array<std::vector<std::pair<Uint, Label>>, std::numeric_limits<Uint>::digits + 1> v;

    template <class U, typename std::enable_if<sizeof(U) == 4>::type * = nullptr>
    static inline int bucket(U x) noexcept {
        return x ? 32 - __builtin_clz(x) : 0;
    }
    template <class U, typename std::enable_if<sizeof(U) == 8>::type * = nullptr>
    static inline int bucket(U x) noexcept {
        return x ? 64 - __builtin_clzll(x) : 0;
    }

    void pull() {
        if (!v[0].empty()) return;
        int i = 1;
        while (v[i].empty()) ++i;
        last = v[i].back().first;
        for (int j = 0; j < int(v[i].size()); j++) last = std::min(last, v[i][j].first);
        for (int j = 0; j < int(v[i].size()); j++) {
            v[bucket(v[i][j].first ^ last)].emplace_back(std::move(v[i][j]));
        }
        v[i].clear();
    }

public:
    radix_heap() : sz(0), last(0) { static_assert(std::numeric_limits<Uint>::digits > 0, "Invalid type."); }
    std::size_t size() const noexcept { return sz; }
    bool empty() const noexcept { return sz == 0; }
    void push(Uint x, const Label &val) { ++sz, v[bucket(x ^ last)].emplace_back(x, val); }
    void push(Uint x, Label &&val) { ++sz, v[bucket(x ^ last)].emplace_back(x, std::move(val)); }
    template <class... Args> void emplace(Uint x, Args &&...args) {
        ++sz, v[bucket(x ^ last)].emplace_back(std::piecewise_construct, std::forward_as_tuple(x), std::forward_as_tuple(args...));
    }
    void pop() { pull(), --sz, v[0].pop_back(); }
    std::pair<Uint, Label> top() { return pull(), v[0].back(); }
    Uint top_key() { return pull(), last; }
    Label &top_label() { return pull(), v[0].back().second; }
    void clear() noexcept {
        sz = 0, last = 0;
        for (auto &vec : v) vec.clear();
    }
    void swap(radix_heap<Uint, Label> &a) { std::swap(sz, a.sz), std::swap(last, a.last), v.swap(a.v); }
};


// Minimum cost flow WITH NO NEGATIVE CYCLE (just negative cost edge is allowed)
// Verified:
// - SRM 770 Div1 Medium https://community.topcoder.com/stat?c=problem_statement&pm=15702
// - CodeChef LTIME98 Ancient Magic https://www.codechef.com/problems/ANCT
template <class Cap = long long, class Cost = long long, Cost INF_COST = std::numeric_limits<Cost>::max() / 2>
struct MinCostFlow {
    struct _edge {
        int to, rev;
        Cap cap;
        Cost cost;
        template <class Ostream> friend Ostream &operator<<(Ostream &os, const _edge &e) {
            return os << '(' << e.to << ',' << e.rev << ',' << e.cap << ',' << e.cost << ')';
        }
    };
    bool _is_dual_infeasible;
    int V;
    std::vector<std::vector<_edge>> g;
    std::vector<Cost> dist;
    std::vector<int> prevv, preve;
    std::vector<Cost> dual; // dual[V]: potential
    std::vector<std::pair<int, int>> pos;

    bool _initialize_dual_dag() {
        std::vector<int> deg_in(V);
        for (int i = 0; i < V; i++) {
            for (const auto &e : g[i]) deg_in[e.to] += (e.cap > 0);
        }
        std::vector<int> st;
        st.reserve(V);
        for (int i = 0; i < V; i++) {
            if (!deg_in[i]) st.push_back(i);
        }
        for (int n = 0; n < V; n++) {
            if (int(st.size()) == n) return false; // Not DAG
            int now = st[n];
            for (const auto &e : g[now]) {
                if (!e.cap) continue;
                deg_in[e.to]--;
                if (deg_in[e.to] == 0) st.push_back(e.to);
                if (dual[e.to] >= dual[now] + e.cost) dual[e.to] = dual[now] + e.cost;
            }
        }
        return true;
    }

    bool _initialize_dual_spfa() { // Find feasible dual's when negative cost edges exist
        dual.assign(V, 0);
        std::queue<int> q;
        std::vector<int> in_queue(V);
        std::vector<int> nvis(V);
        for (int i = 0; i < V; i++) q.push(i), in_queue[i] = true;
        while (q.size()) {
            int now = q.front();
            q.pop(), in_queue[now] = false;
            if (nvis[now] > V) return false; // Negative cycle exists
            nvis[now]++;
            for (const auto &e : g[now]) {
                if (!e.cap) continue;
                if (dual[e.to] > dual[now] + e.cost) {
                    dual[e.to] = dual[now] + e.cost;
                    if (!in_queue[e.to]) in_queue[e.to] = true, q.push(e.to);
                }
            }
        }
        return true;
    }

    bool initialize_dual() {
        return !_is_dual_infeasible or _initialize_dual_dag() or _initialize_dual_spfa();
    }

    template <class heap> void _dijkstra(int s) { // O(ElogV)
        prevv.assign(V, -1);
        preve.assign(V, -1);
        dist.assign(V, INF_COST);
        dist[s] = 0;
        heap q;
        q.emplace(0, s);
        while (!q.empty()) {
            auto p = q.top();
            q.pop();
            int v = p.second;
            if (dist[v] < Cost(p.first)) continue;
            for (int i = 0; i < (int)g[v].size(); i++) {
                _edge &e = g[v][i];
                auto c = dist[v] + e.cost + dual[v] - dual[e.to];
                if (e.cap > 0 and dist[e.to] > c) {
                    dist[e.to] = c, prevv[e.to] = v, preve[e.to] = i;
                    q.emplace(dist[e.to], e.to);
                }
            }
        }
    }

    MinCostFlow(int V = 0) : _is_dual_infeasible(false), V(V), g(V), dual(V, 0) {
        static_assert(INF_COST > 0, "INF_COST must be positive");
    }

    int add_edge(int from, int to, Cap cap, Cost cost) {
        assert(0 <= from and from < V);
        assert(0 <= to and to < V);
        assert(cap >= 0);
        if (cost < 0) _is_dual_infeasible = true;
        pos.emplace_back(from, g[from].size());
        g[from].push_back({to, (int)g[to].size() + (from == to), cap, cost});
        g[to].push_back({from, (int)g[from].size() - 1, (Cap)0, -cost});
        return int(pos.size()) - 1;
    }

    // Flush flow f from s to t. Graph must not have negative cycle.
    using Pque = std::priority_queue<std::pair<Cost, int>, std::vector<std::pair<Cost, int>>, std::greater<std::pair<Cost, int>>>;
    template <class heap = Pque> std::pair<Cap, Cost> flow(int s, int t, const Cap &flow_limit) {
        // You can also use radix_heap<typename std::make_unsigned<Cost>::type, int> as prique
        if (!initialize_dual()) throw; // Fail to find feasible dual
        Cost cost = 0;
        Cap flow_rem = flow_limit;
        while (flow_rem > 0) {
            _dijkstra<heap>(s);
            if (dist[t] == INF_COST) break;
            for (int v = 0; v < V; v++) dual[v] = std::min(dual[v] + dist[v], INF_COST);
            Cap d = flow_rem;
            for (int v = t; v != s; v = prevv[v]) d = std::min(d, g[prevv[v]][preve[v]].cap);
            flow_rem -= d;
            cost += d * (dual[t] - dual[s]);
            for (int v = t; v != s; v = prevv[v]) {
                _edge &e = g[prevv[v]][preve[v]];
                e.cap -= d;
                g[v][e.rev].cap += d;
            }
        }
        return std::make_pair(flow_limit - flow_rem, cost);
    }

    struct edge {
        int from, to;
        Cap cap, flow;
        Cost cost;
        template <class Ostream> friend Ostream &operator<<(Ostream &os, const edge &e) {
            return os << '(' << e.from << "->" << e.to << ',' << e.flow << '/' << e.cap << ",$" << e.cost << ')';
        }
    };

    edge get_edge(int edge_id) const {
        int m = int(pos.size());
        assert(0 <= edge_id and edge_id < m);
        auto _e = g[pos[edge_id].first][pos[edge_id].second];
        auto _re = g[_e.to][_e.rev];
        return {pos[edge_id].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost};
    }
    std::vector<edge> edges() const {
        std::vector<edge> ret(pos.size());
        for (int i = 0; i < int(pos.size()); i++) ret[i] = get_edge(i);
        return ret;
    }

    template <class Ostream> friend Ostream &operator<<(Ostream &os, const MinCostFlow &mcf) {
        os << "[MinCostFlow]V=" << mcf.V << ":";
        for (int i = 0; i < mcf.V; i++) {
            for (auto &e : mcf.g[i]) os << "\n" << i << "->" << e.to << ":cap" << e.cap << ",$" << e.cost;
        }
        return os;
    }
};


int main() {
    cin.tie(nullptr), ios::sync_with_stdio(false);
    int N, K;
    cin >> N >> K;
    constexpr lint INF = 1LL << 60;
    MinCostFlow<int, lint> mcf(N + 2);
    REP(i, N) mcf.add_edge(i, i + 1, K, 0);
    vector<int> A(N + 1);
    FOR(i, 1, N + 1) {
        int m;
        cin >> A[i] >> m;
        while (m--) {
            int b;
            cin >> b;
            mcf.add_edge(b, i, 1, -A[i] + A[b]);
        }
    }
    cout << -mcf.flow<radix_heap<unsigned long long, int>>(0, N, K).second << '\n';
}
0