結果
| 問題 | No.1678 Coin Trade (Multiple) |
| ユーザー |
👑  hitonanode
|
| 提出日時 | 2021-09-10 22:43:53 |
| 言語 | C++23 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 14,743 bytes |
| コンパイル時間 | 2,214 ms |
| コンパイル使用メモリ | 185,464 KB |
| 実行使用メモリ | 77,464 KB |
| 最終ジャッジ日時 | 2023-09-02 19:44:03 |
| 合計ジャッジ時間 | 10,173 ms |
|
ジャッジサーバーID （参考情報） |
judge15 / judge13 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
4,372 KB |
| testcase_01 | AC | 1 ms
4,372 KB |
| testcase_02 | AC | 2 ms
4,368 KB |
| testcase_03 | TLE | - |
| testcase_04 | -- | - |
| testcase_05 | -- | - |
| testcase_06 | -- | - |
| testcase_07 | -- | - |
| testcase_08 | -- | - |
| 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 | -- | - |
ソースコード
#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)
template <class Uint> class radix_heap_array {
int sz;
Uint last;
std::array<std::vector<std::pair<Uint, int>>, std::numeric_limits<Uint>::digits + 1> v;
struct smallpii {
unsigned b : 7;
int j : 25;
};
std::vector<smallpii> i2bj;
template <class U, typename std::enable_if<sizeof(U) == 4>::type* = nullptr>
static inline unsigned 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 unsigned bucket(U x) noexcept {
return x ? 64 - __builtin_clzll(x) : 0;
}
void pull() {
if (!v[0].empty()) return;
int b = 1;
while (v[b].empty()) ++b;
last = v[b].back().first;
for (int j = 0; j < int(v[b].size()); j++) last = std::min(last, v[b][j].first);
for (int j = 0; j < int(v[b].size()); j++) {
int i = v[b][j].second;
auto bnxt = bucket(v[b][j].first ^ last);
i2bj[i] = {bnxt, int(v[bnxt].size())}, v[bnxt].emplace_back(std::move(v[b][j]));
}
v[b].clear();
}
public:
radix_heap_array() : sz(0), last(0) {}
bool empty() const noexcept { return sz == 0; }
int argmin_pop() {
pull(), --sz;
int i = v[0].back().second;
i2bj[i].j = -1;
v[0].pop_back();
return i;
}
void chmin(Uint vnew, int i) {
if (i >= int(i2bj.size())) i2bj.resize(i + 1, {0, -1});
if (i2bj[i].j < 0) {
auto b = bucket(vnew ^ last);
++sz, i2bj[i] = {b, int(v[b].size())}, v[b].emplace_back(vnew, i);
} else if (v[i2bj[i].b][i2bj[i].j].first > vnew) {
auto bold = i2bj[i].b, bnew = bucket(vnew ^ last);
if (bnew < bold) {
int ilast = v[bold].back().second, j = i2bj[i].j;
std::swap(v[bold][j], v[bold].back());
i2bj[ilast].j = j, i2bj[i] = {bnew, int(v[bnew].size())};
v[bnew].emplace_back(vnew, i), v[bold].pop_back();
} else {
v[bold][i2bj[i].j].first = vnew;
}
}
}
void pop() { argmin_pop(); }
std::pair<Uint, int> top() { return pull(), v[0].back(); }
[[deprecated("NOT usual emplace() opeation!")]] void emplace(Uint vnew, int i) { chmin(vnew, i); }
void clear() noexcept { sz = 0, last = 0, i2bj.assign(i2bj.size(), {0, -1}); }
};
// 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();
}
radix_heap_array<unsigned long long> q;
void _dijkstra(int s) { // O(ElogV)
prevv.assign(V, -1);
preve.assign(V, -1);
dist.assign(V, INF_COST);
dist[s] = 0;
q.clear();
q.chmin(0, s);
while (!q.empty()) {
int v = q.argmin_pop();
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.chmin(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.
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(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;
}
};
// Cost scaling
// https://people.orie.cornell.edu/dpw/orie633/
template <class Cap, class Cost, int SCALING = 1, int REFINEMENT_ITER = 20> struct mcf_costscaling {
mcf_costscaling() = default;
mcf_costscaling(int n) : _n(n), to(n), b(n), p(n) {}
int _n;
std::vector<Cap> cap;
std::vector<Cost> cost;
std::vector<int> opposite;
std::vector<std::vector<int>> to;
std::vector<Cap> b;
std::vector<Cost> p;
int add_edge(int from_, int to_, Cap cap_, Cost cost_) {
assert(0 <= from_ and from_ < _n);
assert(0 <= to_ and to_ < _n);
assert(0 <= cap_);
cost_ *= (_n + 1);
const int e = int(cap.size());
to[from_].push_back(e);
cap.push_back(cap_);
cost.push_back(cost_);
opposite.push_back(to_);
to[to_].push_back(e + 1);
cap.push_back(0);
cost.push_back(-cost_);
opposite.push_back(from_);
return e / 2;
}
void add_supply(int v, Cap supply) { b[v] += supply; }
void add_demand(int v, Cap demand) { add_supply(v, -demand); }
template <typename RetCost = Cost> RetCost solve() {
Cost eps = 1;
std::vector<int> que;
for (const auto c : cost) {
while (eps <= -c) eps <<= SCALING;
}
for (; eps >>= SCALING;) {
auto no_admissible_cycle = [&]() -> bool {
for (int i = 0; i < _n; i++) {
if (b[i]) return false;
}
std::vector<Cost> pp = p;
for (int iter = 0; iter < REFINEMENT_ITER; iter++) {
bool flg = false;
for (int e = 0; e < int(cap.size()); e++) {
if (!cap[e]) continue;
int i = opposite[e ^ 1], j = opposite[e];
if (pp[j] > pp[i] + cost[e] + eps) pp[j] = pp[i] + cost[e] + eps, flg = true;
}
if (!flg) return p = pp, true;
}
return false;
};
if (no_admissible_cycle()) continue; // Refine
for (int e = 0; e < int(cap.size()); e++) {
const int i = opposite[e ^ 1], j = opposite[e];
const Cost cp_ij = cost[e] + p[i] - p[j];
if (cap[e] and cp_ij < 0) b[i] -= cap[e], b[j] += cap[e], cap[e ^ 1] += cap[e], cap[e] = 0;
}
que.clear();
int qh = 0;
for (int i = 0; i < _n; i++) {
if (b[i] > 0) que.push_back(i);
}
std::vector<int> iters(_n);
while (qh < int(que.size())) {
const int i = que[qh++];
for (; iters[i] < int(to[i].size()) and b[i]; ++iters[i]) { // Push
int e = to[i][iters[i]];
if (!cap[e]) continue;
int j = opposite[e];
Cost cp_ij = cost[e] + p[i] - p[j];
if (cp_ij >= 0) continue;
Cap f = b[i] > cap[e] ? cap[e] : b[i];
if (b[j] <= 0 and b[j] + f > 0) que.push_back(j);
b[i] -= f, b[j] += f, cap[e] -= f, cap[e ^ 1] += f;
}
if (b[i] > 0) { // Relabel
bool flg = false;
for (int e : to[i]) {
if (!cap[e]) continue;
Cost x = p[opposite[e]] - cost[e] - eps;
if (!flg or x > p[i]) flg = true, p[i] = x;
}
que.push_back(i), iters[i] = 0;
}
}
}
RetCost ret = 0;
for (int e = 0; e < int(cap.size()); e += 2) ret += RetCost(cost[e]) * cap[e ^ 1];
return ret / (_n + 1);
}
std::vector<Cost> potential() const {
std::vector<Cost> ret = p, c0 = cost;
for (auto &x : ret) x /= (_n + 1);
for (auto &x : c0) x /= (_n + 1);
while (true) {
bool flg = false;
for (int i = 0; i < _n; i++) {
for (const auto e : to[i]) {
if (!cap[e]) continue;
int j = opposite[e];
auto y = ret[i] + c0[e];
if (ret[j] > y) ret[j] = y, flg = true;
}
}
if (!flg) break;
}
return ret;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int e) const {
int m = cap.size() / 2;
assert(e >= 0 and e < m);
return {opposite[e * 2 + 1], opposite[e * 2], cap[e * 2] + cap[e * 2 + 1], cap[e * 2 + 1], cost[e * 2] / (_n + 1)};
}
std::vector<edge> edges() const {
int m = cap.size() / 2;
std::vector<edge> result(m);
for (int i = 0; i < m; i++) result[i] = get_edge(i);
return result;
}
};
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);
mcf_costscaling<int, lint> mcf(N + 1);
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]);
}
}
mcf.add_supply(0, K);
mcf.add_demand(N, K);
// cout << -mcf.flow(0, N, K).second << '\n';
cout << -mcf.solve<lint>() << '\n';
}