結果

問題 No.654 Air E869120
ユーザー masutech16
提出日時 2022-05-17 00:23:40
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 26 ms / 2,000 ms
コード長 9,488 bytes
コンパイル時間 2,528 ms
コンパイル使用メモリ 220,900 KB
最終ジャッジ日時 2025-01-29 08:50:55
ジャッジサーバーID
(参考情報)
judge2 / judge4
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 5
other AC * 35
権限があれば一括ダウンロードができます

ソースコード

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

#line 1 "main.cpp"
#include <bits/stdc++.h>
#line 1 "/workspaces/compro/lib/ac-library/atcoder/maxflow.hpp"
#line 9 "/workspaces/compro/lib/ac-library/atcoder/maxflow.hpp"
#line 1 "/workspaces/compro/lib/ac-library/atcoder/internal_queue.hpp"
#line 5 "/workspaces/compro/lib/ac-library/atcoder/internal_queue.hpp"
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T& t) { payload.push_back(t); }
T& front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
} // namespace internal
} // namespace atcoder
#line 11 "/workspaces/compro/lib/ac-library/atcoder/maxflow.hpp"
namespace atcoder {
template <class Cap> struct mf_graph {
public:
mf_graph() : _n(0) {}
explicit mf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
int from_id = int(g[from].size());
int to_id = int(g[to].size());
if (from == to) to_id++;
g[from].push_back(_edge{to, to_id, cap});
g[to].push_back(_edge{from, from_id, 0});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result;
for (int i = 0; i < m; i++) {
result.push_back(get_edge(i));
}
return result;
}
void change_edge(int i, Cap new_cap, Cap new_flow) {
int m = int(pos.size());
assert(0 <= i && i < m);
assert(0 <= new_flow && new_flow <= new_cap);
auto& _e = g[pos[i].first][pos[i].second];
auto& _re = g[_e.to][_e.rev];
_e.cap = new_cap - new_flow;
_re.cap = new_flow;
}
Cap flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
Cap flow(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
std::vector<int> level(_n), iter(_n);
internal::simple_queue<int> que;
auto bfs = [&]() {
std::fill(level.begin(), level.end(), -1);
level[s] = 0;
que.clear();
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto e : g[v]) {
if (e.cap == 0 || level[e.to] >= 0) continue;
level[e.to] = level[v] + 1;
if (e.to == t) return;
que.push(e.to);
}
}
};
auto dfs = [&](auto self, int v, Cap up) {
if (v == s) return up;
Cap res = 0;
int level_v = level[v];
for (int& i = iter[v]; i < int(g[v].size()); i++) {
_edge& e = g[v][i];
if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0) continue;
Cap d =
self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
if (d <= 0) continue;
g[v][i].cap += d;
g[e.to][e.rev].cap -= d;
res += d;
if (res == up) return res;
}
level[v] = _n;
return res;
};
Cap flow = 0;
while (flow < flow_limit) {
bfs();
if (level[t] == -1) break;
std::fill(iter.begin(), iter.end(), 0);
Cap f = dfs(dfs, t, flow_limit - flow);
if (!f) break;
flow += f;
}
return flow;
}
std::vector<bool> min_cut(int s) {
std::vector<bool> visited(_n);
internal::simple_queue<int> que;
que.push(s);
while (!que.empty()) {
int p = que.front();
que.pop();
visited[p] = true;
for (auto e : g[p]) {
if (e.cap && !visited[e.to]) {
visited[e.to] = true;
que.push(e.to);
}
}
}
return visited;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#line 1 "/workspaces/compro/lib/template.hpp"
#line 1 "/workspaces/compro/lib/Assert/Assert.hpp"
#line 6 "/workspaces/compro/lib/Assert/Assert.hpp"
#ifdef LOCAL
#define ASSERT_MSG(expr, msg) \
do { \
if (!(expr)) { \
std::cerr << msg << std::endl; \
assert(expr); \
} \
} while (0)
#define FAIL() ASSERT_MSG(false, "")
#else
#define ASSERT_MSG(...) (void)0
#define FAIL() (void)0
#endif
#line 2 "/workspaces/compro/lib/IO/Pair.hpp"
#ifndef IO_PAIR
#define IO_PAIR
template <class T1, class T2> std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &p) {
std::cout << p.first << ' ' << p.second;
return out;
}
template <class T1, class T2> std::istream &operator>>(std::istream &in, std::pair<T1, T2> &p) {
std::cin >> p.first >> p.second;
return in;
}
#endif
#line 3 "/workspaces/compro/lib/IO/Vector.hpp"
#ifndef IO_VECTOR
#define IO_VECTOR
template <class T> std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
int size = v.size();
for (int i = 0; i < size; i++) {
std::cout << v[i];
if (i != size - 1)
std::cout << " ";
}
return out;
}
template <class T> std::istream &operator>>(std::istream &in, std::vector<T> &v) {
for (auto &el : v) {
std::cin >> el;
}
return in;
}
#endif
#line 7 "/workspaces/compro/lib/template.hpp"
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define RREP(i, n) for (int i = (n - 1); i >= 0; i--)
#define RFOR(i, m, n) for (int i = (n - 1); i >= (m); i--)
#define ALL(v) std::begin(v), std::end(v)
#define coutd(n) cout << fixed << setprecision(n)
#define ll long long int
#define vl vector<ll>
#define vi vector<int>
#define MM << " " <<
using namespace std;
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class F, class T> bool if_all(std::vector<T> &v, F &&func) {
return std::all_of(std::begin(v), std::end(v), func);
}
template <class F, class T> bool if_any(std::vector<T> &v, F &&func) {
return std::any_of(std::begin(v), std::end(v), func);
}
#line 5 "main.cpp"
long long solve(long long N, int M, long long d, const std::vector<long long> &u, const std::vector<long long> &v,
const std::vector<long long> &p, const std::vector<long long> &q, const std::vector<long long> &w) {
map<pair<int, int>, int> mp;
{
int idx = 0;
REP(i, M) {
mp[{u[i], p[i]}] = idx;
idx++;
mp[{v[i], q[i] + d}] = idx;
idx++;
}
mp[{0, -1}] = idx;
idx++;
mp[{N - 1, 1e9 + d}] = idx;
idx++;
}
int s = mp[{0, -1}];
int t = mp[{N - 1, 1e9 + d}];
atcoder::mf_graph<ll> g(t + 1);
//
{
vector<vector<int>> vs(N);
vs[0].push_back(-1);
vs[N - 1].push_back(1e9 + d);
REP(i, M) {
vs[u[i]].push_back(p[i]);
vs[v[i]].push_back(q[i] + d);
}
REP(i, N) {
auto &vec = vs[i];
sort(ALL(vec));
int len = vec.size();
REP(j, len - 1) {
int from = mp[{i, vec[j]}];
int to = mp[{i, vec[j + 1]}];
if (from != to)
g.add_edge(from, to, 1e18);
}
}
REP(i, M) {
int from = mp[{u[i], p[i]}];
int to = mp[{v[i], q[i] + d}];
g.add_edge(from, to, w[i]);
}
}
return g.flow(s, t);
}
// generated by oj-template v4.8.1 (https://github.com/online-judge-tools/template-generator)
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long N;
int M;
long long d;
std::cin >> N >> M;
std::vector<long long> u(M), v(M), p(M), q(M), w(M);
std::cin >> d;
for (int i = 0; i < M; ++i) {
std::cin >> u[i] >> v[i] >> p[i] >> q[i] >> w[i];
u[i]--;
v[i]--;
}
auto ans = solve(N, M, d, u, v, p, q, w);
std::cout << ans << '\n';
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0