結果

問題 No.1301 Strange Graph Shortest Path
ユーザー nok0nok0
提出日時 2020-10-29 22:53:50
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 1,515 ms / 3,000 ms
コード長 11,633 bytes
コンパイル時間 3,684 ms
コンパイル使用メモリ 220,688 KB
最終ジャッジ日時 2025-01-15 16:24:03
ジャッジサーバーID
(参考情報)
judge3 / judge2
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 2
other AC * 33
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp: In function ‘void scan(char*)’:
main.cpp:59:28: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
   59 | void scan(char a[]) { scanf("%s", a); }
      |                       ~~~~~^~~~~~~~~

ソースコード

diff #
プレゼンテーションモードにする

/**
* author: nok0
* created: 2020.10.29 19:10:49
**/
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
#pragma region Macros
#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for(int i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T>>;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define VEC(type, name, size) \
V<type> name(size); \
INPUT(name)
#define VVEC(type, name, h, w) \
VV<type> name(h, V<type>(w)); \
INPUT(name)
#define INT(...) \
int __VA_ARGS__; \
INPUT(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
INPUT(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
INPUT(__VA_ARGS__)
#define CHAR(...) \
char __VA_ARGS__; \
INPUT(__VA_ARGS__)
#define DOUBLE(...) \
DOUBLE __VA_ARGS__; \
INPUT(__VA_ARGS__)
#define LD(...) \
LD __VA_ARGS__; \
INPUT(__VA_ARGS__)
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T>
void scan(V<T> &);
template <class T, class L>
void scan(pair<T, L> &);
template <class T>
void scan(V<T> &a) {
for(auto &i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T>
void scan(T &a) { cin >> a; }
void INPUT() {}
template <class Head, class... Tail>
void INPUT(Head &head, Tail &... tail) {
scan(head);
INPUT(tail...);
}
template <class T>
inline void print(T x) { cout << x << '\n'; }
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for(T &in : v) is >> in;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const V<T> &v) {
REP(i, SZ(v)) {
if(i) os << " ";
os << v[i];
}
return os;
}
//debug
template <typename T>
void view(const V<T> &v) {
cerr << "{ ";
for(const auto &e : v) {
cerr << e << ", ";
}
cerr << "\b\b }";
}
template <typename T>
void view(const VV<T> &vv) {
cerr << "{\n";
for(const auto &v : vv) {
cerr << "\t";
view(v);
cerr << "\n";
}
cerr << "}";
}
template <typename T, typename U>
void view(const V<pair<T, U>> &v) {
cerr << "{\n";
for(const auto &c : v) cerr << "\t(" << c.first << ", " << c.second << ")\n";
cerr << "}";
}
template <typename T, typename U>
void view(const map<T, U> &m) {
cerr << "{\n";
for(auto &t : m) cerr << "\t[" << t.first << "] : " << t.second << "\n";
cerr << "}";
}
template <typename T, typename U>
void view(const pair<T, U> &p) { cerr << "(" << p.first << ", " << p.second << ")"; }
template <typename T>
void view(const set<T> &s) {
cerr << "{ ";
for(auto &t : s) {
view(t);
cerr << ", ";
}
cerr << "\b\b }";
}
template <typename T>
void view(T e) { cerr << e; }
#ifdef LOCAL
void debug_out() {}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
view(H);
cerr << ", ";
debug_out(T...);
}
#define debug(...) \
do { \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "] : ["; \
debug_out(__VA_ARGS__); \
cerr << "\b\b]\n"; \
} while(0)
#else
#define debug(...) (void(0))
#endif
template <class T>
V<T> press(V<T> &x) {
V<T> res = x;
sort(all(res));
res.erase(unique(all(res)), res.end());
REP(i, SZ(x)) {
x[i] = lower_bound(all(res), x[i]) - res.begin();
}
return res;
}
template <class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
if(b) {
cout << -1 << '\n';
exit(0);
}
}
template <class T>
inline void fin(bool b = true, T e = 0) {
if(b) {
cout << e << '\n';
exit(0);
}
}
template <class T>
T divup(T x, T y) { return (x + (y - 1)) / y; }
template <typename T>
T pow(T a, long long n, T e = 1) {
T ret = e;
while(n) {
if(n & 1) ret *= a;
a *= a;
n >>= 1;
}
return ret;
}
struct iofast {
iofast() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
}
} iofast_;
const int inf = 1e9;
const ll INF = 1e18;
#pragma endregion
enum Objective {
MINIMIZE = 1,
MAXIMIZE = -1,
};
enum class Status {
OPTIMAL,
INFEASIBLE,
};
template <class Flow, class Cost, Objective objective = Objective::MINIMIZE, Flow SCALING_FACTOR = 2>
struct MinCostFlow {
private:
using V_id = uint32_t;
using E_id = uint32_t;
struct Edge {
friend struct MinCostFlow;
private:
V_id src, dst;
Flow flow, cap;
Cost cost;
E_id rev;
public:
Edge() = default;
Edge(const V_id src, const V_id dst, const Flow cap, const Cost cost,
const E_id rev)
: src(src), dst(dst), flow(0), cap(cap), cost(cost), rev(rev) {}
[[nodiscard]] Flow residual_cap() const { return cap - flow; }
};
public:
struct EdgePtr {
friend struct MinCostFlow;
private:
const MinCostFlow *instance;
const V_id v;
const E_id e;
EdgePtr(const MinCostFlow *instance, const V_id v, const E_id e)
: instance(instance), v(v), e(e) {}
[[nodiscard]] const Edge &edge() const { return instance->g[v][e]; }
[[nodiscard]] const Edge &rev() const {
const Edge &e = edge();
return instance->g[e.dst][e.rev];
}
public:
[[nodiscard]] V_id src() const { return rev().dst; }
[[nodiscard]] V_id dst() const { return edge().dst; }
[[nodiscard]] Flow flow() const { return edge().flow; }
[[nodiscard]] Flow lower() const { return -rev().cap; }
[[nodiscard]] Flow upper() const { return edge().cap; }
[[nodiscard]] Cost cost() const { return edge().cost; }
[[nodiscard]] Cost gain() const { return -edge().cost; }
};
private:
V_id n;
std::vector<std::vector<Edge>> g;
std::vector<Flow> b;
public:
MinCostFlow() : n(0) {}
V_id add_vertex() {
++n;
g.resize(n);
b.resize(n);
return n - 1;
}
std::vector<V_id> add_vertices(const size_t size) {
std::vector<V_id> ret;
for(V_id i = 0; i < size; ++i) ret.emplace_back(n + i);
n += size;
g.resize(n);
b.resize(n);
return ret;
}
EdgePtr add_edge(const V_id src, const V_id dst, const Flow lower, const Flow upper, const Cost cost) {
const E_id e = g[src].size(), re = src == dst ? e + 1 : g[dst].size();
assert(lower <= upper);
g[src].emplace_back(Edge{src, dst, upper, cost * objective, re});
g[dst].emplace_back(Edge{dst, src, -lower, -cost * objective, e});
return EdgePtr{this, src, e};
}
void add_supply(const V_id v, const Flow amount) { b[v] += amount; }
void add_demand(const V_id v, const Flow amount) { b[v] -= amount; }
private:
static Cost constexpr unreachable = std::numeric_limits<Cost>::max();
Cost farthest;
std::vector<Cost> potential;
std::vector<Cost> dist;
std::vector<Edge *> parent;
std::priority_queue<std::pair<Cost, int>, std::vector<std::pair<Cost, int>>, std::greater<>> pq;
std::vector<V_id> excess_vs, deficit_vs;
Edge &rev(const Edge &e) { return g[e.dst][e.rev]; }
void push(Edge &e, const Flow amount) {
e.flow += amount;
g[e.dst][e.rev].flow -= amount;
}
Cost residual_cost(const V_id src, const V_id dst, const Edge &e) {
return e.cost + potential[src] - potential[dst];
}
bool dual(const Flow delta) {
dist.assign(n, unreachable);
parent.assign(n, nullptr);
excess_vs.erase(std::remove_if(std::begin(excess_vs), std::end(excess_vs), [&](const V_id v) { return b[v] < delta; }), std::end(excess_vs));
deficit_vs.erase(std::remove_if(std::begin(deficit_vs), std::end(deficit_vs), [&](const V_id v) { return b[v] > -delta; }), std::end
            (deficit_vs));
for(const auto v : excess_vs) pq.emplace(dist[v] = 0, v);
farthest = 0;
std::size_t deficit_count = 0;
while(!pq.empty()) {
const auto [d, u] = pq.top();
pq.pop();
if(dist[u] < d) continue;
farthest = d;
if(b[u] <= -delta) ++deficit_count;
if(deficit_count >= deficit_vs.size()) break;
for(auto &e : g[u]) {
if(e.residual_cap() < delta) continue;
const auto v = e.dst;
const auto new_dist = d + residual_cost(u, v, e);
if(new_dist >= dist[v]) continue;
pq.emplace(dist[v] = new_dist, v);
parent[v] = &e;
}
}
pq = decltype(pq)();
for(V_id v = 0; v < n; ++v) {
potential[v] += std::min(dist[v], farthest);
}
return deficit_count > 0;
}
void primal(const Flow delta) {
for(const auto t : deficit_vs) {
if(dist[t] > farthest) continue;
Flow f = -b[t];
V_id v;
for(v = t; parent[v] != nullptr && f >= delta; v = parent[v]->src) {
f = std::min(f, parent[v]->residual_cap());
}
f = std::min(f, b[v]);
if(f < delta) continue;
for(v = t; parent[v] != nullptr;) {
auto &e = *parent[v];
push(e, f);
const size_t u = parent[v]->src;
parent[v] = nullptr;
v = u;
}
b[t] += f;
b[v] -= f;
}
}
void saturate_negative(const Flow delta) {
excess_vs.clear();
deficit_vs.clear();
for(auto &es : g)
for(auto &e : es) {
const Flow rcap = e.residual_cap();
const Cost rcost = residual_cost(e.src, e.dst, e);
if(rcost < 0 && rcap >= delta) {
push(e, rcap);
b[e.src] -= rcap;
b[e.dst] += rcap;
}
}
for(V_id v = 0; v < n; ++v)
if(b[v] != 0) {
(b[v] > 0 ? excess_vs : deficit_vs).emplace_back(v);
}
}
public:
std::pair<Status, Cost> solve() {
potential.resize(n);
for(auto &es : g)
for(auto &e : es) {
const Flow rcap = e.residual_cap();
if(rcap < 0) {
push(e, rcap);
b[e.src] -= rcap;
b[e.dst] += rcap;
}
}
Flow inf_flow = 1;
for(const auto &es : g)
for(const auto &e : es) inf_flow = std::max(inf_flow, e.residual_cap());
Flow delta = 1;
while(delta <= inf_flow) delta *= SCALING_FACTOR;
for(delta /= SCALING_FACTOR; delta; delta /= SCALING_FACTOR) {
saturate_negative(delta);
while(dual(delta)) primal(delta);
}
Cost value = 0;
for(const auto &es : g)
for(const auto &e : es) {
value += e.flow * e.cost;
}
value /= 2;
if(excess_vs.empty() && deficit_vs.empty()) {
return {Status::OPTIMAL, value / objective};
} else {
return {Status::INFEASIBLE, value / objective};
}
}
};
template <class Flow, class Cost>
using MaxGainFlow = MinCostFlow<Flow, Cost, Objective::MAXIMIZE>;
int u, v;
ll c, d;
int main() {
INT(n, m);
MinCostFlow<int, ll> MCF;
MCF.add_vertices(n);
MCF.add_supply(0, 2);
MCF.add_demand(n - 1, 2);
auto add = [&](int u, int v) {
auto w = MCF.add_vertex();
MCF.add_edge(u, w, 0, 2, c);
MCF.add_edge(w, v, 0, 1, 0);
MCF.add_edge(w, v, 0, 1, d - c);
};
REP(i, m) {
cin >> u >> v >> c >> d;
u--, v--;
add(u, v);
add(v, u);
}
auto p = MCF.solve();
print(p.second);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0