text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, y;
cin >> n >> x >> y;
string s;
cin >> s;
string s1 = "1";
while (x--) {
if (x == y) {
s1 += '1';
} else {
s1 += '0';
}
}
int j = s.size() - 1;
int cnt = 0;
for (int i = s1.size() - 1; i > 0; i--) {
if (s1[i] != s[j]) {
cnt++;
}
j--;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, y, count = 0;
cin >> n >> x >> y;
char s[200001];
cin >> s;
for (i = n - x; s[i] != '\0'; i++) {
if (i != n - y - 1 && s[i] == '1') count++;
if (i == n - y - 1 && s[i] == '0') count++;
}
cout << count;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;
const int maxs = 1e5 + 10;
const int maxn = 2e3 + 10;
const int maxm = 6e3 + 10;
const long long INF = 1e14 + 10;
const long long INF_CAP = INF;
struct spaceship {
int x, a, f, p;
} sp[maxs];
struct base {
int d, g;
bool operator<(const base& b) const { return d < b.d; }
};
long long best_goal[maxs];
vector<base> ba[N];
vector<int> pre[N];
vector<int> g[maxs];
bool used[maxs];
int w[N][N], id[maxs];
struct Dinic {
int n, m, s, t, pos;
int d[maxn], head[maxn], que[maxn], ptr[maxn];
int to[maxm], nxt[maxm];
long long cap[maxm];
void init() { memset(head, -1, sizeof head); }
void addedge(int a, int b, long long c) {
cap[m] = c;
to[m] = b;
nxt[m] = head[a];
head[a] = m++;
cap[m] = 0;
to[m] = a;
nxt[m] = head[b];
head[b] = m++;
}
bool bfs() {
pos = 0;
memset(d, -1, sizeof d);
que[pos++] = s;
d[s] = 0;
for (int i = 0; i < pos; i++) {
int x = que[i];
for (int u = head[x]; ~u; u = nxt[u]) {
if (d[to[u]] == -1 && cap[u]) {
d[to[u]] = d[x] + 1;
que[pos++] = to[u];
if (d[t] != -1) return true;
}
}
}
return d[t] != -1;
}
long long dfs(int o, long long mi) {
if (o == t || mi == 0) return mi;
long long res = 0;
for (int& x = ptr[o]; ~x; x = nxt[x])
if (d[to[x]] == d[o] + 1 && cap[x]) {
long long tmp = dfs(to[x], min(mi, cap[x]));
cap[x] -= tmp;
cap[x ^ 1] += tmp;
if (tmp > 0) return tmp;
}
return res;
}
long long maxflow(int s, int t) {
this->s = s;
this->t = t;
long long res = 0;
while (bfs()) {
memcpy(ptr, head, sizeof head);
res += dfs(s, INF_CAP);
}
return res;
}
} D;
int main() {
D.init();
int n, m, s, b, k;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fill(w[i] + 1, w[i] + 1 + n, n), w[i][i] = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
w[b][a] = w[a][b] = min(w[a][b], 1);
}
for (int d = 1; d <= n; d++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = min(w[i][j], w[i][d] + w[d][j]);
}
}
}
scanf("%d%d%d", &s, &b, &k);
for (int i = 1; i <= s; i++) {
scanf("%d%d%d%d", &sp[i].x, &sp[i].a, &sp[i].f, &sp[i].p);
}
for (int i = 0; i < b; i++) {
int x, d, g;
scanf("%d%d%d", &x, &d, &g);
ba[x].push_back(base{d, g});
}
for (int i = 1; i <= n; i++)
if (ba[i].size()) {
int sz = (int)ba[i].size();
sort(ba[i].begin(), ba[i].end());
pre[i].resize(sz);
pre[i][0] = ba[i][0].g;
for (int j = 1; j < sz; j++) pre[i][j] = max(pre[i][j - 1], ba[i][j].g);
}
for (int i = 1; i <= s; i++) {
best_goal[i] = -INF_CAP;
int x = sp[i].x;
for (int j = 1; j <= n; j++) {
if (w[x][j] <= sp[i].f) {
int pos = upper_bound(ba[j].begin(), ba[j].end(), base{sp[i].a, 0}) -
ba[j].begin();
--pos;
if (pos >= 0) {
best_goal[i] = max(best_goal[i], (long long)pre[j][pos] - sp[i].p);
}
}
}
}
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
used[a] = used[b] = 1;
}
long long ans = 0;
int cnt = 0;
for (int i = 1; i <= s; i++) {
if (!used[i]) {
if (best_goal[i] > 0) ans += best_goal[i];
} else {
id[i] = ++cnt;
}
}
int st = 0, ed = cnt + 1;
cnt = 0;
for (int i = 1; i <= s; i++) {
if (used[i]) {
if (best_goal[i] >= 0)
ans += best_goal[i], D.addedge(st, id[i], best_goal[i]);
else
D.addedge(id[i], ed, -best_goal[i]);
for (auto& u : g[i]) D.addedge(id[i], id[u], INF_CAP);
}
}
ans -= D.maxflow(st, ed);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
const ll INF = 1e18;
class Dinic {
private:
const static ll INF = 8 * (ll)1e18;
struct Edge {
const int t;
const ll c;
ll a;
Edge(int tar, ll cap = INF) : t(tar), c(cap), a(cap) {}
};
vector<Edge> edges;
vector<vector<int>> conns;
vector<int> dist, act_ind;
ll push(int ei, ll v) {
edges[ei].a -= v;
edges[ei ^ 1].a += v;
return v;
}
void calcDists(int sink) {
for (int& v : dist) v = -1;
dist[sink] = 0;
vector<int> que = {sink};
for (int j = 0; j < que.size(); ++j) {
for (auto ei : conns[que[j]]) {
int t = edges[ei].t;
if (edges[ei ^ 1].a > 0 && dist[t] == -1) {
dist[t] = dist[que[j]] + 1;
que.push_back(t);
}
}
}
}
ll dfsFlow(int i, int sink, ll cap) {
if (i == sink) return 0;
for (int& j = act_ind[i]; j < conns[i].size(); ++j) {
int ei = conns[i][j];
int t = edges[ei].t;
if (dist[t] != dist[i] - 1 || edges[ei].a == 0) continue;
ll subcap = min(cap, edges[ei].a);
cap -= push(ei, subcap - dfsFlow(t, sink, subcap));
if (!cap) return 0;
}
return cap;
}
public:
Dinic(int n) : conns(n), dist(n), act_ind(n) {}
int addEdge(int s, int t, ll c = INF, bool dir = 1) {
int i = edges.size() / 2;
edges.emplace_back(t, c);
edges.emplace_back(s, dir ? 0 : c);
conns[s].push_back(2 * i);
conns[t].push_back(2 * i + 1);
return i;
}
ll pushFlow(int source, int sink) {
for (ll res = 0;;) {
calcDists(sink);
if (dist[source] == -1) return res;
for (int& v : act_ind) v = 0;
res += INF - dfsFlow(source, sink, INF);
}
}
ll getFlow(int i) const { return edges[2 * i].c - edges[2 * i].a; }
};
ll solve(const Graph& g, const vector<ll>& vals) {
int n = g.size();
int source = n;
int sink = n + 1;
Dinic dinic(n + 2);
ll res = 0;
for (int i = 0; i < n; ++i) {
if (vals[i] < 0) {
dinic.addEdge(i, sink, -vals[i]);
} else {
dinic.addEdge(source, i, vals[i]);
res += vals[i];
}
for (auto t : g[i]) {
dinic.addEdge(i, t);
}
}
res -= dinic.pushFlow(source, sink);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<ll>> dist(n);
for (int i = 0; i < n; ++i) {
dist[i].resize(n, INF);
dist[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
dist[a][b] = 1;
dist[b][a] = 1;
}
for (int i = 0; i < n; ++i) {
for (int a = 0; a < n; ++a) {
for (int b = 0; b < n; ++b) {
dist[a][b] = min(dist[a][b], dist[a][i] + dist[i][b]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ships(s);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
cin >> loc >> atk >> fuel >> cost;
--loc;
ships[i] = tie(loc, atk, fuel, cost);
}
vector<tuple<int, int, int>> bases(b);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
cin >> tar >> def >> gold;
--tar;
bases[i] = tie(tar, def, gold);
}
sort(bases.begin(), bases.end());
vector<vector<pair<int, int>>> offs(n);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
tie(tar, def, gold) = bases[i];
if (offs[tar].empty() || offs[tar].back().second < gold) {
offs[tar].push_back({def, gold});
}
}
vector<ll> vals(s, -INF);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
tie(loc, atk, fuel, cost) = ships[i];
for (int t = 0; t < n; ++t) {
if (dist[loc][t] > fuel) continue;
int low = -1;
int high = (int)offs[t].size() - 1;
while (low != high) {
int mid = (low + high + 1) >> 1;
if (atk >= offs[t][mid].first)
low = mid;
else
high = mid - 1;
}
if (low >= 0) vals[i] = max(vals[i], (ll)offs[t][low].second);
}
vals[i] -= cost;
}
Graph g(s);
for (int j = 0; j < k; ++j) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
ll res = solve(g, vals);
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, index;
long long cap, flow;
Edge(int from, int to, long long cap, long long flow, int index)
: from(from), to(to), index(index), cap(cap), flow(flow) {}
};
struct Dinic {
int N;
vector<vector<Edge>> G;
vector<Edge *> dad;
vector<int> Q;
Dinic(int N) : N(N), G(N), dad(N), Q(N) {}
void AddEdge(int from, int to, long long cap) {
G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
if (from == to) G[from].back().index++;
G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
}
long long BlockingFlow(int s, int t) {
fill(dad.begin(), dad.end(), nullptr);
dad[s] = &G[0][0] - 1;
int head = 0, tail = 0;
Q[tail++] = s;
while (head < tail) {
int x = Q[head++];
for (int i = 0; i < G[x].size(); i++) {
Edge &e = G[x][i];
if (!dad[e.to] && e.cap - e.flow > 0) {
dad[e.to] = &G[x][i];
Q[tail++] = e.to;
}
}
}
if (!dad[t]) return 0;
long long totflow = 0;
for (int i = 0; i < G[t].size(); i++) {
Edge *start = &G[G[t][i].to][G[t][i].index];
long long amt = 1e18;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
if (!e) {
amt = 0;
break;
}
amt = min(amt, e->cap - e->flow);
}
if (amt == 0) continue;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
e->flow += amt;
G[e->to][e->index].flow -= amt;
}
totflow += amt;
}
return totflow;
}
long long GetMaxFlow(int s, int t) {
long long totflow = 0;
while (long long flow = BlockingFlow(s, t)) totflow += flow;
return totflow;
}
};
int n, m, k, s, b;
int d[100][100];
int sa[100000];
long long sp[100000], sbest[100000];
vector<int> rs[100];
map<int, long long> gold[100];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) d[i][j] = -1;
for (int i = 0; i < n; ++i) d[i][i] = 0;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
if (d[u][v] == -1) d[u][v] = d[v][u] = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
if (d[j][i] == -1 || d[i][k] == -1) continue;
d[j][k] = min(d[j][k] == -1 ? (int)1e9 : d[j][k], d[j][i] + d[i][k]);
}
}
cin >> s >> b >> k;
for (int i = 0; i < s; ++i) {
int sx, sf;
cin >> sx >> sa[i] >> sf >> sp[i];
sx--;
sbest[i] = -1e18;
for (int j = 0; j < n; ++j) {
if (d[sx][j] != -1 && sf >= d[sx][j]) rs[j].push_back(i);
}
}
for (int i = 0; i < b; ++i) {
int bx, bd, bg;
cin >> bx >> bd >> bg;
bx--;
gold[bx][bd] = max(gold[bx][bd], (long long)bg);
}
for (int i = 0; i < n; ++i) {
vector<pair<int, long long>> v;
for (auto it : gold[i])
v.push_back({it.first, max(v.empty() ? 0 : v.back().second, it.second)});
sort(rs[i].begin(), rs[i].end(),
[](int a, int b) { return sa[a] < sa[b]; });
int j = 0;
for (int k = 0; k < v.size(); ++k) {
while (j < rs[i].size() && sa[rs[i][j]] < v[k].first) j++;
while (j < rs[i].size() &&
(k == v.size() - 1 || sa[rs[i][j]] < v[k + 1].first)) {
sbest[rs[i][j]] = max(sbest[rs[i][j]], v[k].second - sp[rs[i][j]]);
j++;
}
}
}
long long res = 0;
for (int i = 0; i < s; ++i)
if (sbest[i] >= 0) res += sbest[i];
Dinic dinic(s + 2);
for (int i = 0; i < s; ++i) {
if (sbest[i] >= 0)
dinic.AddEdge(0, i + 2, sbest[i]);
else
dinic.AddEdge(i + 2, 1, -sbest[i]);
}
for (int i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
dinic.AddEdge(u + 2, v + 2, 1e18);
}
res -= dinic.GetMaxFlow(0, 1);
cout << res << "\n";
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
const ll INF = 1e18;
struct MaxFlow {
struct edge {
int a, b;
ll c;
};
vector<edge> es;
vector<vector<int>> g;
vector<int> d, pt;
MaxFlow(int n) : g(n + 1), d(n + 1), pt(n + 1) {}
void addEdge(int a, int b, ll c) {
es.push_back({a, b, c});
g[a].push_back((int)es.size() - 1);
es.push_back({b, a, 0});
g[b].push_back((int)es.size() - 1);
}
bool bfs(int source, int sink) {
queue<int> q({source});
fill(d.begin(), d.end(), (int)g.size() + 1);
d[source] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == sink) break;
for (int k : g[x]) {
edge& e = es[k];
if (e.c > 0 && d[e.b] > d[e.a] + 1) {
d[e.b] = d[e.a] + 1;
q.push(e.b);
}
}
}
return d[sink] != (int)g.size() + 1;
}
ll flow(int x, int sink, ll fl = INF) {
if (x == sink || fl == 0) return fl;
for (int& i = pt[x]; i < (int)g[x].size(); i++) {
edge& e = es[g[x][i]];
edge& oe = es[g[x][i] ^ 1];
if (d[e.b] == d[e.a] + 1) {
if (ll pf = flow(e.b, sink, min(e.c, fl))) {
e.c -= pf;
oe.c += pf;
return pf;
}
}
}
return 0;
}
ll getMaxFlow(int source, int sink) {
ll r = 0;
while (bfs(source, sink)) {
fill(pt.begin(), pt.end(), 0);
while (ll t = flow(source, sink)) r += t;
}
return r;
}
};
ll solve(const Graph& g, const vector<ll>& vals) {
int n = g.size();
int source = n;
int sink = n + 1;
ll res = 0;
MaxFlow dinic(n + 2);
for (int i = 0; i < n; ++i) {
if (vals[i] < 0) {
dinic.addEdge(i, sink, -vals[i]);
} else {
dinic.addEdge(source, i, vals[i]);
res += vals[i];
}
for (auto t : g[i]) {
dinic.addEdge(i, t, INF);
}
}
res -= dinic.getMaxFlow(source, sink);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<ll>> dist(n);
for (int i = 0; i < n; ++i) {
dist[i].resize(n, INF);
dist[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
dist[a][b] = 1;
dist[b][a] = 1;
}
for (int i = 0; i < n; ++i) {
for (int a = 0; a < n; ++a) {
for (int b = 0; b < n; ++b) {
dist[a][b] = min(dist[a][b], dist[a][i] + dist[i][b]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ships(s);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
cin >> loc >> atk >> fuel >> cost;
--loc;
ships[i] = tie(loc, atk, fuel, cost);
}
vector<tuple<int, int, int>> bases(b);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
cin >> tar >> def >> gold;
--tar;
bases[i] = tie(tar, def, gold);
}
sort(bases.begin(), bases.end());
vector<vector<pair<int, int>>> offs(n);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
tie(tar, def, gold) = bases[i];
if (offs[tar].empty() || offs[tar].back().second < gold) {
offs[tar].push_back({def, gold});
}
}
vector<ll> vals(s, -INF);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
tie(loc, atk, fuel, cost) = ships[i];
for (int t = 0; t < n; ++t) {
if (dist[loc][t] > fuel) continue;
int low = -1;
int high = (int)offs[t].size() - 1;
while (low != high) {
int mid = (low + high + 1) >> 1;
if (atk >= offs[t][mid].first)
low = mid;
else
high = mid - 1;
}
if (low >= 0) vals[i] = max(vals[i], (ll)offs[t][low].second);
}
vals[i] -= cost;
}
Graph g(s);
for (int j = 0; j < k; ++j) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
ll res = solve(g, vals);
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
struct Dinic {
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap) {
if (u != v) {
E.emplace_back(Edge(u, v, cap));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
struct ship_t {
long long x, a, f, p;
};
struct base_t {
long long x, d, g;
bool operator<(const base_t &o) const { return d < o.d; }
};
const int N = 1e2 + 10, S = 1e5 + 10;
const long long inf = 1e12 + 42;
ship_t ship[S];
base_t base[S];
long long g[N][N];
vector<int> dep[S];
vector<pair<long long, long long>> bases_at[N];
bool seen[S];
long long val[S];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
g[i][j] = g[j][i] = inf;
}
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u][v] = g[v][u] = min(g[u][v], 1ll);
}
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
for (int i = 1; i <= s; ++i) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p;
}
for (int i = 1; i <= b; ++i) {
cin >> base[i].x >> base[i].d >> base[i].g;
}
sort(base + 1, base + 1 + b);
for (int i = 1; i <= b; ++i) {
int p = base[i].x;
if (bases_at[p].empty() or bases_at[p].back().second < base[i].g) {
bases_at[p].push_back({base[i].d, base[i].g});
}
}
Dinic dinic(s + 2);
int source = 0, sink = s + 1;
long long ans = 0;
for (int i = 1; i <= s; ++i) {
bool found = false;
for (int p = 1; p <= n; ++p) {
if (g[ship[i].x][p] > ship[i].f) {
continue;
}
auto it = upper_bound(bases_at[p].begin(), bases_at[p].end(),
make_pair(ship[i].a, inf));
if (it != bases_at[p].begin()) {
--it;
val[i] = max(val[i], it->second);
found = true;
}
}
val[i] -= ship[i].p;
if (!found) {
val[i] = -inf;
}
if (val[i] >= 0) {
ans += val[i];
dinic.AddEdge(source, i, val[i]);
} else {
dinic.AddEdge(i, sink, -val[i]);
}
}
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
dep[u].push_back(v);
}
for (int i = 1; i <= s; ++i) {
if (val[i] < 0) {
continue;
}
vector<int> vis = {i};
queue<int> q;
q.push(i);
seen[i] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
if (val[u] < 0) {
dinic.AddEdge(i, u, inf);
}
for (auto &v : dep[u]) {
if (!seen[v]) {
seen[v] = true;
vis.push_back(v);
q.push(v);
}
}
}
for (auto &u : vis) {
seen[u] = false;
}
}
cout << ans - dinic.MaxFlow(source, sink);
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity()
? std::numeric_limits<T>::infinty()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
template <class T>
class Dinic {
private:
struct edge {
int from, to;
T cap;
edge *rev;
edge(int u, int v, T c) : from(u), to(v), cap(c), rev(nullptr) {}
};
static constexpr T INF = Inf<T>::inf();
static constexpr int DINF = Inf<int>::inf();
int n, s, t;
std::vector<std::vector<edge *>> g;
public:
Dinic(int n, int s, int t) : n(n), s(s), t(t), g(n) {}
~Dinic() {
for (auto v : g)
for (edge *e : v) delete e;
}
void addEdge(int u, int v, T c) {
edge *in = new edge(u, v, c);
edge *out = new edge(v, u, 0);
g[u].push_back(in);
g[v].push_back(out);
in->rev = out;
out->rev = in;
}
T maxFlow() {
T mxf = 0;
std::vector<int> dist(n, DINF), vis(n);
std::function<T(int, T)> dfs = [&](int u, T fo) -> T {
if (u == t) return fo;
for (; vis[u] < int(g[u].size()); vis[u]++) {
edge *e = g[u][vis[u]];
int v = e->to;
if (dist[v] != dist[u] + 1 || e->cap <= 0) continue;
T foo = dfs(v, std::min(fo, e->cap));
if (foo > 0) {
e->cap -= foo;
e->rev->cap += foo;
return foo;
}
}
return 0;
};
for (;;) {
for (int i = 0; i < n; i++) dist[i] = DINF, vis[i] = 0;
std::queue<int> q;
q.push(s);
dist[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == t) break;
for (edge *e : g[u]) {
int v = e->to;
if (e->cap > 0 && dist[v] == DINF) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
if (dist[t] == DINF) break;
while (T fo = dfs(s, INF)) mxf += fo;
}
return mxf;
}
};
template <class T>
constexpr T Dinic<T>::INF;
template <class T>
constexpr int Dinic<T>::DINF;
int solve() {
int n, m;
cin >> n >> m;
vvi dp(n, vi(n, INF));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
dp[u][v] = dp[v][u] = 1;
}
for (int i = 0; i < n; i++) dp[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
int s, b, k;
cin >> s >> b >> k;
vi xs(s), as(s), fs(s), ps(s), xb(b), db(b), gb(b);
for (int i = 0; i < s; i++) {
cin >> xs[i] >> as[i] >> fs[i] >> ps[i];
xs[i]--;
}
for (int i = 0; i < b; i++) {
cin >> xb[i] >> db[i] >> gb[i];
xb[i]--;
}
vll canGet(s, -BINF);
vector<vpii> bsList(n);
for (int i = 0; i < b; i++) bsList[xb[i]].emplace_back(db[i], gb[i]);
for (int i = 0; i < n; i++) {
sort(bsList[i].begin(), bsList[i].end());
int z = bsList[i].size();
for (int j = 1; j < z; j++)
bsList[i][j].second = max(bsList[i][j].second, bsList[i][j - 1].second);
}
for (int i = 0; i < s; i++)
for (int j = 0; j < n; j++) {
if (dp[xs[i]][j] > fs[i]) continue;
auto it =
upper_bound(bsList[j].begin(), bsList[j].end(), pii{as[i], INF});
if (it == bsList[j].begin()) continue;
it--;
canGet[i] = max(canGet[i], ll(it->second));
}
for (int i = 0; i < s; i++) canGet[i] -= ps[i];
ll ans = 0;
Dinic<ll> g(s + 2, s, s + 1);
for (int i = 0; i < s; i++) {
if (canGet[i] >= 0) {
ans += canGet[i];
g.addEdge(s, i, canGet[i]);
} else {
g.addEdge(i, s + 1, -canGet[i]);
}
}
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g.addEdge(u, v, BINF);
}
ans -= g.maxFlow();
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
const ll INF = 1e18;
class Dinic {
private:
constexpr static ll INF = 8 * (ll)1e18;
struct Edge {
const int s, t;
const ll c;
ll f;
Edge(int src, int tar, ll cap = INF, bool dir = 1)
: s(src), t(tar), c(dir ? cap : 2 * cap), f(dir ? 0 : cap) {}
int getOth(int i) { return i == s ? t : s; }
ll getCap(int i) { return i == s ? c - f : f; }
void push(int i, ll am) { f += (i == s ? am : -am); }
};
const int source, sink, n;
vector<Edge> edges;
vector<vector<int>> conns;
vector<int> dist;
vector<bool> done;
bool calcDists() {
for (int i = 0; i < n; ++i) dist[i] = n;
dist[sink] = 0;
vector<int> que = {sink};
for (int j = 0; j < que.size(); ++j) {
int i = que[j];
for (auto ei : conns[i]) {
int t = edges[ei].getOth(i);
if (edges[ei].getCap(t) == 0) continue;
if (dist[t] == n) {
dist[t] = dist[i] + 1;
que.push_back(t);
}
}
}
return dist[source] < n;
}
ll dfsFlow(int i, ll cap = INF) {
if (i == sink) return cap;
ll res = 0;
for (auto ei : conns[i]) {
int t = edges[ei].getOth(i);
if (done[t] || dist[t] != dist[i] - 1) continue;
ll subcap = min(cap - res, edges[ei].getCap(i));
if (subcap == 0) {
if (cap == res) return res;
} else {
ll add = dfsFlow(t, subcap);
res += add;
edges[ei].push(i, add);
}
}
if (res < cap) done[i] = true;
return res;
}
public:
Dinic(int nn, int s, int t)
: n(nn), conns(nn), dist(nn), done(nn), source(s), sink(t) {}
const Edge& getEdge(int j) const { return edges[j]; }
void addEdge(int a, int b, ll c = INF, bool dir = 1) {
edges.emplace_back(a, b, c, dir);
conns[a].push_back(edges.size() - 1);
conns[b].push_back(edges.size() - 1);
}
ll pushFlow() {
ll res = 0;
while (calcDists()) {
for (int i = 0; i < n; ++i) done[i] = false;
res += dfsFlow(source);
}
return res;
}
};
ll solve(const Graph& g, const vector<ll>& vals) {
int n = g.size();
int source = n;
int sink = n + 1;
Dinic dinic(n + 2, source, sink);
ll res = 0;
for (int i = 0; i < n; ++i) {
if (vals[i] < 0) {
dinic.addEdge(i, sink, -vals[i]);
} else {
dinic.addEdge(source, i, vals[i]);
res += vals[i];
}
for (auto t : g[i]) {
dinic.addEdge(i, t);
}
}
res -= dinic.pushFlow();
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<ll>> dist(n);
for (int i = 0; i < n; ++i) {
dist[i].resize(n, INF);
dist[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
dist[a][b] = 1;
dist[b][a] = 1;
}
for (int i = 0; i < n; ++i) {
for (int a = 0; a < n; ++a) {
for (int b = 0; b < n; ++b) {
dist[a][b] = min(dist[a][b], dist[a][i] + dist[i][b]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ships(s);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
cin >> loc >> atk >> fuel >> cost;
--loc;
ships[i] = tie(loc, atk, fuel, cost);
}
vector<tuple<int, int, int>> bases(b);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
cin >> tar >> def >> gold;
--tar;
bases[i] = tie(tar, def, gold);
}
sort(bases.begin(), bases.end());
vector<vector<pair<int, int>>> offs(n);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
tie(tar, def, gold) = bases[i];
if (offs[tar].empty() || offs[tar].back().second < gold) {
offs[tar].push_back({def, gold});
}
}
vector<ll> vals(s, -INF);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
tie(loc, atk, fuel, cost) = ships[i];
for (int t = 0; t < n; ++t) {
if (dist[loc][t] > fuel) continue;
int low = -1;
int high = (int)offs[t].size() - 1;
while (low != high) {
int mid = (low + high + 1) >> 1;
if (atk >= offs[t][mid].first)
low = mid;
else
high = mid - 1;
}
if (low >= 0) vals[i] = max(vals[i], (ll)offs[t][low].second);
}
vals[i] -= cost;
}
Graph g(s);
for (int j = 0; j < k; ++j) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
ll res = solve(g, vals);
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d[107][107], s, b, k;
struct spaceship {
int x, a, f, p;
} sp[100007];
struct base {
int x, d, g;
} ba[100007];
vector<int> v[107];
bool cmp(int x, int y) { return ba[x].d < ba[y].d; }
vector<pair<int, int> > u[107];
long long val[100007];
int e, head[100007], nxt[1000007], to[1000007], op[1000007];
long long cap[1000007];
void add_edge(int x, int y, long long c) {
nxt[++e] = head[x], to[head[x] = e] = y;
cap[e] = c, op[e] = e + 1;
nxt[++e] = head[y], to[head[y] = e] = x;
cap[e] = 0, op[e] = e - 1;
}
int S, T, nodes, dis[100007], cnt[100007];
long long sap(int x, long long delta) {
if (x == T) return delta;
long long sum = 0;
int mindis = nodes;
for (int i = head[x]; i; i = nxt[i]) {
if (cap[i] && dis[x] == dis[to[i]] + 1) {
long long save = sap(to[i], min(cap[i], delta - sum));
sum += save, cap[i] -= save, cap[op[i]] += save;
if (dis[S] >= nodes || sum == delta) return sum;
}
if (cap[i]) mindis = min(mindis, dis[to[i]]);
}
if (!sum)
if (!--cnt[dis[x]])
dis[S] = nodes;
else
++cnt[dis[x] = mindis + 1];
return sum;
}
long long max_flow() {
long long res = 0;
while (dis[S] < nodes) res += sap(S, 100000000000007LL);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) d[i][j] = 107;
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
if (x == y) continue;
d[x][y] = d[y][x] = 1;
}
for (int t = 1; t <= n; ++t)
for (int i = 1; i <= n; ++i)
if (i != t)
for (int j = 1; j <= n; ++j)
if (j != t && j != i) d[i][j] = min(d[i][j], d[i][t] + d[t][j]);
scanf("%d%d%d", &s, &b, &k);
for (int i = 1; i <= s; ++i)
scanf("%d%d%d%d", &sp[i].x, &sp[i].a, &sp[i].f, &sp[i].p);
for (int i = 1; i <= b; ++i) {
scanf("%d%d%d", &ba[i].x, &ba[i].d, &ba[i].g);
v[ba[i].x].push_back(i);
}
for (int i = 1; i <= n; ++i) {
sort(v[i].begin(), v[i].end(), cmp);
int mx = 0;
for (int j : v[i]) {
mx = max(mx, ba[j].g);
u[i].push_back(make_pair(ba[j].d, mx));
}
}
for (int i = 1; i <= s; ++i) {
val[i] = -100000000000007LL;
for (int j = 1; j <= n; ++j)
if (d[sp[i].x][j] < 107 && d[sp[i].x][j] <= sp[i].f) {
int t = -1, l = 0, r = u[j].size() - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (u[j][mid].first <= sp[i].a)
t = mid, l = mid + 1;
else
r = mid - 1;
}
if (t != -1) val[i] = max(val[i], 1LL * u[j][t].second - sp[i].p);
}
}
S = 0, T = s + 1, nodes = s + 2;
long long ans = 0;
for (int i = 1; i <= s; ++i)
if (val[i] > 0)
ans += val[i], add_edge(S, i, val[i]);
else if (val[i] < 0)
add_edge(i, T, -val[i]);
for (int i = 1, x, y; i <= k; ++i)
scanf("%d%d", &x, &y), add_edge(x, y, 100000000000007LL);
ans -= max_flow();
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize(3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
#pragma GCC push_options
#pragma GCC pop_options
#pragma GCC reset_options
#pragma GCC optimize("O3")
const double eps = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 100000000000000LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void fastll(long long &input_number) {
input_number = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9') {
input_number = (input_number << 3) + (input_number << 1) + ch - '0';
ch = getchar_unlocked();
}
input_number *= sign;
}
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct ShipDT {
long long pos, att, fuel, price, profit;
};
struct BaseDT {
long long pos, def, price;
};
struct dtE {
long long power_, idx;
bool type;
bool operator<(const dtE &other) const {
if (power_ != other.power_) return power_ < other.power_;
return type > other.type;
}
};
long long n, m;
long long dist[105][105];
long long CurMaxgold[105];
vector<dtE> events;
long long ShipN, BaseN, DepM;
ShipDT ship[100005];
BaseDT base[100005];
struct dt {
long long to, cap, backidx;
};
struct dta {
long long pos, step;
};
long long ans;
long long s, e;
long long st[200005];
long long level[200005];
queue<dta> antri;
vector<dt> edge[200005];
void make_edge(long long u, long long v, long long capto, long long backcap) {
long long szu = edge[u].size();
long long szv = edge[v].size();
edge[u].push_back({v, capto, szv});
edge[v].push_back({u, backcap, szu});
return;
}
void bfs(dta now) {
for (int i = 0; i < edge[now.pos].size(); i++) {
long long nx = edge[now.pos][i].to;
if (level[nx]) continue;
if (edge[now.pos][i].cap == 0) continue;
level[nx] = now.step + 1;
antri.push({nx, now.step + 1});
}
return;
}
long long maxflow(long long pos, long long bcap) {
if (pos == e) return bcap;
for (; st[pos] < edge[pos].size(); st[pos]++) {
long long i = st[pos];
long long nx = edge[pos][i].to;
if (level[nx] != level[pos] + 1) continue;
if (edge[pos][i].cap == 0) continue;
long long curflow = maxflow(nx, min(bcap, edge[pos][i].cap));
if (curflow == 0) continue;
edge[pos][i].cap -= curflow;
edge[nx][edge[pos][i].backidx].cap += curflow;
return curflow;
}
return 0;
}
int main() {
cin >> n >> m;
memset(dist, INFMEM, sizeof(dist));
for (int i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
dist[u][v] = 1;
}
for (int i = 1; i <= n; i++) dist[i][i] = 0;
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
cin >> ShipN >> BaseN >> DepM;
for (int i = 1; i <= ShipN; i++) {
cin >> ship[i].pos >> ship[i].att >> ship[i].fuel >> ship[i].price;
events.push_back({ship[i].att, i, 0});
}
for (int i = 1; i <= BaseN; i++) {
cin >> base[i].pos >> base[i].def >> base[i].price;
events.push_back({base[i].def, i, 1});
}
sort(events.begin(), events.end());
for (int i = 1; i <= n; i++) CurMaxgold[i] = -LINF;
for (int i = 0; i < events.size(); i++) {
long long curidx = events[i].idx;
if (events[i].type == 1) {
CurMaxgold[base[curidx].pos] =
max(CurMaxgold[base[curidx].pos], base[curidx].price);
} else {
long long u = ship[curidx].pos;
ship[curidx].profit = -LINF;
for (int j = 1; j <= n; j++) {
if (dist[u][j] <= ship[curidx].fuel) {
ship[curidx].profit =
max(ship[curidx].profit, CurMaxgold[j] - ship[curidx].price);
}
}
}
}
long long ans = 0;
s = 0;
e = ShipN + 1;
for (int i = 1; i <= ShipN; i++) {
if (ship[i].profit < 0) {
make_edge(i, e, abs(ship[i].profit), 0);
} else {
ans += ship[i].profit;
make_edge(s, i, ship[i].profit, 0);
}
}
for (int i = 1; i <= DepM; i++) {
long long u, v;
cin >> u >> v;
make_edge(u, v, LINF, 0);
}
while (1) {
memset(level, 0, sizeof(level));
memset(st, 0, sizeof(st));
level[s] = 1;
antri.push({s, 1});
while (!antri.empty()) {
dta tmp = antri.front();
antri.pop();
bfs(tmp);
}
if (level[e] == 0) break;
long long curflow;
while (curflow = maxflow(s, LINF)) ans -= curflow;
}
printf("%lld\n", ans);
return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[110][110], INF = 1e18;
long long v[100010];
vector<pair<long long, long long>> base[110];
vector<long long> bst[110];
struct Dinic {
int nodes, src, dst;
vector<int> dist, q, work;
struct edge {
int to, rev;
long long f, cap;
};
vector<vector<edge>> g;
Dinic(int x) : nodes(x), g(x), dist(x), q(x), work(x) {}
void add_edge(int s, int t, long long cap) {
g[s].push_back((edge){t, int(g[t].size()), 0, cap});
g[t].push_back((edge){s, int(g[s].size()) - 1, 0, 0});
}
bool dinic_bfs() {
fill(dist.begin(), dist.end(), -1);
dist[src] = 0;
int qt = 0;
q[qt++] = src;
for (int qh = 0; qh < qt; qh++) {
int u = q[qh];
for (int i = 0, ThxDem = int(g[u].size()); i < ThxDem; ++i) {
edge &e = g[u][i];
int v = g[u][i].to;
if (dist[v] < 0 && e.f < e.cap) dist[v] = dist[u] + 1, q[qt++] = v;
}
}
return dist[dst] >= 0;
}
long long dinic_dfs(int u, long long f) {
if (u == dst) return f;
for (int &i = work[u]; i < int(g[u].size()); i++) {
edge &e = g[u][i];
if (e.cap <= e.f) continue;
int v = e.to;
if (dist[v] == dist[u] + 1) {
long long df = dinic_dfs(v, min(f, e.cap - e.f));
if (df > 0) {
e.f += df;
g[v][e.rev].f -= df;
return df;
}
}
}
return 0;
}
long long max_flow(int _src, int _dst) {
src = _src;
dst = _dst;
long long result = 0;
while (dinic_bfs()) {
fill(work.begin(), work.end(), 0);
while (long long delta = dinic_dfs(src, INF)) result += delta;
}
return result;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = n; j < ThxDem; ++j) d[i][j] = INF * (i != j);
for (int i = 0, ThxDem = m; i < ThxDem; ++i) {
int x, y;
cin >> x >> y;
d[x - 1][y - 1] = d[y - 1][x - 1] = 1;
}
for (int k = 0, ThxDem = n; k < ThxDem; ++k)
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = n; j < ThxDem; ++j) {
if (d[i][k] != INF && d[k][j] != INF)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
long long ans = 0, s, b, k;
cin >> s >> b >> k;
for (int i = 0, ThxDem = s; i < ThxDem; ++i) v[i] = -INF;
vector<pair<pair<long long, long long>, pair<long long, long long>>> a(s);
for (int i = 0, ThxDem = s; i < ThxDem; ++i)
cin >> a[i].first.first >> a[i].first.second >> a[i].second.first >>
a[i].second.second,
a[i].first.first--;
for (int i = 0, ThxDem = b; i < ThxDem; ++i) {
long long x, di, g;
cin >> x >> di >> g;
x--;
base[x].push_back({di, g});
}
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
sort(base[i].begin(), base[i].end());
bst[i].resize(int(base[i].size()));
for (int j = 0, ThxDem = int(base[i].size()); j < ThxDem; ++j) {
bst[i][j] = base[i][j].second;
if (j) bst[i][j] = max(bst[i][j], bst[i][j - 1]);
}
}
Dinic nt(s + 2);
for (int i = 0, ThxDem = int(a.size()); i < ThxDem; ++i) {
for (int j = 0, ThxDem = n; j < ThxDem; ++j) {
int top =
upper_bound(base[j].begin(), base[j].end(),
(pair<long long, long long>){a[i].first.second, INF}) -
base[j].begin() - 1;
if (d[a[i].first.first][j] <= a[i].second.first && top >= 0) {
v[i] = max(v[i], bst[j][top] - a[i].second.second);
}
}
if (v[i] < 0)
nt.add_edge(i + 1, s + 1, -v[i]);
else
ans += v[i], nt.add_edge(0, i + 1, v[i]);
}
for (int i = 0, ThxDem = k; i < ThxDem; ++i) {
int x, y;
cin >> x >> y;
nt.add_edge(x, y, INF);
}
cout << ans - nt.max_flow(0, s + 1) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long INF = (long long)1e18 + 33;
const int V = 101;
const int N = 100010;
int G[V][V];
int n;
int m, k;
int a[N][4];
long long c[N];
vector<pair<int, int> > b[N];
struct Edge {
int v, to;
long long cap;
Edge() : v(), to(), cap() {}
Edge(int _v, int _to, long long _cap) : v(_v), to(_to), cap(_cap) {}
};
Edge ed[N];
int edSz;
vector<int> g[N];
int dist[N];
int q[N];
int topQ;
int idx[N];
int idd[N];
int S, T;
void addEdge(int v, int to, long long cap) {
ed[edSz] = Edge(v, to, cap);
g[v].push_back(edSz++);
ed[edSz] = Edge(to, v, 0);
g[to].push_back(edSz++);
}
bool BFS() {
for (int i = 0; i <= T; i++) dist[i] = N;
topQ = 0;
dist[S] = 0;
q[topQ++] = S;
for (int i = 0; i < topQ; i++) {
int v = q[i];
for (int id : g[v]) {
Edge e = ed[id];
if (e.cap <= 0) continue;
int to = e.to;
if (dist[to] <= dist[v] + 1) continue;
dist[to] = dist[v] + 1;
q[topQ++] = to;
}
}
return dist[T] < N;
}
long long dfs(int v, long long flow) {
if (v == T || flow == 0) return flow;
long long res = 0;
for (int &i = idx[v]; i < (int)g[v].size(); i++) {
int id = g[v][i];
Edge e = ed[id];
int to = e.to;
if (dist[to] != dist[v] + 1) continue;
long long df = dfs(to, min(flow, e.cap));
res += df;
flow -= df;
ed[id].cap -= df;
ed[id ^ 1].cap += df;
if (flow == 0) return res;
}
return res;
}
long long Flow() {
long long res = 0;
while (BFS()) {
for (int i = 0; i <= T; i++) idx[i] = 0;
res += dfs(S, INF);
}
return res;
}
void readGraph() {
int e;
scanf("%d%d", &n, &e);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) G[i][j] = (i == j ? 0 : N);
while (e--) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
if (v != u) G[v][u] = G[u][v] = 1;
}
for (int z = 0; z < n; z++)
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) G[x][y] = min(G[x][y], G[x][z] + G[z][y]);
}
long long read() {
readGraph();
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &a[i][0], &a[i][1], &a[i][2], &a[i][3]);
a[i][0]--;
}
for (int i = 0; i < k; i++) {
int v, x, y;
scanf("%d%d%d", &v, &x, &y);
v--;
b[v].push_back(make_pair(x, y));
}
for (int v = 0; v < V; v++) {
sort(b[v].begin(), b[v].end());
for (int i = 1; i < (int)b[v].size(); i++)
b[v][i].second = max(b[v][i].second, b[v][i - 1].second);
}
for (int i = 0; i < n; i++) {
c[i] = -INF;
for (int v = 0; v < V; v++) {
if (b[v].empty()) continue;
if (G[a[i][0]][v] > a[i][2]) continue;
int p =
upper_bound(b[v].begin(), b[v].end(), make_pair(a[i][1] + 1, -1)) -
b[v].begin();
if (p > 0) c[i] = max(c[i], (long long)b[v][p - 1].second);
}
c[i] -= a[i][3];
}
S = 0;
for (int i = 0; i < n; i++) idd[i] = -1;
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
if (idd[v] == -1) idd[v] = S++;
if (idd[u] == -1) idd[u] = S++;
v = idd[v];
u = idd[u];
addEdge(v, u, INF);
}
T = S + 1;
long long ans = 0;
for (int v = 0; v < n; v++) {
if (idd[v] == -1) {
ans += max(0LL, c[v]);
continue;
}
if (c[v] <= 0) {
addEdge(idd[v], T, -c[v]);
} else {
ans += c[v];
addEdge(S, idd[v], c[v]);
}
}
return ans;
}
int main() {
long long ans = read();
printf("%lld\n", ans - Flow());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct ship {
int id, pos, atk, fuel, price;
bool operator<(const ship &o) const { return atk < o.atk; }
};
struct base {
int pos, def, gold;
bool operator<(const base &o) const { return def < o.def; }
};
const ll inf_ll = ll(1e13);
struct edge {
int to;
ll cap;
};
struct flow {
int n, s, t;
vector<vector<int>> g;
vector<edge> e;
flow(int n_) : n(n_), s(n_ - 2), t(n_ - 1), g(n), e() {}
void add_edge(int from, int to, ll cap) {
g[from].push_back(((int)(e).size()));
e.push_back(edge{to, cap});
g[to].push_back(((int)(e).size()));
e.push_back(edge{from, 0LL});
}
vector<int> dist, ptr;
ll add_flow() {
dist.assign(n, -1);
ptr.assign(n, 0);
dist[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int num : g[cur]) {
ll cap = e[num].cap;
int to = e[num].to;
if (cap > 0 && dist[to] == -1) {
dist[to] = dist[cur] + 1;
q.push(to);
}
}
}
return dfs(s, inf_ll);
}
ll dfs(int v, ll to_push) {
if (v == t || to_push == 0) return to_push;
ll pushed = 0;
for (int &i = ptr[v]; i < ((int)(g[v]).size()); i++) {
const int num = g[v][i];
const int to = e[num].to;
const ll cap = e[num].cap;
if (dist[to] == dist[v] + 1) {
ll cur_push = dfs(to, min(to_push, cap));
e[num].cap -= cur_push;
e[num ^ 1].cap += cur_push;
to_push -= cur_push;
pushed += cur_push;
}
if (to_push == 0) break;
}
return pushed;
}
ll max_flow() {
ll ans = 0;
while (ll add = add_flow()) ans += add;
return ans;
}
};
ll solve_work_instr(const vector<vector<int>> &req, const vector<int> &reward,
const vector<int> &cost) {
const int right = ((int)(reward).size()), left = ((int)(cost).size());
const ll sum_rew = accumulate(reward.begin(), reward.end(), 0LL);
flow flow(2 + left + right);
for (int i = 0; i < left; i++) flow.add_edge(flow.s, i, cost[i]);
for (int i = 0; i < right; i++) flow.add_edge(left + i, flow.t, reward[i]);
for (int i = 0; i < right; i++) {
for (int instr : req[i]) flow.add_edge(instr, left + i, inf_ll);
}
return sum_rew - flow.max_flow();
}
void dfs(int x, const vector<vector<int>> &g, vector<char> &used,
vector<int> &reach) {
reach.push_back(x);
used[x] = 1;
for (int dest : g[x])
if (!used[dest]) dfs(dest, g, used, reach);
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n, m;
cin >> n >> m;
const int inf = int(1e9) + 1;
vector<vector<int>> dist(n, vector<int>(n, inf));
for (int i = 0; i < n; i++) dist[i][i] = 0;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
dist[u][v] = dist[v][u] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
int s, b, k;
cin >> s >> b >> k;
vector<ship> ship(s);
vector<base> base(b);
int cur_id = 0;
for (auto &x : ship) {
cin >> x.pos >> x.atk >> x.fuel >> x.price;
--x.pos;
x.id = cur_id++;
}
for (auto &x : base) {
cin >> x.pos >> x.def >> x.gold;
--x.pos;
}
sort(ship.begin(), ship.end());
sort(base.begin(), base.end());
vector<int> best_atk(s, -inf);
vector<int> weak_base(n, -inf);
int ptr = 0;
for (auto x : ship) {
while (ptr < ((int)(base).size()) && base[ptr].def <= x.atk) {
const int where = base[ptr].pos;
const int gold = base[ptr].gold;
weak_base[where] = max(weak_base[where], gold);
ptr++;
}
for (int i = 0; i < n; i++)
if (dist[i][x.pos] <= x.fuel)
best_atk[x.id] = max(best_atk[x.id], weak_base[i] - x.price);
}
vector<vector<int>> g(s), grev(s);
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
grev[y].push_back(x);
}
vector<int> instr;
vector<vector<int>> req;
vector<int> reward, cost;
ll ans = 0;
for (int i = 0; i < s; i++) {
if (g[i].empty() && grev[i].empty())
ans += max(0, best_atk[i]);
else if (best_atk[i] < 0 && best_atk[i] > -inf)
instr.push_back(i);
}
sort(instr.begin(), instr.end());
for (int i = 0; i < ((int)(instr).size()); i++)
cost.push_back(-best_atk[instr[i]]);
vector<char> used(s);
for (int x : best_atk) cerr << x << ' ';
cerr << endl;
for (int i = 0; i < s; i++)
if (!g[i].empty() || !grev[i].empty()) {
if (best_atk[i] >= 0) {
vector<int> reach;
dfs(i, g, used, reach);
for (int x : reach) used[x] = 0;
bool bad = false;
for (int x : reach)
if (best_atk[x] == -inf) bad = true;
if (bad) continue;
req.push_back(vector<int>());
reward.push_back(best_atk[i]);
for (int x : reach)
if (best_atk[x] < 0) {
int pos =
lower_bound(instr.begin(), instr.end(), x) - instr.begin();
assert(pos < ((int)(instr).size()) && instr[pos] == x);
req.back().push_back(pos);
}
}
}
ans += solve_work_instr(req, reward, cost);
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
cout << setprecision(20);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int adj[111][111];
int xp[100010], a[100010], f[100010], p[100010];
int xb[100010], d[100010], g[100010];
const long long inf = 1e17;
long long opt[111];
long long profit[100010];
const long long max_profit = 1000000000;
struct MaxFlow {
struct Node {
vector<long long> adj;
};
Node graf[100010];
struct Edge {
long long u, v, cap;
long long flow;
};
vector<Edge> E;
long long v;
long long s, t;
long long dist[100010];
long long upTo[100010];
long long idd = 0;
inline bool BFS() {
for (long long i = 1; i <= v; i++) dist[i] = -1;
queue<long long> bfs_queue;
bfs_queue.push(s);
dist[s] = 0;
while (!bfs_queue.empty()) {
long long xt = bfs_queue.front();
bfs_queue.pop();
for (long long i = 0; i < graf[xt].adj.size(); i++) {
long long currID = graf[xt].adj[i];
long long xt1 = E[currID].v;
if (dist[xt1] == -1 && E[currID].flow < E[currID].cap) {
bfs_queue.push(xt1);
dist[xt1] = dist[xt] + 1;
}
}
}
return (dist[t] != -1);
}
inline long long DFS(long long xt, long long minCap) {
if (minCap == 0) return 0;
if (xt == t) return minCap;
while (upTo[xt] < graf[xt].adj.size()) {
long long currID = graf[xt].adj[upTo[xt]];
long long xt1 = E[currID].v;
if (dist[xt1] != dist[xt] + 1) {
upTo[xt]++;
continue;
}
long long aug = DFS(xt1, min(minCap, E[currID].cap - E[currID].flow));
if (aug > 0) {
E[currID].flow += aug;
if (currID & 1)
currID--;
else
currID++;
E[currID].flow -= aug;
return aug;
}
upTo[xt]++;
}
return 0;
}
inline long long Dinic() {
long long flow = 0;
while (true) {
if (!BFS()) break;
for (long long i = 1; i <= v; i++) upTo[i] = 0;
while (true) {
long long currFlow = DFS(s, inf);
if (currFlow == 0) break;
flow += currFlow;
}
}
return flow;
}
inline void addEdge(long long u, long long v, long long cap) {
Edge E1, E2;
E1.u = u, E1.v = v, E1.cap = cap, E1.flow = 0;
E2.u = v, E2.v = u, E2.cap = 0, E2.flow = 0;
graf[u].adj.push_back(idd++);
E.push_back(E1);
graf[v].adj.push_back(idd++);
E.push_back(E2);
}
} F;
bool bad[100010];
vector<int> forb[100010];
void prop(int x) {
bad[x] = true;
for (auto i : forb[x]) {
if (!bad[i]) {
prop(i);
}
}
}
int main(int argc, char const *argv[]) {
ios_base ::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
adj[i][j] = 1000000001;
}
}
opt[i] = -inf;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u][v] = adj[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<pair<int, int>> v;
for (int i = 1; i <= s; i++) {
cin >> xp[i] >> a[i] >> f[i] >> p[i];
v.emplace_back(a[i], i);
}
for (int i = 1; i <= b; i++) {
cin >> xb[i] >> d[i] >> g[i];
v.emplace_back(d[i], -i);
}
sort(v.begin(), v.end());
for (auto i : v) {
int id = abs(i.second);
if (i.second > 0) {
int x = xp[id];
profit[id] = -inf;
for (int j = 1; j <= n; j++) {
if (adj[x][j] <= f[id]) {
profit[id] = max(profit[id], opt[j] - p[id]);
}
}
} else {
int x = xb[id];
opt[x] = max(opt[x], (long long)g[id]);
}
}
for (int i = 1; i <= k; i++) {
int u, v;
cin >> u >> v;
forb[v].push_back(u);
}
for (int i = 1; i <= s; i++) {
if (!bad[i] && profit[i] < -max_profit) {
prop(i);
}
}
F.s = s + 1;
F.t = s + 2;
F.v = s + 2;
for (int i = 1; i <= s; i++) {
if (bad[i]) continue;
for (auto j : forb[i]) {
if (!bad[j]) {
F.addEdge(j, i, inf);
}
}
}
long long sum = 0;
for (int i = 1; i <= s; i++) {
if (!bad[i]) {
if (profit[i] > 0) {
F.addEdge(F.s, i, profit[i]);
sum += profit[i];
} else {
F.addEdge(i, F.t, -profit[i]);
}
}
}
cout << sum - F.Dinic() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxm = 100 + 10;
const int maxn = 3e5 + 10;
const int N = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const long long inf1 = 0x3f3f3f3f3f3f3f3f;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
return 1;
}
inline bool read(char &x) {
while ((x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
x == '\n' || x == '\r')
;
return x != EOF;
}
inline bool read(char *x) {
while ((*x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*x == ' ' || *x == '\r')
;
if (*x == EOF) return 0;
while (!(*x == '\n' || *x == ' ' || *x == '\r' || *x == EOF))
*(++x) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*x = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &x, B &...y) {
return read(x) && read(y...);
}
template <typename A>
inline bool write(A x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char x) {
putc(x);
return 0;
}
inline bool write(const char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
inline bool write(char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A x, B... y) {
return write(x) || write(y...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int dis[maxm][maxm];
map<int, int> mp;
struct base {
int def, gold, mmax;
friend bool operator<(base a, base b) { return a.def < b.def; }
};
struct ship {
int x, att, fuel, pri;
} a[N];
vector<base> v[maxm];
long long val[N];
int s, t;
int now[N], dep[N], head[N];
struct edge {
int v;
long long w;
int nxt;
} e[maxn];
int ecnt;
void addedge(int u, int v, long long w) {
e[ecnt] = {v, w, head[u]};
head[u] = ecnt++;
e[ecnt] = {u, 0, head[v]};
head[v] = ecnt++;
}
int bfs() {
queue<int> q;
while (!q.empty()) q.pop();
for (int i = s; i <= t; i++) {
dep[i] = -1;
now[i] = -1;
}
dep[s] = 0;
q.push(s);
now[s] = head[s];
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (e[i].w > 0 && dep[v] == -1) {
dep[v] = dep[u] + 1;
now[v] = head[v];
q.push(v);
}
}
}
return dep[t] != -1;
}
long long dfs(int u, long long mi) {
if (mi == 0 || u == t) return mi;
long long tmp, sum = 0;
for (int i = now[u]; i != -1 && mi; i = e[i].nxt) {
now[u] = i;
int v = e[i].v;
if (e[i].w > 0 && dep[v] == dep[u] + 1) {
tmp = dfs(v, min(mi, e[i].w));
e[i].w -= tmp;
e[i ^ 1].w += tmp;
sum += tmp;
mi -= tmp;
if (!mi) break;
}
}
return sum;
}
long long dinic() {
long long ans = 0;
while (bfs()) {
ans += dfs(s, inf1);
}
return ans;
}
int main() {
memset(head, -1, sizeof(head));
memset(dis, 0x3f, sizeof(dis));
int n, m;
read(n, m);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
read(u, v);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
int snum, bnum, k;
read(snum, bnum, k);
for (int i = 1; i <= snum; i++) {
int x, att, fu, pri;
read(x, att, fu, pri);
a[i] = {x, att, fu, pri};
}
for (int i = 1; i <= bnum; i++) {
int x, def, gol;
read(x, def, gol);
v[x].push_back({def, gol, gol});
}
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
for (int j = 1; j < v[i].size(); j++)
v[i][j].mmax = max(v[i][j].gold, v[i][j - 1].mmax);
}
for (int i = 1; i <= snum; i++) val[i] = -inf1;
for (int i = 1; i <= snum; i++) {
for (int j = 1; j <= n; j++) {
if (a[i].fuel >= dis[a[i].x][j]) {
int l = 0, r = v[j].size() - 1, pos = -1;
while (l <= r) {
int mid = l + r >> 1;
if (v[j][mid].def <= a[i].att) {
l = mid + 1, pos = mid;
} else
r = mid - 1;
}
if (pos < 0) continue;
val[i] = max(val[i], 0ll + v[j][pos].mmax - a[i].pri);
}
}
}
s = 0, t = snum + 1;
for (int i = 1; i <= k; i++) {
int u, v;
read(u, v);
addedge(u, v, inf1);
}
long long tot = 0;
for (int i = 1; i <= snum; i++) {
if (val[i] >= 0) {
tot += val[i];
addedge(s, i, val[i]);
}
if (val[i] < 0) addedge(i, t, -val[i]);
}
tot -= dinic();
printf("%lld\n", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000 + 5, MAXM = 10000 + 10;
const long long int INF = 1e15;
bool visit[MAXN];
int head[MAXN], dist[MAXN], stamp, tmphead[MAXN];
struct EDGE {
int to;
long long int r;
int next;
} edge[MAXM * 2];
void init() {
stamp = 0;
memset(head, -1, sizeof head);
}
void addedge(int a, int b, long long int c) {
edge[stamp] = {b, c, head[a]};
head[a] = stamp++;
edge[stamp] = {a, 0, head[b]};
head[b] = stamp++;
}
int BFS(int s, int t) {
for (int i = 0; i <= t; i++) dist[i] = 1e9;
memset(visit, 0, sizeof visit);
queue<int> q;
q.push(s);
dist[s] = 0;
visit[s] = true;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = head[now]; i != -1; i = edge[i].next) {
int nextnode = edge[i].to;
if (edge[i].r > 0 && !visit[nextnode]) {
dist[nextnode] = dist[now] + 1;
visit[nextnode] = true;
q.push(nextnode);
if (nextnode == t) return dist[t];
}
}
}
return -1;
}
long long int DFS(int now, long long int df, int t) {
if (now == t) return df;
visit[now] = true;
for (int i = tmphead[now]; i != -1; tmphead[now] = i = edge[i].next) {
int nextnode = edge[i].to;
if (edge[i].r > 0 && dist[now] + 1 == dist[nextnode] && !visit[nextnode]) {
long long int f = DFS(nextnode, min(df, edge[i].r), t);
if (f) {
edge[i].r -= f;
edge[i ^ 1].r += f;
return f;
}
}
}
return 0;
}
long long int Dinic(int s, int t) {
long long int flow = 0;
while (BFS(s, t) != -1) {
memcpy(tmphead, head, sizeof head);
while (true) {
memset(visit, 0, sizeof visit);
long long int f = DFS(s, INF, t);
if (!f) break;
flow += f;
}
}
return flow;
}
int dp[101][101];
struct SP {
int x, a, f, p, pro, idx;
bool operator<(const SP& rhs) const { return a < rhs.a; }
} sp[100001];
struct BA {
int x, d, g;
bool operator<(const BA& rhs) const { return d < rhs.d; }
} ba[100001];
int cur[101];
int s1[1001], s2[1001];
map<int, int> mp;
set<int> st;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
init();
for (int i = 1; i <= 100; i++) cur[i] = -1e9 - 1;
for (int i = 1; i <= 100; i++)
for (int j = 1; j <= 100; j++) dp[i][j] = 1e9 + 1;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
dp[u][v] = dp[v][u] = 1;
}
for (int i = 1; i <= 100; i++) dp[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
int s, b, k;
cin >> s >> b >> k;
for (int i = 1; i <= s; i++) {
cin >> sp[i].x >> sp[i].a >> sp[i].f >> sp[i].p;
sp[i].pro = -1e9 - 1;
sp[i].idx = i;
}
sort(sp + 1, sp + s + 1);
for (int i = 1; i <= b; i++) {
cin >> ba[i].x >> ba[i].d >> ba[i].g;
}
sort(ba + 1, ba + b + 1);
int pb = 1;
for (int i = 1; i <= s; i++) {
while (pb <= b && ba[pb].d <= sp[i].a)
cur[ba[pb].x] = max(cur[ba[pb].x], ba[pb].g), pb++;
for (int j = 1; j <= n; j++)
if (dp[j][sp[i].x] <= sp[i].f) sp[i].pro = max(sp[i].pro, cur[j]);
}
for (int i = 1; i <= k; i++) {
cin >> s1[i] >> s2[i];
st.insert(s1[i]);
st.insert(s2[i]);
}
int stp = 0;
for (int it : st) mp[it] = ++stp;
long long int ans = 0;
for (int i = 1; i <= s; i++) {
sp[i].pro -= sp[i].p;
if (sp[i].pro >= 0) ans += sp[i].pro;
if (mp.find(sp[i].idx) != mp.end()) {
if (sp[i].pro > 0)
addedge(stp + 1, mp[sp[i].idx], sp[i].pro);
else if (sp[i].pro < 0)
addedge(mp[sp[i].idx], stp + 2, (sp[i].pro < -1e9 ? INF : -sp[i].pro));
}
}
for (int i = 1; i <= k; i++) addedge(mp[s1[i]], mp[s2[i]], INF);
cout << ans - Dinic(stp + 1, stp + 2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const ld pi = acos(0) * 2;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <typename CT, typename T>
inline void reset_container(CT &c, int sz, T v) {
c.resize(sz);
for (auto &x : c) x = v;
}
int n, m;
int c[101][101];
int s, b, k;
vector<int> ship_at[101];
vector<int> base_at[101];
class ship {
public:
int x, a, f, p;
void input(int id) {
read(x);
read(a);
read(f);
read(p);
ship_at[x].push_back(id);
}
} S[100001];
class base {
public:
int x, d, g;
void input(int id) {
read(x);
read(d);
read(g);
base_at[x].push_back(id);
}
} B[100001];
int r[100001];
vector<int> g[100001];
vector<int> cc[100001];
int root(int u) {
if (r[u] < 0) return u;
return r[u] = root(r[u]);
}
void unite(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
r[v] = u;
}
ll p[100001];
class maxflow {
public:
class edge {
public:
using pointer = edge *;
int v;
ll c;
pointer rev;
edge(int v, ll c) {
this->v = v;
this->c = c;
}
};
vector<edge::pointer> g[100002];
void reset() {
g[0].clear();
g[100001].clear();
flow = 0;
}
void add_edge(int u, int v, ll c) {
g[u].push_back(new edge(v, c));
g[v].push_back(new edge(u, 0));
g[u].back()->rev = g[v].back();
g[v].back()->rev = g[u].back();
}
edge::pointer trace[100002];
int done[100002];
int t;
bool bfs() {
t++;
queue<int> q;
q.push(0);
done[0] = t;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto e : g[u])
if (e->c)
if (done[e->v] != t) {
done[e->v] = t;
q.push(e->v);
trace[e->v] = e;
if (e->v == 100001) return 1;
}
}
return 0;
}
ll flow;
void increase_flow() {
int u = 100001;
ll f = 1e18;
while (u) {
f = min(f, trace[u]->c);
u = trace[u]->rev->v;
}
flow += f;
u = 100001;
while (u) {
trace[u]->c -= f;
trace[u]->rev->c += f;
u = trace[u]->rev->v;
}
}
ll get_flow() {
while (bfs()) increase_flow();
return flow;
}
} MF;
ll get_profit(int i) {
MF.reset();
ll prof = 0;
for (int u : cc[i]) {
if (p[u] >= 0) {
prof += p[u];
MF.add_edge(0, u, p[u]);
} else {
MF.add_edge(u, 100001, -p[u]);
}
for (int v : g[u]) MF.add_edge(u, v, 1e15);
}
ll flow = MF.get_flow();
prof -= flow;
return max(0LL, prof);
}
int main() {
read(n);
read(m);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (i != j) c[i][j] = (1e9) + 420;
for (int i = (1); i <= (m); i++) {
int u, v;
read(u);
read(v);
if (u != v) c[u][v] = c[v][u] = 1;
}
for (int k = (1); k <= (n); k++)
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
c[i][j] = min(c[i][j], c[i][k] + c[k][j]);
read(s);
read(b);
read(k);
for (int i = (1); i <= (s); i++) S[i].input(i);
for (int i = (1); i <= (b); i++) B[i].input(i);
for (int i = (1); i <= (s); i++) r[i] = -1;
for (int i = (1); i <= (k); i++) {
int u, v;
read(u);
read(v);
g[u].push_back(v);
unite(u, v);
}
for (int i = (1); i <= (n); i++) {
sort(base_at[i].begin(), base_at[i].end(),
[](int X, int Y) { return B[X].d < B[Y].d; });
for (int j = (1); j < (base_at[i].size()); j++)
B[base_at[i][j]].g = max(B[base_at[i][j]].g, B[base_at[i][j - 1]].g);
}
for (int i = (1); i <= (s); i++) {
ll prof = -1e15;
for (int v = (1); v <= (n); v++)
if (c[v][S[i].x] <= S[i].f) {
int low = 0, high = ((int)base_at[v].size()) - 1, mid, res = -1;
while (low <= high) {
mid = (low + high) / 2;
if (B[base_at[v][mid]].d <= S[i].a) {
res = mid;
low = mid + 1;
} else
high = mid - 1;
}
if (res != -1) prof = max(prof, (ll)(B[base_at[v][res]].g - S[i].p));
}
p[i] = prof;
}
ll res = 0;
for (int i = (1); i <= (s); i++) cc[root(i)].push_back(i);
for (int i = (1); i <= (s); i++)
if (i == root(i)) res += get_profit(i);
writeln(res);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Dinic {
const int N = 100005;
const long long int INF = 1000LL * 1000 * 1000 * 1000 * 1000 * 1000;
struct edge {
int a, b;
long long int cap, flow;
};
int n, s, t, d[N], ptr[N], q[N];
vector<edge> e;
vector<int> g[N];
int add_edge(int a, int b, long long int cap) {
edge e1 = {a, b, cap, 0};
edge e2 = {b, a, cap, cap};
g[a].push_back(e.size());
e.push_back(e1);
g[b].push_back(e.size());
e.push_back(e2);
return e.size() - 2;
}
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
memset(d + 1, -1, n * sizeof d[0]);
d[s] = 0;
while (qh < qt && d[t] == -1) {
int v = q[qh++];
for (int i = 0; i < (int)g[v].size(); ++i) {
int id = g[v][i], to = e[id].b;
if (d[to] == -1 && e[id].flow < e[id].cap) {
q[qt++] = to;
d[to] = d[v] + 1;
}
}
}
return d[t] != -1;
}
long long int dfs(int v, long long int flow) {
if (!flow) return 0;
if (v == t) return flow;
long long int res = 0;
for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {
int id = g[v][ptr[v]], to = e[id].b;
if (d[to] != d[v] + 1) continue;
long long int pushed = dfs(to, min(flow, e[id].cap - e[id].flow));
e[id].flow += pushed;
e[id ^ 1].flow -= pushed;
res += pushed;
flow -= pushed;
if (flow == 0) break;
}
return res;
}
long long int dinic(int _n, int _s, int _t) {
n = _n;
s = _s;
t = _t;
long long int flow = 0;
for (;;) {
if (!bfs()) break;
memset(ptr, 0, n * sizeof ptr[0]);
flow += dfs(s, INF);
}
return flow;
}
} // namespace Dinic
const int N = 107;
const int NN = 100007;
const int MAXI = 1e6;
const int INF = 1e9 + 7;
int n, m;
int dist[N][N];
int s, b, k;
int pl2[NN], def[NN], gold[NN];
int pl1[NN], att[NN], fuel[NN], price[NN], profit[NN];
vector<int> A[N], B[N];
bool cmp(int a, int b) {
if (att[a] == att[b]) return a < b;
return att[a] < att[b];
}
bool cmp2(int a, int b) {
if (def[a] == def[b]) return a < b;
return def[a] < def[b];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dist[i][j] = i == j ? 0 : INF;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
if (u == v) continue;
dist[u][v] = dist[v][u] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
scanf("%d %d %d", &s, &b, &k);
for (int i = 1; i <= s; ++i) {
scanf("%d %d %d %d", &pl1[i], &att[i], &fuel[i], &price[i]);
A[pl1[i]].push_back(i);
}
for (int i = 1; i <= b; ++i) {
scanf("%d %d %d", &pl2[i], &def[i], &gold[i]);
B[pl2[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) {
sort(A[i].begin(), A[i].end(), cmp);
sort(B[i].begin(), B[i].end(), cmp2);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j < (int)B[i].size(); ++j)
gold[B[i][j]] = max(gold[B[i][j]], gold[B[i][j - 1]]);
for (int i = 1; i <= n; ++i) {
if (A[i].size() == 0) continue;
for (auto t : A[i]) profit[t] = -INF;
for (int j = 1; j <= n; ++j) {
if (B[j].size() == 0) continue;
int wsk = -1;
for (int t : A[i]) {
while (wsk + 1 < (int)B[j].size() && def[B[j][wsk + 1]] <= att[t])
++wsk;
if (wsk > -1 && fuel[t] >= dist[i][j])
profit[t] = max(profit[t], gold[B[j][wsk]] - price[t]);
}
}
}
for (int i = 1; i <= s; ++i) {
long long int weight = 1LL * MAXI * profit[i];
if (profit[i] == -INF) weight = -Dinic::INF;
if (weight == 0) weight = 1;
if (weight > 0)
Dinic::add_edge(1, i + 1, weight);
else
Dinic::add_edge(i + 1, s + 2, -weight);
}
for (int i = 1; i <= k; ++i) {
int u, v;
scanf("%d %d", &u, &v);
Dinic::add_edge(u + 1, v + 1, Dinic::INF);
}
long long int ans = 0LL;
for (int i = 1; i <= s; ++i)
if (profit[i] > 0) ans += profit[i];
ans -= Dinic::dinic(s + 2, 1, s + 2) / MAXI;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, dis[105][105], bit[105][maxn], s, b, c[maxn][4], d[maxn][3],
s1[1123], s2[1123], best[maxn], S, T, cnt;
bool used[maxn];
map<int, int> mp;
vector<int> def;
inline int ID(int x) {
return upper_bound(def.begin(), def.end(), x) - def.begin();
}
inline int get(int x) {
if (mp.find(x) == mp.end()) mp[x] = ++cnt;
return mp[x];
}
inline void update(int x, int val, int *bit) {
while (x <= m) {
bit[x] = max(bit[x], val);
x += x & -x;
}
}
inline int query(int x, int *bit) {
int ret = -inf;
while (x) {
ret = max(ret, bit[x]);
x -= x & -x;
}
return ret;
}
struct edge {
int to;
long long cap;
int rev;
edge() {}
edge(int to, long long cap, int rev) : to(to), cap(cap), rev(rev) {}
};
vector<edge> G[2123];
int level[2123], iter[2123];
inline void addedge(int from, int to, long long cap) {
G[from].push_back(edge(to, cap, G[to].size()));
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
inline void bfs(int s) {
memset(level, -1, sizeof level);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < (int)G[v].size(); ++i) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
long long dfs(int v, int t, long long f) {
if (v == t) return f;
for (int &i = iter[v]; i < (int)G[v].size(); ++i) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
long long d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
inline long long max_flow(int s, int t) {
long long flow = 0;
while (1) {
bfs(s);
if (level[t] < 0) return flow;
memset(iter, 0, sizeof iter);
int f;
while ((f = dfs(s, t, INF)) > 0) flow += f;
}
}
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof dis);
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
scanf("%d%d%d", &s, &b, &k);
for (int i = 1; i <= s; ++i)
for (int j = 0; j < 4; ++j) scanf("%d", &c[i][j]);
for (int i = 1; i <= b; ++i)
for (int j = 0; j < 3; ++j) scanf("%d", &d[i][j]), def.push_back(d[i][1]);
for (int i = 1; i <= k; ++i)
scanf("%d%d", &s1[i], &s2[i]), used[s1[i]] = used[s2[i]] = true;
sort(def.begin(), def.end());
def.erase(unique(def.begin(), def.end()), def.end());
m = def.size();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) bit[i][j] = -inf;
for (int i = 1; i <= b; ++i) update(ID(d[i][1]), d[i][2], bit[d[i][0]]);
for (int i = 1; i <= s; ++i) {
best[i] = -inf;
for (int j = 1; j <= n; ++j)
if (dis[c[i][0]][j] <= c[i][2])
best[i] = max(best[i], query(ID(c[i][1]), bit[j]));
}
for (int i = 1; i <= s; ++i)
if (best[i] != -inf) best[i] -= c[i][3];
long long res = 0;
S = 0, T = 2001;
for (int i = 1; i <= s; ++i)
if (!used[i])
res += max(0, best[i]);
else {
if (best[i] >= 0)
addedge(S, get(i), best[i]), res += best[i];
else if (best[i] == -inf)
addedge(get(i), T, INF);
else
addedge(get(i), T, -best[i]);
}
for (int i = 1; i <= k; ++i) addedge(get(s1[i]), get(s2[i]), INF);
res -= max_flow(S, T);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int INF = 1e9 + 5;
const long long INF_LL = 1e15 + 5;
int g[N][N], dist[N][N];
struct Ship {
int loc, attack, fuel, price;
void read() {
cin >> loc >> attack >> fuel >> price;
--loc;
}
};
vector<pair<int, int>> reward[N];
struct Base {
int loc, defence, gold;
void read() {
cin >> loc >> defence >> gold;
--loc;
reward[loc].emplace_back(defence, gold);
}
};
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
template <typename flow_t>
class Dinic {
public:
Dinic(int _n, int _source, int _sink) : n(_n), source(_source), sink(_sink) {
g.resize(n);
flow.resize(n, vector<flow_t>(n));
level.resize(n);
ptr.resize(n);
}
void add_edge(int from, int to, flow_t cap) {
g[from].push_back(to);
g[to].push_back(from);
flow[from][to] += cap;
}
bool bfs() {
vector<int> q{source};
for (int i = 0; i < (int)q.size(); i++) {
int u = q[i];
for (int v : g[u]) {
if (level[v] == -1 && flow[u][v] > 0) {
level[v] = level[u] + 1;
q.push_back(v);
}
}
}
return level[sink] != -1;
}
flow_t dfs(int u, flow_t pushed) {
if (pushed == 0) {
return 0;
}
if (u == sink) {
return pushed;
}
for (int& pos = ptr[u]; pos < (int)g[u].size(); pos++) {
int v = g[u][pos];
if (level[v] != level[u] + 1 || flow[u][v] == 0) {
continue;
}
flow_t maybe_push = dfs(v, min(pushed, flow[u][v]));
if (maybe_push == 0) {
continue;
}
flow[u][v] -= maybe_push;
flow[v][u] += maybe_push;
return maybe_push;
}
return 0;
}
flow_t max_flow() {
flow_t mf(0);
while (true) {
level.assign(n, -1);
level[source] = 0;
if (!bfs()) {
break;
}
ptr.assign(n, 0);
flow_t now;
do {
now = dfs(source, FLOW_MAX);
mf += now;
} while (now != 0);
}
return mf;
}
private:
const flow_t FLOW_MAX = numeric_limits<flow_t>::max() / 2;
vector<vector<int>> g;
vector<vector<flow_t>> flow;
vector<int> level, ptr;
int n, source, sink;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fill((int*)dist, (int*)dist + N * N, INF);
for (int i = 0; i < int(N); i++) dist[i][i] = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < int(m); i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a][b] = g[b][a] = 1;
dist[a][b] = dist[b][a] = 1;
}
for (int k = 0; k < int(n); k++)
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(n); j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int second, B, K;
cin >> second >> B >> K;
vector<Ship> ships(second);
vector<Base> bases(B);
for (auto& s : ships) {
s.read();
}
for (auto& b : bases) {
b.read();
}
for (int i = 0; i < int(n); i++) {
sort(reward[i].begin(), reward[i].end());
int sz = reward[i].size();
for (int j = 1; j <= int(sz - 1); j++) {
reward[i][j].second = max(reward[i][j].second, reward[i][j - 1].second);
}
}
vector<long long> ship_reward(second, -INF_LL);
for (int i = 0; i < int(second); i++) {
Ship s = ships[i];
for (int base = 0; base < int(n); base++)
if (dist[s.loc][base] < INF) {
int lo = 0, hi = (int)reward[base].size() - 1;
int idx = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (reward[base][mid].first <= s.attack) {
idx = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
if (idx == -1) {
continue;
}
max_self(ship_reward[i], (long long)reward[base][idx].second - s.price);
}
}
vector<pair<int, int>> dependencies;
for (int i = 0; i < int(K); i++) {
int a, b;
cin >> a >> b;
--a, --b;
dependencies.emplace_back(a, b);
}
long long ans = 0;
for (int i = 0; i < int(second); i++) {
if (ship_reward[i] > 0) {
ans += ship_reward[i];
}
}
map<int, int> id;
int nodes = 0;
for (auto [u, v] : dependencies) {
if (!id.count(u)) {
id[u] = nodes++;
}
if (!id.count(v)) {
id[v] = nodes++;
}
}
int source = nodes++;
int sink = nodes++;
Dinic<long long> graph(nodes, source, sink);
for (auto [u, _] : id) {
if (ship_reward[u] >= 0) {
graph.add_edge(source, id[u], ship_reward[u]);
} else {
graph.add_edge(id[u], sink, -ship_reward[u]);
}
}
for (auto [u, v] : dependencies) {
graph.add_edge(id[u], id[v], INF_LL);
}
ans -= graph.max_flow();
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000ll;
vector<pair<int, int> > v[110];
struct spaceship {
int x, a, f;
long long p;
} s[100010];
int n, m, p[110], f[110][110], x, y, id[100010], d, g, S, B, K, D[100010],
e[100010][2];
bool cmp(const int &a, const int &b) { return s[a].a < s[b].a; }
namespace MaxFlow {
struct node {
int to, next;
long long c;
} e[100010];
int hd[10010], cnt, n, cur[10010], dis[10010], q[10010], l, r, x;
void addedge(int x, int y, long long c) {
e[++cnt] = (node){y, hd[x], c}, hd[x] = cnt;
e[++cnt] = (node){x, hd[y], 0}, hd[y] = cnt;
}
bool bfs() {
for (int i = 1; i <= n; i++) dis[i] = 0;
dis[1] = 1, q[l = r = 1] = 1;
while (l <= r) {
x = q[l++];
for (int i = hd[x]; i; i = e[i].next)
if (e[i].c > 0 && !dis[e[i].to])
dis[e[i].to] = dis[x] + 1, q[++r] = e[i].to;
}
return (dis[n] > 0);
}
long long dinic(int x, long long f) {
if (x == n) return f;
for (int &i = cur[x]; i; i = e[i].next)
if (e[i].c > 0 && dis[e[i].to] == dis[x] + 1) {
long long nw = dinic(e[i].to, min(f, e[i].c));
if (nw > 0) return e[i].c -= nw, e[i ^ 1].c += nw, nw;
}
return 0;
}
long long solve() {
long long ans = 0, nw;
while (bfs()) {
for (int i = 1; i <= n; i++) cur[i] = hd[i];
while (nw = dinic(1, inf)) ans += nw;
}
return ans;
}
} // namespace MaxFlow
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = 100000;
for (int i = 1; i <= m; i++) scanf("%d%d", &x, &y), f[x][y] = f[y][x] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
scanf("%d%d%d", &S, &B, &K);
for (int i = 1; i <= S; i++)
id[i] = i, scanf("%d%d%d%d", &s[i].x, &s[i].a, &s[i].f, &s[i].p);
sort(id + 1, id + 1 + S, cmp);
for (int i = 1; i <= B; i++)
scanf("%d%d%d", &x, &d, &g), v[x].push_back(make_pair(d, g));
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end()), p[i] = 0;
for (int j = 1, sz = v[i].size(); j < sz; j++)
v[i][j].second = max(v[i][j].second, v[i][j - 1].second);
}
long long ans = 0;
for (int I = 1; I <= S; I++) {
int i = id[I];
long long ma = -inf;
for (int j = 1; j <= n; j++)
if (f[s[i].x][j] <= s[i].f) {
int sz = v[j].size();
if (!sz) continue;
while (p[j] < sz - 1 && v[j][p[j] + 1].first <= s[i].a) p[j]++;
if (v[j][p[j]].first <= s[i].a)
ma = max(ma, (long long)v[j][p[j]].second);
}
s[i].p = ma - s[i].p;
if (s[i].p > 0) ans += s[i].p;
}
MaxFlow::n = 2, MaxFlow::cnt = 1;
for (int i = 1; i <= K; i++)
scanf("%d%d", &e[i][0], &e[i][1]), D[e[i][0]]++, D[e[i][1]]++;
for (int i = 1; i <= S; i++)
if (D[i]) id[i] = (MaxFlow::n++);
for (int i = 1; i <= K; i++) MaxFlow::addedge(id[e[i][0]], id[e[i][1]], inf);
for (int i = 1; i <= S; i++)
if (D[i]) {
if (s[i].p > 0)
MaxFlow::addedge(1, id[i], s[i].p);
else
MaxFlow::addedge(id[i], MaxFlow::n, -s[i].p);
}
ans -= MaxFlow::solve();
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 3e6 + 10;
const long long INF = 1e15 + 10;
const int mod = 998244353;
const long double eps = 1e-8;
long long read() {
long long n = 0;
char a = getchar();
bool flag = 0;
while (a > '9' || a < '0') {
if (a == '-') flag = 1;
a = getchar();
}
while (a <= '9' && a >= '0') {
n = n * 10 + a - '0', a = getchar();
}
if (flag) n = -n;
return n;
}
struct edge {
int f, t;
long long d;
} l[SZ];
int head[SZ], nxt[SZ], tot = 1;
void build(int f, int t, long long d) {
l[++tot] = (edge){f, t, d};
nxt[tot] = head[f];
head[f] = tot;
}
void insert(int f, int t, long long d) {
build(f, t, d);
build(t, f, 0);
}
int deep[SZ];
bool bfs(int s, int e) {
for (int i = 1; i <= e; i++) deep[i] = 0;
queue<int> q;
q.push(s);
deep[s] = 1;
while (q.size()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = nxt[i]) {
int v = l[i].t;
if (l[i].d && !deep[v]) {
deep[v] = deep[u] + 1;
if (v == e) return true;
q.push(v);
}
}
}
return false;
}
long long dfs(int u, long long flow, int e) {
if (u == e || flow == 0) return flow;
long long ans = flow;
for (int i = head[u]; i; i = nxt[i]) {
int v = l[i].t;
if (l[i].d && deep[v] == deep[u] + 1) {
long long f = dfs(v, min(ans, l[i].d), e);
if (f > 0) {
l[i].d -= f;
l[i ^ 1].d += f;
ans -= f;
if (ans == 0) break;
} else
deep[v] = 0;
}
}
if (ans == flow) deep[u] = 0;
return flow - ans;
}
long long dinic(int s, int e) {
long long ans = 0;
while (bfs(s, e)) {
long long tmp = dfs(s, INF, e);
if (tmp == 0) break;
ans += tmp;
}
return ans;
}
int f[110][110];
struct hhhh {
int x, a, f, p;
} a[SZ];
vector<pair<int, int> > base[SZ];
long long val[SZ];
int id[SZ], ff[SZ], tt[SZ], mark[SZ];
int main() {
int n = read(), m = read();
memset(f, 63, sizeof f);
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
f[x][y] = f[y][x] = 1;
}
for (int k = 1; k <= n; k++) f[k][k] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
int S = read(), B = read(), K = read();
for (int i = 1; i <= S; i++) {
a[i].x = read(), a[i].a = read(), a[i].f = read(), a[i].p = read();
}
for (int i = 1; i <= B; i++) {
int x = read(), d = read(), g = read();
base[x].push_back(make_pair(d, g));
}
for (int i = 1; i <= n; i++) {
sort(base[i].begin(), base[i].end());
int maxg = -1;
for (int j = 0; j < base[i].size(); j++) {
maxg = max(maxg, base[i][j].second);
base[i][j].second = maxg;
}
}
for (int i = 1; i <= S; i++) {
int u = a[i].x;
long long maxg = -INF;
for (int v = 1; v <= n; v++) {
if (f[u][v] <= a[i].f) {
auto it = upper_bound(base[v].begin(), base[v].end(),
make_pair(a[i].a, (int)(1e9 + 1)));
if (it == base[v].begin()) continue;
it--;
maxg = max(maxg, 1ll * it->second);
}
}
if (maxg == -INF)
val[i] = -1e14;
else
val[i] = maxg - a[i].p;
}
for (int i = 1; i <= K; i++) {
ff[i] = read(), tt[i] = read();
mark[ff[i]] = 1;
mark[tt[i]] = 1;
}
long long ans = 0;
for (int i = 1; i <= S; i++)
if (!mark[i]) ans += max(val[i], 0ll);
int tot = 0;
for (int i = 1; i <= S; i++)
if (mark[i]) {
id[i] = ++tot;
}
int s = tot + 1, e = s + 1;
long long sum = 0;
for (int i = 1; i <= S; i++) {
if (!mark[i]) continue;
if (val[i] > 0) {
sum += val[i];
insert(s, id[i], val[i]);
} else {
insert(id[i], e, -val[i]);
}
}
for (int i = 1; i <= K; i++) {
int x = id[ff[i]], y = id[tt[i]];
insert(x, y, INF);
}
cout << ans + sum - dinic(s, e);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
const int maxs = 1e5 + 5;
vector<int> gr[maxs], rg[maxs], sg[maxs];
int x[maxs], a[maxs], f[maxs], p[maxs];
int y[maxs], d[maxs], g[maxs];
int w[maxn][maxn], mg[maxn];
int topo[maxs], scc[maxs], uf[maxs];
long long pf[maxs], sum[maxs], ans[maxs];
long long opt[maxs];
bool ok[maxs], used[maxs];
bool sok[maxs];
void build(int n, int s, int b) {
vector<int> vs(s), vb(b);
iota(vs.begin(), vs.end(), 0);
iota(vb.begin(), vb.end(), 0);
sort(vs.begin(), vs.end(), [&](int i, int j) { return a[i] < a[j]; });
sort(vb.begin(), vb.end(), [&](int i, int j) { return d[i] < d[j]; });
for (int i = 0; i < n; ++i) mg[i] = -1;
for (int i = 0, j = 0; i < s; ++i) {
while (j < b && d[vb[j]] <= a[vs[i]]) {
mg[y[vb[j]]] = max(mg[y[vb[j]]], g[vb[j]]);
++j;
}
int res = -1;
for (int k = 0; k < n; ++k) {
if (w[x[vs[i]]][k] <= f[vs[i]]) res = max(res, mg[k]);
}
if (res == -1)
ok[vs[i]] = false;
else
ok[vs[i]] = true, pf[vs[i]] = res - p[vs[i]];
}
}
void dfs(int x) {
static int sz = 0;
used[x] = true;
for (int i = 0; i < (int)gr[x].size(); ++i) {
int u = gr[x][i];
if (!used[u]) dfs(u);
}
topo[sz++] = x;
}
void rdfs(int x, int s) {
scc[x] = s;
for (int i = 0; i < (int)rg[x].size(); ++i) {
int u = rg[x][i];
if (scc[u] == -1) rdfs(u, s);
}
}
int find(int x) {
if (x == uf[x]) return x;
return uf[x] = find(uf[x]);
}
void merge(int x, int y) { uf[find(x)] = find(y); }
vector<int> walk;
void dfs3(int x) {
walk.push_back(x);
used[x] = true;
for (int i = 0; i < (int)sg[x].size(); ++i) {
int u = sg[x][i];
if (used[u]) continue;
dfs3(u);
}
}
struct dinic {
static const int maxn = maxs;
static const long long inf = 1e18;
struct edge {
int dest, rev;
long long cap;
edge(int d, long long c, int r) : dest(d), cap(c), rev(r) {}
};
vector<edge> g[maxn];
int qu[maxn], ql, qr;
int lev[maxn];
void init() {
for (int i = 0; i < maxn; ++i) g[i].clear();
}
void add_edge(int a, int b, long long c) {
g[a].emplace_back(b, c, g[b].size() - 0);
g[b].emplace_back(a, 0, g[a].size() - 1);
}
bool bfs(int s, int t) {
memset(lev, -1, sizeof(lev));
lev[s] = 0;
ql = qr = 0;
qu[qr++] = s;
while (ql < qr) {
int x = qu[ql++];
for (edge &e : g[x])
if (lev[e.dest] == -1 && e.cap > 0) {
lev[e.dest] = lev[x] + 1;
qu[qr++] = e.dest;
}
}
return lev[t] != -1;
}
long long dfs(int x, int t, long long flow) {
if (x == t) return flow;
long long res = 0;
for (edge &e : g[x])
if (e.cap > 0 && lev[e.dest] == lev[x] + 1) {
long long f = dfs(e.dest, t, min(e.cap, flow - res));
res += f;
e.cap -= f;
g[e.dest][e.rev].cap += f;
}
if (res == 0) lev[x] = -1;
return res;
}
long long operator()(int s, int t) {
long long flow = 0;
for (; bfs(s, t); flow += dfs(s, t, inf))
;
return flow;
}
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) w[i][j] = i == j ? 0 : 1e8;
}
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
if (u == v) continue;
w[u][v] = w[v][u] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) w[i][j] = min(w[i][j], w[i][k] + w[k][j]);
}
}
int s, b, k;
scanf("%d%d%d", &s, &b, &k);
for (int i = 0; i < s; ++i) {
scanf("%d%d%d%d", &x[i], &a[i], &f[i], &p[i]);
--x[i];
}
for (int i = 0; i < b; ++i) {
scanf("%d%d%d", &y[i], &d[i], &g[i]);
--y[i];
}
build(n, s, b);
dinic flow;
long long sum = 0;
for (int i = 0; i < s; ++i) {
if (!ok[i]) {
flow.add_edge(i, s + 1, 2e14);
continue;
}
if (pf[i] >= 0) {
sum += pf[i];
flow.add_edge(s, i, pf[i]);
} else {
flow.add_edge(i, s + 1, -pf[i]);
}
}
while (k--) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
flow.add_edge(u, v, 2e14);
}
printf("%lld\n", sum - flow(s, s + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Dinic {
static const int MAXN = 100005, MAXM = 1000005;
struct Edge {
int to, next;
T cap;
} edge[MAXM];
int head[MAXN], tot;
void clear() {
memset(head, -1, sizeof(head));
tot = 0;
}
Dinic() { clear(); }
void add(int u, int v, T c) {
edge[tot] = (Edge){v, head[u], c};
head[u] = tot++;
edge[tot] = (Edge){u, head[v], (T)0};
head[v] = tot++;
}
int dis[MAXN], que[MAXN], id[MAXN];
bool bfs(int s, int t) {
memset(dis, -1, sizeof(dis));
memcpy(id, head, sizeof(id));
int he = 0, ta = 0;
dis[que[ta++] = s] = 0;
while (he < ta) {
int u = que[he++];
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] < 0 && edge[i].cap) {
dis[que[ta++] = v] = dis[u] + 1;
if (v == t) return true;
}
}
}
return false;
}
T dfs(int u, int t, T f) {
if (u == t) return f;
T flow = 0;
for (int &i = id[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] > dis[u] && edge[i].cap) {
int d = dfs(v, t, min(f, edge[i].cap));
if (!d) continue;
edge[i].cap -= d, edge[i ^ 1].cap += d;
flow += d, f -= d;
if (f == 0) return flow;
}
}
dis[u] = -1;
return flow;
}
T dinic(int s, int t, T inf = 1E9) {
T flow = 0;
while (bfs(s, t)) flow += dfs(s, t, inf);
return flow;
}
};
const long long INF = 1E15;
Dinic<long long> din;
const int MAXN = 100005;
int dis[105][105], xx[MAXN], aa[MAXN], ff[MAXN], pp[MAXN], qq[MAXN], vis[MAXN],
n, m;
struct Node {
int d, g;
} sh[MAXN];
vector<Node> nd[105];
bool cmp(const Node &a, const Node &b) { return a.d < b.d; }
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
dis[j][k] = min(dis[i][j] + dis[i][k], dis[j][k]);
int S, B, K;
scanf("%d%d%d", &S, &B, &K);
for (int i = 1; i <= S; i++) {
scanf("%d%d%d%d", xx + i, aa + i, ff + i, pp + i);
sh[i] = (Node){aa[i], i};
}
sort(sh + 1, sh + 1 + S, cmp);
for (int i = 1; i <= B; i++) {
int x, d, g;
scanf("%d%d%d", &x, &d, &g);
nd[x].push_back((Node){d, g});
}
for (int i = 1; i <= n; i++) {
sort(nd[i].begin(), nd[i].end(), cmp);
int mx = 0;
for (Node &d : nd[i]) {
mx = max(mx, d.g);
d.g = mx;
}
}
fill(qq + 1, qq + 1 + S, -1E9 - 555);
for (int i = 1; i <= n; i++) {
int s = nd[i].size();
for (int j = 1, k = 0; j <= S; j++) {
for (; k < s && nd[i][k].d <= sh[j].d; ++k)
;
if (k > 0 && dis[i][xx[sh[j].g]] <= ff[sh[j].g])
qq[sh[j].g] = max(qq[sh[j].g], nd[i][k - 1].g);
}
}
for (int i = 1; i <= S; i++) pp[i] = qq[i] - pp[i];
for (int i = 1; i <= K; i++) {
int u, v;
scanf("%d%d", &u, &v);
din.add(u, v, INF);
vis[u] = vis[v] = 1;
}
long long ans = 0;
int s = S + 1, t = s + 1;
for (int i = 1; i <= S; i++)
if (!vis[i] && pp[i] > 0) ans += pp[i];
for (int i = 1; i <= S; i++)
if (vis[i]) {
if (pp[i] > 0)
din.add(s, i, pp[i]), ans += pp[i];
else
din.add(i, t, -pp[i]);
}
printf("%lld\n", ans - din.dinic(s, t, INF));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[110][110], INF = 1e18;
long long v[100010];
vector<pair<long long, long long>> base[110];
vector<long long> bst[110];
struct Dinic {
int nodes, src, dst;
vector<int> dist, q, work;
struct edge {
int to, rev;
long long f, cap;
};
vector<vector<edge>> g;
Dinic(int x) : nodes(x), g(x), dist(x), q(x), work(x) {}
void add_edge(int s, int t, long long cap) {
g[s].push_back((edge){t, int(g[t].size()), 0, cap});
g[t].push_back((edge){s, int(g[s].size()) - 1, 0, 0});
}
bool dinic_bfs() {
fill(dist.begin(), dist.end(), -1);
dist[src] = 0;
int qt = 0;
q[qt++] = src;
for (int qh = 0; qh < qt; qh++) {
int u = q[qh];
for (int i = 0, ThxDem = int(g[u].size()); i < ThxDem; ++i) {
edge& e = g[u][i];
int v = g[u][i].to;
if (dist[v] < 0 && e.f < e.cap) dist[v] = dist[u] + 1, q[qt++] = v;
}
}
return dist[dst] >= 0;
}
long long dinic_dfs(int u, long long f) {
if (u == dst) return f;
for (int& i = work[u]; i < int(g[u].size()); i++) {
edge& e = g[u][i];
if (e.cap <= e.f) continue;
int v = e.to;
if (dist[v] == dist[u] + 1) {
long long df = dinic_dfs(v, min(f, e.cap - e.f));
if (df > 0) {
e.f += df;
g[v][e.rev].f -= df;
return df;
}
}
}
return 0;
}
long long max_flow(int _src, int _dst) {
src = _src;
dst = _dst;
long long result = 0;
while (dinic_bfs()) {
fill(work.begin(), work.end(), 0);
while (long long delta = dinic_dfs(src, INF)) result += delta;
}
return result;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = n; j < ThxDem; ++j) d[i][j] = INF * (i != j);
for (int i = 0, ThxDem = m; i < ThxDem; ++i) {
int x, y;
cin >> x >> y;
d[x - 1][y - 1] = d[y - 1][x - 1] = 1;
}
for (int k = 0, ThxDem = n; k < ThxDem; ++k)
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = n; j < ThxDem; ++j) {
if (d[i][k] != INF && d[k][j] != INF)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
long long ans = 0, s, b, k;
cin >> s >> b >> k;
for (int i = 0, ThxDem = s; i < ThxDem; ++i) v[i] = -INF;
vector<pair<pair<long long, long long>, pair<long long, long long>>> a(s);
for (int i = 0, ThxDem = s; i < ThxDem; ++i)
cin >> a[i].first.first >> a[i].first.second >> a[i].second.first >>
a[i].second.second,
a[i].first.first--;
for (int i = 0, ThxDem = b; i < ThxDem; ++i) {
long long x, di, g;
cin >> x >> di >> g;
x--;
base[x].push_back({di, g});
}
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
sort(base[i].begin(), base[i].end());
bst[i].resize(int(base[i].size()));
for (int j = 0, ThxDem = int(base[i].size()); j < ThxDem; ++j) {
bst[i][j] = base[i][j].second;
if (j) bst[i][j] = max(bst[i][j], bst[i][j - 1]);
}
}
Dinic nt(s + 2);
for (int i = 0, ThxDem = int(a.size()); i < ThxDem; ++i) {
for (int j = 0, ThxDem = n; j < ThxDem; ++j) {
int top =
upper_bound(base[j].begin(), base[j].end(),
(pair<long long, long long>){a[i].first.second, INF}) -
base[j].begin() - 1;
if (d[a[i].first.first][j] <= a[i].second.first && top >= 0) {
v[i] = max(v[i], bst[j][top] - a[i].second.second);
}
}
if (v[i] < 0)
nt.add_edge(i + 1, s + 1, -v[i]);
else
ans += v[i], nt.add_edge(0, i + 1, v[i]);
}
for (int i = 0, ThxDem = k; i < ThxDem; ++i) {
int x, y;
cin >> x >> y;
nt.add_edge(x, y, INF);
}
cout << ans - nt.max_flow(0, s + 1) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int Head[2000010], Next[2000010], Go[2000010], Cnt = 0;
struct flow {
int Head[250010], Next[2000010], Go[2000010], Cnt;
long long Val[2000010], Fl[250010];
int Am[250010], H[250010], Pr[250010], Nw[250010];
flow() { Cnt = 1, memset(Head, 0, sizeof Head); }
void addedge(int a, int b, long long c) {
Go[++Cnt] = b;
Next[Cnt] = Head[a];
Head[a] = Cnt;
Val[Cnt] = c;
}
long long getflow(int S, int TT, int tot) {
int first = S;
long long f = 1e18;
Am[0] = tot;
long long ans = 0;
while (H[first] <= tot) {
if (!Nw[first]) Nw[first] = Head[first];
int flag = 0;
for (int &T = Nw[first]; T; T = Next[T])
if (Val[T] && H[Go[T]] == H[first] - 1) {
flag = 1, Pr[Go[T]] = T ^ 1;
Fl[first] = f, f = min(f, Val[T]);
first = Go[T];
if (first == TT) {
ans += f;
while (first != S)
Val[Pr[first]] += f, Val[Pr[first] ^ 1] -= f,
first = Go[Pr[first]];
f = 1e18;
}
break;
}
if (!flag) {
int mn = tot;
for (int T = Head[first]; T; T = Next[T])
if (Val[T] && H[Go[T]] < mn) mn = H[Go[T]], Nw[first] = T;
if (!--Am[H[first]]) break;
Am[H[first] = mn + 1]++;
if (first != S) {
first = Go[Pr[first]];
f = Fl[first];
}
}
}
return ans;
}
} qwq;
int n, m, Dis[105][105], XA[250010], AA[250010], FA[250010], PA[250010],
XB[250010], DB[250010], GB[250010];
long long Ans[100010];
vector<pair<long long, long long> > V[105];
int main() {
scanf("%d%d", &n, &m);
memset(Dis, 63, sizeof Dis);
for (int i = 1; i <= n; i++) Dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
Dis[a][b] = 1, Dis[b][a] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
Dis[j][k] = min(Dis[j][k], Dis[j][i] + Dis[i][k]);
int s, b, k;
scanf("%d%d%d", &s, &b, &k);
for (int i = 1; i <= s; i++)
scanf("%d%d%d%d", &XA[i], &AA[i], &FA[i], &PA[i]);
for (int i = 1; i <= n; i++)
V[i].push_back(pair<long long, long long>(-1e18, -1e18));
for (int i = 1; i <= b; i++) {
int first, d, g;
scanf("%d%d%d", &first, &d, &g);
V[first].push_back(pair<long long, long long>(d, g));
}
for (int i = 1; i <= n; i++) {
sort(V[i].begin(), V[i].end());
for (int j = 1; j < V[i].size(); j++)
V[i][j].second = max(V[i][j].second, V[i][j - 1].second);
}
for (int i = 1; i <= s; i++) {
long long ans = -1e18;
for (int j = 1; j <= n; j++)
if (Dis[XA[i]][j] <= FA[i])
ans =
max(ans,
V[j][lower_bound(V[j].begin(), V[j].end(),
pair<long long, long long>(AA[i] + 1, -1e18)) -
V[j].begin() - 1]
.second);
Ans[i] = ans - PA[i];
}
while (k--) {
int s1, s2;
scanf("%d%d", &s1, &s2);
qwq.addedge(s1, s2, 1e18);
qwq.addedge(s2, s1, 0);
}
long long ans = 0;
for (int i = 1; i <= s; i++)
if (Ans[i] > 0)
ans += Ans[i], qwq.addedge(s + 1, i, Ans[i]), qwq.addedge(i, s + 1, 0);
else
qwq.addedge(i, s + 2, -Ans[i]), qwq.addedge(s + 2, i, 0);
printf("%lld\n", ans - qwq.getflow(s + 1, s + 2, s + 2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
class flow {
private:
int n;
vector<int> head, d, cur;
vector<tuple<int, ll, int>> edge;
bool bfs(int s, int t) {
d.assign(n, -1);
queue<int> que;
que.push(s);
d[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = head[u]; i != -1; i = get<2>(edge[i])) {
int v = get<0>(edge[i]);
if (get<1>(edge[i]) && d[v] == -1) {
d[v] = d[u] + 1;
if (v == t) {
return true;
}
que.push(v);
}
}
}
return false;
}
ll dfs(int u, int t, ll f) {
if (u == t) {
return f;
}
ll res = f;
for (int &i = cur[u]; i != -1 && res; i = get<2>(edge[i])) {
int v = get<0>(edge[i]);
ll &c = get<1>(edge[i]);
if (d[v] == d[u] + 1 && c) {
ll aug = dfs(v, t, min(res, c));
res -= aug;
c -= aug;
get<1>(edge[i ^ 1]) += aug;
}
}
return f - res;
}
public:
flow(int _n) {
n = _n;
head.assign(n, -1);
}
void insert_edge(int u, int v, ll c) {
edge.emplace_back(v, c, head[u]);
head[u] = edge.size() - 1;
edge.emplace_back(u, 0, head[v]);
head[v] = edge.size() - 1;
}
ll max_flow(int s, int t) {
ll flow = 0;
while (bfs(s, t)) {
cur = head;
flow += dfs(s, t, 1e18);
}
return flow;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> dis(n, vector<int>(n, 1e9));
for (int i = 0; i < n; ++i) {
dis[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
dis[u][v] = 1;
dis[v][u] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ship;
vector<vector<pair<int, int>>> base(n);
for (int i = 0; i < s; ++i) {
int x, a, f, p;
cin >> x >> a >> f >> p;
--x;
ship.emplace_back(x, a, f, p);
}
for (int i = 0; i < b; ++i) {
int x, d, g;
cin >> x >> d >> g;
--x;
base[x].emplace_back(d, g);
}
for (int i = 0; i < n; ++i) {
sort(base[i].begin(), base[i].end());
for (int j = 1; j < base[i].size(); ++j) {
base[i][j].second = max(base[i][j].second, base[i][j - 1].second);
}
}
vector<ll> gain(s);
for (int i = 0; i < s; ++i) {
int x = get<0>(ship[i]);
int a = get<1>(ship[i]);
int f = get<2>(ship[i]);
int p = get<3>(ship[i]);
gain[i] = -1e14;
for (int j = 0; j < n; ++j) {
if (dis[x][j] <= f && !base[j].empty() && a >= base[j][0].first) {
gain[i] =
max(gain[i], 1ll * (--upper_bound(base[j].begin(), base[j].end(),
make_pair(a, (int)1e9)))
->second -
p);
}
}
}
vector<bool> used(s);
vector<pair<int, int>> rel;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
used[x] = true;
used[y] = true;
rel.emplace_back(x, y);
}
int cnt = 0;
ll ans = 0;
vector<int> id(s, -1);
for (int i = 0; i < s; ++i) {
if (used[i]) {
id[i] = cnt++;
} else if (gain[i] > 0) {
ans += gain[i];
}
}
flow G(cnt + 2);
int S = cnt;
int T = cnt + 1;
for (int i = 0; i < s; ++i) {
if (used[i]) {
if (gain[i] > 0) {
G.insert_edge(S, id[i], gain[i]);
ans += gain[i];
} else if (gain[i] < 0) {
G.insert_edge(id[i], T, -gain[i]);
}
}
}
for (int i = 0; i < k; ++i) {
G.insert_edge(id[rel[i].first], id[rel[i].second], 1e18);
}
ans -= G.max_flow(S, T);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int INF = 1e9 + 5;
const long long INF_LL = 1e15 + 5;
int g[N][N], dist[N][N];
struct Ship {
int loc, attack, fuel, price;
void read() {
cin >> loc >> attack >> fuel >> price;
--loc;
}
};
vector<pair<int, int>> reward[N];
struct Base {
int loc, defence, gold;
void read() {
cin >> loc >> defence >> gold;
--loc;
reward[loc].emplace_back(defence, gold);
}
};
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
template <typename flow_t>
class Dinic {
public:
Dinic(int _n, int _source, int _sink) : n(_n), source(_source), sink(_sink) {
g.resize(n);
flow.resize(n, vector<flow_t>(n));
level.resize(n);
ptr.resize(n);
}
void add_edge(int from, int to, flow_t cap) {
g[from].push_back(to);
g[to].push_back(from);
flow[from][to] += cap;
}
bool bfs() {
vector<int> q{source};
for (int i = 0; i < (int)q.size(); i++) {
int u = q[i];
for (int v : g[u]) {
if (level[v] == -1 && flow[u][v] > 0) {
level[v] = level[u] + 1;
q.push_back(v);
}
}
}
return level[sink] != -1;
}
flow_t dfs(int u, flow_t pushed) {
if (pushed == 0) {
return 0;
}
if (u == sink) {
return pushed;
}
for (int& pos = ptr[u]; pos < (int)g[u].size(); pos++) {
int v = g[u][pos];
if (level[v] != level[u] + 1 || flow[u][v] == 0) {
continue;
}
flow_t maybe_push = dfs(v, min(pushed, flow[u][v]));
if (maybe_push == 0) {
continue;
}
flow[u][v] -= maybe_push;
flow[v][u] += maybe_push;
return maybe_push;
}
return 0;
}
flow_t max_flow() {
flow_t mf(0);
while (true) {
level.assign(n, -1);
level[source] = 0;
if (!bfs()) {
break;
}
ptr.assign(n, 0);
flow_t now;
do {
now = dfs(source, FLOW_MAX);
mf += now;
} while (now != 0);
}
return mf;
}
private:
const flow_t FLOW_MAX = numeric_limits<flow_t>::max() / 2;
vector<vector<int>> g;
vector<vector<flow_t>> flow;
vector<int> level, ptr;
int n, source, sink;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fill((int*)dist, (int*)dist + N * N, INF);
for (int i = 0; i < int(N); i++) dist[i][i] = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < int(m); i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a][b] = g[b][a] = 1;
dist[a][b] = dist[b][a] = 1;
}
for (int k = 0; k < int(n); k++)
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(n); j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int second, B, K;
cin >> second >> B >> K;
vector<Ship> ships(second);
vector<Base> bases(B);
for (auto& s : ships) {
s.read();
}
for (auto& b : bases) {
b.read();
}
for (int i = 0; i < int(n); i++) {
sort(reward[i].begin(), reward[i].end());
int sz = reward[i].size();
for (int j = 1; j <= int(sz - 1); j++) {
reward[i][j].second = max(reward[i][j].second, reward[i][j - 1].second);
}
}
vector<long long> ship_reward(second, -INF_LL);
for (int i = 0; i < int(second); i++) {
Ship s = ships[i];
for (int base = 0; base < int(n); base++)
if (dist[s.loc][base] < INF) {
int lo = 0, hi = (int)reward[base].size() - 1;
int idx = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (reward[base][mid].first <= s.attack) {
idx = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
if (idx == -1) {
continue;
}
max_self(ship_reward[i], (long long)reward[base][idx].second - s.price);
}
}
vector<pair<int, int>> dependencies;
for (int i = 0; i < int(K); i++) {
int a, b;
cin >> a >> b;
--a, --b;
dependencies.emplace_back(a, b);
}
long long ans = 0;
for (int i = 0; i < int(second); i++) {
if (ship_reward[i] > 0) {
ans += ship_reward[i];
}
}
map<int, int> id;
int nodes = 0;
for (auto [u, v] : dependencies) {
if (!id.count(u)) {
id[u] = nodes++;
}
if (!id.count(v)) {
id[v] = nodes++;
}
}
int source = nodes++;
int sink = nodes++;
Dinic<long long> graph(nodes, source, sink);
for (auto [u, _] : id) {
if (ship_reward[u] >= 0) {
graph.add_edge(source, id[u], ship_reward[u]);
} else {
graph.add_edge(id[u], sink, -ship_reward[u]);
}
}
for (auto [u, v] : dependencies) {
graph.add_edge(id[u], id[v], INF_LL);
}
ans -= graph.max_flow();
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
int to, i;
};
const long long INF = 1e18;
const int N = 105, M = 1e5 + 5, V = 2005, Z = 3e6, S = V - 2, T = V - 1;
int best[M], pos[M], atk[M], fuel[M], dt[V], p[V];
long long cp[Z], fl[Z], d[N][N], cost[M];
int ce = 0;
vector<E> g[V];
vector<pair<int, int>> lt[N];
bool notFree[M], loser[M];
void addEdge(int a, int b, long long c) {
cp[ce] = c;
g[a].push_back({b, ce++});
cp[ce] = 0;
g[b].push_back({a, ce++});
}
bool bfs() {
queue<int> q;
fill(dt, dt + V, -1);
dt[S] = 0;
q.push(S);
while (!q.empty()) {
int node = q.front();
q.pop();
for (E e : g[node]) {
if (cp[e.i] > fl[e.i] && dt[e.to] == -1) {
dt[e.to] = dt[node] + 1;
q.push(e.to);
}
}
}
return dt[T] != -1;
}
long long dfs(int node, long long flow) {
if (node == T) return flow;
for (int &i = p[node]; i < g[node].size(); i++) {
E e = g[node][i];
if (cp[e.i] > fl[e.i] && dt[e.to] == dt[node] + 1) {
int ret = dfs(e.to, min(flow, cp[e.i] - fl[e.i]));
if (ret) {
fl[e.i] += ret;
fl[e.i ^ 1] -= ret;
return ret;
}
}
}
return 0;
}
long long maxFlow() {
long long flow = 0;
while (bfs()) {
memset(p, 0, sizeof(p));
long long ret = 0;
while (ret = dfs(S, INF)) {
flow += ret;
}
}
return flow;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
d[i][j] = INF;
}
d[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
d[b][a] = d[a][b] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
d[j][k] = min(d[j][i] + d[i][k], d[j][k]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
for (int i = 0; i < s; i++) {
cin >> pos[i] >> atk[i] >> fuel[i] >> cost[i];
pos[i]--;
}
for (int i = 0; i < b; i++) {
int pl, def, gold;
cin >> pl >> def >> gold;
pl--;
lt[pl].push_back({def, gold});
}
for (int i = 0; i < n; i++) {
lt[i].push_back({0, 0});
sort(lt[i].begin(), lt[i].end());
for (int j = 1; j < lt[i].size(); j++) {
lt[i][j].second = max(lt[i][j].second, lt[i][j - 1].second);
}
}
for (int i = 0; i < s; i++) {
loser[i] = true;
for (int j = 0; j < n; j++) {
if (d[pos[i]][j] <= fuel[i]) {
int q =
upper_bound(lt[j].begin(), lt[j].end(), make_pair(atk[i] + 1, -1)) -
lt[j].begin();
if (q > 1) loser[i] = false;
best[i] = max(best[i], lt[j][q - 1].second);
}
}
}
vector<int> vip;
vector<pair<int, int>> dep;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
a--, b--;
vip.push_back(a);
vip.push_back(b);
notFree[a] = notFree[b] = 1;
dep.push_back({a, b});
}
sort(vip.begin(), vip.end());
vip.erase(unique(vip.begin(), vip.end()), vip.end());
long long ans = 0;
for (int i = 0; i < s; i++) {
if (!notFree[i] && best[i] > cost[i]) {
ans += best[i] - cost[i];
}
}
for (int i = 0; i < vip.size(); i++) {
if (loser[vip[i]]) cost[vip[i]] = INF;
addEdge(S, i, cost[vip[i]]);
addEdge(i, T, best[vip[i]]);
ans += best[vip[i]];
}
for (auto e : dep) {
e.first = lower_bound(vip.begin(), vip.end(), e.first) - vip.begin();
e.second = lower_bound(vip.begin(), vip.end(), e.second) - vip.begin();
addEdge(e.second, e.first, INF);
}
ans -= maxFlow();
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[3011];
int dist[3011], visited[3011];
int cur[3011];
void init() {
edg.clear();
int i;
for (i = 0; i < 3011; i++) {
g[i].clear();
}
}
void addedge(int from, int to, long long capacity) {
edge e1 = edge{from, to, 0ll, capacity};
edge e2 = edge{to, from, 0ll, 0ll};
edg.push_back(e1), edg.push_back(e2);
g[from].push_back((int)edg.size() - 2);
g[to].push_back((int)edg.size() - 1);
}
bool bfs() {
memset(visited, 0, sizeof(visited));
memset(dist, 0, sizeof(dist));
queue<int> q;
q.push(s);
visited[s] = 1;
dist[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
edge &e = edg[g[v][i]];
int nxt = e.to;
if (!visited[nxt] && e.capacity > e.flow) {
dist[nxt] = dist[v] + 1;
q.push(nxt);
visited[nxt] = 1;
}
}
}
return visited[t];
}
long long dfs(int x, long long cp) {
if (x == t || cp == 0) {
return cp;
}
long long flow = 0, newflow;
for (int &y = cur[x]; y < (int)g[x].size(); y++) {
edge &e = edg[g[x][y]];
if (dist[x] + 1 == dist[e.to]) {
long long minn = min(cp, e.capacity - e.flow);
newflow = dfs(e.to, minn);
if (newflow > 0) {
e.flow += newflow;
edg[g[x][y] ^ 1].flow -= newflow;
flow += newflow;
cp -= newflow;
if (cp == 0) {
break;
}
}
}
}
return flow;
}
long long Dinic() {
long long flow = 0;
while (bfs()) {
memset(cur, 0, sizeof(cur));
flow += dfs(s, 1000000000000000);
}
return flow;
}
};
Maxflow mf;
long long dist[111][111];
int n, m;
struct spa {
int id, x, a, f, p;
bool operator<(spa other) const { return a < other.a; }
};
struct base {
int d, g;
bool operator<(base other) const { return d < other.d; }
};
vector<base> G[111];
spa sp[100011];
long long profit[100011];
pair<int, int> relation[3011];
int special[100011];
vector<int> disc;
int main() {
int i, j, k, S, B;
mf.s = 3011 - 2, mf.t = 3011 - 1;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
if (i != j) {
dist[i][j] = 1000000000000000;
}
}
}
for (i = 0; i < 100011; ++i) profit[i] = -1000000000000000;
for (i = 1; i <= m; ++i) {
int v1, v2;
scanf("%d%d", &v1, &v2);
dist[v1][v2] = dist[v2][v1] = min(dist[v1][v2], 1ll);
}
for (k = 1; k <= n; ++k) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
scanf("%d%d%d", &S, &B, &m);
for (i = 1; i <= S; ++i) {
scanf("%d%d%d%d", &sp[i].x, &sp[i].a, &sp[i].f, &sp[i].p);
sp[i].id = i;
}
for (i = 1; i <= B; ++i) {
int v, d, g;
scanf("%d%d%d", &v, &d, &g);
G[v].push_back(base{d, g});
}
sort(sp + 1, sp + 1 + S);
for (i = 1; i <= n; ++i) {
sort(G[i].begin(), G[i].end());
long long gold = -1000000000000000;
int sz = G[i].size();
for (k = 1, j = 0; k <= S; ++k) {
while (j < sz && sp[k].a >= G[i][j].d) {
gold = max(gold, (long long)G[i][j].g);
++j;
}
if (sp[k].f >= dist[i][sp[k].x]) {
profit[sp[k].id] = max(profit[sp[k].id], gold - sp[k].p);
}
}
}
long long ans = 0, tol = 0;
for (i = 1; i <= m; ++i) {
scanf("%d%d", &relation[i].first, &relation[i].second);
special[relation[i].first] = special[relation[i].second] = 1;
}
for (i = 1; i <= S; ++i) {
if (!special[i] && profit[i] > 0) {
ans += profit[i];
}
if (special[i]) {
disc.push_back(i);
}
}
for (i = 0; i < (int)disc.size(); ++i) {
if (profit[disc[i]] < 0) {
mf.addedge(i, mf.t, -profit[disc[i]]);
} else {
mf.addedge(mf.s, i, profit[disc[i]]);
tol += profit[disc[i]];
}
}
for (i = 1; i <= m; ++i) {
if (binary_search(disc.begin(), disc.end(), relation[i].first) &&
binary_search(disc.begin(), disc.end(), relation[i].second)) {
int id1 = lower_bound(disc.begin(), disc.end(), relation[i].first) -
disc.begin();
int id2 = lower_bound(disc.begin(), disc.end(), relation[i].second) -
disc.begin();
mf.addedge(id1, id2, 1000000000000000);
}
}
ans = ans + tol - mf.Dinic();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
vector<vector<long long>> dist((size_t)n,
vector<long long>((size_t)n, (long long)1e16));
for (long long i = 0; i < n; i++) {
dist[i][i] = (long long)0;
}
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
dist[u][v] = dist[v][u] = 0;
}
for (long long k = 0; k < n; k++) {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
long long s, b, k;
cin >> s >> b >> k;
vector<tuple<long long, long long, long long, long long>> x((size_t)s);
for (long long i = 0; i < s; i++) {
cin >> get<0>(x[i]) >> get<1>(x[i]) >> get<2>(x[i]) >> get<3>(x[i]);
get<0>(x[i])--;
}
vector<tuple<long long, long long, long long>> y((size_t)b);
for (long long i = 0; i < b; i++) {
cin >> get<0>(y[i]) >> get<1>(y[i]) >> get<2>(y[i]);
get<0>(y[i])--;
}
vector<map<long long, long long>> bases((size_t)n);
for (long long i = 0; i < b; i++) {
bases[get<0>(y[i])][get<1>(y[i])] = get<2>(y[i]);
}
for (long long i = 0; i < n; i++) {
for (auto j = bases[i].begin(); j != bases[i].end();) {
if (j == bases[i].begin() || j->second > prev(j)->second) {
j++;
} else {
j = bases[i].erase(j);
}
}
}
vector<long long> damages((size_t)s, (long long)-1e16);
for (long long i = 0; i < s; i++) {
for (long long j = 0; j < n; j++) {
if (get<2>(x[i]) >= dist[get<0>(x[i])][j]) {
auto it = bases[j].upper_bound(get<1>(x[i]));
if (it != bases[j].begin()) {
damages[i] = max(damages[i], prev(it)->second - get<3>(x[i]));
}
}
}
}
vector<vector<long long>> init_adj((size_t)s), init_adj_rev((size_t)s);
vector<vector<pair<long long, long long>>> adj((size_t)s + 2);
vector<map<long long, long long>> flows((size_t)s + 2);
auto add_edge = [&](long long u, long long v, long long w) {
adj[u].emplace_back(v, w);
adj[v].emplace_back(u, 0);
flows[u][v] = 0;
flows[v][u] = 0;
};
for (long long i = 0; i < k; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
if (u != v) {
init_adj[u].push_back(v);
init_adj_rev[v].push_back(u);
add_edge(u, v, (long long)1e16);
}
}
long long o = 0;
for (long long u = 0; u < s; u++) {
o += max(damages[u], (long long)0);
if (damages[u] > 0) {
if (!init_adj[u].empty()) {
add_edge(s, u, damages[u]);
}
} else {
if (!init_adj_rev[u].empty()) {
add_edge(u, s + 1, -damages[u]);
}
}
}
vector<bool> visited;
vector<long long> path;
function<long long(long long)> visit = [&](long long u) {
if (!visited[u]) {
visited[u] = true;
path.push_back(u);
if (u == s + 1) {
return (long long)1e16;
} else {
for (auto [v, w] : adj[u]) {
if (w - flows[u][v] > 0) {
long long a = visit(v);
if (a > 0) {
return min(w - flows[u][v], a);
}
}
}
}
path.pop_back();
}
return (long long)0;
};
while (true) {
visited.assign((long long)s + 2, false);
path.clear();
long long a = visit(s);
if (a > 0) {
for (long long i = 1; i < (long long)path.size(); i++) {
flows[path[i - 1]][path[i]] += a;
flows[path[i]][path[i - 1]] -= a;
}
o -= a;
} else {
break;
}
}
cout << o << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = (int)(1e5) + 7;
vector<int> gr[N];
vector<int> ingr[N];
vector<pair<int, int> > guys[N];
vector<int> pref[N];
const int MAXN = 1e5;
const int INF = 1000000007;
struct edge {
int a, b, cap, flow;
};
int n, s, t, d[MAXN], ptr[MAXN], q[MAXN];
vector<edge> e;
vector<int> g[MAXN];
void add_edge(int a, int b, int cap) {
edge e1 = {a, b, cap, 0};
edge e2 = {b, a, 0, 0};
g[a].push_back((int)e.size());
e.push_back(e1);
g[b].push_back((int)e.size());
e.push_back(e2);
}
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
memset(d, -1, n * sizeof d[0]);
d[s] = 0;
while (qh < qt && d[t] == -1) {
int v = q[qh++];
for (size_t i = 0; i < g[v].size(); ++i) {
int id = g[v][i], to = e[id].b;
if (d[to] == -1 && e[id].flow < e[id].cap) {
q[qt++] = to;
d[to] = d[v] + 1;
}
}
}
return d[t] != -1;
}
int dfs(int v, int flow) {
if (!flow) return 0;
if (v == t) return flow;
for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {
int id = g[v][ptr[v]], to = e[id].b;
if (d[to] != d[v] + 1) continue;
int pushed = dfs(to, min(flow, e[id].cap - e[id].flow));
if (pushed) {
e[id].flow += pushed;
e[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
long long dinic() {
long long flow = 0;
for (;;) {
if (!bfs()) break;
memset(ptr, 0, n * sizeof ptr[0]);
while (int pushed = dfs(s, INF)) flow += pushed;
}
return flow;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long ans = 0;
vector<int> id;
vector<int> cost;
vector<pair<int, int> > go;
{
int n, m;
cin >> n >> m;
int inf = (int)(1e9) + 7;
vector<vector<int> > g(n, vector<int>(n, inf));
for (int i = 0; i < n; i++) g[i][i] = 0;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a][b] = g[b][a] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<int> x(s), a(s), f(s), p(s);
for (int i = 0; i < s; i++) {
cin >> x[i] >> a[i] >> f[i] >> p[i];
x[i]--;
}
vector<int> y(b), d(b), gold(b);
for (int i = 0; i < b; i++) {
cin >> y[i] >> d[i] >> gold[i];
y[i]--;
guys[y[i]].push_back({d[i], gold[i]});
}
for (int i = 0; i < n; i++) {
sort(guys[i].begin(), guys[i].end());
pref[i].resize(guys[i].size());
for (int j = 0; j < (int)pref[i].size(); j++) {
pref[i][j] = guys[i][j].second;
if (j) pref[i][j] = max(pref[i][j], pref[i][j - 1]);
}
}
vector<bool> alive(s);
vector<int> score(s);
for (int i = 0; i < s; i++) {
vector<int> ok;
for (int j = 0; j < n; j++) {
if (g[x[i]][j] <= f[i]) {
int ind = upper_bound(guys[j].begin(), guys[j].end(),
make_pair(a[i], inf)) -
guys[j].begin() - 1;
if (ind >= 0) {
ok.push_back(pref[j][ind]);
}
}
}
if (!ok.empty()) {
score[i] = *max_element(ok.begin(), ok.end()) - p[i];
alive[i] = true;
}
}
vector<bool> in_edge(s);
vector<pair<int, int> > edges;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
u--, v--;
in_edge[u] = in_edge[v] = true;
edges.push_back({u, v});
}
bool ch = true;
while (ch) {
ch = false;
for (auto c : edges) {
if (!alive[c.second] && alive[c.first]) {
ch = true;
alive[c.first] = false;
}
}
}
for (int i = 0; i < s; i++) {
if (!in_edge[i]) {
ans += max(0, score[i]);
}
}
for (int i = 0; i < s; i++) {
if (in_edge[i] && alive[i]) {
id.push_back(i);
cost.push_back(score[i]);
}
}
for (auto c : edges) {
if (!alive[c.first] || !alive[c.second]) {
continue;
}
int u = lower_bound(id.begin(), id.end(), c.first) - id.begin();
int v = lower_bound(id.begin(), id.end(), c.second) - id.begin();
go.push_back({u, v});
}
}
n = 2 + id.size();
s = id.size();
t = id.size() + 1;
for (auto c : go) {
add_edge(c.first, c.second, INF);
}
for (int i = 0; i < (int)id.size(); i++) {
if (cost[i] >= 0) {
ans += cost[i];
add_edge(s, i, cost[i]);
} else {
add_edge(i, t, -cost[i]);
}
}
cout << ans - dinic() << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chkmax(T &a, T b) {
if (a < b) a = b;
}
vector<int> v[105];
vector<int> vs[105], vb[105];
int n, m;
int nn, mm, kk;
int f[100005], d[100005], g[100005], a[100005], x[100005], y[100005], p[100005];
bool cmpf(int x, int y) { return f[x] < f[y]; }
int dd[105];
int fen[100005 << 1];
int val[100005 << 1], vals;
void update(int k, int v) {
for (; k <= vals; k += k & -k) {
chkmax(fen[k], v);
}
return;
}
const int inf = 0x3f3f3f3f;
int calc_mx(int k) {
int res = -inf;
for (; k; k -= k & -k) {
chkmax(res, fen[k]);
}
return res;
}
void update(int k) {
for (auto x : vb[k]) {
update(d[x], g[x]);
}
}
int rd[100005];
void solve(int k) {
memset(dd, -1, sizeof dd);
memset(fen, -1, sizeof fen);
vector<int> A, B;
A.push_back(k);
int now = 0;
update(k);
int tot = 1;
int t = 0;
while (t < vs[k].size() && f[vs[k][t]] == 0) {
int kk = vs[k][t];
chkmax(rd[kk], calc_mx(a[kk]));
t++;
}
while (!A.empty() && t < vs[k].size()) {
B.clear();
now++;
for (auto x : A) {
for (auto y : v[x]) {
if (dd[y] < 0) {
B.push_back(y);
update(y);
dd[y] = dd[x] + 1;
}
}
}
tot += B.size();
while (t < vs[k].size() && f[vs[k][t]] == now) {
int kk = vs[k][t];
chkmax(rd[kk], calc_mx(a[kk]));
t++;
}
A.swap(B);
}
while (t < vs[k].size()) {
int kk = vs[k][t];
chkmax(rd[kk], calc_mx(a[kk]));
t++;
}
return;
}
vector<int> vv[100005];
bool vd[100005], vis[100005];
void dfs(int k) {
vd[k] = 1;
vis[k] = 1;
for (auto x : vv[k]) {
if (vd[x]) continue;
dfs(x);
}
return;
}
map<int, int> H;
int tot;
const long long linf = 1e16;
struct Dinic {
struct edge {
int u, v;
long long cap, flow;
edge() {}
edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
int n;
vector<edge> E;
vector<vector<int> > g;
vector<int> d, pt;
Dinic(int n) : n(n), E(0), g(n), d(n), pt(n) {}
Dinic() {}
void init(int _n) {
n = _n;
g.resize(n);
d.resize(n);
E.resize(0);
pt.resize(n);
for (int i = 0; i < n; i++) g[i].clear();
}
void add_edge(int u, int v, long long cap) {
if (u != v) {
E.push_back(edge(u, v, cap));
g[u].push_back(E.size() - 1);
E.push_back(edge(v, u, 0));
g[v].push_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q;
q.push(S);
fill(d.begin(), d.end(), n + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int i = 0; i < g[u].size(); i++) {
int k = g[u][i];
edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.push(e.v);
}
}
}
return d[T] != n + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
edge &e = E[g[u][i]];
edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long maxflow(int S, int T) {
long long res = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) res += flow;
}
return res;
}
} A;
long long tot_sum;
bool vvis[100005];
void add_edge(int x, int y) {
vvis[x] = vvis[y] = 1;
if (!H.count(x)) {
H[x] = ++tot;
int t = rd[x] - p[x];
if (t < 0)
A.add_edge(tot, 1, -t);
else
A.add_edge(0, tot, t), tot_sum += t;
}
if (!H.count(y)) {
H[y] = ++tot;
int t = rd[y] - p[y];
if (t < 0)
A.add_edge(tot, 1, -t);
else
A.add_edge(0, tot, t), tot_sum += t;
}
A.add_edge(H[x], H[y], linf);
}
int main() {
memset(rd, -1, sizeof rd);
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
scanf("%d %d %d", &nn, &mm, &kk);
for (int i = 1; i <= nn; i++) {
scanf("%d %d %d %d", &x[i], &a[i], &f[i], &p[i]);
if (f[i] >= n) f[i] = n - 1;
val[vals++] = a[i];
vs[x[i]].push_back(i);
}
for (int i = 1; i <= mm; i++) {
scanf("%d %d %d", &y[i], &d[i], &g[i]);
vb[y[i]].push_back(i);
val[vals++] = d[i];
}
sort(val, val + vals);
vals = unique(val, val + vals) - val;
for (int i = 1; i <= nn; i++) {
a[i] = lower_bound(val, val + vals, a[i]) - val + 1;
}
for (int i = 1; i <= mm; i++) {
d[i] = lower_bound(val, val + vals, d[i]) - val + 1;
}
for (int i = 1; i <= n; i++) sort(vs[i].begin(), vs[i].end(), cmpf);
for (int i = 1; i <= n; i++)
if (!vs[i].empty()) solve(i);
for (int i = 1; i <= nn; i++)
if (rd[i] < 0) vis[i] = 1;
while (kk--) {
int x, y;
scanf("%d %d", &x, &y);
vv[y].push_back(x);
}
for (int i = 1; i <= nn; i++)
if (vis[i] && !vd[i]) dfs(i);
A.init(3000);
tot = 1;
for (int i = 1; i <= nn; i++)
if (!vis[i]) {
for (auto x : vv[i])
if (!vis[x]) {
add_edge(x, i);
}
}
long long flow = A.maxflow(0, 1);
flow = tot_sum - flow;
for (int i = 1; i <= nn; i++)
if (!vvis[i] && !vis[i] && rd[i] - p[i] > 0) flow += rd[i] - p[i];
printf("%I64d\n", flow);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
const ll inf = LLONG_MAX / 3;
template <class d>
struct maxflow {
struct E {
ll to, rev;
d cap;
};
vvc<E> g;
vi itr, lv;
maxflow(ll n) : g(n), itr(n), lv(n) {}
void ae(ll s, ll t, d c) {
g[s].push_back({t, (ll)g[t].size(), c});
g[t].push_back({s, (ll)g[s].size() - 1, 0});
}
void bfs(ll s) {
fill(lv.begin(), lv.end(), -1);
lv[s] = 0;
queue<ll> q;
q.push(s);
while (q.size()) {
ll v = q.front();
q.pop();
for (auto e : g[v])
if (e.cap > 0 && lv[e.to] == -1) {
lv[e.to] = lv[v] + 1;
q.push(e.to);
}
}
}
d dfs(ll v, ll t, d f) {
if (v == t) return f;
d res = 0;
for (ll& i = itr[v]; i < (ll)g[v].size(); i++) {
E& e = g[v][i];
if (e.cap > 0 && lv[e.to] == lv[v] + 1) {
d first = dfs(e.to, t, min(f, e.cap));
if (first > 0) {
e.cap -= first;
g[e.to][e.rev].cap += first;
res += first;
f -= first;
if (f <= 0) break;
}
}
}
return res;
}
d calc(ll s, ll t) {
d f = 0;
while (1) {
bfs(s);
if (lv[t] == -1) return f;
fill(itr.begin(), itr.end(), 0);
f += dfs(s, t, 1e9);
}
}
};
void sub(vi pro, ll k) {
ll n = pro.size();
vi iso(n, 1);
vc<pi> es;
for (ll _ = ll(0); _ < ll(k); _++) {
ll first, second;
cin >> first >> second;
first--;
second--;
es.emplace_back(first, second);
iso[first] = 0;
iso[second] = 0;
}
ll base = 0;
vi idx;
for (ll i = ll(0); i < ll(n); i++)
if (iso[i]) {
base += max(ll(0), pro[i]);
} else {
idx.push_back(i);
}
ll s = idx.size();
maxflow<ll> mcf(1 + s + 1);
for (ll i = ll(0); i < ll(s); i++) {
if (pro[idx[i]] > 0) {
base += pro[idx[i]];
mcf.ae(0, 1 + i, pro[idx[i]]);
} else {
mcf.ae(1 + i, 1 + s, -pro[idx[i]]);
}
}
for (auto e : es) {
ll first = lower_bound(idx.begin(), idx.end(), e.first) - idx.begin();
ll second = lower_bound(idx.begin(), idx.end(), e.second) - idx.begin();
mcf.ae(1 + first, 1 + second, inf);
}
cout << base - mcf.calc(0, 1 + s) << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n, m;
cin >> n >> m;
vvc<ll> dist(n, vi(n, inf));
for (ll i = ll(0); i < ll(n); i++) dist[i][i] = 0;
for (ll _ = ll(0); _ < ll(m); _++) {
ll first, second;
cin >> first >> second;
first--;
second--;
dist[first][second] = 1;
dist[second][first] = 1;
}
for (ll k = ll(0); k < ll(n); k++)
for (ll i = ll(0); i < ll(n); i++)
for (ll j = ll(0); j < ll(n); j++)
chmin(dist[i][j], dist[i][k] + dist[k][j]);
ll s, second, k;
cin >> s >> second >> k;
vc<tuple<ll, ll, ll, ll>> xafp;
for (ll i = ll(0); i < ll(s); i++) {
ll x, first, f, p;
cin >> x >> first >> f >> p;
x--;
xafp.emplace_back(x, first, f, p);
}
vc<tuple<ll, ll, ll>> xdg;
for (ll i = ll(0); i < ll(second); i++) {
ll x, d, g;
cin >> x >> d >> g;
x--;
xdg.emplace_back(x, d, g);
}
vc<pi> ord;
for (ll i = ll(0); i < ll(s); i++)
ord.emplace_back(get<1>(xafp[i]), second + i);
for (ll i = ll(0); i < ll(second); i++) ord.emplace_back(get<1>(xdg[i]), i);
vi pro(s);
vi mxg(n, -inf);
sort(ord.begin(), ord.end());
for (auto kv : ord) {
ll i = kv.second;
if (i < second) {
chmax(mxg[get<0>(xdg[i])], get<2>(xdg[i]));
} else {
i -= second;
ll x, first, f, p;
tie(x, first, f, p) = xafp[i];
ll mx = -inf;
for (ll j = ll(0); j < ll(n); j++)
if (dist[x][j] <= f) chmax(mx, mxg[j]);
pro[i] = mx - p;
}
}
sub(pro, k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 111, inf = 1000111222;
const int max_v = 100011;
namespace flow {
struct edge {
int v;
long long res_cap;
edge() {}
edge(int v, long long res_cap) : v(v), res_cap(res_cap) {}
};
vector<edge> all;
vector<int> g[max_v];
void add_edge(int u, int v, long long cap) {
g[u].push_back(all.size());
all.push_back({v, cap});
g[v].push_back(all.size());
all.push_back({u, 0});
}
int h[max_v], num[max_v];
bool bfs(int s, int t) {
for (int i = 0; i <= t; ++i) {
h[i] = -1;
}
h[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int id : g[v]) {
if (all[id].res_cap && h[all[id].v] == -1) {
h[all[id].v] = h[v] + 1;
q.push(all[id].v);
}
}
}
return h[t] != -1;
}
int dfs(int v, int t, int f) {
if (v == t) {
return f;
}
for (int &i = num[v]; i < g[v].size(); ++i) {
int id = g[v][i];
const edge &e = all[id];
if (h[v] + 1 == h[e.v] && e.res_cap) {
int x = dfs(e.v, t, min(1LL * f, e.res_cap));
if (x) {
all[id].res_cap -= x;
all[id ^ 1].res_cap += x;
return x;
}
}
}
return 0;
}
long long dinic(int s, int t) {
long long res = 0;
while (bfs(s, t)) {
memset(num, 0, sizeof(num));
while (int x = dfs(s, t, 2 * inf)) {
res += x;
}
}
return res;
}
} // namespace flow
int n, m, dist[max_n][max_n];
int c1, c2, k;
int v1[max_v], attack[max_v], fluel[max_v], cost1[max_v], a[max_v];
int v2[max_v], defend[max_v], cost2[max_v], U[max_v], V[max_v], bad[max_v];
vector<pair<int, int>> all[max_n];
vector<int> rg[max_v];
void dfs(int v) {
bad[v] = 1;
for (int to : rg[v]) {
if (!bad[to]) {
dfs(to);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dist[i][j] = inf;
}
dist[i][i] = 0;
}
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
dist[u][v] = 1;
dist[v][u] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
scanf("%d%d%d", &c1, &c2, &k);
for (int i = 0; i < c1; ++i) {
scanf("%d%d%d%d", &v1[i], &attack[i], &fluel[i], &cost1[i]);
--v1[i];
}
for (int i = 0; i < c2; ++i) {
scanf("%d%d%d", &v2[i], &defend[i], &cost2[i]);
--v2[i];
all[v2[i]].push_back({defend[i], cost2[i]});
}
for (int i = 0; i < n; ++i) {
sort(all[i].begin(), all[i].end());
for (int j = 1; j < all[i].size(); ++j) {
all[i][j].second = max(all[i][j].second, all[i][j - 1].second);
}
}
for (int i = 0; i < c1; ++i) {
a[i] = -inf;
for (int v = 0; v < n; ++v) {
if (dist[v1[i]][v] > fluel[i]) {
continue;
}
auto it =
upper_bound(all[v].begin(), all[v].end(), make_pair(attack[i], inf));
if (it != all[v].begin()) {
--it;
a[i] = max(a[i], it->second);
}
}
if (a[i] != -inf) {
a[i] -= cost1[i];
} else {
bad[i] = 1;
}
}
int s = c1, t = s + 1;
long long big_inf = 10001112LL * inf;
for (int i = 0; i < k; ++i) {
scanf("%d%d", &U[i], &V[i]);
--U[i];
--V[i];
rg[V[i]].push_back(U[i]);
}
for (int i = 0; i < c1; ++i) {
if (bad[i]) {
dfs(i);
}
}
long long ans = 0;
for (int i = 0; i < c1; ++i) {
if (!bad[i]) {
flow::add_edge(s, i, inf + a[i]);
flow::add_edge(i, t, inf);
ans -= a[i] + inf;
}
}
for (int i = 0; i < k; ++i) {
if (!bad[U[i]] && !bad[V[i]]) {
flow::add_edge(U[i], V[i], big_inf);
}
}
ans += flow::dinic(s, t);
printf("%I64d\n", -ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tav[109][109];
int s, b, KK;
long long legjobb[109][109];
long long profit[100009];
long long infi = 1e18;
struct BaseShip {
int lo;
int pwr;
int fuel;
int cost;
int tp;
int idx;
bool operator<(const BaseShip& BS) const {
if (pwr == BS.pwr) {
return tp < BS.tp;
}
return pwr < BS.pwr;
}
};
vector<BaseShip> t;
void javit(BaseShip& BS) {
for (int i = 1; i <= n; i++) {
if (tav[i][BS.lo] >= 0) {
legjobb[i][tav[i][BS.lo]] =
max(legjobb[i][tav[i][BS.lo]], (long long)BS.cost);
}
}
}
long long ertek(BaseShip& BS) {
long long ret = -infi;
for (int dd = 0; dd <= min(n - 1, BS.fuel); dd++) {
ret = max(ret, (long long)legjobb[BS.lo][dd]);
}
return ret;
}
vector<int> G[100009];
vector<long long> cap[100009];
vector<long long> flow[100009];
vector<int> holvan[100009];
int bejar[100009];
int bejarszam;
int apa[100009];
int apael[100009];
long long profitsum = 0;
int sor[100009];
long long FF() {
long long ret = 0;
int start = 0;
int sk;
int sv;
while (1) {
sk = 1;
sv = 1;
sor[1] = start;
bejarszam++;
bejar[start] = bejarszam;
apa[start] = -1;
apael[start] = -1;
while (sk <= sv) {
int akt = sor[sk];
for (int i = 0; i < G[akt].size(); i++) {
int sz = G[akt][i];
long long cc = cap[akt][i];
if (bejar[sz] == bejarszam) continue;
if (cc == flow[akt][i]) continue;
sv++;
sor[sv] = sz;
apa[sz] = akt;
apael[sz] = i;
bejar[sz] = bejarszam;
}
sk++;
}
if (bejar[s + 1] < bejarszam) break;
long long maxpush = infi;
int akt = s + 1;
while (akt != 0) {
if (cap[apa[akt]][apael[akt]] == 0) {
maxpush = min(maxpush, flow[apa[akt]][apael[akt]]);
} else {
maxpush = min(maxpush,
cap[apa[akt]][apael[akt]] - flow[apa[akt]][apael[akt]]);
}
akt = apa[akt];
}
akt = s + 1;
while (akt != 0) {
if (cap[apa[akt]][apael[akt]] == 0) {
flow[apa[akt]][apael[akt]] -= maxpush;
flow[akt][holvan[apa[akt]][apael[akt]]] -= maxpush;
} else {
flow[apa[akt]][apael[akt]] += maxpush;
flow[akt][holvan[apa[akt]][apael[akt]]] += maxpush;
}
akt = apa[akt];
}
ret += maxpush;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
tav[i][j] = -1;
}
tav[i][i] = 0;
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (a != b) {
tav[a][b] = 1;
tav[b][a] = 1;
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (tav[i][k] >= 0 && tav[k][j] >= 0) {
if (tav[i][j] == -1 || tav[i][j] > tav[i][k] + tav[k][j])
tav[i][j] = tav[i][k] + tav[k][j];
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
legjobb[i][j] = -infi;
}
}
cin >> s >> b >> KK;
t.resize(s + b);
for (int i = 0; i < s; i++) {
cin >> t[i].lo >> t[i].pwr >> t[i].fuel >> t[i].cost;
t[i].tp = 1;
t[i].idx = i + 1;
}
for (int i = s; i < s + b; i++) {
cin >> t[i].lo >> t[i].pwr >> t[i].cost;
t[i].tp = 0;
}
sort(t.begin(), t.end());
for (int i = 0; i < t.size(); i++) {
if (t[i].tp == 0) {
javit(t[i]);
} else {
profit[t[i].idx] = ertek(t[i]) - t[i].cost;
if (profit[t[i].idx] >= 0) {
profitsum += profit[t[i].idx];
}
}
}
for (int i = 1; i <= KK; i++) {
int s1, s2;
cin >> s1 >> s2;
if (s1 == s2) continue;
holvan[s1].push_back(G[s2].size());
holvan[s2].push_back(G[s1].size());
G[s1].push_back(s2);
G[s2].push_back(s1);
cap[s1].push_back(infi);
cap[s2].push_back(0);
flow[s1].push_back(0);
flow[s2].push_back(0);
}
for (int i = 1; i <= s; i++) {
if (G[i].size() == 0) continue;
if (profit[i] >= 0) {
holvan[0].push_back(G[i].size());
holvan[i].push_back(G[0].size());
G[0].push_back(i);
G[i].push_back(0);
cap[0].push_back(profit[i]);
cap[i].push_back(0);
flow[0].push_back(0);
flow[i].push_back(0);
} else {
holvan[s + 1].push_back(G[i].size());
holvan[i].push_back(G[s + 1].size());
G[s + 1].push_back(i);
G[i].push_back(s + 1);
cap[s + 1].push_back(0);
cap[i].push_back(-profit[i]);
flow[s + 1].push_back(0);
flow[i].push_back(0);
}
}
long long mincut = FF();
cout << profitsum - mincut << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
const int Inf = 1000000000;
const int Maxs = 100005;
int n, m;
int dist[Maxn][Maxn];
int S, B, K;
int ax[Maxs], ay[Maxs], az[Maxs], ap[Maxs];
deque<pair<int, int> > inbase[Maxn];
bool fall[Maxs];
int gain[Maxs];
vector<int> rneigh[Maxs], neigh[Maxs];
long long res;
const int MAXN = 2005;
const int INF = 1000000000;
struct edge {
int a, b, cap, flow;
};
int N, s, t, d[MAXN], ptr[MAXN], q[MAXN];
vector<edge> e;
vector<int> g[MAXN];
void add_edge(int a, int b, int cap) {
edge e1 = {a, b, cap, 0};
edge e2 = {b, a, 0, 0};
g[a].push_back((int)e.size());
e.push_back(e1);
g[b].push_back((int)e.size());
e.push_back(e2);
}
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
memset(d, -1, N * sizeof d[0]);
d[s] = 0;
while (qh < qt && d[t] == -1) {
int v = q[qh++];
for (size_t i = 0; i < g[v].size(); ++i) {
int id = g[v][i], to = e[id].b;
if (d[to] == -1 && e[id].flow < e[id].cap) {
q[qt++] = to;
d[to] = d[v] + 1;
}
}
}
return d[t] != -1;
}
int dfs(int v, int flow) {
if (!flow) return 0;
if (v == t) return flow;
for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {
int id = g[v][ptr[v]], to = e[id].b;
if (d[to] != d[v] + 1) continue;
int pushed = dfs(to, min(flow, e[id].cap - e[id].flow));
if (pushed) {
e[id].flow += pushed;
e[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
long long dinic() {
long long flow = 0;
for (;;) {
if (!bfs()) break;
memset(ptr, 0, N * sizeof ptr[0]);
while (int pushed = dfs(s, INF)) flow += pushed;
}
return flow;
}
bool Less(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first) return a.first < b.first;
return a.second > b.second;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) dist[i][j] = Inf;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a != b) dist[a][b] = dist[b][a] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
scanf("%d %d %d", &S, &B, &K);
vector<pair<int, int> > byattack;
for (int i = 0; i < S; i++) {
scanf("%d %d %d %d", &ax[i], &ay[i], &az[i], &ap[i]);
byattack.push_back(pair<int, int>(ay[i], i));
}
sort(byattack.begin(), byattack.end());
for (int i = 0; i < B; i++) {
int x, d, g;
scanf("%d %d %d", &x, &d, &g);
inbase[x].push_back(pair<int, int>(d, g));
}
for (int i = 1; i <= n; i++) {
sort(inbase[i].begin(), inbase[i].end(), Less);
deque<pair<int, int> > tmp;
int lst = -1;
for (int j = 0; j < inbase[i].size(); j++) {
pair<int, int> p = inbase[i][j];
if (p.second > lst) {
tmp.push_back(p);
lst = p.second;
}
}
inbase[i] = tmp;
}
for (int i = 0; i < byattack.size(); i++) {
int ind = byattack[i].second;
int tk = -1;
for (int j = 1; j <= n; j++)
if (dist[ax[ind]][j] <= az[ind]) {
while (inbase[j].size() >= 2 && inbase[j][1].first <= ay[ind])
inbase[j].pop_front();
if (inbase[j].empty()) continue;
if (inbase[j][0].first <= ay[ind]) tk = max(tk, inbase[j][0].second);
}
if (tk == -1)
fall[ind] = true;
else
gain[ind] = tk - ap[ind];
}
for (int i = 0; i < K; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
neigh[a].push_back(b);
rneigh[b].push_back(a);
}
vector<int> Q;
for (int i = 0; i < S; i++)
if (fall[i]) Q.push_back(i);
for (int i = 0; i < Q.size(); i++) {
int v = Q[i];
for (int j = 0; j < rneigh[v].size(); j++) {
int u = rneigh[v][j];
if (!fall[u]) {
fall[u] = true;
Q.push_back(u);
}
}
}
vector<int> un;
for (int i = 0; i < S; i++)
if (!fall[i])
if (rneigh[i].empty() && neigh[i].empty())
res += max(gain[i], 0);
else
un.push_back(i);
N = int(un.size()) + 2;
s = 0, t = N - 1;
for (int i = 0; i < un.size(); i++) {
int v = un[i];
if (gain[v] >= 0) {
res += gain[v];
add_edge(s, i + 1, gain[v]);
} else
add_edge(i + 1, t, -gain[v]);
for (int j = 0; j < neigh[v].size(); j++) {
int u = neigh[v][j];
int ind = lower_bound(un.begin(), un.end(), u) - un.begin();
add_edge(i + 1, ind + 1, INF);
}
}
res -= dinic();
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Dinic {
struct Edge {
long long flow;
int to, next;
};
vector<Edge> edges;
vector<int> adia, at, dist;
int S, D;
void add_Edge(int from, int to, long long cap) {
edges.push_back({cap, to, adia[from]});
adia[from] = edges.size() - 1;
edges.push_back({0, from, adia[to]});
adia[to] = edges.size() - 1;
}
bool bfs() {
queue<int> q;
fill(dist.begin(), dist.end(), 1e9);
dist[S] = 0;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = adia[x]; i != -1; i = edges[i].next) {
if (dist[edges[i].to] > dist[x] + 1 && edges[i].flow) {
dist[edges[i].to] = 1 + dist[x];
q.push(edges[i].to);
}
}
}
return dist[D] < 1e9;
}
long long dfs(int nod, long long fmax) {
if (nod == D) return fmax;
while (at[nod] != -1) {
Edge &e = edges[at[nod]];
long long f;
if (dist[e.to] == dist[nod] + 1 && e.flow &&
(f = dfs(e.to, min(fmax, e.flow)))) {
e.flow -= f;
edges[at[nod] ^ 1].flow += f;
return f;
}
at[nod] = edges[at[nod]].next;
}
return 0;
}
long long GetFlow() {
long long f = 0;
while (bfs()) {
at = adia;
while (long long x = dfs(S, 1e18)) f += x;
}
return f;
}
Dinic(int n = 0, int s = 0, int d = 0) {
S = s, D = d;
at = dist = adia = vector<int>(n + 1, -1);
}
};
const int NMAX = 110;
int dmin[NMAX][NMAX];
struct Object {
int cost, nod, power, id, fuel, atac;
};
vector<Object> ships, bases;
vector<pair<int, int>> dependencies;
int n;
int best_cost[NMAX];
void get_cost_nave() {
fill(best_cost, best_cost + n + 1, -1);
vector<int> nv(ships.size());
iota(nv.begin(), nv.end(), 0);
sort(nv.begin(), nv.end(),
[](int a, int b) { return ships[a].power < ships[b].power; });
sort(bases.begin(), bases.end(),
[](Object a, Object b) { return a.power < b.power; });
int it = 0;
for (auto i : nv) {
while (it != bases.size() && ships[i].power >= bases[it].power) {
best_cost[bases[it].nod] = max(best_cost[bases[it].nod], bases[it].cost);
it++;
}
int best = -1;
for (int nod = 1; nod <= n; nod++)
if (dmin[nod][ships[i].nod] <= ships[i].fuel)
best = max(best, best_cost[nod]);
ships[i].atac = best;
}
}
void read() {
int m, a, b;
scanf("%d%d", &n, &m);
fill(dmin[0], dmin[n + 1], 1e9);
for (int i = 1; i <= n; i++) dmin[i][i] = 0;
while (m--) {
scanf("%d%d", &a, &b);
dmin[a][b] = dmin[b][a] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dmin[i][j] = min(dmin[i][j], dmin[i][k] + dmin[k][j]);
int s, k;
scanf("%d%d%d", &s, &b, &k);
ships.resize(s);
bases.resize(b);
dependencies.resize(k);
for (auto &i : ships) {
scanf("%d%d%d%d", &i.nod, &i.power, &i.fuel, &i.cost);
i.fuel = min(i.fuel, 1000000);
}
for (auto &i : bases) scanf("%d%d%d", &i.nod, &i.power, &i.cost);
for (auto &i : dependencies) scanf("%d%d", &i.first, &i.second);
}
int main() {
read();
get_cost_nave();
long long ans = 0;
int cnt = 2, S = 1, D = 2;
const long long inf = 1e18;
for (auto &i : dependencies) {
i.first--, i.second--;
if (!ships[i.first].id) ships[i.first].id = ++cnt;
if (!ships[i.second].id) ships[i.second].id = ++cnt;
}
Dinic flow(cnt + 1, S, D);
for (auto i : ships) {
if (i.id) {
if (i.atac == -1)
flow.add_Edge(i.id, D, inf);
else {
int castig = i.atac - i.cost;
if (castig > 0) {
ans += castig;
flow.add_Edge(S, i.id, castig);
} else
flow.add_Edge(i.id, D, -castig);
}
} else
ans += max(0, i.atac - i.cost);
}
for (auto i : dependencies)
flow.add_Edge(ships[i.first].id, ships[i.second].id, inf);
ans -= flow.GetFlow();
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const double eps = 1e-9;
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type read(T &x) {
cin >> x;
}
long long read() {
char c;
long long out = 0, f = 1;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
;
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - '0';
return out * f;
}
template <typename T>
typename enable_if<is_integral<T>::value, T>::type read(T &x) {
char c;
T f = 1;
x = 0;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
;
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return x *= f;
}
char read(char &x) {
for (x = getchar(); isspace(x); x = getchar())
;
return x;
}
double read(double &x) {
scanf("%lf", &x);
return x;
}
void read(char *x) { scanf("%s", x); }
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type write(const T &x) {
cout << x;
}
template <typename T>
typename enable_if<is_integral<T>::value, void>::type write(const T &x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void write(const char &x) { putchar(x); }
void write(const double &x) { printf("%.10lf", x); }
void write(const char *x) { printf("%s", x); }
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <typename... Args>
void read(char *x, Args &...args) {
read(x);
read(args...);
}
template <
typename OutputIt,
typename = typename enable_if<
is_same<output_iterator_tag,
typename iterator_traits<OutputIt>::iterator_category>::value ||
(is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>::
iterator_category>::value &&
!is_const<OutputIt>::value)>::type>
void read(OutputIt __first, OutputIt __last) {
for (; __first != __last; ++__first) read(*__first);
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wts(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar(' ');
}
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wtb(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar('\n');
}
}
void wts(const char *x) {
write(x);
putchar(' ');
}
void wtb(const char *x) {
write(x);
putchar('\n');
}
template <typename T>
void wts(const T &x) {
write(x);
putchar(' ');
}
template <typename T>
void wtb(const T &x) {
write(x);
putchar('\n');
}
template <typename... Args>
void wts(const char *x, Args... args) {
wts(x);
wts(args...);
}
template <typename... Args>
void wtb(const char *x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T, typename... Args>
void wts(const T &x, Args... args) {
wts(x);
wts(args...);
}
template <typename T, typename... Args>
void wtb(const T &x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T>
inline bool up(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool dn(T &x, const T &y) {
return y < x ? x = y, 1 : 0;
}
const long long N = 110;
const long long K = 1010;
const long long S = 100010;
const long long mod = 1000000007;
struct Node {
long long x, a, f, p, type, id;
bool operator<(const Node &b) const {
return a == b.a ? type > b.type : a < b.a;
}
} a[S << 1];
queue<long long> q;
bool xianzhi[S];
long long head[S], cur[S], nxt[K << 4], to[K << 4], edge[K << 4], cnt = 1;
long long n, m, c, b, k, ans, mxp[N], g[S], dis[N][N], dep[S], s = S - 2,
t = S - 1;
void add(long long u, long long v, long long w) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = v;
edge[cnt] = w;
}
void Add(long long u, long long v, long long w) {
add(u, v, w);
add(v, u, 0);
}
long long dfs(long long u, long long flow) {
if (dep[u] == dep[t]) return u == t ? flow : 0;
long long v, w, f, out = 0;
for (long long &i = cur[u]; i && flow - out; i = nxt[i]) {
v = to[i];
w = edge[i];
if (w > 0 && dep[v] == dep[u] + 1) {
f = dfs(v, min(w, flow - out));
edge[i] -= f;
edge[i ^ 1] += f;
out += f;
}
}
return out;
}
bool bfs() {
memset(dep, -1, sizeof(dep));
dep[s] = 0;
q.push(s);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long i = head[u]; i; i = nxt[i]) {
long long v = to[i];
long long w = edge[i];
if (w > 0 && dep[v] == -1) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
return dep[t] > 0;
}
long long dinic() {
long long out = 0;
while (bfs()) {
memcpy(cur, head, sizeof(cur));
out += dfs(s, INF);
}
return out;
}
signed main() {
read(n, m);
memset(dis, 0x3f, sizeof(dis));
for (long long i = (1), iend = (m); i <= iend; ++i) {
long long u, v;
read(u, v);
dis[u][v] = dis[v][u] = 1;
}
for (long long i = (1), iend = (n); i <= iend; ++i) dis[i][i] = 0;
for (long long k = (1), kend = (n); k <= kend; ++k)
for (long long i = (1), iend = (n); i <= iend; ++i)
for (long long j = (1), jend = (n); j <= jend; ++j)
dn(dis[i][j], dis[i][k] + dis[k][j]);
read(c, b, k);
for (long long i = (1), iend = (c); i <= iend; ++i) {
read(a[i].x, a[i].a, a[i].f, a[i].p);
a[i].type = 1;
a[i].id = i;
}
for (long long i = (1), iend = (b); i <= iend; ++i) {
read(a[i + c].x, a[i + c].a, a[i + c].p);
a[i + c].type = 2;
}
sort(a + 1, a + c + b + 1);
for (long long i = (1), iend = (n); i <= iend; ++i) mxp[i] = -INF;
for (long long i = (1), iend = (c); i <= iend; ++i) g[i] = -INF;
for (long long i = (1), iend = (c + b); i <= iend; ++i) {
if (a[i].type == 1) {
for (long long j = (1), jend = (n); j <= jend; ++j)
if (dis[a[i].x][j] <= a[i].f) up(g[a[i].id], mxp[j] - a[i].p);
} else
up(mxp[a[i].x], a[i].p);
}
for (long long i = (1), iend = (k); i <= iend; ++i) {
long long u, v;
read(u, v);
Add(u, v, INF);
xianzhi[u] = xianzhi[v] = true;
}
for (long long i = (1), iend = (c); i <= iend; ++i) {
if (xianzhi[i]) {
if (g[i] >= 0) {
ans += g[i];
Add(s, i, g[i]);
} else
Add(i, t, -g[i]);
} else if (g[i] > 0)
ans += g[i];
}
wtb(ans - dinic());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<ll>;
using pii = pair<ll, ll>;
using ld = long double;
const ll inf = (ll)1e18 + 100;
ll n, m;
ll d[100][100];
ll s, b, k;
struct ship {
ll x, a, f, p;
} ss[100000];
struct base {
ll x, d, g;
} bb[100000];
struct maxflow {
struct edge {
ll to, c, f;
};
vector<edge> e;
vector<vi> g;
ll N, S, T;
vi pt, d;
ll A;
bool bfs() {
fill_n(d.begin(), N, inf);
d[S] = 0;
queue<ll> q;
q.push(S);
while (!q.empty()) {
ll v = q.front();
q.pop();
for (ll i : g[v]) {
edge& ee = e[i];
if (ee.c - ee.f >= A && d[ee.to] == inf) {
d[ee.to] = d[v] + 1;
q.push(ee.to);
}
}
}
return (d[T] != inf);
}
ll dfs(ll v, ll cmin) {
if (v == T) {
return cmin;
}
for (; pt[v] < (ll)((g[v]).size()); pt[v]++) {
ll i = g[v][pt[v]];
edge& ee = e[i];
if (ee.c - ee.f >= A && d[ee.to] == d[v] + 1) {
ll f = dfs(ee.to, min(cmin, ee.c - ee.f));
if (f > 0) {
ee.f += f;
e[i ^ 1].f -= f;
return f;
}
}
}
return 0;
}
void dinic() {
d.resize(N);
pt.resize(N);
ll mf = 0;
for (A = inf; A; A >>= 1) {
while (bfs()) {
fill_n(pt.begin(), N, 0);
while (dfs(S, inf))
;
}
}
}
void addEdge(ll u, ll v, ll c) {
static ll i = 0;
e.push_back({v, c, 0});
e.push_back({u, 0, 0});
g[u].push_back(i);
g[v].push_back(i ^ 1);
i += 2;
}
void zhfs(ll v, vector<bool>& was) {
was[v] = true;
for (ll i : g[v]) {
edge& ee = e[i];
if (ee.c - ee.f > 0 && !was[ee.to]) {
zhfs(ee.to, was);
}
}
}
};
vi g1[100000];
vector<pii> e;
bool ban[100000];
ll w[100000];
void dfs(ll v) {
ban[v] = true;
for (ll to : g1[v])
if (!ban[to]) dfs(to);
}
vector<pii> pl[100];
vi pm[100];
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (ll i = 0; i < n; i++)
for (ll j = 0; j < n; j++)
if (i != j) d[i][j] = inf;
for (ll i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
--u;
--v;
d[u][v] = d[v][u] = 1;
}
for (ll k = 0; k < n; k++)
for (ll i = 0; i < n; i++)
for (ll j = 0; j < n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
cin >> s >> b >> k;
for (ll i = 0; i < s; i++)
cin >> ss[i].x >> ss[i].a >> ss[i].f >> ss[i].p, --ss[i].x;
for (ll i = 0; i < b; i++)
cin >> bb[i].x >> bb[i].d >> bb[i].g, --bb[i].x,
pl[bb[i].x].push_back({bb[i].d, bb[i].g});
for (ll i = 0; i < n; i++) {
if (pl[i].empty()) continue;
sort((pl[i]).begin(), (pl[i]).end());
pm[i].resize((ll)((pl[i]).size()));
pm[i][0] = pl[i][0].second;
for (ll j = 1; j < (ll)((pm[i]).size()); j++) {
pm[i][j] = max(pm[i][j - 1], pl[i][j].second);
}
}
vi broken;
maxflow grape;
grape.N = s + 2;
grape.S = grape.N - 2;
grape.T = grape.N - 1;
grape.g.resize(grape.N);
vi ord(s);
iota((ord).begin(), (ord).end(), 0);
sort((ord).begin(), (ord).end(),
[](ll i, ll j) { return ss[i].a < ss[j].a; });
vi pt(n, -1);
for (ll i : ord) {
ll hi = -1;
for (ll p = 0; p < n; p++)
if (ss[i].f >= d[ss[i].x][p]) {
while (pt[p] + 1 < (ll)((pl[p]).size()) &&
ss[i].a >= pl[p][pt[p] + 1].first)
pt[p]++;
if (pt[p] != -1) hi = max(hi, pm[p][pt[p]]);
}
if (hi == -1)
broken.push_back(i);
else {
hi -= ss[i].p;
w[i] = hi;
}
}
for (ll i = 0; i < k; i++) {
ll u, v;
cin >> u >> v;
--u;
--v;
g1[v].push_back(u);
e.push_back({u, v});
}
for (ll u : broken)
if (!ban[u]) dfs(u);
for (ll i = 0; i < s; i++)
if (!ban[i]) {
ll hi = w[i];
if (hi < 0)
grape.addEdge(i, grape.T, -hi);
else if (hi > 0)
grape.addEdge(grape.S, i, hi);
}
for (pii r : e) {
ll u = r.first, v = r.second;
if (!ban[u] && !ban[v]) grape.addEdge(u, v, inf);
}
grape.dinic();
vector<bool> was(grape.N, false);
grape.zhfs(grape.S, was);
ll ans = 0;
for (ll u = 0; u < s; u++) {
if (was[u]) {
ans += w[u];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
return getchar();
static char buf[100000], *l = buf, *r = buf;
return l == r && (r = (l = buf) + fread(buf, 1, 100000, stdin), l == r)
? EOF
: *l++;
}
template <class T>
void read(T &x) {
x = 0;
int f = 1, ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 - '0' + ch;
ch = nc();
}
x *= f;
}
const int inf = 1e9 + 1;
const int maxn = 100 + 5;
const int maxs = 1e5 + 5;
const int maxb = 1e5 + 5;
int n, m;
int s, b, k;
int st, ed;
int val[maxn];
int dis[maxn][maxn];
int head[maxs];
vector<int> adj[maxn];
struct data {
int a, b, c, d, id;
inline bool operator<(const data &other) const { return b < other.b; }
} A[maxs], B[maxb];
struct edge {
int to, nex;
long long cap, flow;
edge(int to = 0, int nex = 0, long long cap = 0, long long flow = 0)
: to(to), nex(nex), cap(cap), flow(flow) {}
};
vector<edge> G;
inline void adde(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
inline void addedge(int u, int v, long long c) {
G.push_back(edge(v, head[u], c, 0)), head[u] = G.size() - 1;
G.push_back(edge(u, head[v], 0, 0)), head[v] = G.size() - 1;
}
namespace dinic {
int dis[maxs], cur[maxs];
bool BFS() {
static int q[maxs];
int hd = 0, tl = 0;
memset(dis, -1, sizeof(dis));
dis[st] = 0;
q[tl++] = st;
while (hd < tl) {
int u = q[hd++];
for (int i = head[u]; ~i; i = G[i].nex) {
int v = G[i].to;
if (dis[v] == -1 && G[i].cap != G[i].flow) {
dis[v] = dis[u] + 1;
q[tl++] = v;
}
}
}
return dis[ed] != -1;
}
long long DFS(int u, long long flow) {
if (u == ed || flow == 0) return flow;
long long rec = flow;
for (int &i = cur[u]; ~i; i = G[i].nex) {
int v = G[i].to;
if (dis[v] == dis[u] + 1) {
long long d = DFS(v, min(flow, G[i].cap - G[i].flow));
G[i].flow += d;
G[i ^ 1].flow -= d;
flow -= d;
if (flow == 0) break;
}
}
return rec - flow;
}
long long maxflow() {
long long flow = 0;
while (BFS()) {
memcpy(cur, head, sizeof(head));
flow += DFS(st, 1e18);
}
return flow;
}
} // namespace dinic
int adde(int x) {
int mx = -1;
for (int i = 1; i <= n; ++i)
if (dis[A[x].a][i] <= A[x].c) {
mx = max(mx, val[i]);
}
if (mx == -1) {
addedge(A[x].id, ed, 1e18);
return 0;
}
mx -= A[x].d;
if (mx < 0) {
addedge(A[x].id, ed, -mx);
return 0;
}
addedge(st, A[x].id, mx);
return mx;
}
void BFS(int st) {
static int q[maxn];
int hd = 0, tl = 0;
for (int i = 1; i <= n; ++i) dis[st][i] = inf;
dis[st][st] = 0;
q[tl++] = st;
while (hd < tl) {
int u = q[hd++];
for (unsigned int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (dis[st][v] == inf) {
dis[st][v] = dis[st][u] + 1;
q[tl++] = v;
}
}
}
}
void init() {
for (int i = 1; i <= n; ++i) BFS(i);
}
long long solve() {
init();
sort(A + 1, A + s + 1);
sort(B + 1, B + b + 1);
long long an = 0;
int i = 1, j = 1;
st = 0, ed = s + 1;
memset(val, -1, sizeof(val));
while (i <= s && j <= b) {
if (B[j].b <= A[i].b) {
val[B[j].a] = max(val[B[j].a], B[j].c);
++j;
} else {
an += adde(i++);
}
}
while (i <= s) an += adde(i++);
return an - dinic ::maxflow();
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
adde(u, v);
}
read(s), read(b), read(k);
for (int i = 1; i <= s; ++i) {
read(A[i].a), read(A[i].b), read(A[i].c), read(A[i].d);
A[i].id = i;
}
for (int i = 1; i <= b; ++i) {
read(B[i].a), read(B[i].b), read(B[i].c);
}
memset(head, -1, sizeof(head));
for (int i = 1; i <= k; ++i) {
int s1, s2;
read(s1), read(s2);
addedge(s1, s2, 1e18);
}
printf("%I64d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[105][105];
vector<pair<long long, long long>> bs[105];
long long mbs[105][100005], pl[100005], pp[100005][4];
template <typename flow_type>
struct dinic {
struct edge {
size_t src, dst, rev;
flow_type flow, cap;
};
int n;
vector<vector<edge>> adj;
dinic(int n) : n(n), adj(n), level(n), q(n), it(n) {}
void add_edge(size_t src, size_t dst, flow_type cap, flow_type rcap = 0) {
adj[src].push_back({src, dst, adj[dst].size(), 0, cap});
if (src == dst) adj[src].back().rev++;
adj[dst].push_back({dst, src, adj[src].size() - 1, 0, rcap});
}
vector<int> level, q, it;
bool bfs(int source, int sink) {
fill(level.begin(), level.end(), -1);
for (int qf = level[q[0] = sink] = 0, qb = 1; qf < qb; ++qf) {
sink = q[qf];
for (edge &e : adj[sink]) {
edge &r = adj[e.dst][e.rev];
if (r.flow < r.cap && level[e.dst] == -1)
level[q[qb++] = e.dst] = 1 + level[sink];
}
}
return level[source] != -1;
}
flow_type augment(int source, int sink, flow_type flow) {
if (source == sink) return flow;
for (; it[source] != adj[source].size(); ++it[source]) {
edge &e = adj[source][it[source]];
if (e.flow < e.cap && level[e.dst] + 1 == level[source]) {
flow_type delta = augment(e.dst, sink, min(flow, e.cap - e.flow));
if (delta > 0) {
e.flow += delta;
adj[e.dst][e.rev].flow -= delta;
return delta;
}
}
}
return 0;
}
flow_type max_flow(int source, int sink) {
for (int u = 0; u < n; ++u)
for (edge &e : adj[u]) e.flow = 0;
flow_type flow = 0;
flow_type oo = numeric_limits<flow_type>::max();
while (bfs(source, sink)) {
fill(it.begin(), it.end(), 0);
for (flow_type f; (f = augment(source, sink, oo)) > 0;) flow += f;
}
return flow;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, u, v;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = ((long long)(1e9 + 7));
for (long long i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
d[u][v] = d[v][u] = 1;
}
for (int i = 0; i < n; i++) d[i][i] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
long long s, b, k, gg, de;
cin >> s >> b >> k;
for (long long i = 0; i < s; i++) {
cin >> pp[i][0] >> pp[i][1] >> pp[i][2] >> pp[i][3];
pp[i][0]--;
pl[i] = -(((long long)(1e9 + 7)) * ((long long)(1e9 + 7)));
}
for (int i = 0; i < b; i++) {
cin >> u >> de >> gg;
u--;
bs[u].push_back(pair<long long, long long>(de, gg));
}
for (int i = 0; i < n; i++) {
sort(bs[i].begin(), bs[i].end());
long long ma = 0;
for (long long j = 0; j < bs[i].size(); j++) {
ma = max(ma, bs[i][j].second);
mbs[i][j] = ma;
}
}
dinic<long long> g(2 + s);
long long s1 = 0;
for (int i = 0; i < s; i++) {
long long ma = 0;
bool ok = 0;
for (int j = 0; j < n; j++) {
if (d[j][pp[i][0]] > pp[i][2]) continue;
long long pos = upper_bound(bs[j].begin(), bs[j].end(),
pair<long long, long long>(
pp[i][1], ((long long)(1e9 + 7)))) -
bs[j].begin();
if (pos) ma = max(ma, mbs[j][pos - 1]), ok = 1;
}
if (ok) pl[i] = ma - pp[i][3];
if (pl[i] > 0) {
g.add_edge(0, i + 1, pl[i]);
s1 += pl[i];
}
if (pl[i] < 0) g.add_edge(i + 1, s + 1, -pl[i]);
}
for (long long i = 0; i < k; i++) {
cin >> u >> v;
g.add_edge(u, v, ((long long)(1e9 + 7)) * ((long long)(1e9 + 7)));
}
cout << (s1 - g.max_flow(0, s + 1)) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dis[110][110], nV, nE, n, m;
struct MaxFlow {
vector<int> G[220100];
struct Edge {
int b, e;
long long f;
} E[221000];
int EC, PV[220100], Q[220100], Level[220100], n, source, sink;
long long flow, INF = 1e16;
void init(int N, int S, int T) {
source = S, sink = T, flow = EC = 0;
n = N;
for (int i = 0; i <= n; i++) G[i].clear();
}
void Add_Edge(int a, int b, long long f) {
G[a].push_back(EC);
G[b].push_back(EC + 1);
E[EC++] = {a, b, f};
E[EC++] = {b, a, 0};
}
long long BlockFlow(int a, long long f) {
if (a == sink) return f;
for (int &i = PV[a]; i >= 0; i--) {
int t = G[a][i];
if (E[t].f && Level[E[t].e] == Level[a] + 1) {
long long ff = BlockFlow(E[t].e, min(E[t].f, f));
if (ff) {
E[t].f -= ff;
E[t ^ 1].f += ff;
return ff;
}
}
}
return 0ll;
}
bool GetLevel() {
int head = 0, tail = 0, i;
for (i = 1; i <= n; i++) Level[i] = -1;
Q[++tail] = source;
Level[source] = 0;
while (head < tail) {
int x = Q[++head];
for (auto &t : G[x]) {
if (E[t].f && Level[E[t].e] == -1) {
Level[E[t].e] = Level[x] + 1;
Q[++tail] = E[t].e;
}
}
}
return Level[sink] != -1;
}
void Dinic() {
int i;
long long t;
flow = 0;
while (GetLevel()) {
for (i = 1; i <= n; i++) PV[i] = G[i].size() - 1;
while (t = BlockFlow(source, INF)) {
flow += t;
}
}
}
} G1;
struct AA {
int x, a, f, cost;
} A[110000];
struct BB {
int d, k;
bool operator<(const BB &p) const { return d < p.d; }
};
vector<BB> U[110];
vector<int> MX[110];
pair<int, int> Ed[1010];
int K, chk[101000];
long long WW[101000];
int main() {
int i, j, k;
scanf("%d%d", &nV, &nE);
for (i = 1; i <= nV; i++)
for (j = 1; j <= nV; j++)
if (i != j) dis[i][j] = 1e9;
for (i = 0; i < nE; i++) {
int a, b;
scanf("%d%d", &a, &b);
dis[a][b] = dis[b][a] = 1;
}
for (k = 1; k <= nV; k++)
for (i = 1; i <= nV; i++)
for (j = 1; j <= nV; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
scanf("%d%d%d", &n, &m, &K);
for (i = 1; i <= n; i++) {
scanf("%d%d%d%d", &A[i].x, &A[i].a, &A[i].f, &A[i].cost);
}
for (i = 1; i <= m; i++) {
int x, d, k;
scanf("%d%d%d", &x, &d, &k);
U[x].push_back({d, k});
}
for (i = 1; i <= nV; i++) {
int sz = U[i].size();
if (!sz) continue;
MX[i].resize(sz);
sort(U[i].begin(), U[i].end());
for (j = 0; j < sz; j++) {
MX[i][j] = U[i][j].k;
if (j) MX[i][j] = max(MX[i][j], MX[i][j - 1]);
}
}
for (i = 1; i <= n; i++) {
long long z = -1e16;
for (j = 1; j <= nV; j++) {
if (U[j].empty() || A[i].f < dis[A[i].x][j]) continue;
BB tp = {A[i].a + 1, 0};
int pv = lower_bound(U[j].begin(), U[j].end(), tp) - U[j].begin();
if (!pv) continue;
z = max(z, 0ll + MX[j][pv - 1] - A[i].cost);
}
WW[i] = z;
}
for (i = 0; i < K; i++) {
int a, b;
scanf("%d%d", &a, &b);
Ed[i] = {a, b};
chk[a] = chk[b] = 1;
}
long long sum = 0;
G1.init(n + 2, n + 1, n + 2);
long long BS = 1e10, tt = 0;
for (i = 1; i <= n; i++) {
if (!chk[i]) {
sum += max(WW[i], 0ll);
} else {
tt += BS;
G1.Add_Edge(G1.source, i, BS);
G1.Add_Edge(i, G1.sink, BS - WW[i]);
}
}
for (i = 0; i < K; i++) {
G1.Add_Edge(Ed[i].first, Ed[i].second, G1.INF);
}
G1.Dinic();
printf("%lld\n", sum + tt - G1.flow);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
class MaxFlow {
public:
long long cap[100000], flow[100000];
int to[100000], prev[100000], last[5000], used[5000], level[5000];
int V, E;
MaxFlow(int n) {
V = n;
E = 0;
for (int(i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
}
void init(int n, int es) {
V = n;
E = 0;
for (int(i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
for (int(i) = 0; (i) < (int)(V); (i)++) {
used[i] = 0;
level[i] = 0;
}
for (int(i) = 0; (i) < (int)(es); (i)++) {
cap[i] = flow[i] = to[i] = prev[i] = 0;
}
}
void add_edge(int x, int y, long long f) {
cap[E] = f;
flow[E] = 0;
to[E] = y;
prev[E] = last[x];
last[x] = E;
E++;
cap[E] = 0;
flow[E] = 0;
to[E] = x;
prev[E] = last[y];
last[y] = E;
E++;
}
bool bfs(int s, int t) {
int i;
for (int(i) = 0; (i) < (int)(V); (i)++) level[i] = -1;
queue<int> q;
q.push(s);
level[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (i = last[x]; i >= 0; i = prev[i])
if (level[to[i]] == -1 && cap[i] > flow[i]) {
q.push(to[i]);
level[to[i]] = level[x] + 1;
}
}
return (level[t] != -1);
}
long long dfs(int v, int t, long long f) {
int i;
if (v == t) return f;
for (i = used[v]; i >= 0; used[v] = i = prev[i])
if (level[to[i]] > level[v] && cap[i] > flow[i]) {
long long tmp = dfs(to[i], t, min(f, cap[i] - flow[i]));
if (tmp > 0) {
flow[i] += tmp;
flow[i ^ 1] -= tmp;
return tmp;
}
}
return 0;
}
vector<pair<int, int> > positive_edges() {
vector<pair<int, int> > ans;
for (int(i) = 0; (i) < (int)(V); (i)++)
for (int j = last[i]; j >= 0; j = prev[j])
if (cap[j] - flow[j] > 0) ans.push_back(make_pair(i, to[j]));
return ans;
}
long long maxflow(int s, int t) {
while (bfs(s, t)) {
for (int(i) = 0; (i) < (int)(V); (i)++) used[i] = last[i];
while (dfs(s, t, (1LL << 60)) != 0)
;
}
long long ans = 0;
for (int i = last[s]; i >= 0; i = prev[i]) ans += flow[i];
return ans;
}
};
int dis[105][105], s, b, h;
struct ship {
int x, a, f, p;
int pro = -1;
void rd() { scanf("%d%d%d%d", &x, &a, &f, &p); }
} sp[100035];
struct baase {
int x, d, g;
void rd() { scanf("%d%d%d", &x, &d, &g); }
} bs[100035];
int baseInf[105][100035 * 2];
int u[100035], v[100035], pos[100035];
bool vis[100035];
long long ans;
void cal2() {
for (int(i) = 1; (i) <= (int)(k); (i)++) {
scanf("%d%d", u + i, v + i);
vis[u[i]] = 1;
vis[v[i]] = 1;
}
for (int(i) = 1; (i) <= (int)(s); (i)++)
if (!vis[i] && sp[i].pro > sp[i].p) {
ans += sp[i].pro - sp[i].p;
}
vector<int> vp;
for (int(i) = 1; (i) <= (int)(s); (i)++)
if (vis[i]) {
vp.push_back(i);
pos[i] = vp.size();
}
int N = vp.size();
int S = 0, T = N + 1;
MaxFlow mf = MaxFlow(T + 5);
for (int(i) = 0; (i) < (int)(N); (i)++) {
int id = vp[i];
if (sp[id].pro >= sp[id].p) {
mf.add_edge(S, i + 1, sp[id].pro - sp[id].p);
ans += sp[id].pro - sp[id].p;
} else {
if (sp[id].pro == -1)
mf.add_edge(i + 1, T, (1LL << 60));
else
mf.add_edge(i + 1, T, sp[id].p - sp[id].pro);
}
}
for (int(i) = 1; (i) <= (int)(k); (i)++) {
int x = u[i], y = v[i];
mf.add_edge(pos[x], pos[y], (1LL << 60));
}
ans -= mf.maxflow(S, T);
printf("%lld\n", ans);
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(n); (j)++)
dis[i][j] = i == j ? 0 : (1000000000) + 5;
for (int(i) = 1; (i) <= (int)(m); (i)++) {
int u, v;
scanf("%d%d", &u, &v);
if (u == v) continue;
dis[u][v] = dis[v][u] = 1;
}
for (int(k) = 1; (k) <= (int)(n); (k)++)
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(n); (j)++)
mintt(dis[i][j], dis[i][k] + dis[k][j]);
scanf("%d%d%d", &s, &b, &k);
for (int(i) = 1; (i) <= (int)(s); (i)++) sp[i].rd();
for (int(i) = 1; (i) <= (int)(b); (i)++) bs[i].rd();
map<int, int> hsh;
int cnt = 0;
for (int(i) = 1; (i) <= (int)(s); (i)++) hsh[sp[i].a];
for (int(i) = 1; (i) <= (int)(b); (i)++) hsh[bs[i].d];
for (auto& p : hsh) p.second = ++cnt;
for (int(i) = 1; (i) <= (int)(s); (i)++) sp[i].a = hsh[sp[i].a];
for (int(i) = 1; (i) <= (int)(b); (i)++) bs[i].d = hsh[bs[i].d];
memset(baseInf, -1, sizeof(baseInf));
for (int(j) = 1; (j) <= (int)(b); (j)++) {
maxtt(baseInf[bs[j].x][bs[j].d], bs[j].g);
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(cnt); (j)++)
maxtt(baseInf[i][j], baseInf[i][j - 1]);
for (int(i) = 1; (i) <= (int)(s); (i)++) {
for (int(j) = 1; (j) <= (int)(n); (j)++)
if (dis[sp[i].x][j] <= sp[i].f) {
maxtt(sp[i].pro, baseInf[j][sp[i].a]);
}
}
cal2();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity()
? std::numeric_limits<T>::infinty()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
template <class T>
class Dinic {
private:
struct edge {
int from, to;
T cap;
edge *rev;
edge(int u, int v, T c) : from(u), to(v), cap(c), rev(nullptr) {}
};
static constexpr T INF = Inf<T>::inf();
int n, s, t;
std::vector<std::vector<edge *>> g;
public:
Dinic(int n, int s, int t) : n(n), s(s), t(t), g(n) {}
~Dinic() {
for (auto v : g)
for (edge *e : v) delete e;
}
void addEdge(int u, int v, T c) {
edge *in = new edge(u, v, c);
edge *out = new edge(v, u, 0);
g[u].push_back(in);
g[v].push_back(out);
in->rev = out;
out->rev = in;
}
T maxFlow() {
T mxf = 0;
std::vector<T> dist(n, INF), vis(n);
std::function<T(int, T)> dfs = [&](int u, T fo) -> T {
if (u == t) return fo;
for (; vis[u] < int(g[u].size()); vis[u]++) {
edge *e = g[u][vis[u]];
int v = e->to;
if (dist[v] != dist[u] + 1 || e->cap <= 0) continue;
T foo = dfs(v, std::min(fo, e->cap));
if (foo > 0) {
e->cap -= foo;
e->rev->cap += foo;
return foo;
}
}
return 0;
};
for (;;) {
for (int i = 0; i < n; i++) dist[i] = INF, vis[i] = 0;
std::queue<int> q;
q.push(s);
dist[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == t) break;
for (edge *e : g[u]) {
int v = e->to;
if (e->cap > 0 && dist[v] == INF) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
if (dist[t] == INF) break;
while (T fo = dfs(s, INF)) mxf += fo;
}
return mxf;
}
};
template <class T>
constexpr T Dinic<T>::INF;
int solve() {
int n, m;
cin >> n >> m;
vvi dp(n, vi(n, INF));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
dp[u][v] = dp[v][u] = 1;
}
for (int i = 0; i < n; i++) dp[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
int s, b, k;
cin >> s >> b >> k;
vi xs(s), as(s), fs(s), ps(s), xb(b), db(b), gb(b);
for (int i = 0; i < s; i++) {
cin >> xs[i] >> as[i] >> fs[i] >> ps[i];
xs[i]--;
}
for (int i = 0; i < b; i++) {
cin >> xb[i] >> db[i] >> gb[i];
xb[i]--;
}
vll canGet(s, -BINF);
vector<vpii> bsList(n);
for (int i = 0; i < b; i++) bsList[xb[i]].emplace_back(db[i], gb[i]);
for (int i = 0; i < n; i++) {
sort(bsList[i].begin(), bsList[i].end());
int z = bsList[i].size();
for (int j = 1; j < z; j++)
bsList[i][j].second = max(bsList[i][j].second, bsList[i][j - 1].second);
}
for (int i = 0; i < s; i++)
for (int j = 0; j < n; j++) {
if (dp[xs[i]][j] > fs[i]) continue;
auto it =
upper_bound(bsList[j].begin(), bsList[j].end(), pii{as[i], INF});
if (it == bsList[j].begin()) continue;
it--;
canGet[i] = max(canGet[i], ll(it->second));
}
for (int i = 0; i < s; i++) canGet[i] -= ps[i];
ll ans = 0;
Dinic<ll> g(s + 2, s, s + 1);
for (int i = 0; i < s; i++) {
if (canGet[i] >= 0) {
ans += canGet[i];
g.addEdge(s, i, canGet[i]);
} else {
g.addEdge(i, s + 1, -canGet[i]);
}
}
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g.addEdge(u, v, BINF);
}
ans -= g.maxFlow();
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long large = 2000000000000000000LL;
struct Edge {
int from, to;
long long cap, flow;
};
struct Dinic {
int n, m, s, t;
vector<Edge> edges;
vector<vector<int> > G;
vector<bool> vis;
vector<int> dis;
vector<int> cur;
void init(int maxn) {
edges.clear();
G.assign(maxn + 10, vector<int>(0));
vis.assign(maxn + 10, false);
dis.assign(maxn + 10, 0);
cur.assign(maxn + 10, 0);
n = maxn;
}
void addEdge(int from, int to, long long cap) {
edges.push_back((Edge){from, to, cap, 0});
edges.push_back((Edge){to, from, 0, 0});
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
bool BFS() {
vis.assign(n + 10, false);
queue<int> q;
q.push(s);
dis[s] = 0;
vis[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)G[u].size(); i++) {
Edge& e = edges[G[u][i]];
if (!vis[e.to] && e.cap > e.flow) {
vis[e.to] = 1;
dis[e.to] = dis[u] + 1;
q.push(e.to);
}
}
}
return vis[t];
}
long long DFS(int x, long long a) {
if (x == t || a == 0) return a;
long long flow = 0, f;
for (int& i = cur[x]; i < (int)G[x].size(); i++) {
Edge& e = edges[G[x][i]];
if (dis[x] + 1 == dis[e.to] &&
(f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
e.flow += f;
edges[G[x][i] ^ 1].flow -= f;
flow += f;
a -= f;
if (a == 0) break;
}
}
return flow;
}
long long maxflow(int s, int t) {
this->s = s;
this->t = t;
long long flow = 0;
while (BFS()) {
cur.assign(n + 10, 0);
flow += DFS(s, large);
}
return flow;
}
void clearflow() {
vis.assign(n + 10, false);
dis.assign(n + 10, 0);
cur.assign(n + 10, 0);
for (int i = 0; i < (int)edges.size(); i++) {
edges[i].flow = 0;
}
}
};
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > g(n, vector<int>(n, 1000000000));
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x][y] = g[y][x] = 1;
}
for (int i = 0; i < n; i++) g[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
int s, b;
cin >> s >> b;
int k;
cin >> k;
vector<int> ps(s, 0), a(s, 0), f(s, 0), p(s, 0);
vector<int> pb(b, 0), d(b, 0), gold(b, 0);
for (int i = 0; i < s; i++) {
cin >> ps[i] >> a[i] >> f[i] >> p[i];
ps[i]--;
}
for (int i = 0; i < b; i++) {
cin >> pb[i] >> d[i] >> gold[i];
pb[i]--;
}
vector<vector<pair<int, int> > > adj(n, vector<pair<int, int> >());
for (int i = 0; i < b; i++) {
adj[pb[i]].push_back(pair<int, int>(d[i], gold[i]));
}
for (int i = 0; i < n; i++) sort(adj[i].begin(), adj[i].end());
for (int i = 0; i < n; i++) {
for (int j = 0; j < (int)adj[i].size(); j++) {
if (j) adj[i][j].second = max(adj[i][j].second, adj[i][j - 1].second);
}
}
for (int i = 0; i < s; i++) {
int ans = -1;
for (int j = 0; j < n; j++) {
if (g[ps[i]][j] > f[i]) continue;
int pt = upper_bound(adj[j].begin(), adj[j].end(),
pair<int, int>(a[i], 1000000010)) -
adj[j].begin();
pt--;
if (pt >= 0) ans = max(ans, adj[j][pt].second);
}
if (ans != -1)
p[i] = ans - p[i];
else
p[i] = -large;
}
Dinic din;
din.init(s + 10);
int st = s;
int en = st + 1;
long long sum = 0;
for (int i = 0; i < s; i++) {
if (p[i] > 0) {
din.addEdge(st, i, p[i]);
sum += p[i];
} else
din.addEdge(i, en, -p[i]);
}
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
din.addEdge(x, y, large);
}
cout << sum - din.maxflow(st, en) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long from, to, cap, flow, index;
Edge(int from, int to, long long cap, long long flow, int index)
: from(from), to(to), cap(cap), flow(flow), index(index) {}
};
struct PushRelabel {
int N;
vector<vector<Edge>> G;
vector<int> dist, active, count;
vector<long long> excess;
queue<int> Q;
PushRelabel(int N)
: N(N), G(N), excess(N), dist(N), active(N), count(2 * N) {}
void AddEdge(int from, int to, long long cap) {
G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
if (from == to) G[from].back().index++;
G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
}
void Enqueue(int v) {
if (!active[v] && excess[v] > 0) {
active[v] = true;
Q.push(v);
}
}
void Push(Edge &e) {
long long amt = min(excess[e.from], e.cap - e.flow);
if (dist[e.from] <= dist[e.to] || amt == 0) return;
e.flow += amt;
G[e.to][e.index].flow -= amt;
excess[e.to] += amt;
excess[e.from] -= amt;
Enqueue(e.to);
}
void Gap(int k) {
for (int v = 0; v < N; v++) {
if (dist[v] < k) continue;
count[dist[v]]--;
dist[v] = max(dist[v], N + 1);
count[dist[v]]++;
Enqueue(v);
}
}
void Relabel(int v) {
count[dist[v]]--;
dist[v] = 2 * N;
for (int i = 0; i < G[v].size(); i++)
if (G[v][i].cap - G[v][i].flow > 0)
dist[v] = min(dist[v], dist[G[v][i].to] + 1);
count[dist[v]]++;
Enqueue(v);
}
void Discharge(int v) {
for (int i = 0; excess[v] > 0 && i < G[v].size(); i++) Push(G[v][i]);
if (excess[v] > 0) {
if (count[dist[v]] == 1)
Gap(dist[v]);
else
Relabel(v);
}
}
long long GetMaxFlow(int s, int t) {
count[0] = N - 1;
count[N] = 1;
dist[s] = N;
active[s] = active[t] = true;
for (int i = 0; i < G[s].size(); i++) {
excess[s] += G[s][i].cap;
Push(G[s][i]);
}
while (!Q.empty()) {
int v = Q.front();
Q.pop();
active[v] = false;
Discharge(v);
}
long long totflow = 0;
for (int i = 0; i < G[s].size(); i++) totflow += G[s][i].flow;
return totflow;
}
};
const int INF = 1e5;
long long dis[101][101], n, m, u, v, gold[101], po[101], go, vis[100005];
long long ans, tot[100005];
vector<pair<int, int>> bases[101];
long long xs[100005], a[100005], f[100005], p[100005];
long long xb[100005], d[100005], g[100005];
vector<pair<int, int>> ships;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (j != i) dis[i][j] = INF;
}
for (int i = 0; i < m; ++i) {
cin >> u >> v;
if (u != v) dis[u][v] = dis[v][u] = 1;
}
for (int b = 1; b <= n; ++b)
for (int a = 1; a <= n; ++a)
for (int c = 1; c <= n; ++c)
dis[a][c] = min(dis[a][c], dis[a][b] + dis[b][c]);
int s, b, k;
cin >> s >> b >> k;
for (int i = 0; i < s; ++i) {
cin >> xs[i] >> a[i] >> f[i] >> p[i];
ships.push_back(make_pair(a[i], i));
}
for (int i = 0; i < b; ++i) {
cin >> xb[i] >> d[i] >> g[i];
bases[xb[i]].push_back(make_pair(d[i], g[i]));
}
for (int i = 1; i <= n; ++i) sort(bases[i].begin(), bases[i].end());
sort(ships.begin(), ships.end());
for (int j = 1; j <= n; j++) gold[j] = -(1LL << 55);
for (int i = 0; i < s; ++i) {
for (int j = 1; j <= n; ++j)
while (po[j] != (int)bases[j].size() &&
bases[j][po[j]].first <= ships[i].first)
gold[j] = max(gold[j], (long long)bases[j][po[j]++].second);
go = -(1LL << 55);
u = ships[i].second;
for (int j = 1; j <= n; ++j)
if (dis[j][xs[u]] < INF && dis[j][xs[u]] <= f[u]) {
go = max(go, gold[j]);
}
tot[u] = go - p[u];
}
PushRelabel pr(s + 2);
long long ls = 0;
for (int i = 0; i < s; i++) {
if (tot[i] > 0)
ls += tot[i], pr.AddEdge(0, i + 2, tot[i]);
else
pr.AddEdge(i + 2, 1, -tot[i]);
}
for (int i = 0; i < k; ++i) {
cin >> u >> v, u--, v--;
pr.AddEdge(u + 2, v + 2, (1LL << 55));
}
ls -= pr.GetMaxFlow(0, 1);
cout << ls << "\n";
}
|
#include <bits/stdc++.h>
using ll = long long;
const ll LINF = 1e13;
using namespace std;
namespace ProconLib {
template <typename cost_t = long long, bool hasNegativeCost = false,
cost_t INF = LINF>
class Flow {
public:
struct Edge {
int to;
cost_t cap, rev;
cost_t cost;
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
private:
int N;
Graph g;
vector<int> level;
vector<int> iter;
void bfs(int s);
cost_t dfs(int v, int t, cost_t f);
public:
Flow(int N) : N(N), g(N){};
void addEdge(int from, int to, cost_t cap);
void addEdge(int from, int to, cost_t cap, cost_t cost);
cost_t maxFlow(int s, int t);
cost_t minCostFlow(int s, int t, cost_t f);
};
template <typename cost_t, bool hasNegativeCost, cost_t INF>
void Flow<cost_t, hasNegativeCost, INF>::addEdge(int from, int to, cost_t cap) {
g[from].push_back({to, cap, int(g[to].size()), 0});
g[to].push_back({from, cost_t(0), int(g[from].size()) - 1, 0});
}
template <typename cost_t, bool hasNegativeCost, cost_t INF>
void Flow<cost_t, hasNegativeCost, INF>::addEdge(int from, int to, cost_t cap,
cost_t cost) {
g[from].push_back({to, cap, int(g[to].size()), cost});
g[to].push_back({from, cost_t(0), int(g[from].size()) - 1, -cost});
}
template <typename cost_t, bool hasNegativeCost, cost_t INF>
cost_t Flow<cost_t, hasNegativeCost, INF>::maxFlow(int s, int t) {
cost_t flow = 0;
while (true) {
bfs(s);
if (level[t] < 0) return flow;
iter.assign(N, 0);
cost_t f;
while ((f = dfs(s, t, INF)) > 0) {
flow += f;
}
}
}
template <typename cost_t, bool hasNegativeCost, cost_t INF>
void Flow<cost_t, hasNegativeCost, INF>::bfs(int s) {
level.assign(N, -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < g[v].size(); i++) {
Edge& e = g[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
template <typename cost_t, bool hasNegativeCost, cost_t INF>
cost_t Flow<cost_t, hasNegativeCost, INF>::dfs(int v, int t, cost_t f) {
if (v == t) return f;
for (int& i = iter[v]; i < g[v].size(); i++) {
Edge& e = g[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
cost_t d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
template <typename cost_t, bool hasNegativeCost, cost_t INF>
cost_t Flow<cost_t, hasNegativeCost, INF>::minCostFlow(int s, int t, cost_t f) {
using P = pair<cost_t, int>;
cost_t res = 0;
vector<cost_t> h(N, 0);
vector<int> used(N), preve(N), prevv(N);
vector<cost_t> dist(N);
while (f > 0) {
fill(dist.begin(), dist.end(), INF);
dist[s] = 0;
if (!hasNegativeCost) {
fill(used.begin(), used.end(), 0);
priority_queue<P, vector<P>, greater<P>> que;
que.push(make_pair(cost_t(0), s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (used[v]) continue;
used[v] = true;
for (int i = 0; i < g[v].size(); i++) {
Edge& e = g[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(make_pair(dist[e.to], e.to));
}
}
}
} else {
bool update = true;
while (update) {
update = false;
for (int v = 0; v < N; v++) {
if (dist[v] == INF) continue;
for (int i = 0; i < g[v].size(); i++) {
Edge& e = g[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
prevv[e.to] = v;
preve[e.to] = i;
update = true;
}
}
}
}
}
if (dist[t] == INF) {
return -1;
}
if (!hasNegativeCost) {
for (int v = 0; v < N; v++) h[v] += dist[v];
}
cost_t d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, g[prevv[v]][preve[v]].cap);
}
f -= d;
if (!hasNegativeCost) {
res += d * h[t];
} else {
res += d * dist[t];
}
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 res;
}
} // namespace ProconLib
struct Spaceship {
int x, a, f, p;
};
struct Base {
int x, d, g;
};
using namespace ProconLib;
using vvi = vector<vector<int>>;
void dfs(int v, vvi& g, vector<int>& used, vector<int>& vs) {
used[v] = true;
vs.push_back(v);
for (auto to : g[v]) {
if (used[to]) continue;
dfs(to, g, used, vs);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> dist(n, vector<int>(n, 1e9 + 5));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
dist[u][v] = 1;
dist[v][u] = 1;
}
for (int i = 0; i < n; i++) dist[i][i] = 0;
int s, b, k;
cin >> s >> b >> k;
vector<Spaceship> ship(s);
for (int i = 0; i < s; i++) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p, ship[i].x--;
}
vector<Base> base(b);
for (int i = 0; i < b; i++) {
cin >> base[i].x >> base[i].d >> base[i].g;
base[i].x--;
}
vvi sg(s);
for (int i = 0; i < k; i++) {
int s1, s2;
cin >> s1 >> s2;
s1--, s2--;
sg[s1].push_back(s2);
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
vector<ll> profit(s, -LINF);
vector<vector<int>> bids(n);
for (int i = 0; i < b; i++) {
bids[base[i].x].push_back(i);
}
auto cmp = [&](int lhs, int rhs) { return base[lhs].d < base[rhs].d; };
for (int i = 0; i < n; i++) sort(bids[i].begin(), bids[i].end(), cmp);
vector<vector<int>> accMax(n);
for (int i = 0; i < n; i++) {
accMax[i].resize(bids[i].size() + 1);
for (int j = 0; j < bids[i].size(); j++) {
accMax[i][j + 1] = max(accMax[i][j], base[bids[i][j]].g);
}
}
for (int i = 0; i < s; i++) {
int x = ship[i].x;
for (int v = 0; v < n; v++) {
if (dist[x][v] <= ship[i].f) {
int lb = -1, ub = bids[v].size();
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (base[bids[v][mid]].d <= ship[i].a)
lb = mid;
else
ub = mid;
}
ll sc = accMax[v][ub] - ship[i].p;
if (ub > 0) profit[i] = max(profit[i], sc);
}
}
}
auto doFlow = [&](const vvi& graph, const vector<ll>& mpPro) {
int n = graph.size();
const int S = n;
const int T = n + 1;
Flow<ll> flow(n + 2);
ll sum = 0;
for (int i = 0; i < n; i++) {
if (mpPro[i] > 0) {
sum += mpPro[i];
flow.addEdge(S, i, mpPro[i]);
flow.addEdge(i, T, 0);
} else {
flow.addEdge(S, i, 0);
flow.addEdge(i, T, -mpPro[i]);
}
}
for (int i = 0; i < n; i++) {
for (auto to : graph[i]) {
flow.addEdge(i, to, LINF);
}
}
return sum - flow.maxFlow(S, T);
};
vvi undirSG(s);
for (int i = 0; i < s; i++) {
for (auto to : sg[i]) {
undirSG[i].push_back(to);
undirSG[to].push_back(i);
}
}
ll res = 0;
vector<int> used(s);
for (int i = 0; i < s; i++) {
if (!used[i]) {
vector<int> vs;
dfs(i, undirSG, used, vs);
if (vs.size() == 1) {
if (profit[i] > 0) res += profit[i];
continue;
}
map<int, int> mp;
int id = 0;
for (auto v : vs) {
mp[v] = id++;
}
vvi mapG(id);
vector<ll> mpPro(id);
for (auto v : vs) {
mpPro[mp[v]] = profit[v];
for (auto to : sg[v]) {
mapG[mp[v]].push_back(mp[to]);
}
}
res += doFlow(mapG, mpPro);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const long long oo = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
int dist[128][128];
struct ss {
int x, a, f, p;
} SS[100000];
long long best[100000];
vector<pair<int, int>> BASE[128];
template <typename flow_type>
struct dinic {
struct edge {
size_t src, dst, rev;
flow_type flow, cap;
};
int n;
vector<vector<edge>> adj;
dinic(int n) : n(n), adj(n), level(n), q(n), it(n) {}
void add_edge(size_t src, size_t dst, flow_type cap, flow_type rcap = 0) {
adj[src].push_back({src, dst, adj[dst].size(), 0, cap});
if (src == dst) adj[src].back().rev++;
adj[dst].push_back({dst, src, adj[src].size() - 1, 0, rcap});
}
vector<int> level, q, it;
bool bfs(int source, int sink) {
fill(level.begin(), level.end(), -1);
for (int qf = level[q[0] = sink] = 0, qb = 1; qf < qb; ++qf) {
sink = q[qf];
for (edge &e : adj[sink]) {
edge &r = adj[e.dst][e.rev];
if (r.flow < r.cap && level[e.dst] == -1)
level[q[qb++] = e.dst] = 1 + level[sink];
}
}
return level[source] != -1;
}
flow_type augment(int source, int sink, flow_type flow) {
if (source == sink) return flow;
for (; it[source] != adj[source].size(); ++it[source]) {
edge &e = adj[source][it[source]];
if (e.flow < e.cap && level[e.dst] + 1 == level[source]) {
flow_type delta = augment(e.dst, sink, min(flow, e.cap - e.flow));
if (delta > 0) {
e.flow += delta;
adj[e.dst][e.rev].flow -= delta;
return delta;
}
}
}
return 0;
}
flow_type max_flow(int source, int sink) {
for (int u = 0; u < n; ++u)
for (edge &e : adj[u]) e.flow = 0;
flow_type flow = 0;
flow_type oo = numeric_limits<flow_type>::max();
while (bfs(source, sink)) {
fill(it.begin(), it.end(), 0);
for (flow_type f; (f = augment(source, sink, oo)) > 0;) flow += f;
}
return flow;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
memset(dist, 0x3f, sizeof dist);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
dist[u][v] = dist[v][u] = 1;
}
for (int i = 0; i < n; ++i) dist[i][i] = 0;
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int s, b, k;
cin >> s >> b >> k;
for (int i = 0; i < s; ++i) {
cin >> SS[i].x >> SS[i].a >> SS[i].f >> SS[i].p;
SS[i].x--;
best[i] = -oo;
}
for (int i = 0; i < b; ++i) {
int x, d, g;
cin >> x >> d >> g;
x--;
BASE[x].push_back({d, g});
}
for (int i = 0; i < n; ++i) {
sort(BASE[i].begin(), BASE[i].end());
vector<pair<int, int>> inc;
for (auto p : BASE[i]) {
if (inc.empty() || p.second > inc.back().second) {
inc.push_back(p);
}
}
for (int j = 0; j < s; ++j) {
if (SS[j].f < dist[SS[j].x][i]) continue;
int p =
upper_bound(inc.begin(), inc.end(), pair<int, int>(SS[j].a, mod)) -
inc.begin();
if (p) {
--p;
best[j] = max(best[j], 1LL * (inc[p].second - SS[j].p));
}
}
}
dinic<long long> closure(s + 2);
for (int i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
closure.add_edge(u + 2, v + 2, oo);
}
long long positive = 0;
for (int i = 0; i < s; ++i) {
if (best[i] >= 0) {
positive += best[i];
closure.add_edge(0, i + 2, best[i]);
} else {
closure.add_edge(i + 2, 1, -best[i]);
}
}
long long cut = closure.max_flow(0, 1);
cout << positive - cut << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
class edge {
public:
int e, nxt;
long long cap;
edge(int e1 = -1, int nxt1 = -1, long long cap1 = 0) {
e = e1, nxt = nxt1, cap = cap1;
}
};
int S, T;
int dep[2510];
bool vis[2510];
class graph {
public:
edge g[3000000];
int head[2510], tmpcnt;
int cur[2510];
void init() {
memset(head, 255, sizeof(head));
tmpcnt = 0;
}
void addedge(int s, int e, long long cap) {
if (cap == 0) return;
g[tmpcnt] = edge(e, head[s], cap), head[s] = tmpcnt++;
g[tmpcnt] = edge(s, head[e], 0), head[e] = tmpcnt++;
}
bool bfs() {
memset(vis, 0, sizeof(vis));
memset(dep, 0, sizeof(dep));
queue<int> q;
q.push(S);
vis[S] = 1;
while (!q.empty()) {
int fr = q.front();
q.pop();
for (int i = head[fr]; i != -1; i = g[i].nxt) {
if (g[i].cap > 0 && !vis[g[i].e]) {
dep[g[i].e] = dep[fr] + 1;
vis[g[i].e] = 1;
q.push(g[i].e);
}
}
}
return vis[T];
}
long long dfs(int np, long long maxflow) {
long long f, flow = 0;
if (np == T || !maxflow) return maxflow;
for (int i = cur[np]; i != -1; i = g[i].nxt) {
cur[np] = i;
if (g[i].cap > 0 && dep[g[i].e] == dep[np] + 1 &&
(f = dfs(g[i].e, min(g[i].cap, maxflow))) > 0) {
g[i].cap -= f;
g[i ^ 1].cap += f;
flow += f;
maxflow -= f;
if (!maxflow) break;
}
}
return flow;
}
long long dinic() {
long long out = 0;
while (bfs()) memcpy(cur, head, sizeof(cur)), out += dfs(S, INF);
return out;
}
} G;
int n, m, dis[110][110], s, B, K;
long long vl[100010];
class ship {
public:
int x, a, f, p;
} sp[100010];
vector<pair<int, int> > bas[110];
class dependency {
public:
int s, e;
} dpd[1010];
int flag[1000010];
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1, ti, tj; i <= m; i++) {
scanf("%d%d", &ti, &tj);
dis[ti][tj] = dis[tj][ti] = min(dis[ti][tj], 1);
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
scanf("%d%d%d", &s, &B, &K);
for (int i = 1; i <= s; i++)
scanf("%d%d%d%d", &sp[i].x, &sp[i].a, &sp[i].f, &sp[i].p);
for (int i = 1, ti, tj, tk; i <= B; i++) {
scanf("%d%d%d", &ti, &tj, &tk);
bas[ti].push_back(make_pair(tj, tk));
}
for (int i = 1; i <= n; i++) {
sort(bas[i].begin(), bas[i].end());
reverse(bas[i].begin(), bas[i].end());
vector<pair<int, int> > tmp;
for (auto &x : bas[i]) {
while (!tmp.empty() && x.second >= tmp.back().second) tmp.pop_back();
tmp.push_back(x);
}
reverse(tmp.begin(), tmp.end());
bas[i] = tmp;
}
for (int i = 1; i <= K; i++)
scanf("%d%d", &dpd[i].s, &dpd[i].e), flag[dpd[i].s] = flag[dpd[i].e] = 1;
for (int i = 1; i <= s; i++) {
int mxp = -1e9;
for (int j = 1; j <= n; j++) {
if (dis[sp[i].x][j] <= sp[i].f) {
auto x = upper_bound(bas[j].begin(), bas[j].end(),
make_pair(sp[i].a + 1, -1000000000));
if (x == bas[j].begin()) continue;
x--;
mxp = max(mxp, x->second);
}
}
if (mxp == -1e9)
vl[i] = -1e18;
else
vl[i] = mxp - sp[i].p;
}
vector<int> used;
used.push_back(0);
long long ans = 0;
for (int i = 1; i <= s; i++) {
if (!flag[i]) {
if (vl[i] > 0) ans += vl[i];
} else
flag[i] = used.size(), used.push_back(i);
}
int cnt = used.size();
cnt--;
S = cnt + 1;
T = cnt + 2;
G.init();
for (int i = 1; i <= cnt; i++) {
if (vl[used[i]] >= 0)
G.addedge(S, i, vl[used[i]]), ans += vl[used[i]];
else
G.addedge(i, T, -vl[used[i]]);
}
for (int i = 1; i <= K; i++) G.addedge(flag[dpd[i].s], flag[dpd[i].e], INF);
printf("%lld\n", ans - G.dinic());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000002013;
const double pi = atan(1.0) * 4.0;
const double eps = 1e-8;
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
int bc(int n) { return n ? bc((n - 1) & n) + 1 : 0; }
const int N = 100001;
int i, j, k, m, n, h;
string s;
int d[101][101];
int attackx[N], attacka[N], attackd[N], attackp[N], profit[N], basen;
vector<pair<int, int> > bases[N];
int dead[N];
vector<int> depends1[N], depends2[N];
void DFS(int i) {
if (dead[i]) return;
dead[i] = 1;
for (int j : depends2[i]) {
DFS(j);
}
}
vector<int> adj[2002];
long long a[2002][2002], v[2002], t;
int rec(int i, long long fl) {
v[i] = 1;
if (i == t) return 1;
for (int j : adj[i])
if (a[i][j] >= fl && !v[j] && rec(j, fl)) {
a[i][j] -= fl;
a[j][i] += fl;
return 1;
}
return 0;
}
long long Flow() {
long long ret = 0;
long long fl = 1e18;
while (fl) {
for (i = 0; i <= t; i++) v[i] = 0;
if (rec(0, fl))
ret += fl;
else
fl /= 2;
}
return ret;
}
void AddEdge(int i, int j, long long f) {
a[i][j] = f;
adj[i].push_back(j);
adj[j].push_back(i);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = (i != j) * inf;
for (int i = 1; i <= m; i++) {
cin >> j >> k;
d[j][k] = d[k][j] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
cin >> m >> basen >> k;
for (int i = 1; i <= m; i++)
cin >> attackx[i] >> attacka[i] >> attackd[i] >> attackp[i];
for (int tt = 1; tt <= basen; tt++) {
pair<int, int> p;
cin >> i >> p.first >> p.second;
p.second *= -1;
bases[i].push_back(p);
}
while (k--) {
int s1, s2;
cin >> s1 >> s2;
depends1[s1].push_back(s2);
depends2[s2].push_back(s1);
}
for (int i = 1; i <= n; i++)
if (!bases[i].empty()) {
sort(bases[i].begin(), bases[i].end());
vector<pair<int, int> > newbases;
for (pair<int, int>& p : bases[i]) {
p.second *= -1;
if (newbases.empty()) {
newbases.push_back(p);
} else if (p.second > newbases.back().second)
newbases.push_back(p);
}
bases[i] = newbases;
}
for (int i = 1; i <= m; i++) {
profit[i] = -inf;
for (int j = 1; j <= n; j++)
if (attackd[i] >= d[attackx[i]][j] && !bases[j].empty()) {
auto it = upper_bound(bases[j].begin(), bases[j].end(),
pair<int, int>(attacka[i], inf));
if (it != bases[j].begin()) {
it--;
profit[i] = max(profit[i], it->second);
}
}
}
for (int i = 1; i <= m; i++)
if (profit[i] < 0) DFS(i);
long long ans = 0;
for (int i = 1; i <= m; i++)
if (!dead[i] && depends1[i].empty() && depends2[i].empty()) {
dead[i] = 1;
if (profit[i] > attackp[i]) ans += profit[i] - attackp[i];
}
t = 0;
map<int, int> M;
for (int i = 1; i <= m; i++)
if (!dead[i]) {
M[i] = ++t;
}
t++;
long long pSum = 0, aSum = 0;
for (int i = 1; i <= m; i++)
if (!dead[i]) {
pSum += profit[i];
aSum += attackp[i];
AddEdge(0, M[i], profit[i]);
AddEdge(M[i], t, attackp[i]);
for (int j : depends1[i])
if (!dead[j]) {
AddEdge(M[i], M[j], 1e18);
}
}
long long z = Flow();
ans += pSum - z;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dist[100][100];
const int nax = 1e5 + 10;
vector<pair<int, int>> base[nax];
struct Ship {
int x, a, f;
long long p;
};
Ship ship[nax];
int easiest_base[100];
struct Edge {
int end;
long long cap;
};
vector<Edge> edges;
vector<int> node[nax];
void addEdge(int a, int b, long long w) {
node[a].push_back(edges.size());
edges.push_back({b, w});
node[b].push_back(edges.size());
edges.push_back({a, 0});
}
int done[nax];
long long maxFlow(int p, int sink, long long ma = 1e18) {
if (p == sink) return ma;
if (ma == 0 || done[p]++) return 0;
for (int ei : node[p]) {
Edge& e = edges[ei];
long long flow;
if (e.cap && (flow = maxFlow(e.end, sink, min(ma, e.cap)))) {
edges[ei].cap -= flow;
edges[ei ^ 1].cap += flow;
return flow;
}
}
return 0;
}
int has_edge[nax];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dist[i][j] = i == j ? 0 : 1e9;
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
dist[a][b] = dist[b][a] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
int ships, bases, deps;
cin >> ships >> bases >> deps;
for (int i = 0; i < ships; i++) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p;
ship[i].x--;
}
fill_n(easiest_base, n, 1e9 + 10);
for (int i = 0; i < bases; i++) {
int x, d, g;
cin >> x >> d >> g;
x--;
base[x].push_back({d, g});
easiest_base[x] = min(easiest_base[x], d);
}
for (int i = 0; i < n; i++) {
sort(base[i].begin(), base[i].end());
vector<pair<int, int>> comp = {{0, 0}};
for (auto p : base[i]) {
if (p.second <= comp.back().second) continue;
if (p.first == comp.back().first) comp.pop_back();
comp.push_back(p);
}
base[i] = comp;
}
int source = ships, sink = ships + 1, N = ships + 2;
long long sum = 0;
for (int i = 0; i < deps; i++) {
int a, b;
cin >> a >> b;
a--, b--;
addEdge(a, b, 1e18);
has_edge[a] = has_edge[b] = 1;
}
for (int i = 0; i < ships; i++) {
int most_gold = -1;
for (int j = 0; j < n; j++) {
if (easiest_base[j] > ship[i].a || dist[ship[i].x][j] > ship[i].f)
continue;
int gold = prev(upper_bound(base[j].begin(), base[j].end(),
make_pair(ship[i].a, (int)2e9)))
->second;
most_gold = max(most_gold, gold);
}
if (!has_edge[i]) {
sum += max(most_gold - ship[i].p, 0ll);
continue;
}
if (most_gold == -1)
ship[i].p = 1e15;
else {
addEdge(source, i, most_gold);
sum += most_gold;
}
addEdge(i, sink, ship[i].p);
}
long long flow = 0;
while (1) {
fill_n(done, N, 0);
long long newflow = maxFlow(source, sink);
if (!newflow) break;
flow += newflow;
}
cout << sum - flow << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const long long INFTY = 1LL << 60;
int N, M, S, B, K;
long long dist[105][105];
long long maxG[105];
int spos[MAXN], fuel[MAXN], price[MAXN];
int bpos[MAXN], gold[MAXN];
long long profit[MAXN];
vector<tuple<int, int, int> > E;
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
struct Dinic {
const static long long INFTY = 1LL << 60;
int N;
vector<Edge> E;
vector<vector<int> > g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void addEdge(int u, int v, long long cap) {
if (u != v) {
E.push_back(Edge(u, v, cap));
g[u].push_back(E.size() - 1);
E.push_back(Edge(v, u, 0));
g[v].push_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q;
q.push(S);
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.push(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = INFTY) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = min(flow, e.cap - e.flow);
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long maxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++) dist[i][j] = dist[j][i] = INFTY;
for (int i = 0, a, b; i < M; i++) {
cin >> a >> b;
if (a != b) dist[a][b] = dist[b][a] = 1;
}
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
cin >> S >> B >> K;
for (int i = 1, a; i <= S; i++) {
cin >> spos[i] >> a >> fuel[i] >> price[i];
E.emplace_back(a, 1, i);
}
for (int i = 1, d; i <= B; i++) {
cin >> bpos[i] >> d >> gold[i];
E.emplace_back(d, 0, i);
}
for (int i = 1; i <= S; i++) profit[i] = -INFTY;
for (int i = 1; i <= N; i++) maxG[i] = -INFTY;
sort(E.begin(), E.end());
for (tuple<int, int, int> e : E) {
int power, type, idx;
tie(power, type, idx) = e;
if (type == 0)
maxG[bpos[idx]] = max(maxG[bpos[idx]], (long long)gold[idx]);
else {
for (int i = 1; i <= N; i++)
if (fuel[idx] >= dist[spos[idx]][i])
profit[idx] = max(profit[idx], maxG[i] - price[idx]);
}
}
Dinic dinic(S + 2);
long long ans = 0;
for (int i = 1; i <= S; i++) {
if (profit[i] > 0) {
dinic.addEdge(0, i, profit[i]);
ans += profit[i];
} else
dinic.addEdge(i, S + 1, -profit[i]);
}
for (int i = 0, a, b; i < K; i++) {
cin >> a >> b;
dinic.addEdge(a, b, INFTY);
}
cout << ans - dinic.maxFlow(0, S + 1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17;
const long long maxn = 100015;
const long long maxm = 1000005;
long long g[105][105];
long long num[maxn];
long long id[maxn];
long long cnt;
void floyed(long long n) {
for (long long k = 1; k <= n; k++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
};
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct Edge {
long long to, next, cap, flow;
} edge[maxm];
long long tol, head[maxn];
void init() {
tol = 2;
memset(head, -1, sizeof(head));
}
void addedge(long long u, long long v, long long w, long long rw = 0) {
edge[tol].to = v;
edge[tol].cap = w;
edge[tol].flow = 0;
edge[tol].next = head[u];
head[u] = tol++;
edge[tol].to = u;
edge[tol].cap = rw;
edge[tol].flow = 0;
edge[tol].next = head[v];
head[v] = tol++;
}
long long Q[maxn];
long long dep[maxn], cur[maxn], sta[maxn];
bool bfs(long long s, long long t, long long n) {
long long front = 0, tail = 0;
memset(dep, -1, sizeof(dep[0]) * (n + 1));
dep[s] = 0;
Q[tail++] = s;
while (front < tail) {
long long u = Q[front++];
for (long long i = head[u]; i != -1; i = edge[i].next) {
long long v = edge[i].to;
if (edge[i].cap > edge[i].flow && dep[v] == -1) {
dep[v] = dep[u] + 1;
if (v == t) {
return true;
}
Q[tail++] = v;
}
}
}
return false;
}
long long dinic(long long s, long long t, long long n) {
long long maxflow = 0;
while (bfs(s, t, n)) {
for (long long i = 0; i < n; i++) {
cur[i] = head[i];
}
long long u = s, tail = 0;
while (cur[s] != -1) {
if (u == t) {
long long tp = INF;
for (long long i = tail - 1; i >= 0; i--) {
tp = min(tp, edge[sta[i]].cap - edge[sta[i]].flow);
}
maxflow += tp;
for (long long i = tail - 1; i >= 0; i--) {
edge[sta[i]].flow += tp;
edge[sta[i] ^ 1].flow -= tp;
if (edge[sta[i]].cap - edge[sta[i]].flow == 0) {
tail = i;
}
}
u = edge[sta[tail] ^ 1].to;
} else if (cur[u] != -1 && edge[cur[u]].cap > edge[cur[u]].flow &&
dep[u] + 1 == dep[edge[cur[u]].to]) {
sta[tail++] = cur[u];
u = edge[cur[u]].to;
} else {
while (u != s && cur[u] == -1) {
u = edge[sta[--tail] ^ 1].to;
}
cur[u] = edge[cur[u]].next;
}
}
}
return maxflow;
}
long long fuckacm[100005];
long long ps[105];
long long shipos[maxn], atk[maxn], f[maxn], p[maxn], baspos[maxn], d[maxn],
gold[maxn], val[maxn], D[maxn];
bool svis[maxn];
vector<pair<long long, long long> > v1[105];
long long e[maxn][2];
bool cmp(long long x, long long y) { return atk[x] < atk[y]; }
long long ans = 0;
signed main() {
long long n, m, u, v, s, b, k;
n = read(), m = read();
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
if (i == j)
g[i][j] = 0;
else
g[i][j] = g[j][i] = INF;
}
}
for (long long i = 1; i <= m; i++) {
u = read(), v = read();
g[u][v] = g[v][u] = 1;
}
floyed(n);
s = read(), b = read(), k = read();
for (long long i = 1; i <= s; i++) {
shipos[i] = read(), atk[i] = read(), f[i] = read(), p[i] = read();
id[i] = i;
}
for (long long i = 1; i <= b; i++) {
baspos[i] = read(), d[i] = read(), gold[i] = read();
v1[baspos[i]].emplace_back(pair<long long, long long>(d[i], gold[i]));
}
sort(id + 1, id + 1 + s, cmp);
for (long long i = 1; i <= n; i++) {
sort(v1[i].begin(), v1[i].end());
ps[i] = 0;
for (long long j = 1; j < v1[i].size(); j++) {
v1[i][j].second = max(v1[i][j].second, v1[i][j - 1].second);
}
}
for (long long I = 1; I <= s; I++) {
long long i = id[I];
long long ma = -INF;
for (long long j = 1; j <= n; j++) {
if (g[shipos[i]][j] <= f[i]) {
if (v1[j].empty()) continue;
while (ps[j] < v1[j].size() - 1 && v1[j][ps[j] + 1].first <= atk[i])
ps[j]++;
if (v1[j][ps[j]].first <= atk[i]) ma = max(ma, v1[j][ps[j]].second);
}
}
val[i] = ma - p[i];
if (val[i] > 0) ans += val[i];
}
for (long long i = 1; i <= k; i++) {
e[i][0] = read(), e[i][1] = read();
D[e[i][0]]++, D[e[i][1]]++;
}
long long S = 2015 + 1, T = S + 1;
init();
for (long long i = 1; i <= s; i++) {
if (D[i]) id[i] = ++cnt;
}
for (long long i = 1; i <= s; i++) {
if (D[i]) {
if (val[i] > 0)
addedge(S, id[i], val[i]);
else
addedge(id[i], T, -val[i]);
}
}
for (long long i = 1; i <= k; i++) {
addedge(id[e[i][0]], id[e[i][1]], INF);
}
ans -= dinic(S, T, T + 1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Dinic {
private:
struct Edge {
long long to, cap, rev;
Edge(long long t, long long c, long long r) : to(t), cap(c), rev(r) {}
};
long long V;
std::vector<std::vector<Edge>> graph;
std::vector<long long> level, iter;
public:
Dinic(long long v) : V(v) {
graph.resize(v);
level.resize(v, -1);
iter.resize(v, 0);
}
void add_edge(long long from, long long to, long long cap) {
graph[from].emplace_back(to, cap, graph[to].size());
graph[to].emplace_back(from, 0, graph[from].size() - 1);
}
void bfs(long long s) {
std::fill(level.begin(), level.end(), -1);
std::queue<long long> queue;
level[s] = 0;
queue.push(s);
while (!queue.empty()) {
long long v = queue.front();
queue.pop();
for (long long i = 0; i < (long long)graph[v].size(); ++i) {
Edge& e = graph[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
queue.push(e.to);
}
}
}
}
long long dfs(long long v, long long t, long long f) {
if (v == t) return f;
for (long long& i = iter[v]; i < (long long)graph[v].size(); ++i) {
Edge& e = graph[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
long long d = dfs(e.to, t, std::min(f, e.cap));
if (d > 0) {
e.cap -= d;
graph[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(long long s, long long t) {
long long res = 0;
while (true) {
bfs(s);
if (level[t] < 0) return res;
std::fill(iter.begin(), iter.end(), 0);
long long f;
while ((f = dfs(s, t, LLONG_MAX)) > 0) {
res += f;
}
}
}
};
long long dist[200][200];
long long x[200000], a[200000], f[200000], p[200000];
long long y[200000], d[200000], g[200000];
vector<pair<long long, long long>> v[200][200];
bool used[200000];
long long s1[2000], s2[2000];
signed main() {
long long n, m;
cin >> n >> m;
memset(d, 0x3f, sizeof(d));
for (long long i = 0; i < (n); i++) dist[i][i] = 0;
for (long long i = 0; i < (m); i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
a--;
b--;
if (a == b) continue;
dist[a][b] = dist[b][a] = 1;
}
for (long long k = 0; k < (n); k++)
for (long long i = 0; i < (n); i++)
for (long long j = 0; j < (n); j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
long long s, b, k;
scanf("%lld%lld%lld", &s, &b, &k);
for (long long i = 0; i < (s); i++) {
scanf("%lld%lld%lld%lld", &x[i], &a[i], &f[i], &p[i]);
x[i]--;
}
for (long long i = 0; i < (b); i++) {
scanf("%lld%lld%lld", &y[i], &d[i], &g[i]);
y[i]--;
}
for (long long i = 0; i < (k); i++) {
scanf("%lld%lld", &s1[i], &s2[i]);
s1[i]--;
s2[i]--;
used[s1[i]] = used[s2[i]] = true;
}
for (long long i = 0; i < (n); i++) {
for (long long j = 0; j < (b); j++) {
if (dist[i][y[j]] != 0x3f3f3f3f3f3f3f3f) {
v[i][dist[i][y[j]]].push_back(pair<long long, long long>(d[j], g[j]));
}
}
for (long long j = 0; j < (n); j++) {
sort(v[i][j].begin(), v[i][j].end(),
[](pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
});
vector<pair<long long, long long>> u;
for (pair<long long, long long> p : v[i][j]) {
if (u.empty() || u.back().second < p.second) u.push_back(p);
}
v[i][j] = u;
}
}
long long ans = 0;
vector<long long> vs;
for (long long i = 0; i < (s); i++) {
if (used[i]) vs.push_back(i);
}
sort(vs.begin(), vs.end());
vs.erase(unique(vs.begin(), vs.end()), vs.end());
Dinic dinic(vs.size() + 2);
for (long long i = 0; i < (s); i++) {
long long Max = -1;
for (long long j = 0; j < (min(n, f[i] + 1)); j++) {
long long it = upper_bound(v[x[i]][j].begin(), v[x[i]][j].end(),
pair<long long, long long>(a[i], INT_MAX)) -
v[x[i]][j].begin();
if (it) {
it--;
Max = max(Max, v[x[i]][j][it].second);
}
}
if (!used[i]) {
if (Max - p[i] > 0) ans += Max - p[i];
} else {
long long id = lower_bound(vs.begin(), vs.end(), i) - vs.begin();
if (Max == -1) {
dinic.add_edge(vs.size(), id, 0);
dinic.add_edge(id, vs.size() + 1, LLONG_MAX / 100000);
} else if (Max - p[i] > 0) {
ans += Max - p[i];
dinic.add_edge(vs.size(), id, Max - p[i]);
dinic.add_edge(id, vs.size() + 1, 0);
} else {
dinic.add_edge(vs.size(), id, 0);
dinic.add_edge(id, vs.size() + 1, p[i] - Max);
}
}
}
for (long long i = 0; i < (k); i++) {
long long S1 = lower_bound(vs.begin(), vs.end(), s1[i]) - vs.begin();
long long S2 = lower_bound(vs.begin(), vs.end(), s2[i]) - vs.begin();
if (S1 == S2) continue;
dinic.add_edge(S1, S2, LLONG_MAX / 100000);
}
cout << ans - dinic.max_flow(vs.size(), vs.size() + 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
struct Dinic {
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap) {
if (u != v) {
E.emplace_back(Edge(u, v, cap));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
struct ship_t {
long long x, a, f, p;
};
struct base_t {
long long x, d, g;
bool operator<(const base_t &o) const { return d < o.d; }
};
const int N = 1e2 + 10, S = 1e5 + 10;
const long long inf = 1e12 + 42;
ship_t ship[S];
base_t base[S];
long long g[N][N];
vector<int> dep[S];
vector<pair<long long, long long>> bases_at[N];
bool seen[S];
long long val[S];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
g[i][j] = g[j][i] = inf;
}
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u][v] = g[v][u] = min(g[u][v], 1ll);
}
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
for (int i = 1; i <= s; ++i) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p;
}
for (int i = 1; i <= b; ++i) {
cin >> base[i].x >> base[i].d >> base[i].g;
}
sort(base + 1, base + 1 + b);
for (int i = 1; i <= b; ++i) {
int p = base[i].x;
if (bases_at[p].empty() or bases_at[p].back().second < base[i].g) {
bases_at[p].push_back({base[i].d, base[i].g});
}
}
Dinic dinic(s + 2);
int source = 0, sink = s + 1;
long long ans = 0;
for (int i = 1; i <= s; ++i) {
bool found = false;
for (int p = 1; p <= n; ++p) {
if (g[ship[i].x][p] > ship[i].f) {
continue;
}
auto it = upper_bound(bases_at[p].begin(), bases_at[p].end(),
make_pair(ship[i].a, inf));
if (it != bases_at[p].begin()) {
--it;
val[i] = max(val[i], it->second);
found = true;
}
}
val[i] -= ship[i].p;
if (!found) {
val[i] = -inf;
}
if (val[i] >= 0) {
ans += val[i];
dinic.AddEdge(source, i, val[i]);
} else {
dinic.AddEdge(i, sink, -val[i]);
}
}
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
dep[u].push_back(v);
}
for (int i = 1; i <= s; ++i) {
if (val[i] < 0) {
continue;
}
vector<int> vis = {i};
queue<int> q;
q.push(i);
seen[i] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
if (val[u] < 0) {
dinic.AddEdge(i, u, inf);
}
for (auto &v : dep[u]) {
if (!seen[v]) {
seen[v] = true;
vis.push_back(v);
q.push(v);
}
}
}
for (auto &u : vis) {
seen[u] = false;
}
}
cout << ans - dinic.MaxFlow(source, sink);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 100000000000000;
const long double eps = 1e-8;
struct edge {
int to;
long long cap;
int rev;
};
vector<edge> G[100000];
bool used[100000];
void add_edge(int from, int to, long long cap) {
G[from].push_back(edge{to, cap, (int)G[to].size()});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1});
}
long long dfs(int v, int t, long long f) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(int s, int t) {
long long flow = 0;
for (;;) {
memset(used, 0, sizeof(used));
long long f = dfs(s, t, INF);
if (f == 0) return flow;
flow += f;
}
}
int distr[101][101];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
distr[i][j] = 0;
else
distr[i][j] = mod;
}
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
distr[a][b] = distr[b][a] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
distr[i][j] = min(distr[i][j], distr[i][k] + distr[k][j]);
}
}
}
int nl, nr, nrel;
cin >> nl >> nr >> nrel;
vector<int> xl(nl), a(nl), f(nl), p(nl);
vector<int> xr(nr), b(nr), g(nr);
for (int i = 0; i < nl; i++) {
cin >> xl[i] >> a[i] >> f[i] >> p[i];
xl[i]--;
}
for (int i = 0; i < nr; i++) {
cin >> xr[i] >> b[i] >> g[i];
xr[i]--;
}
vector<pair<int, int>> rel(nrel);
for (int i = 0; i < nrel; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
rel[i] = {u, v};
}
vector<vector<pair<int, int>>> vb(n);
for (int i = 0; i < nr; i++) {
vb[xr[i]].push_back({b[i], g[i]});
}
vector<vector<int>> bb(n), hg(n);
for (int i = 0; i < n; i++) {
sort(vb[i].begin(), vb[i].end());
bb[i].resize(vb[i].size());
hg[i].resize(vb[i].size() + 1);
int ma = -2 * mod;
for (int j = 0; j < (int)vb[i].size(); j++) {
bb[i][j] = vb[i][j].first;
hg[i][j] = ma;
ma = max(ma, vb[i][j].second);
}
hg[i][vb[i].size()] = ma;
}
vector<bool> cant(nl, false);
vector<long long> val(nl);
for (int i = 0; i < nl; i++) {
int maval = -2 * mod;
for (int j = 0; j < n; j++) {
int d = distr[xl[i]][j];
if (d > f[i]) continue;
int id = upper_bound(bb[j].begin(), bb[j].end(), a[i]) - bb[j].begin();
maval = max(maval, hg[j][id]);
}
if (maval == -2 * mod) {
cant[i] = true;
}
val[i] = (long long)maval - (long long)p[i];
}
vector<bool> exi(nl, false);
for (int i = 0; i < nrel; i++) {
int u = rel[i].first, v = rel[i].second;
exi[u] = exi[v] = true;
}
vector<int> ids;
vector<int> trans(nl);
long long ans = 0;
for (int i = 0; i < nl; i++) {
if (!exi[i]) {
ans += max((long long)0, val[i]);
} else {
trans[i] = ids.size();
ids.push_back(i);
}
}
int s = ids.size();
int t = s + 1;
for (int i = 0; i < ids.size(); i++) {
int id = ids[i];
long long cost = val[id];
if (cost < 0) {
add_edge(s, i, -cost);
add_edge(i, t, 0);
} else {
add_edge(s, i, 0);
add_edge(i, t, cost);
}
if (cant[id]) {
add_edge(s, i, INF);
}
}
for (int i = 0; i < nrel; i++) {
int u = rel[i].first, v = rel[i].second;
u = trans[u], v = trans[v];
add_edge(v, u, INF);
}
long long sum = 0;
for (int i = 0; i < ids.size(); i++) {
if (val[ids[i]] >= 0) {
sum += val[ids[i]];
}
}
long long z = max_flow(s, t);
sum -= z;
ans += sum;
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100;
const int MAXSHIP = 100000;
const int MAXBASE = 100000;
const int MAXDEP = 1000;
const int MAXGN = 2 + MAXSHIP;
const int MAXGM = MAXSHIP + MAXDEP;
typedef struct MF {
int n, m;
int ghead[MAXGN], gnxt[2 * MAXGM], gto[2 * MAXGM];
long long gcap[2 * MAXGM];
void init(int _n) {
n = _n, m = 0;
for (int i = (0); i < (n); ++i) ghead[i] = -1;
}
void addedge(int a, int b, long long c) {
gnxt[2 * m + 0] = ghead[a], ghead[a] = 2 * m + 0, gto[2 * m + 0] = b,
gcap[2 * m + 0] = c;
gnxt[2 * m + 1] = ghead[b], ghead[b] = 2 * m + 1, gto[2 * m + 1] = a,
gcap[2 * m + 1] = 0;
++m;
}
int d[MAXGN];
int q[MAXGN], qhead, qtail;
int cur[MAXGN];
long long dinic(int s, int t) {
long long ret = 0;
int niter = 0;
while (true) {
for (int i = (0); i < (n); ++i) d[i] = INT_MAX;
qhead = qtail = 0;
d[s] = 0, q[qhead++] = s;
while (qtail < qhead && d[t] == INT_MAX) {
int at = q[qtail++];
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (gcap[x] == 0 || d[to] != INT_MAX) continue;
d[to] = d[at] + 1;
q[qhead++] = to;
}
}
if (d[t] == INT_MAX) return ret;
for (int i = (0); i < (n); ++i) cur[i] = ghead[i];
ret += dfs(s, t, LLONG_MAX);
++niter;
}
}
long long dfs(int at, int t, long long rem) {
long long ret = 0;
if (at == t) return rem;
if (d[at] >= d[t]) return 0;
for (; cur[at] != -1; cur[at] = gnxt[cur[at]]) {
int to = gto[cur[at]];
long long cap = gcap[cur[at]];
if (d[to] != d[at] + 1 || cap == 0) continue;
long long now = dfs(to, t, min(cap, rem));
rem -= now;
ret += now;
if (gcap[cur[at]] != LLONG_MAX) gcap[cur[at]] -= now;
if (gcap[cur[at] ^ 1] != LLONG_MAX) gcap[cur[at] ^ 1] += now;
if (rem == 0) return ret;
}
return ret;
}
} MF;
MF g;
struct Ship {
int pos, attack, fuel, cost;
};
struct Base {
int pos, defense, gold;
};
bool operator<(const Base &a, const Base &b) {
if (a.gold != b.gold) return a.gold > b.gold;
return a.defense < b.defense;
}
int n, m;
int d[MAXN][MAXN];
int nship, nbase, ndep;
Ship ship[MAXSHIP];
Base base[MAXBASE];
vector<int> dep[MAXSHIP];
vector<Base> opt[MAXN];
long long best[MAXSHIP];
vector<int> rdep[MAXSHIP];
bool alive[MAXSHIP];
int q[MAXSHIP], qhead, qtail;
int nid, sid, tid, shipid[MAXSHIP];
long long solve() {
for (int i = (0); i < (nbase); ++i) opt[base[i].pos].push_back(base[i]);
for (int i = (0); i < (n); ++i) sort(opt[i].begin(), opt[i].end());
for (int i = (0); i < (n); ++i) {
int nsz = 0;
for (int j = (0); j < (((int)(opt[i]).size())); ++j)
if (nsz == 0 || opt[i][j].defense < opt[i][nsz - 1].defense)
opt[i][nsz++] = opt[i][j];
opt[i].resize(nsz);
}
for (int i = (0); i < (nship); ++i) best[i] = LLONG_MIN;
for (int i = (0); i < (nship); ++i)
for (int j = (0); j < (n); ++j)
if (d[ship[i].pos][j] <= ship[i].fuel && ((int)(opt[j]).size()) > 0 &&
ship[i].attack >= opt[j].back().defense) {
int l = -1, r = ((int)(opt[j]).size()) - 1;
while (l + 1 < r) {
int m = l + (r - l) / 2;
if (ship[i].attack >= opt[j][m].defense)
r = m;
else
l = m;
}
best[i] = max(best[i], (long long)opt[j][r].gold - ship[i].cost);
}
for (int i = (0); i < (nship); ++i)
for (int j = (0); j < (((int)(dep[i]).size())); ++j) {
int k = dep[i][j];
rdep[k].push_back(i);
}
qhead = qtail = 0;
for (int i = (0); i < (nship); ++i) {
alive[i] = best[i] != LLONG_MIN;
if (!alive[i]) q[qhead++] = i;
}
while (qtail < qhead) {
int at = q[qtail++];
for (int i = (0); i < (((int)(rdep[at]).size())); ++i) {
int to = rdep[at][i];
if (alive[to]) alive[to] = false, q[qhead++] = to;
}
}
nid = 0, sid = nid++, tid = nid++;
for (int i = (0); i < (nship); ++i)
if (!alive[i])
shipid[i] = -1;
else
shipid[i] = nid++;
g.init(nid);
long long sum = 0;
for (int i = (0); i < (nship); ++i)
if (alive[i]) {
if (best[i] > 0) sum += best[i], g.addedge(sid, shipid[i], best[i]);
if (best[i] < 0) g.addedge(shipid[i], tid, -best[i]);
}
for (int i = (0); i < (nship); ++i)
for (int j = (0); j < (((int)(dep[i]).size())); ++j) {
int k = dep[i][j];
if (!alive[i]) continue;
assert(alive[k]);
g.addedge(shipid[i], shipid[k], LLONG_MAX);
}
long long flow = g.dinic(sid, tid);
return sum - flow;
}
void run() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) d[i][j] = i == j ? 0 : INT_MAX;
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
d[a][b] = min(d[a][b], 1);
d[b][a] = min(d[b][a], 1);
}
for (int k = (0); k < (n); ++k)
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j)
if (d[i][k] != INT_MAX && d[k][j] != INT_MAX)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
scanf("%d%d%d", &nship, &nbase, &ndep);
for (int i = (0); i < (nship); ++i)
scanf("%d%d%d%d", &ship[i].pos, &ship[i].attack, &ship[i].fuel,
&ship[i].cost),
--ship[i].pos;
for (int i = (0); i < (nbase); ++i)
scanf("%d%d%d", &base[i].pos, &base[i].defense, &base[i].gold),
--base[i].pos;
for (int i = (0); i < (ndep); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
dep[a].push_back(b);
}
printf("%lld\n", solve());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
const long long foo = (long long)1e18;
namespace Maxflow {
const int maxv = 2e5 + 5;
const int maxe = 1e7 + 5;
int n, s, t, E;
int adj[maxe], nxt[maxe], lst[maxv], ptr[maxv], lev[maxv], que[maxv];
long long flw[maxe], cap[maxe];
void init(int nn, int ss, int tt) {
n = nn, s = ss, t = tt, E = 0;
fill_n(lst, n, -1);
}
void add(int u, int v, long long c1, long long c2) {
adj[E] = v, flw[E] = 0, cap[E] = c1, nxt[E] = lst[u], lst[u] = E++;
adj[E] = u, flw[E] = 0, cap[E] = c2, nxt[E] = lst[v], lst[v] = E++;
}
int bfs() {
fill_n(lev, n, 0), lev[s] = 1;
int qsize = 0;
que[qsize++] = s;
for (int i = 0; i < qsize; i++) {
for (int u = que[i], e = lst[u]; ~e; e = nxt[e]) {
int v = adj[e];
if (flw[e] < cap[e] && !lev[v]) {
lev[v] = lev[u] + 1;
que[qsize++] = v;
}
}
}
return lev[t];
}
long long dfs(int u, long long bot) {
if (u == t) return bot;
for (int& e = ptr[u]; ~e; e = nxt[e]) {
int v = adj[e];
long long delta = 0;
if (lev[v] == lev[u] + 1 && flw[e] < cap[e] &&
(delta = dfs(v, min(bot, cap[e] - flw[e]))) > 0) {
flw[e] += delta;
flw[e ^ 1] -= delta;
return delta;
}
}
return 0;
}
long long maxflow(int ss = -1, int tt = -1) {
if (~ss) s = ss;
if (~tt) t = tt;
fill_n(flw, E, 0);
long long total = 0;
while (bfs()) {
for (int i = 0; i < n; i++) ptr[i] = lst[i];
for (long long delta = dfs(s, foo); delta > 0; delta = dfs(s, foo))
total += delta;
}
return total;
}
vector<pair<pair<int, int>, long long> > gomory_hu() {
vector<pair<pair<int, int>, long long> > tree;
vector<int> p(n);
for (int u = 1; u < n; u++) {
tree.push_back(make_pair(make_pair(p[u], u), maxflow(u, p[u])));
for (int v = u + 1; v < n; ++v) {
if (lev[v] && p[v] == p[u]) {
p[v] = u;
}
}
}
return tree;
}
} // namespace Maxflow
void chemthan() {
int n, m;
cin >> n >> m;
vector<vector<int> > d(n, vector<int>(n, INF));
for (int i = (0); i < (n); ++i) d[i][i] = 0;
for (int i = (0); i < (m); ++i) {
int u, v;
cin >> u >> v;
u--, v--;
if (u ^ v) {
d[u][v] = d[v][u] = 1;
}
}
for (int w = (0); w < (n); ++w)
for (int u = (0); u < (n); ++u)
for (int v = (0); v < (n); ++v) chkmin(d[u][v], d[u][w] + d[w][v]);
int s, b, k;
cin >> s >> b >> k;
vector<int> x(s), a(s), f(s), p(s);
for (int i = (0); i < (s); ++i) {
cin >> x[i] >> a[i] >> f[i] >> p[i], x[i]--;
}
vector<vector<pair<int, int> > > g(n);
for (int i = (0); i < (b); ++i) {
int x, d, gg;
cin >> x >> d >> gg, x--;
g[x].push_back(make_pair(d, gg));
}
for (int u = (0); u < (n); ++u) {
sort((g[u]).begin(), (g[u]).end());
for (int i = (1); i < (int((g[u]).size())); ++i) {
chkmax(g[u][i].second, g[u][i - 1].second);
}
}
vector<int> c(s), cc(s);
for (int i = (0); i < (s); ++i) {
for (int u = (0); u < (n); ++u)
if (d[x[i]][u] <= f[i]) {
int k =
upper_bound((g[u]).begin(), (g[u]).end(), make_pair(a[i], INF)) -
g[u].begin() - 1;
if (0 <= k) {
chkmax(c[i], g[u][k].second);
cc[i] = 1;
}
}
c[i] -= p[i];
}
int tot = s, S = tot++, t = tot++;
Maxflow::init(tot, S, t);
long long res = 0;
for (int i = (0); i < (s); ++i) {
if (0 <= c[i]) {
Maxflow::add(S, i, c[i], 0);
res += c[i];
} else {
Maxflow::add(i, t, -c[i], 0);
}
}
for (int i = (0); i < (k); ++i) {
int u, v;
cin >> u >> v;
u--, v--;
Maxflow::add(u, v, LINF, 0);
}
for (int i = (0); i < (s); ++i) {
if (!cc[i]) {
Maxflow::add(i, t, LINF, 0);
}
}
cout << res - Maxflow::maxflow() << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
struct Dinic {
static const int MXN = 250000;
struct Edge {
long long v, f, re;
Edge(long long a, long long b, long long c) : v(a), f(b), re(c) {}
};
int n, s, t, level[MXN];
vector<Edge> E[MXN];
void init(int _n, int _s, int _t) {
n = _n;
s = _s;
t = _t;
for (int i = 0; i <= n; i++) E[i].clear();
}
void add_edge(int u, int v, long long f) {
E[u].push_back(Edge(v, f, E[v].size()));
E[v].push_back(Edge(u, 0, E[u].size() - 1));
}
bool BFS() {
memset(level, -1, sizeof(level));
queue<int> que;
que.push(s);
level[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto it : E[u]) {
if (it.f > 0 && level[it.v] == -1) {
level[it.v] = level[u] + 1;
que.push(it.v);
}
}
}
return level[t] != -1;
}
long long DFS(int u, long long nf) {
if (u == t) return nf;
long long res = 0;
for (auto &it : E[u]) {
if (it.f > 0 && level[it.v] == level[u] + 1) {
long long tf = DFS(it.v, min(nf, (long long)it.f));
res += tf;
nf -= tf;
it.f -= tf;
E[it.v][it.re].f += tf;
if (nf == 0) return res;
}
}
if (!res) level[u] = -1;
return res;
}
long long flow(long long res = 0) {
while (BFS()) res += DFS(s, 1e18);
return res;
}
} flow;
int vis[100005], s;
void go(int first, int t) {
for (auto it : v[first]) {
if (vis[it] != t) {
flow.add_edge(t, it + s, 1e18);
vis[it] = t;
go(it, t);
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int dis[105][105];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) dis[i][j] = 1e9;
dis[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int first, second;
scanf("%d %d", &first, &second);
dis[first][second] = dis[second][first] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
dis[j][k] = min(dis[j][i] + dis[i][k], dis[j][k]);
}
}
}
int B, k;
scanf("%d %d %d", &s, &B, &k);
int first[100005], a[100005], f[100005], p[100005];
vector<pair<int, int> > base[105];
for (int i = 1; i <= s; i++) {
scanf("%d %d %d %d", &first[i], &a[i], &f[i], &p[i]);
}
for (int i = 0; i < B; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
base[a].push_back(make_pair(b, c));
}
for (int i = 1; i <= n; i++) {
sort(base[i].begin(), base[i].end());
vector<pair<int, int> > tmp = base[i];
base[i].clear();
base[i].push_back(make_pair(0, 0));
for (auto it : tmp) {
if (it.second > base[i].back().second) {
base[i].push_back(it);
}
}
}
int val[100005];
for (int i = 1; i <= s; i++) {
val[i] = -p[i];
for (int j = 1; j <= n; j++) {
if (dis[first[i]][j] <= f[i]) {
val[i] = max(val[i], (lower_bound(base[j].begin(), base[j].end(),
make_pair(a[i], 1000000009)) -
1)
->second -
p[i]);
}
}
}
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d %d", &a, &b);
v[b].push_back(a);
}
flow.init(2 * s + 10, 0, 2 * s + 1);
long long ans = 0;
for (int i = 1; i <= s; i++) {
if (val[i] > 0) {
ans += val[i];
flow.add_edge(i + s, 2 * s + 1, val[i]);
} else if (val[i] < 0) {
if (val[i] == -p[i])
flow.add_edge(0, i, 1e18);
else
flow.add_edge(0, i, -val[i]);
go(i, i);
}
}
printf("%lld\n", ans - flow.flow());
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
struct Dinic {
struct Edge {
long long flow;
int to, next;
};
vector<Edge> edges;
vector<int> adia, at, dist;
int S, D;
void add_Edge(int from, int to, long long cap) {
edges.push_back({cap, to, adia[from]});
adia[from] = edges.size() - 1;
edges.push_back({0, from, adia[to]});
adia[to] = edges.size() - 1;
}
bool bfs() {
queue<int> q;
fill(dist.begin(), dist.end(), 1e9);
dist[S] = 0;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = adia[x]; i != -1; i = edges[i].next) {
if (dist[edges[i].to] > dist[x] + 1 && edges[i].flow) {
dist[edges[i].to] = 1 + dist[x];
q.push(edges[i].to);
}
}
}
return dist[D] < 1e9;
}
long long dfs(int nod, long long fmax) {
if (nod == D) return fmax;
while (at[nod] != -1) {
Edge& e = edges[at[nod]];
long long f;
if (dist[e.to] == dist[nod] + 1 && e.flow &&
(f = dfs(e.to, min(fmax, e.flow)))) {
e.flow -= f;
edges[at[nod] ^ 1].flow += f;
return f;
}
at[nod] = edges[at[nod]].next;
}
return 0;
}
long long GetFlow() {
long long f = 0;
while (bfs()) {
at = adia;
while (long long x = dfs(S, 1e18)) f += x;
}
return f;
}
Dinic(int n = 0, int s = 0, int d = 0) {
S = s, D = d;
at = dist = adia = vector<int>(n + 1, -1);
}
};
const int NMAX = 110;
int dmin[NMAX][NMAX];
struct Object {
int cost, nod, power, id, fuel, atac;
};
vector<Object> ships, bases;
vector<pair<int, int>> dependencies;
int n;
int best_cost[NMAX];
void get_cost_nave() {
fill(best_cost, best_cost + n + 1, -1);
vector<int> nv(ships.size());
iota(nv.begin(), nv.end(), 0);
sort(nv.begin(), nv.end(),
[](int a, int b) { return ships[a].power < ships[b].power; });
sort(bases.begin(), bases.end(),
[](Object a, Object b) { return a.power < b.power; });
int it = 0;
for (auto i : nv) {
while (it != bases.size() && ships[i].power >= bases[it].power) {
best_cost[bases[it].nod] = max(best_cost[bases[it].nod], bases[it].cost);
it++;
}
int best = -1;
for (int nod = 1; nod <= n; nod++)
if (dmin[nod][ships[i].nod] <= ships[i].fuel)
best = max(best, best_cost[nod]);
ships[i].atac = best;
}
}
void read() {
int m, a, b;
scanf("%d%d", &n, &m);
fill(dmin[0], dmin[n + 1], 1e9);
for (int i = 1; i <= n; i++) dmin[i][i] = 0;
while (m--) {
scanf("%d%d", &a, &b);
dmin[a][b] = dmin[b][a] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dmin[i][j] = min(dmin[i][j], dmin[i][k] + dmin[k][j]);
int s, k;
scanf("%d%d%d", &s, &b, &k);
ships.resize(s);
bases.resize(b);
dependencies.resize(k);
for (auto& i : ships) {
scanf("%d%d%d%d", &i.nod, &i.power, &i.fuel, &i.cost);
i.fuel = min(i.fuel, 1000000);
}
for (auto& i : bases) scanf("%d%d%d", &i.nod, &i.power, &i.cost);
for (auto& i : dependencies) scanf("%d%d", &i.first, &i.second);
}
int main() {
read();
get_cost_nave();
long long ans = 0;
int cnt = 2, S = 1, D = 2;
const long long inf = 1e18;
for (auto& i : dependencies) i.first--, i.second--;
for (int i = 0; i < ships.size(); i++) ships[i].id = ++cnt;
Dinic flow(cnt + 1, S, D);
for (auto i : ships) {
if (i.atac == -1)
flow.add_Edge(i.id, D, inf);
else {
int castig = i.atac - i.cost;
if (castig > 0) {
ans += castig;
flow.add_Edge(S, i.id, castig);
} else
flow.add_Edge(i.id, D, -castig);
}
}
for (auto i : dependencies)
flow.add_Edge(ships[i.first].id, ships[i.second].id, inf);
ans -= flow.GetFlow();
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9;
const long long inf_ll = 1e18;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 1e5 + 100;
const int LOG = 22;
const int mod = 1e9 + 7;
const int MX = 1e6 + 100;
const long long MOD = 1000000000949747713ll;
int dis[128][128];
int x[MAXN], a[MAXN], f[MAXN], p[MAXN];
int x2[MAXN], d2[MAXN], g2[MAXN];
int s, b;
int n;
long long cost[MAXN];
struct event {
int type;
int id;
int power;
bool operator<(const event &o) const {
if (o.power != power) return power < o.power;
return type < o.type;
}
};
int mx_val[MAXN];
void calc_cost() {
for (int i = 1; i <= s; ++i) {
cost[i] = -inf_ll;
}
for (int i = 1; i <= n; ++i) {
mx_val[i] = -1;
}
vector<event> events;
for (int i = 1; i <= s; ++i) {
event temp;
temp.type = 1;
temp.id = i;
temp.power = a[i];
events.push_back(temp);
}
for (int i = 1; i <= b; ++i) {
event temp;
temp.type = 0;
temp.id = i;
temp.power = d2[i];
events.push_back(temp);
}
sort(events.begin(), events.end());
for (auto &cur : events) {
int id = cur.id;
if (cur.type == 0) {
mx_val[x2[id]] = max(mx_val[x2[id]], g2[id]);
} else {
int res = -1;
for (int to = 1; to <= n; ++to) {
if (mx_val[to] == -1) continue;
if (dis[x[id]][to] <= f[id]) res = max(res, mx_val[to]);
}
if (res == -1) continue;
cost[id] = res - p[id];
}
}
for (int i = 1; i <= s; ++i) {
if (debug) cout << i << " -- " << cost[i] << endl;
}
}
vector<int> g[MAXN];
vector<int> gr[MAXN];
vector<int> g1[MAXN];
int used[MAXN];
vector<int> order;
void def_top_sort(int v) {
used[v] = 1;
for (int to : g[v]) {
if (!used[to]) {
def_top_sort(to);
}
}
order.push_back(v);
}
int comp[MAXN];
void dfs_clr(int v, int clr) {
comp[v] = clr;
for (int to : gr[v]) {
if (!comp[to]) {
dfs_clr(to, clr);
}
}
}
long long new_cost[MAXN];
int k;
void dfs_top(int v) {
used[v] = 1;
for (int to : g1[v]) {
if (!used[to]) dfs_top(to);
}
order.push_back(v);
}
int taken[MAXN];
int super_used[MAXN];
int timer = 0;
long long get_val(int v) {
if (taken[v]) return 0;
if (super_used[v] == timer) return 0;
super_used[v] = timer;
long long res = new_cost[v];
for (int to : g1[v]) {
res += get_val(to);
res = max(res, -inf_ll);
}
return res;
}
void dfs_take(int v) {
taken[v] = true;
for (int to : g1[v]) {
if (!taken[to]) dfs_take(to);
}
}
void build_scc() {
for (int i = 1; i <= k; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
gr[b].push_back(a);
}
for (int i = 1; i <= s; ++i) {
if (!used[i]) def_top_sort(i);
}
reverse(order.begin(), order.end());
int N = 0;
for (int v : order) {
if (comp[v] == 0) {
++N;
dfs_clr(v, N);
}
}
for (int i = 1; i <= s; ++i) {
if (debug) cout << "ver " << i << " " << comp[i] << endl;
}
set<pair<int, int> > edges;
for (int v = 1; v <= s; ++v) {
for (int to : g[v]) {
int v1 = comp[v], v2 = comp[to];
if (v1 == v2) continue;
if (edges.count({v1, v2})) continue;
edges.insert({v1, v2});
g1[v1].push_back(v2);
if (debug) cout << "add edge " << v1 << " " << v2 << endl;
}
}
for (int v = 1; v <= s; ++v) {
new_cost[comp[v]] += cost[v];
new_cost[comp[v]] = max(new_cost[comp[v]], -inf_ll);
}
order.clear();
memset(used, 0, sizeof used);
for (int v = 1; v <= N; ++v) {
if (!used[v]) dfs_top(v);
}
long long ans = 0;
for (int v : order) {
timer++;
long long val = get_val(v);
if (val > 0) {
ans += val;
dfs_take(v);
}
}
cout << ans;
}
void solve() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int e = 1; e <= n; ++e) {
dis[i][e] = inf_int;
}
dis[i][i] = 0;
}
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
dis[a][b] = 1;
dis[b][a] = 1;
}
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int e = 1; e <= n; ++e) {
dis[i][e] = min(dis[i][e], dis[i][k] + dis[k][e]);
}
}
}
cin >> s >> b >> k;
for (int i = 1; i <= s; ++i) {
cin >> x[i] >> a[i] >> f[i] >> p[i];
}
for (int i = 1; i <= b; ++i) {
cin >> x2[i] >> d2[i] >> g2[i];
}
calc_cost();
build_scc();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int t = 1;
while (t--) solve();
if (debug)
cerr << endl << "time : " << (1.0 * clock() / CLOCKS_PER_SEC) << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) {
a = b;
}
}
template <typename T>
void uax(T &a, T b) {
if (b > a) {
a = b;
}
}
const long long INF = 1e15;
namespace Dinic {
const long long N = 100 * 1000 + 228;
struct edge {
long long from, to, cap, flow;
long long rem() { return cap - flow; }
edge() {}
edge(long long _from, long long _to, long long _cap, long long _flow) {
from = _from;
to = _to;
cap = _cap;
flow = _flow;
}
};
long long n;
vector<long long> g[N];
long long fir[N], d[N];
vector<edge> e;
long long F = 0;
void add_edge(long long u, long long v, long long c) {
g[u].push_back((long long)e.size());
e.push_back(edge(u, v, c, 0LL));
g[v].push_back((long long)e.size());
e.push_back(edge(v, u, 0LL, 0LL));
}
bool bfs(long long s, long long t) {
for (long long i = 1; i <= n; ++i) d[i] = INF;
d[s] = 0;
vector<long long> q;
q.push_back(s);
for (long long i = 0; i < (long long)q.size(); ++i) {
long long v = q[i];
for (long long num : g[v]) {
long long to = e[num].to;
if (e[num].rem() && d[v] + 1 < d[to]) {
d[to] = d[v] + 1;
q.push_back(to);
}
}
}
return d[t] != INF;
}
long long dfs(long long v, long long t, long long c = INF) {
if (v == t) {
F += c;
return c;
}
for (; fir[v] < (long long)g[v].size(); ++fir[v]) {
long long i = g[v][fir[v]];
long long to = e[i].to;
if (d[v] + 1 == d[to] && e[i].rem()) {
long long x = dfs(to, t, min(c, e[i].rem()));
if (x) {
e[i].flow += x;
e[i ^ 1].flow -= x;
return x;
}
}
}
return 0;
}
long long max_flow(long long s, long long t) {
F = 0;
while (bfs(s, t)) {
for (long long i = 1; i <= n; ++i) fir[i] = 0;
while (dfs(s, t))
;
}
return F;
}
}; // namespace Dinic
const long long N = 105;
struct SHIP {
long long x, a, f, p;
SHIP() {}
SHIP(long long _x, long long _a, long long _f, long long _p) {
x = _x, a = _a, f = _f, p = _p;
}
};
SHIP ship[N * 1000];
long long d[N][N];
long long value[N * 1000];
vector<pair<long long, long long> > list228[N * 1000];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
d[i][j] = INF;
}
d[i][i] = 0;
}
for (long long i = 0; i < m; ++i) {
long long u, v;
cin >> u >> v;
d[u][v] = d[v][u] = 1;
}
for (long long k = 1; k <= n; ++k) {
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
if (d[i][k] != INF && d[k][j] != INF) {
uin(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
long long s, b, k;
cin >> s >> b >> k;
for (long long i = 1; i <= s; ++i) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p;
}
for (long long i = 1; i <= b; ++i) {
long long x, d, g;
cin >> x >> d >> g;
list228[x].push_back(make_pair(d, g));
}
for (long long i = 1; i <= n; ++i) {
sort(list228[i].begin(), list228[i].end());
for (long long j = 1; j < (long long)list228[i].size(); ++j) {
uax(list228[i][j].second, list228[i][j - 1].second);
}
}
for (long long i = 1; i <= s; ++i) {
bool ok = 0;
for (long long v = 1; v <= n; ++v) {
if (d[ship[i].x][v] > ship[i].f || list228[v].empty()) continue;
long long l = 0, r = (long long)list228[v].size();
while (r - l > 1) {
long long mid = (l + r) >> 1;
if (list228[v][mid].first <= ship[i].a) {
l = mid;
} else {
r = mid;
}
}
if (list228[v][l].first <= ship[i].a) {
uax(value[i], list228[v][l].second);
ok = 1;
}
}
if (!ok) value[i] = -INF;
}
for (long long i = 1; i <= s; ++i) {
if (value[i] != -INF) value[i] -= ship[i].p;
}
Dinic::n = s + 2;
for (long long i = 0; i < k; ++i) {
long long u, v;
cin >> u >> v;
Dinic::add_edge(u, v, INF);
}
long long S = s + 1, T = s + 2;
long long sumpos = 0;
for (long long i = 1; i <= s; ++i) {
if (value[i] > 0) {
Dinic::add_edge(S, i, value[i]);
sumpos += value[i];
} else {
Dinic::add_edge(i, T, -value[i]);
}
}
long long res = sumpos - Dinic::max_flow(S, T);
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
class flow {
private:
int n;
vector<int> head, d, cur;
vector<tuple<int, ll, int>> edge;
bool bfs(int s, int t) {
d.assign(n, -1);
queue<int> que;
que.push(s);
d[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = head[u]; i != -1; i = get<2>(edge[i])) {
int v = get<0>(edge[i]);
if (get<1>(edge[i]) && d[v] == -1) {
d[v] = d[u] + 1;
if (v == t) {
return true;
}
que.push(v);
}
}
}
return false;
}
ll dfs(int u, int t, ll f) {
if (u == t) {
return f;
}
ll res = f;
for (int &i = cur[u]; i != -1 && res; i = get<2>(edge[i])) {
int v = get<0>(edge[i]);
ll &c = get<1>(edge[i]);
if (d[v] == d[u] + 1 && c) {
ll aug = dfs(v, t, min(res, c));
res -= aug;
c -= aug;
get<1>(edge[i ^ 1]) += aug;
}
}
return f - res;
}
public:
flow(int _n) {
n = _n;
head.assign(n, -1);
}
void insert_edge(int u, int v, ll c) {
edge.emplace_back(v, c, head[u]);
head[u] = edge.size() - 1;
edge.emplace_back(u, 0, head[v]);
head[v] = edge.size() - 1;
}
ll max_flow(int s, int t) {
ll flow = 0;
while (bfs(s, t)) {
cur = head;
flow += dfs(s, t, 1e18);
}
return flow;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> dis(n, vector<int>(n, 1e9));
for (int i = 0; i < n; ++i) {
dis[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
dis[u][v] = 1;
dis[v][u] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ship;
vector<vector<pair<int, int>>> base(n);
for (int i = 0; i < s; ++i) {
int x, a, f, p;
cin >> x >> a >> f >> p;
--x;
ship.emplace_back(x, a, f, p);
}
for (int i = 0; i < b; ++i) {
int x, d, g;
cin >> x >> d >> g;
--x;
base[x].emplace_back(d, g);
}
for (int i = 0; i < n; ++i) {
sort(base[i].begin(), base[i].end());
for (int j = 1; j < base[i].size(); ++j) {
base[i][j].second = max(base[i][j].second, base[i][j - 1].second);
}
}
vector<ll> gain(s);
for (int i = 0; i < s; ++i) {
int x = get<0>(ship[i]);
int a = get<1>(ship[i]);
int f = get<2>(ship[i]);
int p = get<3>(ship[i]);
gain[i] = -1e14;
for (int j = 0; j < n; ++j) {
if (dis[x][j] <= f && !base[j].empty() && a >= base[j][0].first) {
gain[i] =
max(gain[i], 1ll * (--upper_bound(base[j].begin(), base[j].end(),
make_pair(a, (int)1e9)))
->second -
p);
}
}
}
vector<bool> used(s);
vector<pair<int, int>> rel;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
used[x] = true;
used[y] = true;
rel.emplace_back(x, y);
}
int cnt = 0;
ll ans = 0;
vector<int> id(s, -1);
for (int i = 0; i < s; ++i) {
if (used[i]) {
id[i] = cnt++;
} else if (gain[i] > 0) {
ans += gain[i];
}
}
flow G(cnt + 2);
int S = cnt;
int T = cnt + 1;
for (int i = 0; i < s; ++i) {
if (used[i]) {
if (gain[i] > 0) {
G.insert_edge(S, id[i], gain[i]);
ans += gain[i];
} else if (gain[i] < 0) {
G.insert_edge(id[i], T, -gain[i]);
}
}
}
for (int i = 0; i < k; ++i) {
G.insert_edge(id[rel[i].first], id[rel[i].second], 1e18);
}
ans -= G.max_flow(S, T);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
const int N = 105;
const int B = 100005;
int d[N][N], gain[B];
void floyd(int n) {
for (int i = 0; i < n; i++) d[i][i] = 0;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = min(d[i][j], d[i][k] + d[j][k]);
}
struct ship {
int x, a, f, p;
};
struct base {
int x, d, g;
};
struct node {
vector<base> bases;
vector<int> maxs;
void add(base base) { bases.push_back(base); }
void prepare() {
sort(bases.begin(), bases.end(),
[](base a, base b) -> bool { return a.d < b.d; });
maxs.push_back(-1);
for (int i = 0; i < ((int)bases.size()); i++) {
maxs.push_back(max(maxs.back(), bases[i].g));
}
}
int bin(int s) {
int izq = 0, der = ((int)bases.size()) - 1;
int res = ((int)bases.size());
while (izq <= der) {
int med = (izq + der) / 2;
if (bases[med].d > s)
res = med, der = med - 1;
else
izq = med + 1;
}
if (res < ((int)bases.size())) assert(bases[res].d > s);
return res;
}
int query(int strength) {
int p = bin(strength);
return maxs[p];
}
};
const long long INF = 1e15;
struct Dinic {
int nodes, src, dst;
vector<int> dist, q, work;
struct edge {
int to, rev;
long long f, cap;
};
vector<vector<edge>> g;
Dinic(int x) : nodes(x), g(x), dist(x), q(x), work(x) {}
void add_edge(int s, int t, long long cap) {
g[s].push_back((edge){t, ((int)g[t].size()), 0, cap});
g[t].push_back((edge){s, ((int)g[s].size()) - 1, 0, 0});
}
bool dinic_bfs() {
fill(dist.begin(), dist.end(), -1);
dist[src] = 0;
int qt = 0;
q[qt++] = src;
for (int qh = 0; qh < qt; qh++) {
int u = q[qh];
for (int i = 0; i < ((int)g[u].size()); i++) {
edge &e = g[u][i];
int v = g[u][i].to;
if (dist[v] < 0 && e.f < e.cap) dist[v] = dist[u] + 1, q[qt++] = v;
}
}
return dist[dst] >= 0;
}
long long dinic_dfs(int u, long long f) {
if (u == dst) return f;
for (int &i = work[u]; i < ((int)g[u].size()); i++) {
edge &e = g[u][i];
if (e.cap <= e.f) continue;
int v = e.to;
if (dist[v] == dist[u] + 1) {
long long df = dinic_dfs(v, min(f, e.cap - e.f));
if (df > 0) {
e.f += df;
g[v][e.rev].f -= df;
return df;
}
}
}
return 0;
}
long long max_flow(int _src, int _dst) {
src = _src;
dst = _dst;
long long result = 0;
while (dinic_bfs()) {
fill(work.begin(), work.end(), 0);
while (long long delta = dinic_dfs(src, INF)) result += delta;
}
return result;
}
};
int main() {
int n, m, s, b, k;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = 1000;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
d[u][v] = d[v][u] = 1;
}
floyd(n);
cin >> s >> b >> k;
vector<ship> ships;
vector<node> nodes(n);
for (int i = 0; i < s; i++) {
int x, a, f, p;
cin >> x >> a >> f >> p;
x--;
ships.push_back({x, a, min(200, f), p});
}
for (int i = 0; i < b; i++) {
int x, d, g;
cin >> x >> d >> g;
x--;
nodes[x].add({x, d, g});
}
for (int i = 0; i < n; i++) nodes[i].prepare();
memset(gain, -1, sizeof(gain));
for (int i = 0; i < s; i++) {
for (int j = 0; j < n; j++)
if (d[ships[i].x][j] <= ships[i].f) {
gain[i] = max(gain[i], nodes[j].query(ships[i].a));
}
}
Dinic d(s + 2);
long long tot = 0;
for (int i = 0; i < s; i++) {
if (gain[i] == -1) {
d.add_edge(i, s + 1, 1e18);
} else {
long long g = gain[i] - ships[i].p;
if (g > 0)
d.add_edge(s, i, g), tot += g;
else
d.add_edge(i, s + 1, -g);
}
}
for (int i = 0; i < k; i++) {
int s, t;
cin >> s >> t;
s--, t--;
d.add_edge(s, t, INF);
}
cout << tot - d.max_flow(s, s + 1) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
struct Dinic {
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap) {
if (u != v) {
E.emplace_back(Edge(u, v, cap));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
struct ship_t {
long long x, a, f, p;
};
struct base_t {
long long x, d, g;
bool operator<(const base_t &o) const { return d < o.d; }
};
const int N = 1e2 + 10, S = 1e5 + 10;
const long long inf = 1e12 + 42;
ship_t ship[S];
base_t base[S];
long long g[N][N];
vector<int> dep[S];
vector<pair<long long, long long>> bases_at[N];
bool seen[S];
long long val[S];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
g[i][j] = g[j][i] = inf;
}
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u][v] = g[v][u] = min(g[u][v], 1ll);
}
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
for (int i = 1; i <= s; ++i) {
cin >> ship[i].x >> ship[i].a >> ship[i].f >> ship[i].p;
}
for (int i = 1; i <= b; ++i) {
cin >> base[i].x >> base[i].d >> base[i].g;
}
sort(base + 1, base + 1 + b);
for (int i = 1; i <= b; ++i) {
int p = base[i].x;
if (bases_at[p].empty() or bases_at[p].back().second < base[i].g) {
bases_at[p].push_back({base[i].d, base[i].g});
}
}
Dinic dinic(s + 2);
int source = 0, sink = s + 1;
long long ans = 0;
for (int i = 1; i <= s; ++i) {
bool found = false;
for (int p = 1; p <= n; ++p) {
if (g[ship[i].x][p] > ship[i].f) {
continue;
}
auto it = upper_bound(bases_at[p].begin(), bases_at[p].end(),
make_pair(ship[i].a, inf));
if (it != bases_at[p].begin()) {
--it;
val[i] = max(val[i], it->second);
found = true;
}
}
val[i] -= ship[i].p;
if (!found) {
val[i] = -inf;
}
if (val[i] >= 0) {
ans += val[i];
dinic.AddEdge(source, i, val[i]);
} else {
dinic.AddEdge(i, sink, -val[i]);
}
}
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
dep[u].push_back(v);
dinic.AddEdge(u, v, inf);
}
cout << ans - dinic.MaxFlow(source, sink);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ll = long long;
using pii = pair<ll, ll>;
using pll = pair<ll, ll>;
using vi = vector<ll>;
using vll = vector<ll>;
struct Dinic {
struct Edge {
ll v, c, inv;
};
public:
Dinic() : n(-1) {}
void AddEdge(ll a, ll b, ll cap, ll bi_dir) {
if (n < max(a, b)) {
n = max(n, max(a, b));
ResizeVectors();
}
e_orig[a].push_back(Edge{b, cap, ((ll)(e_orig[b]).size())});
e_orig[b].push_back(Edge{a, bi_dir * cap, ((ll)(e_orig[a]).size()) - 1});
}
ll MaxFlow(ll s, ll t) {
if (t > n || s > n) {
n = max(s, t);
ResizeVectors();
}
e = e_orig;
ll result = 0;
while (Bfs(s, t)) {
fill_n(beg.begin(), n + 1, 0);
result += Dfs(s, t, kInf);
}
return result;
}
vector<bool> MinCut(ll s, ll t) {
assert(!Bfs(s, t));
vector<bool> res(n + 1);
for (ll i = (0); i <= (n); ++i) {
res[i] = (dis[i] <= n);
}
return res;
}
vector<pair<ll, ll>> EdgeCut(ll s, ll t) {
vector<bool> left_part = MinCut(s, t);
vector<pair<ll, ll>> cut;
for (ll v = (0); v <= (n); ++v) {
for (auto edge : e_orig[v]) {
if (edge.c != 0 && left_part[v] && !left_part[edge.v]) {
cut.push_back({v, edge.v});
}
}
}
return cut;
}
private:
ll n;
vector<vector<Edge>> e_orig, e;
vector<ll> dis, beg;
bool Bfs(ll s, ll t) {
fill_n(dis.begin(), n + 1, n + 1);
dis[s] = 0;
vector<ll> que;
que.push_back(s);
for (ll i = (0); i <= ((ll)(((ll)(que).size())) - 1); ++i) {
ll v = que[i];
for (auto edge : e[v]) {
ll nei = edge.v;
if (edge.c && dis[nei] > dis[v] + 1) {
dis[nei] = dis[v] + 1;
que.push_back(nei);
if (nei == t) {
return true;
}
}
}
}
return false;
}
ll Dfs(ll v, ll t, ll min_cap) {
ll result = 0;
if (v == t || min_cap == 0) {
return min_cap;
}
for (ll& i = beg[v]; i < ((ll)(e[v]).size()); i++) {
ll nei = e[v][i].v, c = e[v][i].c;
if (dis[nei] == dis[v] + 1 && c > 0) {
ll flow_here = Dfs(nei, t, min(min_cap, c));
result += flow_here;
min_cap -= flow_here;
e[v][i].c -= flow_here;
e[nei][e[v][i].inv].c += flow_here;
}
if (min_cap == 0) {
break;
}
}
return result;
}
void ResizeVectors() {
e_orig.resize(n + 2);
beg.resize(n + 2);
dis.resize(n + 2);
}
static const ll kInf = 1e18;
};
const ll MaxN = 2048;
const ll MaxItems = 5e5;
ll n, m;
vi adj[MaxN];
ll s, b, k, h;
ll dist[MaxN][MaxN];
vector<pii> at_vert[MaxN];
ll sp_loc[MaxItems], sp_atk[MaxItems], sp_fuel[MaxItems], sp_price[MaxItems];
ll bs_loc[MaxItems], bs_def[MaxItems], bs_gold[MaxItems];
vi dep_adj[MaxItems];
bool any_dep[MaxItems];
ll dep_idx[MaxItems];
int32_t main() {
scanf("%lld%lld", &n, &m);
for (ll i = 0; i <= n; ++i) {
for (ll j = 0; j <= n; ++j) {
dist[i][j] = 2e9;
}
dist[i][i] = 0;
}
for (ll i = 0; i < m; ++i) {
ll u, v;
scanf("%lld%lld", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
if (u != v) {
dist[u][v] = dist[v][u] = 1;
}
}
for (ll k = 1; k <= n; ++k) {
for (ll i = 1; i <= n; ++i) {
for (ll j = 1; j <= n; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
scanf("%lld%lld%lld", &s, &b, &k);
for (ll i = 0; i < s; ++i) {
scanf("%lld%lld%lld%lld", &sp_loc[i], &sp_atk[i], &sp_fuel[i],
&sp_price[i]);
}
for (ll i = 0; i < b; ++i) {
scanf("%lld%lld%lld", &bs_loc[i], &bs_def[i], &bs_gold[i]);
at_vert[bs_loc[i]].emplace_back(bs_def[i], bs_gold[i]);
}
for (ll v = 1; v <= n; ++v) {
auto& X = at_vert[v];
sort(X.begin(), X.end());
const ll sz = X.size();
ll cur_max = -1;
ll ptr = 0;
for (ll i = 0; i < sz; ++i) {
if (X[i].second <= cur_max) {
continue;
}
X[ptr++] = X[i];
cur_max = X[i].second;
}
X.resize(ptr);
debug() << " ["
<< "v"
": "
<< (v) << "] "
<< " ["
<< "X"
": "
<< (X) << "] ";
}
const ll kSmallInf = 2e16;
const ll kLargeInf = 2e16;
vll sp_best(s, -kLargeInf);
for (ll i = 0; i < s; ++i) {
for (ll v = 1; v <= n; ++v) {
if (sp_fuel[i] < dist[sp_loc[i]][v]) {
continue;
}
const ll atk = sp_atk[i];
auto iter = lower_bound(at_vert[v].begin(), at_vert[v].end(),
pii(atk, kSmallInf));
if (iter == at_vert[v].begin()) {
continue;
} else {
ll bnd = prev(iter)->second;
sp_best[i] = max(sp_best[i], (ll)bnd - sp_price[i]);
}
}
debug() << " ["
<< "i"
": "
<< (i) << "] "
<< " ["
<< "sp_best[i]"
": "
<< (sp_best[i]) << "] ";
}
for (ll i = 0; i < k; ++i) {
ll u, v;
scanf("%lld%lld", &u, &v);
--u;
--v;
any_dep[u] = any_dep[v] = true;
dep_adj[u].push_back(v);
}
ll ans = 0;
ll curidx = 0;
for (ll i = 0; i < s; ++i) {
if (!any_dep[i] && sp_best[i] >= 0) {
ans += sp_best[i];
}
dep_idx[i] = curidx++;
}
Dinic dinic;
const ll source = curidx;
const ll sink = source + 1;
debug() << " ["
<< "source"
": "
<< (source) << "] "
<< " ["
<< "sink"
": "
<< (sink) << "] ";
for (ll i = 0; i < s; ++i) {
if (!any_dep[i]) {
continue;
}
if (sp_best[i] >= 0) {
dinic.AddEdge(source, dep_idx[i], sp_best[i], 0);
ans += sp_best[i];
} else {
dinic.AddEdge(dep_idx[i], sink, -sp_best[i], 0);
}
for (ll j : dep_adj[i]) {
dinic.AddEdge(dep_idx[i], dep_idx[j], kLargeInf, 0);
}
}
const ll flow = dinic.MaxFlow(source, sink);
ans -= flow;
assert(ans >= 0);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Dinic {
static const int MAXN = 100005, MAXM = 1000005;
struct Edge {
int to, next;
T cap;
} edge[MAXM];
int head[MAXN], tot;
void clear() {
memset(head, -1, sizeof(head));
tot = 0;
}
Dinic() { clear(); }
void add(int u, int v, T c) {
edge[tot] = (Edge){v, head[u], c};
head[u] = tot++;
edge[tot] = (Edge){u, head[v], (T)0};
head[v] = tot++;
}
int dis[MAXN], que[MAXN], id[MAXN];
bool bfs(int s, int t) {
memset(dis, -1, sizeof(dis));
memcpy(id, head, sizeof(id));
int he = 0, ta = 0;
dis[que[ta++] = s] = 0;
while (he < ta) {
int u = que[he++];
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] < 0 && edge[i].cap) {
dis[que[ta++] = v] = dis[u] + 1;
if (v == t) return true;
}
}
}
return false;
}
T dfs(int u, int t, T f) {
if (u == t) return f;
T flow = 0;
for (int &i = id[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] > dis[u] && edge[i].cap) {
int d = dfs(v, t, min(f, edge[i].cap));
if (!d) continue;
edge[i].cap -= d, edge[i ^ 1].cap += d;
flow += d, f -= d;
if (f == 0) return flow;
}
}
dis[u] = -1;
return flow;
}
T dinic(int s, int t, T inf = 1E9) {
T flow = 0;
while (bfs(s, t)) flow += dfs(s, t, inf);
return flow;
}
};
const long long INF = 1E15;
Dinic<long long> din;
const int MAXN = 100005;
int dis[105][105], xx[MAXN], aa[MAXN], ff[MAXN], pp[MAXN], qq[MAXN], vis[MAXN],
n, m;
struct Node {
int d, g;
} sh[MAXN];
vector<Node> nd[105];
bool cmp(const Node &a, const Node &b) { return a.d < b.d; }
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
dis[j][k] = min(dis[i][j] + dis[i][k], dis[j][k]);
int S, B, K;
scanf("%d%d%d", &S, &B, &K);
for (int i = 1; i <= S; i++) {
scanf("%d%d%d%d", xx + i, aa + i, ff + i, pp + i);
sh[i] = (Node){aa[i], i};
}
sort(sh + 1, sh + 1 + S, cmp);
for (int i = 1; i <= B; i++) {
int x, d, g;
scanf("%d%d%d", &x, &d, &g);
nd[x].push_back((Node){d, g});
}
for (int i = 1; i <= n; i++) {
sort(nd[i].begin(), nd[i].end(), cmp);
int mx = 0;
for (Node &d : nd[i]) {
mx = max(mx, d.g);
d.g = mx;
}
}
fill(qq + 1, qq + 1 + S, -1E9);
for (int i = 1; i <= n; i++) {
int s = nd[i].size();
for (int j = 1, k = 0; j <= S; j++) {
for (; k < s && nd[i][k].d <= sh[j].d; ++k)
;
if (k > 0 && dis[i][xx[sh[j].g]] <= ff[sh[j].g])
qq[sh[j].g] = max(qq[sh[j].g], nd[i][k - 1].g);
}
}
for (int i = 1; i <= S; i++) pp[i] = qq[i] - pp[i];
for (int i = 1; i <= K; i++) {
int u, v;
scanf("%d%d", &u, &v);
din.add(u, v, INF);
vis[u] = vis[v] = 1;
}
long long ans = 0;
int s = S + 1, t = s + 1;
for (int i = 1; i <= S; i++)
if (!vis[i] && pp[i] > 0) ans += pp[i];
for (int i = 1; i <= S; i++)
if (vis[i]) {
if (pp[i] > 0)
din.add(s, i, pp[i]), ans += pp[i];
else
din.add(i, t, -pp[i]);
}
printf("%lld\n", ans - din.dinic(s, t, INF));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxs = 200000;
const char dbuf[] = "DWAS";
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
char s[maxs + 1];
int xv[maxs + 1];
int yv[maxs + 1];
int lprv[maxs + 1];
int bprv[maxs + 1];
int rprv[maxs + 1];
int tprv[maxs + 1];
int lnxt[maxs + 1];
int bnxt[maxs + 1];
int rnxt[maxs + 1];
int tnxt[maxs + 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T;
cin >> T;
for (int TN = 0; TN < T; TN++) {
cin >> s;
int n = strlen(s);
xv[0] = 0;
yv[0] = 0;
for (int i = 0; i < n; i++) {
int d = find(dbuf, dbuf + 4, s[i]) - dbuf;
xv[i + 1] = xv[i] + dx[d];
yv[i + 1] = yv[i] + dy[d];
}
lprv[0] = rprv[0] = xv[0];
bprv[0] = tprv[0] = yv[0];
for (int i = 1; i <= n; i++) {
lprv[i] = min(lprv[i - 1], xv[i]);
bprv[i] = min(bprv[i - 1], yv[i]);
rprv[i] = max(rprv[i - 1], xv[i]);
tprv[i] = max(tprv[i - 1], yv[i]);
}
lnxt[n] = rnxt[n] = xv[n];
bnxt[n] = tnxt[n] = yv[n];
for (int i = n - 1; i >= 0; i--) {
lnxt[i] = min(lnxt[i + 1], xv[i]);
bnxt[i] = min(bnxt[i + 1], yv[i]);
rnxt[i] = max(rnxt[i + 1], xv[i]);
tnxt[i] = max(tnxt[i + 1], yv[i]);
}
long long ans = 0x7f7f7f7f7f7f7f7fll;
for (int i = 0; i <= n; i++) {
for (int d = 0; d < 4; d++) {
int w =
max(rprv[i], rnxt[i] + dx[d]) - min(lprv[i], lnxt[i] + dx[d]) + 1;
int h =
max(tprv[i], tnxt[i] + dy[d]) - min(bprv[i], bnxt[i] + dy[d]) + 1;
ans = min(ans, (long long)w * h);
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
int x = 0, y = 0;
int max_x = 0;
int max_y = 0;
int min_x = 0;
int min_y = 0;
int l_min_x = -1;
int l_min_y = -1;
int l_max_x = -1;
int l_max_y = -1;
int r_min_x = -1;
int r_min_y = -1;
int r_max_x = -1;
int r_max_y = -1;
for (int i = 0; i < s.size(); ++i) {
char c = s[i];
if (c == 'W') {
++y;
} else if (c == 'A') {
--x;
} else if (c == 'S') {
--y;
} else {
++x;
}
if (x > max_x) {
max_x = x;
l_max_x = r_max_x = i;
} else if (x == max_x) {
r_max_x = i;
}
if (y > max_y) {
max_y = y;
l_max_y = r_max_y = i;
} else if (y == max_y) {
r_max_y = i;
}
if (x < min_x) {
min_x = x;
l_min_x = r_min_x = i;
} else if (x == min_x) {
r_min_x = i;
}
if (y < min_y) {
min_y = y;
l_min_y = r_min_y = i;
} else if (y == min_y) {
r_min_y = i;
}
}
long long ans = 1LL * (max_x - min_x + 1) * (max_y - min_y + 1);
if (max_x - min_x > 1 && (r_min_x < l_max_x || r_max_x < l_min_x)) {
ans = min(ans, 1LL * (max_x - min_x) * (max_y - min_y + 1));
}
if (max_y - min_y > 1 && (r_min_y < l_max_y || r_max_y < l_min_y)) {
ans = min(ans, 1LL * (max_x - min_x + 1) * (max_y - min_y));
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
const int maxn = 222222;
int a[maxn], n;
long long ans;
int mx[maxn][2], mi[maxn][2];
int sufmx[maxn][2], sufmi[maxn][2];
void dfs(int now, int x, int y) {
if (now > n) return;
x += dx[a[now - 1]];
y += dy[a[now - 1]];
mx[now][0] = max(mx[now - 1][0], x);
mx[now][1] = max(mx[now - 1][1], y);
mi[now][0] = min(mi[now - 1][0], x);
mi[now][1] = min(mi[now - 1][1], y);
sufmx[now][0] = x;
sufmi[now][0] = x;
sufmx[now][1] = y;
sufmi[now][1] = y;
if (now + 1 <= n) {
dfs(now + 1, x, y);
for (int i = 0; i < 2; i++) {
sufmx[now][i] = max(sufmx[now][i], sufmx[now + 1][i]);
sufmi[now][i] = min(sufmi[now][i], sufmi[now + 1][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
a[i] = 0;
} else if (s[i] == 'S') {
a[i] = 1;
} else if (s[i] == 'A') {
a[i] = 2;
} else if (s[i] == 'D') {
a[i] = 3;
}
}
mx[0][0] = mx[0][1] = 0;
mi[0][0] = mi[0][1] = 0;
dfs(1, 0, 0);
ans = (long long)(mx[n][1] - mi[n][1] + 1) * (mx[n][0] - mi[n][0] + 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (sufmx[i + 1][j] > sufmi[i + 1][j] || mx[i][j] > mi[i][j])
if (sufmx[i + 1][j] > mx[i][j] && sufmi[i + 1][j] > mi[i][j]) {
ans = min(ans, (long long)(sufmx[i + 1][j] - mi[i][j]) *
(mx[n][j ^ 1] - mi[n][j ^ 1] + 1));
} else if (sufmx[i + 1][j] < mx[i][j] && sufmi[i + 1][j] < mi[i][j]) {
ans = min(ans, (long long)(mx[i][j] - sufmi[i + 1][j]) *
(mx[n][j ^ 1] - mi[n][j ^ 1] + 1));
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
const int nax = 2e5 + 10;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
int xp[nax], yp[nax], xin[nax], xax[nax], yin[nax], yax[nax];
void solve() {
string S;
cin >> S;
int N = (int)S.length();
int x = 0, y = 0;
for (int i = 0; i < N; ++i) {
if (S[i] == 'A') --x;
if (S[i] == 'D') ++x;
if (S[i] == 'W') ++y;
if (S[i] == 'S') --y;
xp[i + 1] = x;
yp[i + 1] = x;
xin[i + 1] = min(xin[i], x);
xax[i + 1] = max(xax[i], x);
yin[i + 1] = min(yin[i], y);
yax[i + 1] = max(yax[i], y);
}
long long area = (xax[N] - xin[N] + 1) * 1LL * (yax[N] - yin[N] + 1);
int max_x = x, min_x = x, max_y = y, min_y = y;
for (int i = N - 1; i >= 0; --i) {
if (S[i] == 'W') --y;
if (S[i] == 'A') ++x;
if (S[i] == 'S') ++y;
if (S[i] == 'D') --x;
uax(max_x, x);
uax(max_y, y);
uin(min_x, x);
uin(min_y, y);
for (int j = 0; j < 4; ++j) {
long long xx =
max(xax[i] + dx[j], max_x) - min(xin[i] + dx[j], min_x) + 1LL;
long long yy =
max(yax[i] + dy[j], max_y) - min(yin[i] + dy[j], min_y) + 1LL;
uin(area, xx * yy);
}
}
cout << area << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int main() {
int q;
cin >> q;
while (q--) {
string in;
cin >> in;
long long x = 0, y = 0;
long long lmax_y = 0, lmax_x = 0, fmin_x = 0, fmin_y = 0;
long long fmax_y = 0, fmax_x = 0, lmin_x = 0, lmin_y = 0;
long long max_y = 0, max_x = 0, min_x = 0, min_y = 0;
for (int i = 0; i < in.length(); ++i) {
if (in[i] == 'W') {
++y;
if (max_y < y) {
fmax_y = i;
max_y = y;
} else if (max_y == y)
lmax_y = i;
}
if (in[i] == 'A') {
--x;
if (min_x > x) {
fmin_x = i;
min_x = x;
} else if (min_x == x)
lmin_x = i;
}
if (in[i] == 'S') {
--y;
if (min_y > y) {
fmin_y = i;
min_y = y;
} else if (min_y == y)
lmin_y = i;
;
}
if (in[i] == 'D') {
++x;
if (max_x < x) {
fmax_x = i;
max_x = x;
} else if (max_x == x)
lmax_x = i;
}
}
long long tmp_min = (max_x - min_x + 1) * (max_y - min_y + 1);
if (max_x - min_x + 1 > 2 && (lmax_x < fmin_x || lmin_x < fmax_x) &&
tmp_min > (max_x - min_x) * (max_y - min_y + 1))
tmp_min = (max_x - min_x) * (max_y - min_y + 1);
if (max_y - min_y + 1 > 2 && (lmax_y < fmin_y || lmin_y < fmax_y) &&
tmp_min > (max_x - min_x + 1) * (max_y - min_y))
tmp_min = (max_x - min_x + 1) * (max_y - min_y);
cout << tmp_min << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 9e18;
const long double pi = 2 * acos(0.0);
const int N = 1000005;
long long int tes, n;
string s;
vector<long long int> sieve(N, 0);
void si() {
sieve[1] = 1;
for (int i = 2; i < N; i++) {
if (sieve[i] == 0) {
for (int j = i; j < N; j += i) {
sieve[j] = i;
}
}
}
}
long long int power(long long int x, long long int y) {
long long int res = 1ll;
while (y > 0) {
if (y & 1) res = res * x;
y >>= 1;
x = x * x;
}
return res;
}
void solve() {
cin >> s;
n = (int)((s).size());
vector<long long int> arr, brr;
;
for (int i = 0; i < n; i++) {
if (s[i] == 'W' || s[i] == 'S') {
if (s[i] == 'W')
arr.push_back(+1);
else
arr.push_back(-1);
} else {
if (s[i] == 'A')
brr.push_back(-1);
else
brr.push_back(+1);
}
}
vector<long long int> cum_a((int)((arr).size()) + 1, 0),
cum_b((int)((brr).size()) + 1, 0);
;
for (int i = 0; i < (int)((arr).size()); i++) {
cum_a[i + 1] = cum_a[i] + arr[i];
};
for (int i = 0; i < (int)((brr).size()); i++) {
cum_b[i + 1] = cum_b[i] + brr[i];
}
long long int maxi_a = -inf, mini_a = inf, maxi_b = -inf, mini_b = inf,
ind_maxi_a = -1, ind_mini_a = -1, ind_maxi_b = -1,
ind_mini_b = -1;
;
for (int i = 0; i < (int)((arr).size()) + 1; i++) {
if (cum_a[i] > maxi_a) {
maxi_a = cum_a[i];
ind_maxi_a = i;
} else if (cum_a[i] == maxi_a) {
ind_maxi_a = i;
}
if (cum_a[i] < mini_a) {
mini_a = cum_a[i];
ind_mini_a = i;
}
};
for (int i = 0; i < (int)((brr).size()) + 1; i++) {
if (cum_b[i] > maxi_b) {
maxi_b = cum_b[i];
ind_maxi_b = i;
} else if (cum_b[i] == maxi_b) {
ind_maxi_b = i;
}
if (cum_b[i] < mini_b) {
mini_b = cum_b[i];
ind_mini_b = i;
}
}
long long int area = (maxi_a - mini_a + 1) * (maxi_b - mini_b + 1);
if (ind_maxi_a < ind_mini_a) {
area = min(area, (max(2ll, maxi_a - mini_a)) * (maxi_b - mini_b + 1));
}
if (ind_maxi_b < ind_mini_b) {
area = min(area, (maxi_a - mini_a + 1) * (max(2ll, maxi_b - mini_b)));
}
maxi_a = -inf, mini_a = inf, maxi_b = -inf, mini_b = inf, ind_maxi_a = -1,
ind_mini_a = -1, ind_maxi_b = -1, ind_mini_b = -1;
;
for (int i = 0; i < (int)((arr).size()) + 1; i++) cum_a[i] *= -1;
;
for (int i = 0; i < (int)((brr).size()) + 1; i++) cum_b[i] *= -1;
;
for (int i = 0; i < (int)((arr).size()) + 1; i++) {
if (cum_a[i] > maxi_a) {
maxi_a = cum_a[i];
ind_maxi_a = i;
} else if (cum_a[i] == maxi_a) {
ind_maxi_a = i;
}
if (cum_a[i] < mini_a) {
mini_a = cum_a[i];
ind_mini_a = i;
}
};
for (int i = 0; i < (int)((brr).size()) + 1; i++) {
if (cum_b[i] > maxi_b) {
maxi_b = cum_b[i];
ind_maxi_b = i;
} else if (cum_b[i] == maxi_b) {
ind_maxi_b = i;
}
if (cum_b[i] < mini_b) {
mini_b = cum_b[i];
ind_mini_b = i;
}
}
if (ind_maxi_a < ind_mini_a) {
area = min(area, (max(2ll, maxi_a - mini_a)) * (maxi_b - mini_b + 1));
}
if (ind_maxi_b < ind_mini_b) {
area = min(area, (maxi_a - mini_a + 1) * (max(2ll, maxi_b - mini_b)));
}
cout << area << "\n";
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> tes;
while (tes--) {
solve();
}
}
|
#include <bits/stdc++.h>
int Max(int* a, int b, int* l_p, int* f_p, int j) {
if (b == *a) {
*a = b;
*l_p = j;
} else if (b > *a) {
*a = b;
*l_p = j;
*f_p = j;
}
return 0;
}
int Min(int* a, int b, int* l_p, int* f_p, int j) {
if (b == *a) {
*a = b;
*l_p = j;
} else if (b < *a) {
*a = b;
*l_p = j;
*f_p = j;
}
return 0;
}
long long min(long long a, long long b) { return a < b ? a : b; }
int main() {
int T;
scanf("%d", &T);
for (int i = 0; i < T; i++) {
char move[200005];
scanf("%s", move);
int init_v = 0, init_h = 0;
int min_x = 0, min_y = 0, max_x = 0, max_y = 0;
int l_min_x = 0, l_max_x = 0, l_min_y = 0, l_max_y = 0;
int f_min_x = 0, f_max_x = 0, f_min_y = 0, f_max_y = 0;
for (int j = 0; j < strlen(move); j++) {
if (move[j] == 'W') {
init_v++;
Max(&max_y, init_v, &l_max_y, &f_max_y, j);
} else if (move[j] == 'S') {
init_v--;
Min(&min_y, init_v, &l_min_y, &f_min_y, j);
} else if (move[j] == 'A') {
init_h--;
Min(&min_x, init_h, &l_min_x, &f_min_x, j);
} else if (move[j] == 'D') {
init_h++;
Max(&max_x, init_h, &l_max_x, &f_max_x, j);
}
}
int x_l = (max_x - min_x + 1);
int y_l = (max_y - min_y + 1);
int m_y_l = y_l;
int m_x_l = x_l;
if (l_min_x < f_max_x && (max_x - min_x) >= 2) {
m_x_l--;
}
if (l_max_x < f_min_x && (max_x - min_x) >= 2) {
m_x_l--;
}
if (l_min_y < f_max_y && (max_y - min_y) >= 2) {
m_y_l--;
}
if (l_max_y < f_min_y && (max_y - min_y) >= 2) {
m_y_l--;
}
long long ans = min((long long)(x_l) * (long long)m_y_l,
(long long)m_x_l * (long long)y_l);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[200010];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", a);
int l = 0, r = 0, u = 0, d = 0, len = strlen(a), x = 0, y = 0;
int fl = 0, fr = 0, fu = 0, fd = 0;
for (int i = 0; i < len; i++) {
if (a[i] == 'W') {
if (++y > u)
u = y, fd = 0, fu = 1;
else if (y == u)
fu = 1;
}
if (a[i] == 'A') {
if (--x < l)
l = x, fr = 0, fl = 1;
else if (x == l)
fl = 1;
}
if (a[i] == 'S') {
if (--y < d)
d = y, fu = 0, fd = 1;
else if (y == d)
fd = 1;
}
if (a[i] == 'D') {
if (++x > r)
r = x, fl = 0, fr = 1;
else if (x == r)
fr = 1;
}
}
x = r - l + 1, y = u - d + 1;
long long s = 1LL * x * y, k = s;
if (x > 2 && fl * fr == 0) s = k - y;
if (y > 2 && fu * fd == 0)
if (k - x < s) s = k - x;
printf("%I64d\n", s);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 2e5 + 7;
int T, U, D, L, R;
long long ans;
char s[N];
int main() {
T = read();
while (T--) {
scanf("%s", s);
int n = strlen(s);
int x = 0, y = 0;
U = D = L = R = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') y++;
if (s[i] == 'S') y--;
if (s[i] == 'A') x--;
if (s[i] == 'D') x++;
R = max(R, x);
L = min(L, x);
U = max(U, y);
D = min(D, y);
}
ans = 1ll * (R - L + 1) * (U - D + 1);
x = y = 0;
bool flag = 0, GG = 0;
int l = 0, r = 0, u = 0, d = 0;
for (int i = 0; i < n; i++) {
if (U - D <= 1 || !D) {
GG = 1;
break;
}
if (s[i] == 'W') y++;
if (s[i] == 'S') y--;
if (s[i] == 'A') x--;
if (s[i] == 'D') x++;
if (y == D && !flag) {
y++;
flag = 1;
}
r = max(r, x);
l = min(l, x);
u = max(u, y);
d = min(d, y);
if (y <= D || y > U || x < L || x > R) {
GG = 1;
break;
}
}
if (!GG) ans = min(ans, 1ll * (r - l + 1) * (u - d + 1));
x = y = flag = l = r = u = d = GG = 0;
for (int i = 0; i < n; i++) {
if (U - D <= 1 || !U) {
GG = 1;
break;
}
if (s[i] == 'W') y++;
if (s[i] == 'S') y--;
if (s[i] == 'A') x--;
if (s[i] == 'D') x++;
if (y == U && !flag) {
y--;
flag = 1;
}
r = max(r, x);
l = min(l, x);
u = max(u, y);
d = min(d, y);
if (y >= U || y < D || x < L || x > R) {
GG = 1;
break;
}
}
if (!GG) ans = min(ans, 1ll * (r - l + 1) * (u - d + 1));
x = y = flag = l = r = u = d = GG = 0;
for (int i = 0; i < n; i++) {
if (R - L <= 1 || !R) {
GG = 1;
break;
}
if (s[i] == 'W') y++;
if (s[i] == 'S') y--;
if (s[i] == 'A') x--;
if (s[i] == 'D') x++;
if (x == R && !flag) {
x--;
flag = 1;
}
r = max(r, x);
l = min(l, x);
u = max(u, y);
d = min(d, y);
if (y > U || y < D || x < L || x >= R) {
GG = 1;
break;
}
}
if (!GG) ans = min(ans, 1ll * (r - l + 1) * (u - d + 1));
x = y = flag = l = r = u = d = GG = 0;
for (int i = 0; i < n; i++) {
if (R - L <= 1 || !L) {
GG = 1;
break;
}
if (s[i] == 'W') y++;
if (s[i] == 'S') y--;
if (s[i] == 'A') x--;
if (s[i] == 'D') x++;
if (x == L && !flag) {
x++;
flag = 1;
}
r = max(r, x);
l = min(l, x);
u = max(u, y);
d = min(d, y);
if (y > U || y < D || x <= L || x > R) {
GG = 1;
break;
}
}
if (!GG) ans = min(ans, 1ll * (r - l + 1) * (u - d + 1));
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
struct info {
int minValue, maxValue;
};
info operator+(info A, info B) {
info output;
output.minValue = min(A.minValue, B.minValue);
output.maxValue = max(A.maxValue, B.maxValue);
return output;
}
struct node {
int lazy;
info value;
int l, r;
node *L, *R;
node() {}
node(int l, int r) {
this->lazy = 0;
this->value = {MAXN, -MAXN};
this->l = l;
this->r = r;
this->L = nullptr;
this->R = nullptr;
}
void updateLazy() {
this->value.maxValue += this->lazy;
this->value.minValue += this->lazy;
if (this->l != this->r) {
this->L->lazy += this->lazy;
this->R->lazy += this->lazy;
}
this->lazy = 0;
}
void build() {
if (this->l == this->r) {
return;
}
this->L = new node(this->l, (this->l + this->r) / 2);
this->R = new node((this->l + this->r) / 2 + 1, this->r);
this->L->build();
this->R->build();
}
void update(int q, int val) {
this->updateLazy();
if (this->l == this->r && this->l == q) {
this->value = {val, val};
return;
}
if (this->r < q || this->l > q) return;
this->L->update(q, val);
this->R->update(q, val);
this->value = this->L->value + this->R->value;
}
void reset(int q) {
this->updateLazy();
if (this->l == this->r && this->l == q) {
this->value = {MAXN, -MAXN};
return;
}
if (this->r < q || this->l > q) return;
this->L->reset(q);
this->R->reset(q);
this->value = this->L->value + this->R->value;
}
void update(int ql, int qr, int val) {
this->updateLazy();
if (this->l >= ql && this->r <= qr) {
this->value.minValue += val;
this->value.maxValue += val;
if (this->l != this->r) {
this->L->lazy += val;
this->R->lazy += val;
}
return;
}
if (this->r < ql || this->l > qr) return;
this->L->update(ql, qr, val);
this->R->update(ql, qr, val);
this->value = this->L->value + this->R->value;
}
};
node *T1, *T2;
int prefix1[MAXN], prefix2[MAXN];
long long calcValue(int sum1, int sum2) {
long long side1 = 1;
if (min(sum1, T1->value.minValue) < 0) side1 -= min(sum1, T1->value.minValue);
if (max(sum1, T1->value.maxValue) > 0) side1 += max(sum1, T1->value.maxValue);
long long side2 = 1;
if (min(sum2, T2->value.minValue) < 0) side2 -= min(sum2, T2->value.minValue);
if (max(sum2, T2->value.maxValue) > 0) side2 += max(sum2, T2->value.maxValue);
return side1 * side2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
T1 = new node(0, s.size());
T1->build();
T2 = new node(0, s.size());
T2->build();
int sum1 = 0, sum2 = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W')
sum1--;
else if (s[i] == 'S')
sum1++;
if (s[i] == 'A')
sum2--;
else if (s[i] == 'D')
sum2++;
T1->update(i, sum1);
T2->update(i, sum2);
}
long long answer = calcValue(sum1, sum2);
int currSum1 = 0, currSum2 = 0;
for (int i = 0; i < s.size(); i++) {
T1->update(i, s.size() - 1, -1);
currSum1--;
answer = min(answer, calcValue(currSum1, currSum2));
T1->update(i, s.size() - 1, +1);
currSum1++;
if (s[i] == 'W')
currSum1--;
else if (s[i] == 'S')
currSum1++;
if (s[i] == 'A')
currSum2--;
else if (s[i] == 'D')
currSum2++;
}
T1->update(s.size(), sum1 - 1);
answer = min(answer, calcValue(sum1 - 1, sum2));
T1->reset(s.size());
currSum1 = 0, currSum2 = 0;
for (int i = 0; i < s.size(); i++) {
T1->update(i, s.size() - 1, +1);
currSum1++;
answer = min(answer, calcValue(currSum1, currSum2));
T1->update(i, s.size() - 1, -1);
currSum1--;
if (s[i] == 'W')
currSum1--;
else if (s[i] == 'S')
currSum1++;
if (s[i] == 'A')
currSum2--;
else if (s[i] == 'D')
currSum2++;
}
T1->update(s.size(), sum1 + 1);
answer = min(answer, calcValue(sum1 + 1, sum2));
T1->reset(s.size());
currSum1 = 0, currSum2 = 0;
for (int i = 0; i < s.size(); i++) {
T2->update(i, s.size() - 1, -1);
currSum2--;
answer = min(answer, calcValue(currSum1, currSum2));
T2->update(i, s.size() - 1, +1);
currSum2++;
if (s[i] == 'W')
currSum1--;
else if (s[i] == 'S')
currSum1++;
if (s[i] == 'A')
currSum2--;
else if (s[i] == 'D')
currSum2++;
}
T2->update(s.size(), sum2 - 1);
answer = min(answer, calcValue(sum1, sum2 - 1));
T2->reset(s.size());
currSum1 = 0, currSum2 = 0;
for (int i = 0; i < s.size(); i++) {
T2->update(i, s.size() - 1, +1);
currSum2++;
answer = min(answer, calcValue(currSum1, currSum2));
T2->update(i, s.size() - 1, -1);
currSum2--;
if (s[i] == 'W')
currSum1--;
else if (s[i] == 'S')
currSum1++;
if (s[i] == 'A')
currSum2--;
else if (s[i] == 'D')
currSum2++;
}
T2->update(s.size(), sum2 + 1);
answer = min(answer, calcValue(sum1, sum2 + 1));
T2->reset(s.size());
cout << answer << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn];
struct matrix {
int x1, y1, x2, y2;
} st[maxn], ed[maxn];
inline int getx(char t) {
if (t == 'W' || t == 'S') return 0;
if (t == 'D') return 1;
return -1;
}
inline int gety(char t) {
if (t == 'A' || t == 'D') return 0;
if (t == 'W') return 1;
return -1;
}
void update(int x, int y, matrix &a) {
if (x < a.x1) a.x1 = x;
if (x > a.x2) a.x2 = x;
if (y < a.y1) a.y1 = y;
if (y > a.y2) a.y2 = y;
}
matrix move(char t, matrix &a) {
matrix re = a;
re.x1 += getx(t), re.x2 += getx(t);
re.y1 += gety(t), re.y2 += gety(t);
return re;
}
long long getsize(matrix a, matrix b) {
long long mnx, mny, mxx, mxy;
mnx = a.x1 < b.x1 ? a.x1 : b.x1;
mny = a.y1 < b.y1 ? a.y1 : b.y1;
mxx = a.x2 > b.x2 ? a.x2 : b.x2;
mxy = a.y2 > b.y2 ? a.y2 : b.y2;
return (mxx - mnx + 1) * (mxy - mny + 1);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s);
int x = 0, y = 0, n = strlen(s);
matrix rg = (matrix){0, 0, 0, 0};
for (int i = 0; i < n; i++) {
st[i] = rg;
x += getx(s[i]), y += gety(s[i]);
update(x, y, rg);
}
st[n] = rg;
rg = (matrix){x, y, x, y};
ed[n] = rg;
for (int i = n - 1; i >= 0; i--) {
x -= getx(s[i]), y -= gety(s[i]);
update(x, y, rg);
ed[i] = rg;
}
long long ans = 1e18;
for (int i = 0; i <= n; i++) {
long long val;
val = getsize(st[i], move('W', ed[i]));
if (val < ans) ans = val;
val = getsize(st[i], move('A', ed[i]));
if (val < ans) ans = val;
val = getsize(st[i], move('S', ed[i]));
if (val < ans) ans = val;
val = getsize(st[i], move('D', ed[i]));
if (val < ans) ans = val;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3, s4, s;
long long n, i, q, MAXX, MINX, MAXY, MINY, j, x, y, RES, l, xa, xb, ya, yb;
int main() {
cin >> n;
for (q = 1; q <= n; q++) {
MAXX = 0;
MINX = 0;
MAXY = 0;
MINY = 0;
x = 0;
y = 0;
xa = xb = ya = yb = 0;
RES = INT_MAX;
cin >> s;
s1 = s2 = s3 = s4 = s;
l = 0;
for (i = 0; i <= s.length() - 1; i++) {
if (s[i] == 'A') x -= 1;
if (MINX > x) {
MINX = x;
xa = i;
}
if (s[i] == 'D') x += 1;
if (MAXX < x) {
MAXX = x;
xb = i;
}
if (s[i] == 'W') y += 1;
if (MAXY < y) {
MAXY = y;
yb = i;
}
if (s[i] == 'S') y -= 1;
if (MINY > y) {
MINY = y;
ya = i;
}
}
RES = (MAXX - MINX + 1) * (MAXY - MINY + 1);
s1.insert(s1.begin() + xa, 'D');
s2.insert(s2.begin() + xb, 'A');
s3.insert(s3.begin() + ya, 'W');
s4.insert(s4.begin() + yb, 'S');
x = 0;
y = 0;
MAXX = -0;
MINX = 0;
MAXY = -0;
MINY = 0;
for (i = 0; i <= s1.length() - 1; i++) {
if (s1[i] == 'A') x -= 1;
if (MINX > x) MINX = x;
if (s1[i] == 'D') x += 1;
if (MAXX < x) MAXX = x;
if (s1[i] == 'W') y += 1;
if (MAXY < y) MAXY = y;
if (s1[i] == 'S') y -= 1;
if (MINY > y) MINY = y;
}
if (((MAXX - MINX + 1) * (MAXY - MINY + 1)) < RES)
RES = (MAXX - MINX + 1) * (MAXY - MINY + 1);
x = 0;
y = 0;
MAXX = -0;
MINX = 0;
MAXY = -0;
MINY = 0;
for (i = 0; i <= s2.length() - 1; i++) {
if (s2[i] == 'A') x -= 1;
if (MINX > x) MINX = x;
if (s2[i] == 'D') x += 1;
if (MAXX < x) MAXX = x;
if (s2[i] == 'W') y += 1;
if (MAXY < y) MAXY = y;
if (s2[i] == 'S') y -= 1;
if (MINY > y) MINY = y;
}
if (((MAXX - MINX + 1) * (MAXY - MINY + 1)) < RES)
RES = (MAXX - MINX + 1) * (MAXY - MINY + 1);
x = 0;
y = 0;
MAXX = -0;
MINX = 0;
MAXY = -0;
MINY = 0;
for (i = 0; i <= s3.length() - 1; i++) {
if (s3[i] == 'A') x -= 1;
if (MINX > x) MINX = x;
if (s3[i] == 'D') x += 1;
if (MAXX < x) MAXX = x;
if (s3[i] == 'W') y += 1;
if (MAXY < y) MAXY = y;
if (s3[i] == 'S') y -= 1;
if (MINY > y) MINY = y;
}
if (((MAXX - MINX + 1) * (MAXY - MINY + 1)) < RES)
RES = (MAXX - MINX + 1) * (MAXY - MINY + 1);
x = 0;
y = 0;
MAXX = -0;
MINX = 0;
MAXY = -0;
MINY = 0;
for (i = 0; i <= s4.length() - 1; i++) {
if (s4[i] == 'A') x -= 1;
if (MINX > x) MINX = x;
if (s4[i] == 'D') x += 1;
if (MAXX < x) MAXX = x;
if (s4[i] == 'W') y += 1;
if (MAXY < y) MAXY = y;
if (s4[i] == 'S') y -= 1;
if (MINY > y) MINY = y;
}
if (((MAXX - MINX + 1) * (MAXY - MINY + 1)) < RES)
RES = (MAXX - MINX + 1) * (MAXY - MINY + 1);
cout << RES << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt) {
string s;
cin >> s;
int t, b, l, r;
int t0, t1, b0, b1, l0, l1, r0, r1;
t = b = l = r = t0 = t1 = b0 = b1 = l0 = l1 = r0 = r1 = 0;
int x = 0, y = 0;
for (int i = 0; i < s.size(); i++) {
char c = s[i];
switch (c) {
case 'W':
y += 1;
if (y > t) {
t = y;
t0 = i;
t1 = 0;
} else if (y == t) {
t1 = i;
}
break;
case 'S':
y -= 1;
if (y < b) {
b = y;
b0 = i;
b1 = 0;
} else if (y == b) {
b1 = i;
}
break;
case 'A':
x -= 1;
if (x < l) {
l = x;
l0 = i;
l1 = 0;
} else if (x == l) {
l1 = i;
}
break;
case 'D':
x += 1;
if (x > r) {
r = x;
r0 = i;
r1 = 0;
} else if (x == r) {
r1 = i;
}
break;
}
}
long long sq = (t - b + 1) * (r - l + 1);
if (t - b > 1 && ((!t1 && !b1) || (t1 && !b1 && (t1 < b0 || t0 > b0)) ||
(b1 && !t1 && (b1 < t0 || b0 > t0)) ||
(b1 && t1 && (b1 < t0 || t1 < b0)))) {
sq = (long long)(t - b) * (r - l + 1);
}
if (r - l > 1 && ((!r1 && !l1) || (r1 && !l1 && (r1 < l0 || r0 > l0)) ||
(l1 && !r1 && (l1 < r0 || l0 > r0)) ||
(l1 && r1 && (l1 < r0 || r1 < l0)))) {
sq = min(sq, (long long)(t - b + 1) * (r - l));
}
cout << sq << '\n';
tt--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2e5 + 5;
int n, m, k, T;
struct node {
long long w, a, s, d;
} pre[maxn], suf[maxn];
char c[maxn];
void solve() {
scanf("%s", c + 1);
n = strlen(c + 1);
int x = 0, y = 0, w = 0, a = 0, s = 0, d = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == 'W') ++y;
if (c[i] == 'S') --y;
if (c[i] == 'A') --x;
if (c[i] == 'D') ++x;
w = max(w, y);
a = min(a, x);
s = min(s, y);
d = max(d, x);
pre[i].w = w - y, pre[i].a = a - x, pre[i].s = s - y, pre[i].d = d - x;
}
x = 0, y = 0, w = 0, a = 0, s = 0, d = 0;
for (int i = n; i >= 1; i--) {
if (c[i] == 'W') --y;
if (c[i] == 'S') ++y;
if (c[i] == 'A') ++x;
if (c[i] == 'D') --x;
w = max(w, y);
a = min(a, x);
s = min(s, y);
d = max(d, x);
suf[i].w = w - y, suf[i].a = a - x, suf[i].s = s - y, suf[i].d = d - x;
}
long long ans = 1ll * (suf[1].d - suf[1].a + 1) * (suf[1].w - suf[1].s + 1);
for (int i = 1; i <= n; i++) {
ans = min(ans, 1ll *
(max(pre[i].w, suf[i + 1].w + 1) -
min(pre[i].s, suf[i + 1].s + 1) + 1) *
1ll *
(max(pre[i].d, suf[i + 1].d) -
min(pre[i].a, suf[i + 1].a) + 1));
ans = min(ans, 1ll *
(max(pre[i].w, suf[i + 1].w - 1) -
min(pre[i].s, suf[i + 1].s - 1) + 1) *
1ll *
(max(pre[i].d, suf[i + 1].d) -
min(pre[i].a, suf[i + 1].a) + 1));
ans = min(
ans,
1ll * (max(pre[i].w, suf[i + 1].w) - min(pre[i].s, suf[i + 1].s) + 1) *
1ll *
(max(pre[i].d, suf[i + 1].d + 1) - min(pre[i].a, suf[i + 1].a + 1) +
1));
ans = min(
ans,
1ll * (max(pre[i].w, suf[i + 1].w) - min(pre[i].s, suf[i + 1].s) + 1) *
1ll *
(max(pre[i].d, suf[i + 1].d - 1) - min(pre[i].a, suf[i + 1].a - 1) +
1));
}
printf("%lld\n", ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210000;
int row[N];
int col[N];
char str[N];
int main() {
int T, n;
scanf("%d", &T);
for (int t = 1; t <= T; t++) {
scanf("%s", str + 1);
int len = strlen(str + 1);
int row_index = 0, col_index = 0;
int row_max_left = 0, row_max_right = 0;
int col_max_left = 0, col_max_right = 0;
int row_min_left = 0, row_min_right = 0;
int col_min_left = 0, col_min_right = 0;
int row_max = 0, row_min = 0;
int col_max = 0, col_min = 0;
for (int i = 1; i <= len; i++) {
if (str[i] == 'W') {
++col_index;
col[col_index] = col[col_index - 1] + 1;
if (col[col_index] > col_max) {
col_max_left = col_index;
col_max = col[col_index];
}
if (col[col_index] >= col_max) {
col_max_right = col_index;
col_max = col[col_index];
}
}
if (str[i] == 'S') {
++col_index;
col[col_index] = col[col_index - 1] - 1;
if (col[col_index] < col_min) {
col_min_left = col_index;
col_min = col[col_index];
}
if (col[col_index] <= col_min) {
col_min_right = col_index;
col_min = col[col_index];
}
}
if (str[i] == 'A') {
++row_index;
row[row_index] = row[row_index - 1] - 1;
if (row[row_index] < row_min) {
row_min_left = row_index;
row_min = row[row_index];
}
if (row[row_index] <= row_min) {
row_min_right = row_index;
row_min = row[row_index];
}
}
if (str[i] == 'D') {
++row_index;
row[row_index] = row[row_index - 1] + 1;
if (row[row_index] > row_max) {
row_max_left = row_index;
row_max = row[row_index];
}
if (row[row_index] >= row_max) {
row_max_right = row_index;
row_max = row[row_index];
}
}
}
long long l = row_max - row_min + 1;
long long w = col_max - col_min + 1;
long long ans = (long long)l * w;
long long tmp = (long long)ans;
if (row_max_right < row_min_left && l > 2 ||
row_min_right < row_max_left && l > 2)
tmp = min(tmp, ans - w);
if (col_max_right < col_min_left && w > 2 ||
col_min_right < col_max_left && w > 2)
tmp = min(tmp, ans - l);
printf("%lld\n", tmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005], t1[1000005], t2[1000005];
int sp[1000005], nrt1, nrt2, ok1, ok2;
long long lat1, lat2;
void f(int &ok1, long long &lat1, int nrt) {
int i, mini, maxi, poz, poz2;
mini = 0;
maxi = 0;
for (i = 1; i <= nrt; i++) {
maxi = max(maxi, sp[i]);
mini = min(mini, sp[i]);
}
for (i = 0; i <= nrt; i++)
if (mini == sp[i]) {
poz = i;
break;
}
for (i = nrt; i >= 0; i--)
if (maxi == sp[i]) {
poz2 = i;
break;
}
if (poz > poz2) ok1 = 1;
lat1 = maxi - mini + 1;
for (i = 0; i <= nrt; i++)
if (maxi == sp[i]) {
poz = i;
break;
}
for (i = nrt; i >= 0; i--)
if (mini == sp[i]) {
poz2 = i;
break;
}
if (poz > poz2) ok1 = 1;
}
int main() {
int i, nrt;
cin >> nrt;
while (nrt--) {
cin >> s;
int n = strlen(s);
nrt1 = 0;
nrt2 = 0;
ok1 = 0;
ok2 = 0;
for (i = 0; i < n; i++) {
if ((s[i] == 'S') || (s[i] == 'W')) {
t1[nrt1] = s[i];
nrt1++;
} else {
t2[nrt2] = s[i];
nrt2++;
}
}
if (t1[0] == 'S')
sp[1] = -1;
else
sp[1] = 1;
for (i = 2; i <= nrt1; i++)
sp[i] = sp[i - 1] + ((t1[i - 1] == 'S') ? -1 : 1);
f(ok1, lat1, nrt1);
if (t2[0] == 'A')
sp[1] = -1;
else
sp[1] = 1;
for (i = 1; i <= nrt2; i++)
sp[i] = sp[i - 1] + ((t2[i - 1] == 'A') ? -1 : 1);
f(ok2, lat2, nrt2);
long long ans = lat1 * lat2;
if ((ok1) && (lat1 > 2)) ans = min(ans, (lat1 - 1) * lat2);
if ((ok2) && (lat2 > 2)) ans = min(ans, (lat2 - 1) * lat1);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int len, flag = 0;
string s;
long long solve(char c1, char c2) {
int Min = 0, Max = 0, sum = 0;
int p_lastMax = -1, p_firstMax = -1, p_lastMin = -1, p_firstMin = -1;
int c = 0;
for (int i = 0; i < len; i++) {
bool ys = 0;
if (s[i] == c1) sum--, ys = 1;
if (s[i] == c2) sum++, ys = 1;
if (ys) {
c++;
if (sum == Max) {
p_lastMax = i;
}
if (sum > Max) {
p_firstMax = p_lastMax = i;
Max = sum;
}
if (sum == Min) {
p_lastMin = i;
}
if (sum < Min) {
p_firstMin = p_lastMin = i;
Min = sum;
}
}
}
long long tmp = Max - Min + 1;
if ((c > 1) && (p_lastMax < p_firstMin || p_firstMax > p_lastMin)) {
tmp--;
flag++;
}
return tmp;
}
int main() {
int T;
cin >> T;
while (T--) {
flag = 0;
cin >> s;
len = s.size();
long long W = solve('W', 'S');
long long H = solve('A', 'D');
long long ans;
if (flag == 2)
ans = min(W * (H + 1), (W + 1) * H);
else
ans = W * H;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
struct Input {
Input(istream &in) : in(&in) {}
template <class T>
T next() const {
T x;
*in >> x;
return x;
}
int ni() const { return next<int>(); }
string ns() const { return next<string>(); }
istream *in;
};
Input in(cin);
class Output {
private:
ostream *out;
template <typename T>
void printSingle(const T &value) {
*out << value;
}
public:
Output(ostream &out) : out(&out) {}
inline void print() {}
template <typename T, typename... Ts>
inline void print(const T &f, const Ts &...args) {
printSingle(f);
if (sizeof...(args) != 0) {
*out << ' ';
print(args...);
}
}
template <typename... Ts>
inline void println(const Ts &...args) {
print(args...);
*out << '\n';
}
template <typename... Ts>
inline void operator()(const Ts &...args) {
println(args...);
}
};
Output out(cout);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
string dir = "WSAD";
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int64_t getResult(const string &s) {
int x = 0, y = 0;
int miX = 0, maX = 0;
int miY = 0, maY = 0;
for (int i = 0; i < (s.length()); ++i) {
int d;
for (d = 0; d < 4; ++d)
if (dir[d] == s[i]) break;
x += dx[d];
y += dy[d];
if (miX > x) {
miX = x;
}
if (maX < x) {
maX = x;
}
if (miY > y) {
miY = y;
}
if (maY < y) {
maY = y;
}
}
int64_t h = (maX - miX + 1);
int64_t w = (maY - miY + 1);
int64_t res = h * w;
return res;
}
const int INF = 1000000000;
struct SegmentTreeMin {
int n;
vector<int> tmin, tmax;
vector<int> tadd;
SegmentTreeMin(int n) : n(n) {
tmin = vec<int>(4 * n, 0);
tmax = vec<int>(4 * n, 0);
tadd = vec<int>(4 * n, 0);
}
void combine(int v) {
tmin[v] = min(tmin[2 * v], tmin[2 * v + 1]);
tmax[v] = max(tmax[2 * v], tmax[2 * v + 1]);
}
void push(int v) {
if (tadd[v] != 0) {
if (2 * v < tmin.size()) {
tmin[2 * v] += tadd[v];
tmax[2 * v] += tadd[v];
tadd[2 * v] += tadd[v];
}
if (2 * v + 1 < tmin.size()) {
tmin[2 * v + 1] += tadd[v];
tmax[2 * v + 1] += tadd[v];
tadd[2 * v + 1] += tadd[v];
}
tadd[v] = 0;
}
}
void update(int pos, int val) {
int v = 1;
int le = 0, ri = n;
while (le + 1 < ri) {
push(v);
int m = (le + ri) / 2;
if (pos < m) {
ri = m;
v *= 2;
} else {
le = m;
v = 2 * v + 1;
}
}
tmin[v] = val;
tmax[v] = val;
tadd[v] = 0;
v /= 2;
while (v) {
combine(v);
v /= 2;
}
}
void internalAdd(int l, int r, int v, int vl, int vr, int delta) {
if (l >= vr || vl >= r) return;
push(v);
if (vl >= l && vr <= r) {
tadd[v] += delta;
if (tmin[v] != INF) {
tmin[v] += delta;
tmax[v] += delta;
}
return;
}
int vm = (vl + vr) / 2;
internalAdd(l, r, 2 * v, vl, vm, delta);
internalAdd(l, r, 2 * v + 1, vm, vr, delta);
combine(v);
}
void updateSuffix(int from, int delta) {
internalAdd(from, n, 1, 0, n, delta);
}
pair<int, int> internalGet(int l, int r, int v, int vl, int vr) {
if (l >= vr || vl >= r) return {0, 0};
push(v);
if (vl >= l && vr <= r) {
return {tmax[v], tmin[v]};
}
int vm = (vl + vr) / 2;
pair<int, int> p1 = internalGet(l, r, 2 * v, vl, vm);
pair<int, int> p2 = internalGet(l, r, 2 * v + 1, vm, vr);
return {max(p1.first, p2.first), min(p1.second, p2.second)};
}
pair<int, int> get(int le, int ri) {
return internalGet(le, ri + 1, 1, 0, n);
}
};
void solveOne() {
auto s = in.ns();
auto res = getResult(s);
SegmentTreeMin streeX(s.length() + 1), streeY(s.length() + 1);
int x = 0, y = 0;
streeX.update(0, x);
streeY.update(0, y);
for (int i = 0; i < (s.length()); ++i) {
int d;
for (d = 0; d < 4; ++d)
if (dir[d] == s[i]) break;
x += dx[d];
y += dy[d];
;
;
streeX.update(i + 1, x);
streeY.update(i + 1, y);
}
for (int i = 0; i < (s.length()); ++i) {
{
auto px1 = streeX.get(0, i);
streeX.updateSuffix(i, 1);
auto px2 = streeX.get(i, s.length());
streeX.updateSuffix(i, -1);
pair<int, int> py = streeY.get(0, s.length());
pair<int, int> px = {max(px1.first, px2.first),
min(px1.second, px2.second)};
int64_t h = px.first - px.second + 1;
int64_t w = py.first - py.second + 1;
res = min(res, h * w);
}
{
auto px1 = streeX.get(0, i);
streeX.updateSuffix(i, -1);
auto px2 = streeX.get(i, s.length());
streeX.updateSuffix(i, 1);
pair<int, int> py = streeY.get(0, s.length());
pair<int, int> px = {max(px1.first, px2.first),
min(px1.second, px2.second)};
int64_t h = px.first - px.second + 1;
int64_t w = py.first - py.second + 1;
res = min(res, h * w);
}
{
auto py1 = streeY.get(0, i);
streeY.updateSuffix(i, 1);
auto py2 = streeY.get(i, s.length());
streeY.updateSuffix(i, -1);
pair<int, int> px = streeX.get(0, s.length());
pair<int, int> py = {max(py1.first, py2.first),
min(py1.second, py2.second)};
int64_t h = px.first - px.second + 1;
int64_t w = py.first - py.second + 1;
res = min(res, h * w);
}
{
auto py1 = streeY.get(0, i);
streeY.updateSuffix(i, -1);
auto py2 = streeY.get(i, s.length());
streeY.updateSuffix(i, 1);
pair<int, int> px = streeX.get(0, s.length());
pair<int, int> py = {max(py1.first, py2.first),
min(py1.second, py2.second)};
int64_t h = px.first - px.second + 1;
int64_t w = py.first - py.second + 1;
res = min(res, h * w);
}
}
res = min(res, getResult("S" + s));
res = min(res, getResult("W" + s));
res = min(res, getResult("A" + s));
res = min(res, getResult("D" + s));
res = min(res, getResult(s + "S"));
res = min(res, getResult(s + "W"));
res = min(res, getResult(s + "A"));
res = min(res, getResult(s + "D"));
out(res);
}
void solve(istream &inStream, ostream &outStream) {
in = Input(inStream);
out = Output(outStream);
auto tests = in.ni();
while (tests--) {
solveOne();
}
}
int main() {
solve(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int n = s.length();
vector<long long> x(n + 1, 0), y(n + 1, 0);
for (int i = 0; i < n; i++) {
x[i + 1] = x[i];
y[i + 1] = y[i];
if (s[i] == 'W')
x[i + 1]++;
else if (s[i] == 'A')
y[i + 1]--;
else if (s[i] == 'S')
x[i + 1]--;
else
y[i + 1]++;
}
vector<long long> xlh(n + 1), xll(n + 1), ylh(n + 1), yll(n + 1);
for (int i = 1; i <= n; i++) {
xlh[i] = max(xlh[i - 1], x[i]);
xll[i] = min(xll[i - 1], x[i]);
ylh[i] = max(ylh[i - 1], y[i]);
yll[i] = min(yll[i - 1], y[i]);
}
vector<long long> xrh(n + 1), xrl(n + 1), yrh(n + 1), yrl(n + 1);
xrh[n] = xrl[n] = x[n];
yrh[n] = yrl[n] = y[n];
for (int i = n - 1; i >= 0; i--) {
xrh[i] = max(xrh[i + 1], x[i]);
xrl[i] = min(xrl[i + 1], x[i]);
yrh[i] = max(yrh[i + 1], y[i]);
yrl[i] = min(yrl[i + 1], y[i]);
}
long long ans = (xlh[n] - xll[n] + 1) * (ylh[n] - yll[n] + 1);
for (int i = 0; i < n; i++) {
ans = min(ans, (max({xlh[i], xrh[i] + 1, x[i] + 1}) -
min({xll[i], xrl[i] + 1, x[i] + 1}) + 1) *
(max(ylh[i], yrh[i]) - min(yll[i], yrl[i]) + 1));
ans = min(ans, (max({xlh[i], xrh[i] - 1, x[i] - 1}) -
min({xll[i], xrl[i] - 1, x[i] - 1}) + 1) *
(max(ylh[i], yrh[i]) - min(yll[i], yrl[i]) + 1));
ans = min(ans, (max(xlh[i], xrh[i]) - min(xll[i], xrl[i]) + 1) *
(max({ylh[i], yrh[i] - 1, y[i] - 1}) -
min({yll[i], yrl[i] - 1, y[i] - 1}) + 1));
ans = min(ans, (max(xlh[i], xrh[i]) - min(xll[i], xrl[i]) + 1) *
(max({ylh[i], yrh[i] + 1, y[i] + 1}) -
min({yll[i], yrl[i] + 1, y[i] + 1}) + 1));
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
long long f(vector<long long> arr, long long depth = 1) {
vector<long long> pref = arr;
for (long long i = 1; i < arr.size(); i++) {
pref[i] += pref[i - 1];
}
long long mx = 0, mn = 0;
for (auto x : pref) {
mx = max(mx, x);
mn = min(mn, x);
}
long long ind = 0;
for (long long i = 0; i < arr.size(); i++) {
if (pref[i] == mx) {
ind = i;
break;
}
}
if (depth == 0) {
return mx + abs(mn) + 1;
}
vector<long long> na;
for (long long i = 0; i < ind; i++) {
na.push_back(arr[i]);
}
na.push_back(-1);
for (long long i = ind; i < arr.size(); i++) na.push_back(arr[i]);
return f(na, 0);
}
void sol() {
string s;
cin >> s;
vector<long long> x, y;
for (auto el : s) {
if (el == 'W') {
y.push_back(1);
} else if (el == 'S') {
y.push_back(-1);
} else if (el == 'A') {
x.push_back(-1);
} else {
x.push_back(1);
}
}
long long n = f(x, 0), m = f(y, 0);
long long n1 = f(x), m1 = f(y);
for (auto &el : x) {
el *= -1;
}
for (auto &el : y) {
el *= -1;
}
n1 = min(n1, f(x));
m1 = min(m1, f(y));
cout << min(n1 * m, n * m1) << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
while (t--) {
sol();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const char cc[4] = {'W', 'S', 'A', 'D'};
const int xx[4] = {-1, 1, 0, 0};
const int yy[4] = {0, 0, -1, 1};
int n;
char aa[N], a[N];
int px[N], py[N];
int minpx[N], maxpx[N], minpy[N], maxpy[N];
int sx[N], sy[N];
int minsx[N], maxsx[N], minsy[N], maxsy[N];
void solv() {
cin >> aa;
n = strlen(aa);
for (int i = 1; i <= n; ++i) a[i] = aa[i - 1];
for (int i = 1; i <= n; ++i) {
px[i] = px[i - 1];
py[i] = py[i - 1];
for (int j = 0; j < 4; ++j) {
if (a[i] == cc[j]) {
px[i] += xx[j];
py[i] += yy[j];
}
}
maxpx[i] = max(maxpx[i - 1], px[i]);
minpx[i] = min(minpx[i - 1], px[i]);
maxpy[i] = max(maxpy[i - 1], py[i]);
minpy[i] = min(minpy[i - 1], py[i]);
}
sx[n + 1] = 0;
sy[n + 1] = 0;
maxsx[n + 1] = maxsy[n + 1] = minsx[n + 1] = minsy[n + 1] = 0;
int maxx = 0, minx = 0, maxy = 0, miny = 0;
for (int i = n; i >= 1; --i) {
sx[i] = sx[i + 1];
sy[i] = sy[i + 1];
for (int j = 0; j < 4; ++j) {
if (a[i] == cc[j]) {
sx[i] += xx[j];
sy[i] += yy[j];
}
}
maxx = max(maxx, sx[i]);
minx = min(minx, sx[i]);
maxy = max(maxy, sy[i]);
miny = min(miny, sy[i]);
maxsx[i] = sx[i] - minx;
minsx[i] = sx[i] - maxx;
maxsy[i] = sy[i] - miny;
minsy[i] = sy[i] - maxy;
}
long long ans = (maxpx[n] - minpx[n] + 1) * 1LL * (maxpy[n] - minpy[n] + 1);
for (int i = 0; i <= n; ++i) {
for (int j = 0; j < 4; ++j) {
int maxx = maxpx[i];
int minx = minpx[i];
int maxy = maxpy[i];
int miny = minpy[i];
maxx = max(maxx, px[i] + xx[j]);
minx = min(minx, px[i] + xx[j]);
maxy = max(maxy, py[i] + yy[j]);
miny = min(miny, py[i] + yy[j]);
maxx = max(maxx, px[i] + xx[j] + maxsx[i + 1]);
minx = min(minx, px[i] + xx[j] + minsx[i + 1]);
maxy = max(maxy, py[i] + yy[j] + maxsy[i + 1]);
miny = min(miny, py[i] + yy[j] + minsy[i + 1]);
ans = min(ans, (maxx - minx + 1) * 1LL * (maxy - miny + 1));
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
constexpr ll inf = 0x3FFFFFFFF;
struct res {
ll l = 0;
ll r = 0;
ll d = 0;
ll u = 0;
ll lastl = 0;
ll lastr = 0;
ll lastd = 0;
ll lastu = 0;
ll get() { return (r + 1 - l) * (u + 1 - d); }
};
res calc(const string& s) {
ll x = 0;
ll y = 0;
res r;
for (ll i = 0; i < (int)(s).size(); i++) {
char c = s[i];
if (c == 'W') y++;
if (c == 'S') y--;
if (c == 'A') x--;
if (c == 'D') x++;
if (x > r.r) {
r.r = x;
r.lastr = i;
}
if (x < r.l) {
r.l = x;
r.lastl = i;
}
if (y > r.u) {
r.u = y;
r.lastu = i;
}
if (y < r.d) {
r.d = y;
r.lastd = i;
}
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
string s;
cin >> s;
res r = calc(s);
ll out = r.get();
string a, b, c, d;
for (ll i = 0; i < (int)(s).size(); i++) {
if (i == r.lastl) a += 'D';
if (i == r.lastr) b += 'A';
if (i == r.lastu) c += 'S';
if (i == r.lastd) d += 'W';
a += s[i];
b += s[i];
c += s[i];
d += s[i];
}
for (const string& x : {a, b, c, d}) {
res c = calc(x);
out = min(out, c.get());
}
cout << out << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, hs1, hs2, hp, vs1, vs2, vp, ths1, ths2, thp, tvs1, tvs2,
tvp;
cin >> t;
string s;
while (t-- > 0) {
hs1 = 0;
hs2 = 0;
hp = 0;
vs1 = 0;
vs2 = 0;
vp = 0;
ths1 = 0;
ths2 = 0;
thp = 0;
tvs1 = 0;
tvs2 = 0;
tvp = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'W') {
hp++;
if (hp > hs1) hs1 = hp;
}
if (s[i] == 'S') {
hp--;
if (hp < hs2) hs2 = hp;
}
if (s[i] == 'A') {
vp--;
if (vp < vs2) vs2 = vp;
}
if (s[i] == 'D') {
vp++;
if (vp > vs1) vs1 = vp;
}
}
bool fh1 = 0, fh2 = 0, fv1 = 0, fv2 = 0, h1 = 1, h2 = 1, v1 = 1, v2 = 1;
if (thp == hs1) fh1 = 1;
if (thp == hs2) fh2 = 1;
if (tvp == vs2) fv2 = 1;
if (tvp == vs1) fv1 = 1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'W') {
thp++;
if (thp == hs1) fh1 = 1;
if (fh2 == 1)
if (thp == hs1) h1 = 0;
}
if (s[i] == 'S') {
thp--;
if (thp == hs2) fh2 = 1;
if (fh1 == 1)
if (thp == hs2) h2 = 0;
}
if (s[i] == 'A') {
tvp--;
if (tvp == vs2) fv2 = 1;
if (fv1 == 1)
if (tvp == vs2) v2 = 0;
}
if (s[i] == 'D') {
tvp++;
if (tvp == vs1) fv1 = 1;
if (fv2 == 1)
if (tvp == vs1) v1 = 0;
}
}
long long int mi = (hs1 - hs2 + 1) * (vs1 - vs2 + 1);
if (v1 + v2 == 1 && vs1 - vs2 != 1)
mi = min(mi, (hs1 - hs2 + 1) * (vs1 - vs2));
if (h1 + h2 == 1 && hs1 - hs2 != 1)
mi = min(mi, (hs1 - hs2) * (vs1 - vs2 + 1));
cout << mi << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
bool hor = false;
bool ver = false;
long long cantW = 0;
long long cantA = 0;
long long cantS = 0;
long long cantD = 0;
long long der = 0;
long long izq = 0;
long long up = 0;
long long down = 0;
long long y = 0;
long long x = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == 'W') {
y++;
if (y > up) up = y;
cantW++;
} else if (s[i] == 'S') {
y--;
if (y < down) down = y;
cantS++;
} else if (s[i] == 'A') {
x--;
if (x < izq) izq = x;
cantA++;
} else if (s[i] == 'D') {
x++;
if (x > der) der = x;
cantD++;
}
}
vector<int> ups(s.size() + 1);
vector<int> downs(s.size() + 1);
vector<int> izqs(s.size() + 1);
vector<int> ders(s.size() + 1);
x = 0;
y = 0;
if (up == 0) ups[0] = 1;
if (down == 0) downs[0] = 1;
if (izq == 0) izqs[0] = 1;
if (der == 0) ders[0] = 1;
for (long long i = 0; i < s.size(); i++) {
ups[i + 1] = ups[i];
downs[i + 1] = downs[i];
izqs[i + 1] = izqs[i];
ders[i + 1] = ders[i];
if (s[i] == 'W') {
y++;
if (y == up) ups[i + 1]++;
} else if (s[i] == 'S') {
y--;
if (y == down) downs[i + 1]++;
} else if (s[i] == 'A') {
x--;
if (x == izq) izqs[i + 1]++;
} else if (s[i] == 'D') {
x++;
if (x == der) ders[i + 1]++;
}
}
x = 0;
y = 0;
long long up2 = 0;
long long down2 = 0;
long long izq2 = 0;
long long der2 = 0;
bool cambio = false;
for (long long i = 0; i < s.size(); i++) {
if (!cambio && ups[i] < ups[i + 1]) {
cambio = true;
y--;
if (y < down2) down2 = y;
}
if (s[i] == 'W') {
y++;
if (y > up2) up2 = y;
} else if (s[i] == 'S') {
y--;
if (y < down2) down2 = y;
}
}
if (cambio && up2 < up && down2 >= down) ver = true;
x = 0;
y = 0;
up2 = 0;
down2 = 0;
izq2 = 0;
der2 = 0;
cambio = false;
for (long long i = 0; i < s.size(); i++) {
if (!cambio && downs[i] < downs[i + 1]) {
cambio = true;
y++;
if (y > up2) up2 = y;
}
if (s[i] == 'W') {
y++;
if (y > up2) up2 = y;
} else if (s[i] == 'S') {
y--;
if (y < down) down2 = y;
}
}
if (cambio && down2 > down && up2 <= up) ver = true;
x = 0;
y = 0;
up2 = 0;
down2 = 0;
izq2 = 0;
der2 = 0;
cambio = false;
for (long long i = 0; i < s.size(); i++) {
if (!cambio && izqs[i] < izqs[i + 1]) {
cambio = true;
x++;
}
if (s[i] == 'D') {
x++;
if (x > der2) der2 = x;
} else if (s[i] == 'A') {
x--;
if (x < izq2) izq2 = x;
}
}
if (cambio && izq2 > izq && der2 <= der) hor = true;
x = 0;
y = 0;
up2 = 0;
down2 = 0;
izq2 = 0;
der2 = 0;
cambio = false;
for (long long i = 0; i < s.size(); i++) {
if (!cambio && ders[i] < ders[i + 1]) {
cambio = true;
x--;
}
if (s[i] == 'D') {
x++;
if (x > der2) der2 = x;
} else if (s[i] == 'A') {
x--;
if (x < izq2) izq2 = x;
}
}
if (cambio && izq2 >= izq && der2 < der) hor = true;
long long area = 1;
long long h = der - izq;
long long v = up - down;
hor &= (h > 1);
ver &= (v > 1);
if (cantW == 0 && cantS == 0 && cantA == 0 && cantD == 0)
cout << 1 << '\n';
else if (cantD == 0 && cantA == 0) {
if (ver) {
cout << v << '\n';
} else {
cout << v + 1 << '\n';
}
} else if (cantS == 0 && cantW == 0) {
if (hor) {
cout << h << '\n';
} else {
cout << h + 1 << '\n';
}
} else {
if (ver && hor) {
cout << min(h * (v + 1), v * (h + 1)) << '\n';
} else if (ver) {
cout << v * (h + 1) << '\n';
} else if (hor) {
cout << h * (v + 1) << '\n';
} else {
cout << (h + 1) * (v + 1) << '\n';
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char cc = getchar();
long long cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const long long N = 2e5 + 5;
char s[N];
long long a[N], b[N], sum1[N], sum2[N], mi1[N], mx1[N], mi2[N], mx2[N], n, num,
cnt;
signed main() {
long long T = read();
while (T--) {
scanf("%s", s + 1);
n = strlen(s + 1), num = 0, cnt = 0;
for (long long i = 1; i <= n; ++i) {
if (s[i] == 'W') a[++num] = 1;
if (s[i] == 'S') a[++num] = -1;
if (s[i] == 'A') b[++cnt] = -1;
if (s[i] == 'D') b[++cnt] = 1;
}
for (long long i = 1; i <= num; ++i)
sum1[i] = a[i] + sum1[i - 1], mi1[i] = min(sum1[i], mi1[i - 1]),
mx1[i] = max(sum1[i], mx1[i - 1]);
for (long long i = 1; i <= cnt; ++i)
sum2[i] = b[i] + sum2[i - 1], mi2[i] = min(sum2[i], mi2[i - 1]),
mx2[i] = max(sum2[i], mx2[i - 1]);
long long Ans = (mx1[num] - mi1[num] + 1) * (mx2[cnt] - mi2[cnt] + 1);
long long x = mx1[num] - mi1[num], y = mx2[cnt] - mi2[cnt];
long long mx = 0, mi = 0, Mi, Mx, xx = x, yy = y;
for (long long i = num; i >= 1; --i) {
mi = min(sum1[i] - 1, mi), mx = max(sum1[i] - 1, mx);
Mi = min(mi, mi1[i]), Mx = max(mx, mx1[i]);
xx = min(xx, Mx - Mi);
}
Ans = min(Ans, (xx + 1) * (y + 1));
xx = x, mx = 0, mi = 0;
for (long long i = num; i >= 1; --i) {
mi = min(sum1[i] + 1, mi), mx = max(sum1[i] + 1, mx);
Mi = min(mi, mi1[i]), Mx = max(mx, mx1[i]);
xx = min(xx, Mx - Mi);
}
Ans = min(Ans, (xx + 1) * (y + 1));
mx = mi = 0;
yy = y;
for (long long i = cnt; i >= 1; --i) {
mi = min(sum2[i] - 1, mi), mx = max(sum2[i] - 1, mx);
Mi = min(mi, mi2[i]), Mx = max(mx, mx2[i]);
yy = min(yy, Mx - Mi);
}
Ans = min(Ans, (x + 1) * (yy + 1));
mx = mi = 0;
yy = y;
for (long long i = cnt; i >= 1; --i) {
mi = min(sum2[i] + 1, mi), mx = max(sum2[i] + 1, mx);
Mi = min(mi, mi2[i]), Mx = max(mx, mx2[i]);
yy = min(yy, Mx - Mi);
}
Ans = min(Ans, (x + 1) * (yy + 1));
printf("%I64d\n", Ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int yatay, dikey;
long long k = 0;
long long minny = 0;
long long maxxy = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'D')
k++;
else if (s[i] == 'A')
k--;
minny = min(minny, k);
maxxy = max(maxxy, k);
}
int num = 0;
int last = 0;
k = 0;
if (k == minny && last != -1) {
num++;
last = -1;
}
if (k == maxxy && last != 1) {
num++;
last = 1;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'D')
k++;
else if (s[i] == 'A')
k--;
if (k == minny && last != -1) {
num++;
last = -1;
}
if (k == maxxy && last != 1) {
num++;
last = 1;
}
}
yatay = num < 3;
if (maxxy <= minny + 1) yatay = 0;
long long minnd = 0;
long long maxxd = 0;
k = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W')
k++;
else if (s[i] == 'S')
k--;
minnd = min(minnd, k);
maxxd = max(maxxd, k);
}
num = 0;
last = 0;
k = 0;
if (k == minnd && last != -1) {
num++;
last = -1;
}
if (k == maxxd && last != 1) {
num++;
last = 1;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W')
k++;
else if (s[i] == 'S')
k--;
if (k == minnd && last != -1) {
num++;
last = -1;
}
if (k == maxxd && last != 1) {
num++;
last = 1;
}
}
dikey = (num < 3);
if (maxxd <= minnd + 1) dikey = 0;
cout << min((maxxy - minny + 1) * (maxxd - minnd + 1) -
yatay * ((maxxd - minnd + 1)),
(maxxy - minny + 1) * (maxxd - minnd + 1) -
dikey * (maxxy - minny + 1))
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 100;
struct node {
long long minx, miny, maxx, maxy;
} aa[maxn], bb[maxn];
char a[maxn];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> (a + 1);
a[0] = ' ';
int len = strlen(a) - 1;
long long x = 0, y = 0;
for (int i = 1; i <= len; i++) {
if (a[i] == 'D') {
x++;
a[i] = 'A';
} else if (a[i] == 'S') {
y--;
a[i] = 'W';
} else if (a[i] == 'A') {
x--;
a[i] = 'D';
} else if (a[i] == 'W') {
a[i] = 'S';
y++;
}
aa[i].maxx = max(aa[i - 1].maxx, x);
aa[i].maxy = max(aa[i - 1].maxy, y);
aa[i].minx = min(aa[i - 1].minx, x);
aa[i].miny = min(aa[i - 1].miny, y);
}
bb[len].maxx = bb[len].minx = x;
bb[len].maxy = bb[len].miny = y;
for (int i = len; i >= 1; i--) {
if (a[i] == 'D') {
x++;
}
if (a[i] == 'S') {
y--;
}
if (a[i] == 'A') {
x--;
}
if (a[i] == 'W') {
y++;
}
bb[i - 1].maxx = max(bb[i].maxx, x);
bb[i - 1].maxy = max(bb[i].maxy, y);
bb[i - 1].minx = min(bb[i].minx, x);
bb[i - 1].miny = min(bb[i].miny, y);
}
long long ans = 999999999999, xx, yy, xxx, yyy;
for (int i = 0; i < len; i++) {
xx = min(aa[i].minx, bb[i].minx - 1);
yy = min(aa[i].miny, bb[i].miny);
xxx = max(aa[i].maxx, bb[i].maxx - 1);
yyy = max(aa[i].maxy, bb[i].maxy);
ans = min(ans, (xxx - xx + 1) * (yyy - yy + 1));
xx = min(aa[i].minx, bb[i].minx + 1);
yy = min(aa[i].miny, bb[i].miny);
xxx = max(aa[i].maxx, bb[i].maxx + 1);
yyy = max(aa[i].maxy, bb[i].maxy);
ans = min(ans, (xxx - xx + 1) * (yyy - yy + 1));
xx = min(aa[i].minx, bb[i].minx);
yy = min(aa[i].miny, bb[i].miny - 1);
xxx = max(aa[i].maxx, bb[i].maxx);
yyy = max(aa[i].maxy, bb[i].maxy - 1);
ans = min(ans, (xxx - xx + 1) * (yyy - yy + 1));
xx = min(aa[i].minx, bb[i].minx);
yy = min(aa[i].miny, bb[i].miny + 1);
xxx = max(aa[i].maxx, bb[i].maxx);
yyy = max(aa[i].maxy, bb[i].maxy + 1);
ans = min(ans, (xxx - xx + 1) * (yyy - yy + 1));
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int MXN = (int)1e6 + 7;
const int mod = (int)1e9 + 7;
char s[MXN];
int xx[] = {0, 1, 0, -1};
int yy[] = {1, 0, -1, 0};
int dir(char ch) {
if (ch == 'W')
return 0;
else if (ch == 'D')
return 1;
else if (ch == 'S')
return 2;
else
return 3;
}
pair<int, int> pos[MXN];
int lmxn[MXN][4], rmxn[MXN][4];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", s + 1);
int l = strlen(s + 1);
for (int i = 0; i < 4; i++) rmxn[l + 1][i] = 0;
int x = 0, y = 0;
for (int i = 1; i <= l; i++) {
int d = dir(s[i]);
x += xx[d];
y += yy[d];
pos[i] = {x, y};
for (int j = 0; j < 4; j++) lmxn[i][j] = lmxn[i - 1][j];
lmxn[i][0] = max(lmxn[i][0], y);
lmxn[i][1] = max(lmxn[i][1], x);
lmxn[i][2] = min(lmxn[i][2], y);
lmxn[i][3] = min(lmxn[i][3], x);
}
long long ans =
(lmxn[l][0] - lmxn[l][2] + 1) * 1ll * (lmxn[l][1] - lmxn[l][3] + 1);
x = 0, y = 0;
for (int i = l; i >= 1; i--) {
int d = dir(s[i]);
d = (d + 2) % 4;
x += xx[d];
y += yy[d];
for (int j = 0; j < 4; j++) rmxn[i][j] = rmxn[i + 1][j];
rmxn[i][0] = max(rmxn[i][0], y);
rmxn[i][1] = max(rmxn[i][1], x);
rmxn[i][2] = min(rmxn[i][2], y);
rmxn[i][3] = min(rmxn[i][3], x);
int l, r, b, t;
t = max(rmxn[i][0] - y + 1, lmxn[i - 1][0] - pos[i - 1].second);
r = max(rmxn[i][1] - x, lmxn[i - 1][1] - pos[i - 1].first);
d = min(rmxn[i][2] - y + 1, lmxn[i - 1][2] - pos[i - 1].second);
l = min(rmxn[i][3] - x, lmxn[i - 1][3] - pos[i - 1].first);
ans = min(ans, (t - d + 1) * 1ll * (r - l + 1));
t = max(rmxn[i][0] - y, lmxn[i - 1][0] - pos[i - 1].second);
r = max(rmxn[i][1] - x + 1, lmxn[i - 1][1] - pos[i - 1].first);
d = min(rmxn[i][2] - y, lmxn[i - 1][2] - pos[i - 1].second);
l = min(rmxn[i][3] - x + 1, lmxn[i - 1][3] - pos[i - 1].first);
ans = min(ans, (t - d + 1) * 1ll * (r - l + 1));
t = max(rmxn[i][0] - y - 1, lmxn[i - 1][0] - pos[i - 1].second);
r = max(rmxn[i][1] - x, lmxn[i - 1][1] - pos[i - 1].first);
d = min(rmxn[i][2] - y - 1, lmxn[i - 1][2] - pos[i - 1].second);
l = min(rmxn[i][3] - x, lmxn[i - 1][3] - pos[i - 1].first);
ans = min(ans, (t - d + 1) * 1ll * (r - l + 1));
t = max(rmxn[i][0] - y, lmxn[i - 1][0] - pos[i - 1].second);
r = max(rmxn[i][1] - x - 1, lmxn[i - 1][1] - pos[i - 1].first);
d = min(rmxn[i][2] - y, lmxn[i - 1][2] - pos[i - 1].second);
l = min(rmxn[i][3] - x - 1, lmxn[i - 1][3] - pos[i - 1].first);
ans = min(ans, (t - d + 1) * 1ll * (r - l + 1));
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 7;
const long long MAX = 200010;
const long double EPS = 1e-9;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t) {
t--;
string s;
cin >> s;
long long n = s.size();
vector<vector<long long> > rui(n + 1, vector<long long>(4));
long long nowx = 0, nowy = 0;
for (long long i = (0); i < (n); i++) {
if (s[i] == 'D') {
nowx++;
} else if (s[i] == 'S') {
nowy--;
} else if (s[i] == 'A') {
nowx--;
} else {
nowy++;
}
rui[i + 1][0] = max(rui[i][0], nowx);
rui[i + 1][1] = min(rui[i][1], nowy);
rui[i + 1][2] = min(rui[i][2], nowx);
rui[i + 1][3] = max(rui[i][3], nowy);
}
long long X = rui[n][0] - rui[n][2] + 1;
long long Y = rui[n][3] - rui[n][1] + 1;
long long ans = X * Y;
vector<vector<long long> > rm(n + 1, vector<long long>(4));
rm[n][0] = nowx;
rm[n][1] = nowy;
rm[n][2] = nowx;
rm[n][3] = nowy;
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == 'D') {
nowx--;
} else if (s[i] == 'S') {
nowy++;
} else if (s[i] == 'A') {
nowx++;
} else {
nowy--;
}
rm[i][0] = max(rm[i + 1][0], nowx);
rm[i][1] = min(rm[i + 1][1], nowy);
rm[i][2] = min(rm[i + 1][2], nowx);
rm[i][3] = max(rm[i + 1][3], nowy);
}
for (long long i = (0); i < (n); i++) {
if (s[i] == 'D') {
nowx++;
} else if (s[i] == 'S') {
nowy--;
} else if (s[i] == 'A') {
nowx--;
} else {
nowy++;
}
if (rui[n][0] - rui[i + 1][0] > 0) {
if (rm[i + 1][2] > rui[i + 1][2]) ans = min(ans, X * Y - Y);
}
if (rui[n][1] - rui[i + 1][1] < 0) {
if (rm[i + 1][3] < rui[i + 1][3]) ans = min(ans, X * Y - X);
}
if (rui[n][2] - rui[i + 1][2] < 0) {
if (rm[i + 1][0] < rui[i + 1][0]) ans = min(ans, X * Y - Y);
}
if (rui[n][3] - rui[i + 1][3] > 0) {
if (rm[i + 1][1] > rui[i + 1][1]) ans = min(ans, X * Y - X);
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
string s;
int pSum1[200004];
int pSum2[200004];
int min1, min2, max1, max2;
int fmin, fmax, lmin, lmax;
int width, heigth, pwidth, pheigth;
int i1, i2;
long long ans;
for (int i = 0; i < T; i++) {
s.clear();
cin >> s;
pSum1[0] = 0;
pSum2[0] = 0;
min1 = 0;
min2 = 0;
max1 = 0;
max2 = 0;
i1 = 0, i2 = 0;
for (int j = 0; j < s.length(); j++) {
if (s[j] == 'W') {
pSum1[i1 + 1] = pSum1[i1] + 1;
if (pSum1[i1 + 1] > max1) max1 = pSum1[i1 + 1];
i1++;
}
if (s[j] == 'S') {
pSum1[i1 + 1] = pSum1[i1] - 1;
if (pSum1[i1 + 1] < min1) min1 = pSum1[i1 + 1];
i1++;
}
if (s[j] == 'A') {
pSum2[i2 + 1] = pSum2[i2] - 1;
if (pSum2[i2 + 1] < min2) min2 = pSum2[i2 + 1];
i2++;
}
if (s[j] == 'D') {
pSum2[i2 + 1] = pSum2[i2] + 1;
if (pSum2[i2 + 1] > max2) max2 = pSum2[i2 + 1];
i2++;
}
}
width = max2 - min2 + 1;
heigth = max1 - min1 + 1;
pwidth = width;
pheigth = heigth;
fmin = -1;
fmax = -1;
for (int j = 0; j < i1 + 1; j++) {
if (pSum1[j] == min1) {
lmin = j;
if (fmin == -1) fmin = j;
}
if (pSum1[j] == max1) {
lmax = j;
if (fmax == -1) fmax = j;
}
}
if ((fmin > lmax || fmax > lmin) && heigth > 2) pheigth--;
fmin = -1;
fmax = -1;
for (int j = 0; j < i2 + 1; j++) {
if (pSum2[j] == min2) {
lmin = j;
if (fmin == -1) fmin = j;
}
if (pSum2[j] == max2) {
lmax = j;
if (fmax == -1) fmax = j;
}
}
if ((fmin > lmax || fmax > lmin) && width > 2) pwidth--;
ans = min((long long)heigth * pwidth, (long long)pheigth * width);
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
string S;
cin >> S;
S = "*" + S;
int N = (int)S.size();
vector<int> h(N + 1), v(N + 1);
for (int i = 1; i <= N; i++) {
h[i] = h[i - 1];
v[i] = v[i - 1];
if (S[i] == 'D') {
h[i]++;
}
if (S[i] == 'A') {
h[i]--;
}
if (S[i] == 'W') {
v[i]++;
}
if (S[i] == 'S') {
v[i]--;
}
}
vector<int> ml(N + 1), mr(N + 1), mu(N + 1), md(N + 1);
mr[N] = h[N];
ml[N] = h[N];
mu[N] = v[N];
md[N] = v[N];
for (int i = N - 1; i >= 0; i--) {
mr[i] = max(h[i], mr[i + 1]);
ml[i] = min(h[i], ml[i + 1]);
mu[i] = max(v[i], mu[i + 1]);
md[i] = min(v[i], md[i + 1]);
}
long long ans = 1LL * (abs(md[0]) + mu[0] + 1) * (abs(ml[0]) + mr[0] + 1);
int ch = 0, cv = 0;
int cl = 0, cr = 0, cu = 0, cd = 0;
for (int i = 0; i < N; i++) {
long long R = 1LL *
(1 + max({cr, ch + 1, mr[i] + 1}) +
abs(min({cl, ch + 1, ml[i] + 1}))) *
(1 + mu[0] + abs(md[0]));
long long L = 1LL *
(1 + max({cr, ch - 1, mr[i] - 1}) +
abs(min({cl, ch - 1, ml[i] - 1}))) *
(1 + mu[0] + abs(md[0]));
long long U = 1LL *
(1 + max({cu, cv + 1, mu[i] + 1}) +
abs(min({cd, cv + 1, md[i] + 1}))) *
(1 + mr[0] + abs(ml[0]));
long long D = 1LL *
(1 + max({cu, cv - 1, mu[i] - 1}) +
abs(min({cd, cv - 1, md[i] - 1}))) *
(1 + mr[0] + abs(ml[0]));
ans = min({ans, L, R, U, D});
if (S[i] == 'D') {
ch++;
cr = max(ch, cr);
}
if (S[i] == 'A') {
ch--;
cl = min(ch, cl);
}
if (S[i] == 'W') {
cv++;
cu = max(cv, cu);
}
if (S[i] == 'S') {
cv--;
cd = min(cv, cd);
}
}
cout << ans << '\n';
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.