text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 22 + 5;
const int MAXV = 2000;
const int MAXE = 500000;
const int INF = (int)1e7 + 10;
struct E {
int to, co;
E(int t = 0, int c = 0) : to(t), co(c) {}
} eg[2 * MAXE];
struct Flow {
vector<int> e[MAXV];
int ei, v;
void init(int n) {
v = n;
ei = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add(int a, int b, int c) {
eg[ei] = E(b, c);
e[a].push_back(ei);
ei++;
eg[ei] = E(a, 0);
e[b].push_back(ei);
ei++;
}
int d[MAXV], qu[MAXV], ql, qr;
bool BFS() {
memset(d, -1, v * sizeof(int));
ql = qr = 0;
qu[qr++] = 0;
d[0] = 0;
while (ql < qr && d[v - 1] == -1) {
int n = qu[ql++];
vector<int> &v = e[n];
for (int i = v.size() - 1; i >= 0; i--) {
int u = v[i];
if (d[eg[u].to] == -1 && eg[u].co > 0) {
d[eg[u].to] = d[n] + 1;
qu[qr++] = eg[u].to;
}
}
}
return d[v - 1] != -1;
}
int ptr[MAXV];
int go(int n, int p) {
if (n == v - 1) return p;
vector<int> &u = e[n];
int temp;
for (int i = ptr[n]; i < ((int)(u).size()); i++) {
if (d[n] + 1 != d[eg[u[i]].to] || eg[u[i]].co == 0) continue;
if ((temp = go(eg[u[i]].to, min(p, eg[u[i]].co))) == 0) continue;
eg[u[i]].co -= temp;
eg[u[i] ^ 1].co += temp;
ptr[n] = i;
return temp;
}
ptr[n] = ((int)(u).size());
return 0;
}
int max_flow() {
int ans = 0, temp;
while (BFS()) {
for (int i = 0; i < v; i++) ptr[i] = 0;
while ((temp = go(0, INF)) > 0) ans += temp;
}
return ans;
}
} flow;
char s[MAXN][MAXN];
int dis[MAXN * MAXN][MAXN * MAXN];
vector<pair<pair<int, int>, int> > ma, fe;
queue<int> que;
void bfs(int sx, int sy, int n, int m, int *d) {
int start = sx * m + sy;
fill(d, d + n * m, n * m + 10);
d[start] = 0;
que.push(start);
while (!que.empty()) {
int tmp = que.front();
que.pop();
int x = tmp / m, y = tmp % m;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
for (int i = 0; i < 4; i++) {
int ax = x + dx[i], ay = y + dy[i];
if (ax < 0 || ax >= n || ay < 0 || ay >= m || s[ax][ay] == '#') continue;
int a = x * m + y, b = ax * m + ay;
if (d[b] > d[a] + 1) {
d[b] = d[a] + 1;
que.push(b);
}
}
}
}
bool C(long long mid, int n, int m, int male, int female) {
male = ((int)(ma).size());
female = ((int)(fe).size());
flow.init(male * 2 + 2 * n * m + 2);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
flow.add(i * m + j + 1, n * m + i * m + j + 1, 1);
for (int i1 = 0; i1 < ma.size(); i1++) {
flow.add(0, 2 * n * m + i1 + 1, 1);
auto man = ma[i1];
int x = man.first.first, y = man.first.second, t = man.second;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' || dis[x * m + y][i * m + j] == n * m + 10 ||
1LL * dis[x * m + y][i * m + j] * t > mid)
continue;
flow.add(2 * n * m + i1 + 1, i * m + j + 1, 1);
}
}
}
for (int i2 = 0; i2 < fe.size(); i2++) {
flow.add(2 * n * m + male + i2 + 1, 2 * n * m + male + female + 1, 1);
auto woman = fe[i2];
int x = woman.first.first, y = woman.first.second, t = woman.second;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' || dis[x * m + y][i * m + j] == n * m + 10 ||
1LL * dis[x * m + y][i * m + j] * t > mid)
continue;
flow.add(n * m + i * m + j + 1, 2 * n * m + male + i2 + 1, 1);
}
}
}
return flow.max_flow() == male;
}
int main() {
int n, m, male, female;
scanf("%d%d%d%d", &n, &m, &male, &female);
if (abs(male - female) != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') continue;
bfs(i, j, n, m, dis[i * m + j]);
}
}
int r, c, x;
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
if (male > female)
fe.push_back(make_pair(make_pair(r, c), x));
else
ma.push_back(make_pair(make_pair(r, c), x));
for (int i = 0; i < male; i++) {
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
ma.push_back(make_pair(make_pair(r, c), x));
}
for (int i = 0; i < female; i++) {
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
fe.push_back(make_pair(make_pair(r, c), x));
}
long long lb = -1, ub = 1LL << 60;
while (ub - lb > 1) {
long long mid = (ub + lb) / 2;
if (C(mid, n, m, male, female))
ub = mid;
else
lb = mid;
}
printf("%I64d\n", ub == (1LL << 60) ? -1 : ub);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 22 + 5;
const int MAXV = 2000;
const int MAXE = 500000;
const int INF = (int)1e7 + 10;
struct E {
int to, co;
E(int t = 0, int c = 0) : to(t), co(c) {}
} eg[2 * MAXE];
struct Flow {
vector<int> e[MAXV];
int ei, v;
void init(int n) {
v = n;
ei = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add(int a, int b, int c) {
eg[ei] = E(b, c);
e[a].push_back(ei);
ei++;
eg[ei] = E(a, 0);
e[b].push_back(ei);
ei++;
}
int d[MAXV], qu[MAXV], ql, qr;
bool BFS() {
memset(d, -1, v * sizeof(int));
ql = qr = 0;
qu[qr++] = 0;
d[0] = 0;
while (ql < qr && d[v - 1] == -1) {
int n = qu[ql++];
vector<int> &v = e[n];
for (int i = v.size() - 1; i >= 0; i--) {
int u = v[i];
if (d[eg[u].to] == -1 && eg[u].co > 0) {
d[eg[u].to] = d[n] + 1;
qu[qr++] = eg[u].to;
}
}
}
return d[v - 1] != -1;
}
int ptr[MAXV];
int go(int n, int p) {
if (n == v - 1) return p;
vector<int> &u = e[n];
int temp;
for (int i = ptr[n]; i < ((int)(u).size()); i++) {
if (d[n] + 1 != d[eg[u[i]].to] || eg[u[i]].co == 0) continue;
if ((temp = go(eg[u[i]].to, min(p, eg[u[i]].co))) == 0) continue;
eg[u[i]].co -= temp;
eg[u[i] ^ 1].co += temp;
ptr[n] = i;
return temp;
}
ptr[n] = ((int)(u).size());
return 0;
}
int max_flow() {
int ans = 0, temp;
while (BFS()) {
for (int i = 0; i < v; i++) ptr[i] = 0;
while ((temp = go(0, INF)) > 0) ans += temp;
}
return ans;
}
} flow;
char s[MAXN][MAXN];
int dis[MAXN * MAXN][MAXN * MAXN];
vector<pair<pair<int, int>, int> > ma, fe;
queue<int> que;
void bfs(int sx, int sy, int n, int m, int *d) {
int start = sx * m + sy;
fill(d, d + n * m, n * m + 10);
d[start] = 0;
que.push(start);
while (!que.empty()) {
int tmp = que.front();
que.pop();
int x = tmp / m, y = tmp % m;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
for (int i = 0; i < 4; i++) {
int ax = x + dx[i], ay = y + dy[i];
if (ax < 0 || ax >= n || ay < 0 || ay >= m || s[ax][ay] == '#') continue;
int a = x * m + y, b = ax * m + ay;
if (d[b] > d[a] + 1) {
d[b] = d[a] + 1;
que.push(b);
}
}
}
}
bool C(long long mid, int n, int m, int male, int female) {
male = ((int)(ma).size());
female = ((int)(fe).size());
flow.init(male * 2 + 2 * n * m + 2);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
flow.add(i * m + j + 1, n * m + i * m + j + 1, 1);
for (int i1 = 0; i1 < ma.size(); i1++) {
flow.add(0, 2 * n * m + i1 + 1, 1);
auto man = ma[i1];
int x = man.first.first, y = man.first.second, t = man.second;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' || dis[x * m + y][i * m + j] == n * m + 10 ||
1LL * dis[x * m + y][i * m + j] * t > mid)
continue;
flow.add(2 * n * m + i1 + 1, i * m + j + 1, 1);
}
}
}
for (int i2 = 0; i2 < fe.size(); i2++) {
flow.add(2 * n * m + male + i2 + 1, 2 * n * m + male + female + 1, 1);
auto woman = fe[i2];
int x = woman.first.first, y = woman.first.second, t = woman.second;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' || dis[x * m + y][i * m + j] == n * m + 10 ||
1LL * dis[x * m + y][i * m + j] * t > mid)
continue;
flow.add(n * m + i * m + j + 1, 2 * n * m + male + i2 + 1, 1);
}
}
}
return flow.max_flow() == male;
}
int main() {
int n, m, male, female;
scanf("%d%d%d%d", &n, &m, &male, &female);
if (abs(male - female) != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') continue;
bfs(i, j, n, m, dis[i * m + j]);
}
}
int r, c, x;
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
if (male > female)
fe.push_back(make_pair(make_pair(r, c), x));
else
ma.push_back(make_pair(make_pair(r, c), x));
for (int i = 0; i < male; i++) {
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
ma.push_back(make_pair(make_pair(r, c), x));
}
for (int i = 0; i < female; i++) {
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
fe.push_back(make_pair(make_pair(r, c), x));
}
long long lb = -1, ub = 1LL << 60;
while (ub - lb > 1) {
long long mid = (ub + lb) / 2;
if (C(mid, n, m, male, female))
ub = mid;
else
lb = mid;
}
printf("%I64d\n", ub == (1LL << 60) ? -1 : ub);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 22 + 5;
const int MAXM = 2e5 + 5;
int n, m;
char str[MAXN][MAXN];
inline int id(int i, int j) { return (i - 1) * m + j; }
int dis[MAXN * MAXN][MAXN * MAXN];
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
inline void bfs(std::pair<int, int> v, int dis[]) {
for (int i = 1; i <= n * m; ++i) dis[i] = 1e9 + 114514;
dis[id(v.first, v.second)] = 0;
std::queue<std::pair<int, int> > q;
q.push(v);
while (!q.empty()) {
std::pair<int, int> v = q.front();
q.pop();
if (str[v.first][v.second] == '#') continue;
for (int k = 0; k <= 3; ++k) {
int xx = v.first + dx[k], yy = v.second + dy[k];
if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && str[xx][yy] != '#' &&
dis[id(xx, yy)] > 1e9) {
dis[id(xx, yy)] = dis[id(v.first, v.second)] + 1;
q.push(std::make_pair(xx, yy));
}
}
}
}
struct Node {
int x, y, z;
long long t;
Node(int x = 0, int y = 0, int z = 0, long long t = 0)
: x(x), y(y), z(z), t(t) {}
inline bool operator<(const Node &_) const { return t < _.t; }
};
Node B[MAXM], G[MAXM];
int k;
namespace F {
struct Edge {
int to, w, nxt;
} e[MAXM << 5];
int S, T, N;
int head[MAXM], cur[MAXM], cnt = 1, dep[MAXM];
int ans = 0;
inline void clear() {
for (int i = 1; i <= N; ++i) head[i] = cur[i] = 0;
cnt = 1;
ans = 0;
}
inline void add(int u, int v, int w) {
e[++cnt] = (Edge){v, w, head[u]};
head[u] = cnt;
e[++cnt] = (Edge){u, 0, head[v]};
head[v] = cnt;
}
inline bool bfs() {
for (int i = 0; i <= N; ++i) cur[i] = head[i], dep[i] = 0;
std::queue<int> q;
q.push(S);
dep[S] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = head[v]; i; i = e[i].nxt) {
if (e[i].w > 0 && !dep[e[i].to]) {
dep[e[i].to] = dep[v] + 1;
if (e[i].to == T) return 1;
q.push(e[i].to);
}
}
}
return dep[T];
}
inline int dfs(int v, int flow = 1e9) {
if (v == T) return flow;
if (!flow) return 0;
int ans = 0;
for (int &i = cur[v]; i; i = e[i].nxt) {
if (e[i].w > 0 && dep[e[i].to] == dep[v] + 1) {
int t = dfs(e[i].to, std::min(e[i].w, flow));
if (t > 0) {
e[i].w -= t;
e[i ^ 1].w += t;
flow -= t;
ans += t;
if (!flow) return ans;
}
}
}
if (!ans) dep[v] = 0;
return ans;
}
inline void Dinic() {
int flow;
while (bfs()) {
while ((flow = dfs(S))) ans += flow;
}
}
} // namespace F
std::vector<Node> edge[MAXM], tmp;
int ts[MAXM];
std::mt19937 g32(114514);
inline bool chk(long long lim) {
F::clear();
F::N = 2 * n * m + 2 * k + 2;
F::S = F::N - 1;
F::T = F::N;
for (int i = 1; i <= k; ++i)
F::add(F::S, 2 * n * m + i, 1), F::add(2 * n * m + k + i, F::T, 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) F::add(id(i, j), n * m + id(i, j), 1);
for (int i = 1; i <= k; ++i) {
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
if (dis[id(B[i].x, B[i].y)][id(x, y)] > 1e9) continue;
long long d = 1ll * dis[id(B[i].x, B[i].y)][id(x, y)] * B[i].z;
if (d > lim) continue;
F::add(n * m + id(x, y), 2 * n * m + k + i, 1);
}
}
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
if (dis[id(G[i].x, G[i].y)][id(x, y)] > 1e9) continue;
long long d = 1ll * dis[id(G[i].x, G[i].y)][id(x, y)] * G[i].z;
if (d > lim) continue;
F::add(2 * n * m + i, id(x, y), 1);
}
}
}
F::Dinic();
return F::ans == k;
}
int main() {
int b, g;
scanf("%d%d%d%d", &n, &m, &b, &g);
if (std::abs(b - g) != 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%s", str[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) bfs(std::make_pair(i, j), dis[id(i, j)]);
int _, __, ___;
scanf("%d%d%d", &_, &__, &___);
for (int i = 1; i <= b; ++i) scanf("%d%d%d", &B[i].x, &B[i].y, &B[i].z);
for (int i = 1; i <= g; ++i) scanf("%d%d%d", &G[i].x, &G[i].y, &G[i].z);
k = std::max(b, g);
if (b < g)
B[k] = Node(_, __, ___);
else
G[k] = Node(_, __, ___);
long long l = 0, r = 1e18, ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (chk(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;
bool space[25][25], vis[25][25];
int dist[600][600];
int make_label(int x, int y) { return x * m + y; }
void bfs(int x, int y) {
memset(vis, 0, sizeof(vis));
queue<pair<pair<int, int>, int>> que;
que.push({{x, y}, 0});
vis[x][y] = 1;
int s = make_label(x, y);
while (!que.empty()) {
auto cur = que.front();
que.pop();
dist[s][make_label(cur.first.first, cur.first.second)] = cur.second;
for (auto &dir : directions) {
pair<int, int> next_step = {cur.first.first + dir.first,
cur.first.second + dir.second};
if (next_step.first >= 0 && next_step.first < n &&
next_step.second >= 0 && next_step.second < m &&
!vis[next_step.first][next_step.second] &&
space[next_step.first][next_step.second]) {
que.push({next_step, cur.second + 1});
vis[next_step.first][next_step.second] = 1;
}
}
}
}
struct edge {
int u, v, w;
edge() {}
edge(int u, int v, int w) {
this->u = u;
this->v = v;
this->w = w;
}
};
struct edmonds_karp {
int n, m;
vector<edge> edge_set;
vector<vector<int>> graph;
edmonds_karp() {}
edmonds_karp(int n) {
this->n = n;
this->m = 0;
graph.resize(n);
}
void add_directed_edge(int u, int v, int w) {
edge_set.push_back({u, v, w});
graph[u].push_back(m);
m++;
edge_set.push_back({v, u, 0});
graph[v].push_back(m);
m++;
}
bool bfs() {
vector<bool> vis(n);
queue<pair<int, int>> que;
vector<pair<int, int>> path;
que.push({0, -1});
vis[0] = 1;
while (!que.empty()) {
auto cur = que.front();
que.pop();
if (cur.first == n - 1) {
int min_value = edge_set[path[cur.second].first].w;
for (int i = cur.second; i != -1; i = path[i].second) {
min_value = min(min_value, edge_set[path[i].first].w);
}
for (int i = cur.second; i != -1; i = path[i].second) {
edge_set[path[i].first].w -= min_value;
edge_set[path[i].first ^ 1].w += min_value;
}
return 1;
}
for (int e : graph[cur.first]) {
if (edge_set[e].w > 0 && !vis[edge_set[e].v]) {
vis[edge_set[e].v] = 1;
path.push_back({e, cur.second});
que.push({edge_set[e].v, path.size() - 1});
}
}
}
return 0;
}
int max_flow() {
while (bfs())
;
int flow = 0;
for (int e : graph[0]) {
flow += edge_set[e ^ 1].w;
}
return flow;
}
};
int main() {
int male, female;
cin >> n >> m >> male >> female;
string s;
vector<pair<int, int>> valid_point;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
space[i][j] = s[j] == '.';
if (space[i][j]) {
valid_point.push_back({i, j});
}
}
}
memset(dist, 0x3f, sizeof(dist));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (space[i][j]) {
bfs(i, j);
}
}
}
vector<pair<pair<int, int>, int>> males, females;
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
if (male == female + 1) {
females.push_back({{x, y}, t});
} else if (male == female - 1) {
males.push_back({{x, y}, t});
} else {
cout << "-1" << endl;
exit(0);
}
for (int i = 0; i < male; i++) {
cin >> x >> y >> t;
x--;
y--;
males.push_back({{x, y}, t});
}
for (int i = 0; i < female; i++) {
cin >> x >> y >> t;
x--;
y--;
females.push_back({{x, y}, t});
}
male = females.size();
female = females.size();
long long lower = 0, upper = 1e11;
while (lower < upper) {
long long mid = (lower + upper) / 2;
int label1 = male + 1, label2 = label1 + valid_point.size(),
label3 = label2 + valid_point.size(), label4 = label3 + female;
edmonds_karp solver(label4 + 1);
for (int i = 1; i <= male; i++) {
solver.add_directed_edge(0, i, 1);
}
for (int i = 1; i <= male; i++) {
for (int j = label1; j < label2; j++) {
if (dist[make_label(males[i - 1].first.first,
males[i - 1].first.second)]
[make_label(valid_point[j - label1].first,
valid_point[j - label1].second)] < 100 &&
1ll *
dist[make_label(males[i - 1].first.first,
males[i - 1].first.second)]
[make_label(valid_point[j - label1].first,
valid_point[j - label1].second)] *
males[i - 1].second <=
mid) {
solver.add_directed_edge(i, j, 1);
}
}
}
for (int i = label1; i < label2; i++) {
solver.add_directed_edge(i, i + valid_point.size(), 1);
}
for (int i = label2; i < label3; i++) {
for (int j = label3; j < label4; j++) {
if (dist[make_label(valid_point[i - label2].first,
valid_point[i - label2].second)]
[make_label(females[j - label3].first.first,
females[j - label3].first.second)] < 100 &&
1ll *
dist[make_label(valid_point[i - label2].first,
valid_point[i - label2].second)]
[make_label(females[j - label3].first.first,
females[j - label3].first.second)] *
females[j - label3].second <=
mid) {
solver.add_directed_edge(i, j, 1);
}
}
}
for (int i = label3; i < label4; i++) {
solver.add_directed_edge(i, label4, 1);
}
if (solver.max_flow() == male) {
upper = mid;
} else {
lower = mid + 1;
}
}
cout << (lower == 1e11 ? -1 : lower) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int INF = 1000000000;
const int inf = INF;
struct Edge {
int from, to, cap, flow, index;
Edge(int from, int to, int cap, int flow, int index)
: from(from), to(to), cap(cap), flow(flow), index(index) {}
};
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, int 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(), (Edge *)NULL);
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];
int amt = INF;
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;
}
};
struct node {
int r, c, t;
node() {}
node(int r, int c, int t) : r(r), c(c), t(t) {}
};
vector<node> qm, qf;
node read() {
int r, c, t;
cin >> r >> c >> t;
r--;
c--;
return node(r, c, t);
}
const int MAXN = 25;
const int MAXT = 600;
char mat[MAXN][MAXN];
int n, m, male, female;
int id[MAXN][MAXN];
int dis[MAXT][MAXT];
int main() {
cin >> n >> m >> male >> female;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
if (male < female)
qm.push_back(read());
else
qf.push_back(read());
for (int i = 0; i < male; i++) qm.push_back(read());
for (int i = 0; i < female; i++) qf.push_back(read());
if (male < female)
male++;
else
female++;
if (male != female) {
cout << -1 << endl;
return 0;
}
int tot = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mat[i][j] == '.') id[i][j] = tot++;
for (int i = 0; i < tot; i++)
for (int j = 0; j < tot; j++) dis[i][j] = (i == j) ? 0 : inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mat[i][j] == '.')
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < m; jj++)
if (mat[ii][jj] == '.' && abs(i - ii) + abs(j - jj) == 1)
dis[id[i][j]][id[ii][jj]] = 1;
for (int k = 0; k < tot; k++)
for (int i = 0; i < tot; i++)
for (int j = 0; j < tot; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
long long lo = 0, hi = 1LL << 60, ans = -1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
Dinic res(male + female + 2 * tot + 2);
for (int i = 0; i < (int)qm.size(); i++) {
int index = id[qm[i].r][qm[i].c];
for (int j = 0; j < tot; j++)
if (dis[index][j] != inf && (long long)dis[index][j] * qm[i].t <= mid)
res.AddEdge(i, male + j, 1);
}
for (int j = 0; j < tot; j++) res.AddEdge(male + j, male + tot + j, 1);
for (int j = 0; j < tot; j++)
for (int k = 0; k < (int)qf.size(); k++) {
int index = id[qf[k].r][qf[k].c];
if (dis[index][j] != inf && (long long)dis[index][j] * qf[k].t <= mid)
res.AddEdge(male + tot + j, male + tot + tot + k, 1);
}
int source = male + tot + tot + female;
int sink = source + 1;
for (int i = 0; i < male; i++) res.AddEdge(source, i, 1);
for (int i = 0; i < female; i++) res.AddEdge(male + tot + tot + i, sink, 1);
if (res.GetMaxFlow(source, sink) == male)
ans = mid, hi = mid - 1;
else
lo = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
ll gcd(ll x, ll y) {
while (y ^= x ^= y ^= x %= y)
;
return x;
}
using namespace std;
const int maxn = 2e3 + 9, dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
struct {
int nex, t, cap;
} g[maxn * 800] = {};
int head[maxn], sz, iter[maxn], dis[maxn];
void addedge(int f, int t, int cap) {
g[sz] = {head[f], t, cap};
head[f] = sz++;
g[sz] = {head[t], f, 0};
head[t] = sz++;
}
int Q[maxn];
int bfs(int s, int t) {
int l = 0, r = 0;
Q[r++] = s;
memset(dis, 0, sizeof dis);
dis[s] = 1;
iter[s] = head[s];
while (l < r)
for (int u = Q[l++], i = head[u]; ~i; i = g[i].nex) {
int v = g[i].t;
if (g[i].cap && !dis[v]) {
dis[v] = dis[u] + 1;
iter[v] = head[v];
if (t == v) return 1;
Q[r++] = v;
}
}
return 0;
}
int dfs(int s, int t, int cap, int flow = 0) {
if (s == t) return cap;
for (int &i = iter[s]; ~i; i = g[i].nex) {
auto &e = g[i];
if (e.cap && dis[e.t] == dis[s] + 1) {
int di = dfs(e.t, t, min(e.cap, cap - flow));
if (di)
flow += di, e.cap -= di, g[i ^ 1].cap += di;
else
dis[e.t] = -9;
if (flow == cap) break;
}
}
return flow;
}
int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t)) ans += dfs(s, t, 99999);
return ans;
}
int n, m, ma, fe, vtx;
char mp[25][25] = {};
struct pii {
ll x, y;
} peo[2][500];
ll ti[2][500] = {};
vector<pii> dis2[2][500];
void bfs2(int ty, int in) {
int dis[25][25] = {};
memset(dis, -1, sizeof dis);
int nx = peo[ty][in].x - 1, ny = peo[ty][in].y - 1, x, y;
auto &dis3 = dis2[ty][in];
queue<int> Q;
Q.push(nx * m + ny);
dis[nx][ny] = 0;
dis3.push_back({nx * m + ny, 0});
while (Q.size()) {
nx = Q.front() / m, ny = Q.front() % m;
Q.pop();
for (int i = 0; i < 4; i++) {
x = nx + dx[i], y = ny + dy[i];
if (x < 0 || y < 0 || x >= n || y >= m || mp[x][y] != '.' || ~dis[x][y])
continue;
dis[x][y] = dis[nx][ny] + 1;
dis3.push_back({x * m + y, dis[x][y] * ti[ty][in]});
Q.push(x * m + y);
}
}
}
int s = 2001, t = 2002, mal = 0, gd1 = 500, gd2 = 1000, fem = 1500;
int judge(ll ans) {
memset(head, -1, sizeof head), sz = 0;
int flows = 0;
for (int i = 0; i < vtx; i++) addedge(s, mal + i, 1);
for (int i = 0; i < vtx; i++) addedge(fem + i, t, 1);
for (int i = 0; i < n * m; i++) addedge(gd1 + i, gd2 + i, 1);
for (int i = 0; i < vtx; i++)
for (auto &j : dis2[0][i]) {
if (j.y <= ans) addedge(mal + i, gd1 + j.x, 1);
}
for (int i = 0; i < vtx; i++)
for (auto &j : dis2[1][i]) {
if (j.y <= ans) addedge(gd2 + j.x, fem + i, 1);
}
return dinic(s, t) >= vtx;
}
int main() {
scanf("%d%d%d%d", &n, &m, &ma, &fe);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
int ox, oy, ot;
scanf("%d%d%d", &ox, &oy, &ot);
for (int i = 0; i < ma; i++)
scanf("%d%d%d", &peo[0][i].x, &peo[0][i].y, &ti[0][i]);
for (int i = 0; i < fe; i++)
scanf("%d%d%d", &peo[1][i].x, &peo[1][i].y, &ti[1][i]);
if (ma > fe)
peo[1][fe] = {ox, oy}, ti[1][fe++] = ot;
else
peo[0][ma] = {ox, oy}, ti[0][ma++] = ot;
if (ma != fe) return puts("-1"), 0;
vtx = ma;
for (int i = 0; i < vtx; i++) bfs2(0, i);
for (int i = 0; i < vtx; i++) bfs2(1, i);
ll lb = -1, ub = 1e13, mid;
while (ub > lb + 1) {
mid = lb + ub >> 1;
if (judge(mid))
ub = mid;
else
lb = mid;
}
if (ub == (ll)1e13)
puts("-1");
else
printf("%lld\n", ub);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
char grid[25][25];
vector<pair<int, int> > males;
vector<pair<int, int> > females;
long long dist[500][500];
const int INF = 1e9;
const long long INFLL = 1e18;
char& get(int i) { return grid[i / m][i % m]; }
void floyd() {
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) dist[i][j] = INFLL;
for (int i = 0; i < n * m; i++) {
if (get(i) == '#') continue;
dist[i][i] = 0;
if (i / m && get(i - m) == '.') dist[i][i - m] = dist[i - m][i] = 1;
if (i % m && get(i - 1) == '.') dist[i][i - 1] = dist[i - 1][i] = 1;
}
for (int k = 0; k < n * m; k++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
vector<int> adj[2013];
int res[2013][2013];
const int source = 2011, sink = 2012;
const int male = 0, female = 500, grid1 = 1000, grid2 = 1500;
void conn(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
res[a][b] = 1;
}
void make(long long K) {
for (int i = 0; i < 2013; i++) {
adj[i].clear();
for (int j = 0; j < 2013; j++) res[i][j] = 0;
}
for (int i = 0; i < tot; i++) conn(source, male + i);
for (int i = 0; i < tot; i++) conn(female + i, sink);
for (int i = 0; i < tot; i++)
for (int j = 0; j < n * m; j++)
if (dist[males[i].first][j] <= K / males[i].second)
conn(male + i, grid1 + j);
for (int i = 0; i < tot; i++)
for (int j = 0; j < n * m; j++)
if (dist[females[i].first][j] <= K / females[i].second)
conn(grid2 + j, female + i);
for (int i = 0; i < n * m; i++) conn(grid1 + i, grid2 + i);
}
int h[2013];
queue<int> frontier;
int on[2013];
bool level() {
for (int i = 0; i < 2013; i++) h[i] = INF;
h[source] = 0;
frontier.push(source);
while (frontier.size() > 0) {
int x = frontier.front();
frontier.pop();
for (int i : adj[x])
if (res[x][i] && h[i] == INF) {
h[i] = h[x] + 1;
frontier.push(i);
}
}
return (h[sink] != INF);
}
int dfs(int x, int c = INF) {
if (x == sink) return c;
int flow = 0;
while (on[x] < adj[x].size()) {
int i = adj[x][on[x]];
if (h[i] == h[x] + 1 && res[x][i]) {
int go = dfs(i, min(c - flow, res[x][i]));
res[x][i] -= go;
res[i][x] += go;
flow += go;
if (flow == c) break;
}
on[x] += 1;
}
return flow;
}
int maxflow() {
int flow = 0;
while (true) {
if (!level()) break;
for (int i = 0; i < 2013; i++) on[i] = 0;
flow += dfs(source);
}
return flow;
}
bool check(long long K) {
make(K);
return (maxflow() == tot);
}
void read(int num, vector<pair<int, int> >& dest) {
for (int i = 0; i < num; i++) {
int r, c, t;
scanf("%d%d%d", &r, &c, &t);
dest.push_back(make_pair((r - 1) * m + c - 1, t));
}
}
int main() {
int a, b;
scanf("%d%d%d%d", &n, &m, &a, &b);
if (abs(a - b) != 1) return printf("-1\n"), 0;
for (int i = 0; i < n; i++) scanf(" %s", &grid[i]);
int r, c, t;
scanf("%d%d%d", &r, &c, &t);
if (a < b)
males.push_back(make_pair((r - 1) * m + c - 1, t));
else
females.push_back(make_pair((r - 1) * m + c - 1, t));
read(a, males);
read(b, females);
tot = max(a, b);
floyd();
long long low = -1;
long long high = INFLL;
while (high - low > 1) {
if (check((low + high + 1) / 2))
high = (low + high + 1) / 2;
else
low = (low + high + 1) / 2;
}
printf("%lld\n", (high == INFLL) ? -1 : high);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int id;
int x, y;
long long int w;
edge(int id, int x, int y, long long int w) : id(id), x(x), y(y), w(w) {}
};
struct edge2 {
int viz;
int cap;
int dual;
edge2(int viz, int cap, int dual) : viz(viz), cap(cap), dual(dual) {}
};
int dx[] = {0, -1, 0, 1};
int dy[] = {1, 0, -1, 0};
long long int d[25][25];
char grid[25][25];
vector<edge> v;
vector<edge2> g[2005];
int n, m;
int flow;
int s, t;
int male_id;
int fem_id;
int p[2005];
int p_edge[2005];
int d2[2005];
bool comp(const struct edge &a, const struct edge &b) { return a.w < b.w; }
void inline BFS(int sx, int sy, int id, int cost) {
int x, y;
int nx, ny;
queue<pair<int, int> > fila;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
d[i][j] = 10000000000000000LL;
}
}
d[sx][sy] = 0;
fila.push(make_pair(sx, sy));
while (!fila.empty()) {
x = fila.front().first;
y = fila.front().second;
fila.pop();
for (int i = 0; i < 4; i++) {
nx = x + dx[i];
ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (grid[nx][ny] != '#' && d[nx][ny] > d[x][y] + cost) {
d[nx][ny] = d[x][y] + cost;
fila.push(make_pair(nx, ny));
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (d[i][j] != 10000000000000000LL) {
v.push_back(edge(id, i, j, d[i][j]));
}
}
}
return;
}
int inline BFS2(int s, int t) {
int next;
int viz;
int cap;
queue<int> fila;
memset(d2, 0x3f3f3f3f, sizeof(d2));
d2[s] = 0;
fila.push(s);
while (!fila.empty()) {
next = fila.front();
fila.pop();
for (int i = 0; i < (int)g[next].size(); i++) {
viz = g[next][i].viz;
cap = g[next][i].cap;
if (cap && d2[viz] > d2[next] + 1) {
d2[viz] = d2[next] + 1;
p[viz] = next;
p_edge[viz] = i;
fila.push(viz);
}
}
}
return d2[t] != 0x3f3f3f3f;
}
void inline add_edge(int x, int y, int cap) {
g[x].push_back(edge2(y, cap, (int)g[y].size()));
g[y].push_back(edge2(x, 0, (int)g[x].size() - 1));
return;
}
void max_flow(int s, int t) {
int augment;
int dual;
int cap;
int idx;
while (BFS2(s, t)) {
augment = 0x3f3f3f3f;
for (int v = t; v != s; v = p[v]) {
idx = p_edge[v];
cap = g[p[v]][idx].cap;
augment = min(augment, g[p[v]][idx].cap);
}
for (int v = t; v != s; v = p[v]) {
idx = p_edge[v];
dual = g[p[v]][idx].dual;
g[p[v]][idx].cap -= augment;
g[v][dual].cap += augment;
}
flow += augment;
}
return;
}
void build_graph(void) {
int idx, idx2;
for (int i = 2 * 22 * 22 + 1; i < male_id; i++) {
add_edge(s, i, 1);
}
for (int i = male_id; i < fem_id; i++) {
add_edge(i, t, 1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] != '#') {
idx = 22 * i + j;
idx2 = 22 * 22 + idx;
add_edge(idx, idx2, 1);
}
}
}
return;
}
int main(void) {
int male, fem;
int x, y, z;
int idx;
long long int best;
int ok = 0;
int next_group;
int size;
scanf(" %d %d %d %d", &n, &m, &male, &fem);
for (int i = 0; i < n; i++) {
scanf(" %s", grid[i]);
}
if (male == fem || abs(male - fem) > 1) {
printf("-1\n");
} else {
scanf(" %d %d %d", &x, &y, &z);
x--;
y--;
male_id = 2 * 22 * 22 + 1;
fem_id = 2 * 22 * 22 + 1 + male;
if (male < fem) {
fem_id++;
BFS(x, y, male_id++, z);
} else {
BFS(x, y, fem_id++, z);
}
for (int i = 0; i < male; i++) {
scanf(" %d %d %d", &x, &y, &z);
x--;
y--;
BFS(x, y, male_id++, z);
}
for (int i = 0; i < fem; i++) {
scanf(" %d %d %d", &x, &y, &z);
x--;
y--;
BFS(x, y, fem_id++, z);
}
if (fem < male) {
fem++;
}
sort(v.begin(), v.end(), comp);
size = (int)sqrt((int)v.size());
s = fem_id;
t = fem_id + 1;
build_graph();
best = -1;
flow = 0;
next_group = 0;
for (int i = 0; (i + 1) * size < (int)v.size(); i++) {
next_group = i + 1;
for (int j = i * size; j < (i + 1) * size; j++) {
idx = 22 * v[j].x + v[j].y;
if (v[j].id < male_id) {
add_edge(v[j].id, idx, 1);
} else {
idx = 22 * 22 + idx;
add_edge(idx, v[j].id, 1);
}
}
max_flow(s, t);
if (flow == fem) {
ok = 1;
break;
}
}
if (!ok) {
for (int i = next_group * size; i < (int)v.size(); i++) {
idx = 22 * v[i].x + v[i].y;
if (v[i].id < male_id) {
add_edge(v[i].id, idx, 1);
} else {
idx = 22 * 22 + idx;
add_edge(idx, v[i].id, 1);
}
max_flow(s, t);
if (flow == fem) {
best = v[i].w;
break;
}
}
} else {
flow = 0;
for (int i = 0; i <= t; i++) {
g[i].clear();
}
build_graph();
for (int i = 0; i < (next_group - 1) * size; i++) {
idx = 22 * v[i].x + v[i].y;
if (v[i].id < male_id) {
add_edge(v[i].id, idx, 1);
} else {
idx = 22 * 22 + idx;
add_edge(idx, v[i].id, 1);
}
}
for (int i = (next_group - 1) * size; i < (int)v.size(); i++) {
idx = 22 * v[i].x + v[i].y;
if (v[i].id < male_id) {
add_edge(v[i].id, idx, 1);
} else {
idx = 22 * 22 + idx;
add_edge(idx, v[i].id, 1);
}
max_flow(s, t);
if (flow == fem) {
best = v[i].w;
break;
}
}
}
printf("%lld\n", best);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
constexpr int N = 25;
int xx[] = {0, 0, 1, -1};
int yy[] = {1, -1, 0, 0};
vector<int> v[N][N];
template <class FlowT>
class MaxFlow {
public:
static const int maxn = 550, maxm = 7e4;
static const FlowT FlowEPS = FlowT(1e-8), FlowINF = FlowT(1 << 29);
int to[maxm * 2], prv[maxm * 2], hed[maxn], dis[maxn], pos[maxn];
FlowT cap[maxm * 2];
int n, m;
inline void init(int N) {
n = N, m = 0;
memset(hed, -1, n * sizeof hed[0]);
}
private:
inline void add_single_edge(int v, int u, FlowT c) {
to[m] = u, prv[m] = hed[v], cap[m] = c, hed[v] = m++;
}
public:
inline void add_edge(int v, int u, FlowT c) {
add_single_edge(v, u, c);
add_single_edge(u, v, 0);
}
inline bool bfs(int source, int sink) {
static int qu[maxn], head, tail;
head = tail = 0;
memset(dis, -1, n * sizeof dis[0]);
dis[source] = 0;
qu[tail++] = source;
while (head < tail) {
int v = qu[head++];
for (int e = hed[v]; e + 1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == -1)
dis[to[e]] = dis[v] + 1, qu[tail++] = to[e];
if (dis[sink] + 1) break;
}
return dis[sink] + 1;
}
inline FlowT dfs(int v, int sink, FlowT cur = FlowINF) {
if (v == sink) return cur;
FlowT ans = 0;
for (int &e = pos[v]; e + 1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == dis[v] + 1) {
FlowT tmp = dfs(to[e], sink, min(cur, cap[e]));
cur -= tmp;
ans += tmp;
cap[e] -= tmp;
cap[e ^ 1] += tmp;
if (cur <= FlowEPS / 2) break;
}
return ans;
}
inline FlowT flow(int source, int sink) {
FlowT ans = 0;
while (bfs(source, sink)) {
memcpy(pos, hed, n * sizeof hed[0]);
ans += dfs(source, sink);
}
return ans;
}
};
MaxFlow<int> fl;
int vs[N][N], dis[N][N];
bool a[N][N];
int r[2][N * N], c[2][N * N], n, num[N][N], vis[N * N * N];
long long t[2][N * N];
void bfs_edge(int one, bool b, long long mx) {
pair<int, int> qu[N * N] = {};
memset(vs, 0, sizeof vs);
memset(dis, 0, sizeof dis);
int head = 0, tail = 1;
qu[0] = {r[b][one], c[b][one]}, vs[r[b][one]][c[b][one]] = 1;
one = b * n + one;
while (tail > head) {
pair<int, int> x = qu[head++];
if (!b)
fl.add_edge(one, num[x.first][x.second], 1);
else
fl.add_edge(num[x.first][x.second] + 1, one, 1);
for (int i = 0; i < 4; i++) {
int ox = xx[i] + x.first, oy = yy[i] + x.second;
if (!vs[ox][oy] && !a[ox][oy] && dis[x.first][x.second] < mx) {
vs[ox][oy] = 1;
dis[ox][oy] = dis[x.first][x.second] + 1;
qu[tail++] = {ox, oy};
}
}
}
}
int32_t main() {
int X = in(), Y = in(), first = in(), M = in();
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
char c;
cin >> c;
a[i][j] = (c == '#');
}
for (int i = 0; i < N; i++) a[0][i] = a[i][0] = a[X + 1][i] = a[i][Y + 1] = 1;
n = max(first, M);
int cnt = 2 * n + 1;
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
num[i][j] = cnt;
cnt += 2;
}
if (first == M - 1)
r[0][M - 1] = in(), c[0][M - 1] = in(), t[0][M - 1] = in();
else if (M == first - 1)
r[1][first - 1] = in(), c[1][first - 1] = in(), t[1][first - 1] = in();
else
return cout << "-1\n", 0;
for (int i = 0; i < first; i++)
r[0][i] = in(), c[0][i] = in(), t[0][i] = in();
for (int i = 0; i < M; i++) r[1][i] = in(), c[1][i] = in(), t[1][i] = in();
bfs_edge(0, 0, 2);
long long s = -1, e = 1e15;
while (e - s > 1) {
fl.init(cnt + 5);
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
fl.add_edge(num[i][j], num[i][j] + 1, 1);
}
long long mid = (s + e) / 2;
for (int i = 0; i < n; i++) {
bfs_edge(i, 0, mid / t[0][i]);
}
for (int i = 0; i < n; i++) {
bfs_edge(i, 1, mid / t[1][i]);
}
int sou = cnt + 1, sin = cnt + 2;
for (int i = 0; i < n; i++) fl.add_edge(sou, i, 1);
for (int i = 0; i < n; i++) fl.add_edge(i + n, sin, 1);
int ans = fl.flow(sou, sin);
if (ans == n)
e = mid;
else
s = mid;
}
if (e == 1e15) return cout << "-1\n", 0;
cout << e << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
string R[30];
struct EdmondsKarp {
struct Edge {
int dest;
long long int cap;
long long int flow;
int back;
};
EdmondsKarp(int n) : G(n) {}
void addEdge(int src, int dest, long long int cap) {
if (src == dest) return;
Edge e1 = {dest, cap, 0, (int)G[dest].size()};
Edge e2 = {src, 0, 0, (int)G[src].size()};
G[src].push_back(e1);
G[dest].push_back(e2);
}
long long int maxFlow(int s, int t) {
long long int ret = 0;
vector<pair<int, int> > parent;
while (true) {
parent.clear();
parent.resize(G.size(), pair<int, int>(-1, -1));
queue<int> Q;
Q.push(s);
parent[s] = pair<int, int>(s, -1);
while (!Q.empty()) {
int v = Q.front();
Q.pop();
if (v == t) break;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i].flow == G[v][i].cap) continue;
int x = G[v][i].dest;
if (parent[x].first != -1) continue;
parent[x] = pair<int, int>(v, i);
Q.push(x);
}
}
if (parent[t].first == -1) break;
long long int a = -1;
int v = t;
while (v != s) {
pair<int, int> p = parent[v];
long long int rem =
G[p.first][p.second].cap - G[p.first][p.second].flow;
if (a < 0 || rem < a) a = rem;
v = p.first;
}
ret += a;
v = t;
while (v != s) {
pair<int, int> p = parent[v];
G[p.first][p.second].flow += a;
G[v][G[p.first][p.second].back].flow -= a;
v = p.first;
}
}
return ret;
}
vector<vector<Edge> > G;
};
long long int d[32][32][32][32];
struct S {
void read() {
cin >> i >> j >> t;
--i;
--j;
}
long long int i;
long long int j;
long long int t;
};
int main() {
cin.sync_with_stdio(false);
cin >> n >> m;
long long int M, F;
cin >> M >> F;
for (long long int i = 0; i < n; ++i) {
cin >> R[i];
}
for (long long int a = 0; a < n; ++a) {
for (long long int b = 0; b < m; ++b) {
for (long long int a2 = 0; a2 < n; ++a2) {
for (long long int b2 = 0; b2 < m; ++b2) {
d[a][b][a2][b2] = LLONG_MAX / 10;
}
}
}
}
for (long long int a = 0; a < n; ++a) {
for (long long int b = 0; b < m; ++b) {
d[a][b][a][b] = 0;
if (R[a][b] == '#') continue;
auto edge = [a, b](long long int a2, long long int b2) {
if (a2 < 0 || a2 >= n) return;
if (b2 < 0 || b2 >= m) return;
if (R[a2][b2] == '#') return;
d[a][b][a2][b2] = 1;
};
edge(a - 1, b);
edge(a + 1, b);
edge(a, b - 1);
edge(a, b + 1);
}
}
for (long long int ak = 0; ak < n; ++ak) {
for (long long int bk = 0; bk < m; ++bk) {
for (long long int ai = 0; ai < n; ++ai) {
for (long long int bi = 0; bi < m; ++bi) {
for (long long int aj = 0; aj < n; ++aj) {
for (long long int bj = 0; bj < m; ++bj) {
d[ai][bi][aj][bj] =
min(d[ai][bi][aj][bj], d[ai][bi][ak][bk] + d[ak][bk][aj][bj]);
}
}
}
}
}
}
S boss;
vector<S> males(M);
vector<S> females(F);
boss.read();
for (S& s : males) s.read();
for (S& s : females) s.read();
long long int mn = m * n;
long long int a = 0;
long long int b = LLONG_MAX / 100000;
while (a != b) {
long long int mid = (a + b) / 2;
bool ok = false;
for (int q = 0; q < 2; ++q) {
if (q == 0) {
++M;
males.push_back(boss);
} else {
++F;
females.push_back(boss);
}
if (F == M) {
long long int indM = 0;
long long int indF = indM + M;
long long int indR1 = indF + F;
long long int indR2 = indR1 + mn;
long long int indA = indR2 + mn;
long long int indB = indA + 1;
EdmondsKarp krp(indB + 1);
for (long long int i = 0; i < M; ++i) {
krp.addEdge(indA, indM + i, 1);
}
for (long long int i = 0; i < F; ++i) {
krp.addEdge(indF + i, indB, 1);
}
for (long long int i = 0; i < mn; ++i) {
krp.addEdge(indR1 + i, indR2 + i, 1);
}
int si = 0;
for (S s : males) {
for (long long int i = 0; i < n; ++i) {
for (long long int j = 0; j < m; ++j) {
if (d[i][j][s.i][s.j] != LLONG_MAX / 10 &&
d[i][j][s.i][s.j] * s.t <= mid) {
krp.addEdge(indM + si, indR1 + m * i + j, 1);
}
}
}
++si;
}
si = 0;
for (S s : females) {
for (long long int i = 0; i < n; ++i) {
for (long long int j = 0; j < m; ++j) {
if (d[i][j][s.i][s.j] != LLONG_MAX / 10 &&
d[i][j][s.i][s.j] * s.t <= mid) {
krp.addEdge(indR2 + m * i + j, indF + si, 1);
}
}
}
++si;
}
long long int flow = krp.maxFlow(indA, indB);
if (flow == M && M == F) {
ok = true;
}
}
if (q == 0) {
--M;
males.pop_back();
} else {
--F;
females.pop_back();
}
}
if (ok) {
b = mid;
} else {
a = mid + 1;
}
}
if (a >= LLONG_MAX / 100000) a = -1;
cout << a << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int N, int Ne>
struct flow {
using F = int;
F inf = 1e9;
int n, s, t;
int ehd[N], cur[N], ev[Ne << 1], enx[Ne << 1], eid = 1;
void clear() { eid = 1, memset(ehd, 0, sizeof(ehd)); }
F ew[Ne << 1], dis[N];
void Eadd(int u, int v, F w) {
++eid, enx[eid] = ehd[u], ew[eid] = w, ev[eid] = v, ehd[u] = eid;
}
void add(int u, int v, F w) { Eadd(u, v, w), Eadd(v, u, 0); }
bool bfs() {
queue<int> q;
for (int i = (1); i <= (n); i++) dis[i] = inf, cur[i] = ehd[i];
q.push(s), dis[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = ehd[u]; i; i = enx[i])
if (ew[i] && dis[ev[i]] == inf) {
dis[ev[i]] = dis[u] + 1, q.push(ev[i]);
}
}
return dis[t] < inf;
}
F dfs(int x, F now) {
if (!now || x == t) return now;
F res = 0, f;
for (int i = cur[x]; i; i = enx[i]) {
cur[x] = i;
if (ew[i] && dis[ev[i]] == dis[x] + 1) {
f = dfs(ev[i], min(now, ew[i])), ew[i] -= f, now -= f, ew[i ^ 1] += f,
res += f;
if (!now) break;
}
}
return res;
}
F max_flow() {
F res = 0;
while (bfs()) res += dfs(s, inf);
return res;
}
};
const int N = 24, S = N * N;
int n, m, A, B;
int det[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
char s[N][N];
struct node {
int x, y, w;
int d[N][N];
void bfs() {
queue<pair<int, int> > q;
memset(d, 0x3f, sizeof(d));
q.push(make_pair(x, y)), d[x][y] = 0;
while (!q.empty()) {
int sx = q.front().first, sy = q.front().second;
q.pop();
for (int i = (0); i <= (3); i++) {
int px = sx + det[i][0], py = sy + det[i][1];
if (s[px][py] == '.' && d[px][py] > n * m)
d[px][py] = d[sx][sy] + 1, q.push(make_pair(px, py));
}
}
}
} pa[S], pb[S];
flow<S * 3, S * S * 5> a;
bool check(long long X) {
a.clear(), a.n = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 2,
a.s = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 1,
a.t = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 2;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
a.add(((0) * n * m + ((i)-1) * m + (j) + A + B),
((1) * n * m + ((i)-1) * m + (j) + A + B), 1);
for (int x = (1); x <= (A); x++) {
a.add(a.s, x, 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (pa[x].d[i][j] <= n * m && (long long)pa[x].d[i][j] * pa[x].w <= X)
a.add(x, ((0) * n * m + ((i)-1) * m + (j) + A + B), 1);
}
for (int x = (1); x <= (B); x++) {
a.add(x + A, a.t, 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (pb[x].d[i][j] <= n * m && (long long)pb[x].d[i][j] * pb[x].w <= X)
a.add(((1) * n * m + ((i)-1) * m + (j) + A + B), x + A, 1);
}
return a.max_flow() == A;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> A >> B;
for (int i = (1); i <= (n); i++) cin >> (s[i] + 1);
if (abs(A - B) != 1) return cout << "-1\n", 0;
if (A < B) {
++A;
for (int i = (1); i <= (A); i++) cin >> pa[i].x >> pa[i].y >> pa[i].w;
for (int i = (1); i <= (B); i++) cin >> pb[i].x >> pb[i].y >> pb[i].w;
} else {
++B;
cin >> pb[B].x >> pb[B].y >> pb[B].w;
for (int i = (1); i <= (A); i++) cin >> pa[i].x >> pa[i].y >> pa[i].w;
for (int i = (1); i <= (B - 1); i++) cin >> pb[i].x >> pb[i].y >> pb[i].w;
}
for (int i = (1); i <= (A); i++) pa[i].bfs();
for (int i = (1); i <= (B); i++) pb[i].bfs();
long long l = 0, r = 1e13, ns = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
ns = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ns << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
template <class T, class S>
struct maxflow {
int node, st, ed, *es, *emem, **edge, **rev, *level, *queue;
T **flow, eps;
void malloc(int N) {
int i;
es = (int *)std::malloc(N * sizeof(int));
emem = (int *)std::malloc(N * sizeof(int));
level = (int *)std::malloc(N * sizeof(int));
queue = (int *)std::malloc(N * sizeof(int));
edge = (int **)std::malloc(N * sizeof(int *));
rev = (int **)std::malloc(N * sizeof(int *));
flow = (T **)std::malloc(N * sizeof(T *));
for (i = 0; i < N; i++)
emem[i] = 0, edge[i] = rev[i] = NULL, flow[i] = NULL;
}
void *malloc(int N, void *mem) {
int i;
es = (int *)mem;
emem = es + N;
level = emem + N;
queue = level + N;
edge = (int **)(queue + N);
rev = edge + N;
flow = (T **)(rev + N);
for (i = 0; i < N; i++)
emem[i] = 0, edge[i] = rev[i] = NULL, flow[i] = NULL;
return (void *)(flow + N);
}
void levelize(void) {
int i, j, k, t, s = 0, e = 1;
for (i = 0; i < node; i++) level[i] = -1;
level[st] = 0;
queue[0] = st;
while (s != e) {
i = queue[s++];
t = level[i] + 1;
for (j = 0; j < es[i]; j++)
if (flow[i][j] > eps) {
k = edge[i][j];
if (level[k] != -1) continue;
level[k] = t;
queue[e++] = k;
if (k == ed) return;
}
}
}
S pushflow(int i, S lim) {
int j, k, l;
S s, t, r = 0;
if (i == ed) return lim;
for (j = 0; j < es[i]; j++)
if (flow[i][j] > eps) {
k = edge[i][j];
if (level[k] != level[i] + 1) continue;
s = min(lim, (S)flow[i][j]);
t = pushflow(k, s);
if (!t) continue;
r += t;
lim -= t;
l = rev[i][j];
flow[i][j] -= t;
flow[k][l] += t;
if (!lim) break;
}
if (lim) level[i] = -1;
return r;
}
S solve(int st_, int ed_) {
S r = 0;
st = st_;
ed = ed_;
for (;;) {
levelize();
if (level[ed] == -1) break;
r += pushflow(st, numeric_limits<S>::max());
}
return r;
}
void init(int N) {
int i;
node = N;
for (i = 0; i < N; i++) es[i] = 0;
eps = (T)1e-9;
}
void memoryExpand(int i, int sz) {
if (sz <= emem[i]) return;
sz = max(sz, max(3, emem[i] * 2));
emem[i] = sz;
edge[i] = (int *)realloc(edge[i], sz * sizeof(int));
rev[i] = (int *)realloc(rev[i], sz * sizeof(int));
flow[i] = (T *)realloc(flow[i], sz * sizeof(T));
}
void addEdge(int n1, int n2, T f1, T f2) {
int s1 = es[n1]++, s2 = es[n2]++;
if (s1 >= emem[n1]) memoryExpand(n1, es[n1]);
if (s2 >= emem[n2]) memoryExpand(n2, es[n2]);
edge[n1][s1] = n2;
edge[n2][s2] = n1;
flow[n1][s1] = f1;
flow[n2][s2] = f2;
rev[n1][s1] = s2;
rev[n2][s2] = s1;
}
void addEdgeAdv(int n1, int n2, T f1, T f2) {
int s1 = es[n1]++, s2 = es[n2]++;
edge[n1][s1] = n2;
edge[n2][s2] = n1;
flow[n1][s1] = f1;
flow[n2][s2] = f2;
rev[n1][s1] = s2;
rev[n2][s2] = s1;
}
void setGraph(int N, int M, int n1[], int n2[], int f1[], int f2[]) {
int i;
node = N;
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) es[n1[i]]++, es[n2[i]]++;
for (i = 0; i < N; i++) memoryExpand(i, es[i]);
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) addEdgeAdv(n1[i], n2[i], f1[i], f2[i]);
eps = (T)1e-9;
}
void *setGraph(int N, int M, int n1[], int n2[], T f1[], T f2[], void *mem) {
int i, j, k;
node = N;
for (i = 0; i < N; i++) es[i] = emem[i] = 0;
for (i = 0; i < M; i++) es[n1[i]]++, es[n2[i]]++;
edge[0] = (int *)mem;
for (i = 1; i < N; i++) edge[i] = edge[i - 1] + es[i - 1];
rev[0] = edge[N - 1] + es[N - 1];
for (i = 1; i < N; i++) rev[i] = rev[i - 1] + es[i - 1];
flow[0] = (T *)(rev[N - 1] + es[N - 1]);
for (i = 1; i < N; i++) flow[i] = flow[i - 1] + es[i - 1];
mem = (void *)(flow[N - 1] + es[N - 1]);
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) addEdgeAdv(n1[i], n2[i], f1[i], f2[i]);
eps = (T)1e-9;
return mem;
}
};
char memarr[17000000];
void *mem = memarr;
int X, Y, XY;
char mp[32][32];
int dist[544][544];
int M, F;
int mx[1000], my[1000], mt[1000], mxy[1000];
int fx[1000], fy[1000], ft[1000], fxy[1000];
template <class T>
void unique(T arr[], int &sz, int sorted = 0) {
int i, k = 0;
if (!sorted) sort(arr, arr + sz);
for (i = 0; i < sz; i++)
if (!k || arr[k - 1] != arr[i]) arr[k++] = arr[i];
sz = k;
}
long long val[11000000];
int sz;
int main() {
int i, j, k;
int bx, by, bt;
int node, st, ed;
long long A, B, C, CC;
maxflow<int, int> flow;
reader(&X, &Y, &M, &F);
XY = X * Y;
if (!(M + 1 == F || M == F + 1)) {
writerLn(-1);
return 0;
}
for (i = 0; i < X; i++) reader(mp[i]);
reader(&bx, &by, &bt);
for (i = 0; i < M; i++) reader(mx + i, my + i, mt + i);
for (i = 0; i < F; i++) reader(fx + i, fy + i, ft + i);
if (M < F)
mx[M] = bx, my[M] = by, mt[M] = bt, M++;
else
fx[F] = bx, fy[F] = by, ft[F] = bt, F++;
for (i = 0; i < XY; i++)
for (j = 0; j < XY; j++) dist[i][j] = 1000000000;
for (i = 0; i < XY; i++) dist[i][i] = 0;
for (i = 0; i < X; i++)
for (j = 0; j < Y; j++)
if (mp[i][j] == '.') {
if (i && mp[i - 1][j] == '.') {
dist[i * Y + j][(i - 1) * Y + j] = 1;
dist[(i - 1) * Y + j][i * Y + j] = 1;
}
if (j && mp[i][j - 1] == '.') {
dist[i * Y + j][i * Y + (j - 1)] = 1;
dist[i * Y + (j - 1)][i * Y + j] = 1;
}
}
for (k = 0; k < XY; k++)
for (i = 0; i < XY; i++)
for (j = i; j < XY; j++)
dist[j][i] = dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
node = M + F + XY + XY;
st = node++;
ed = node++;
flow.malloc(node);
for (i = 0; i < M; i++) mxy[i] = (mx[i] - 1) * Y + (my[i] - 1);
for (i = 0; i < F; i++) fxy[i] = (fx[i] - 1) * Y + (fy[i] - 1);
sz = 0;
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[mxy[i]][j];
if (k == 1000000000) continue;
val[sz++] = (long long)k * mt[i];
}
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[fxy[i]][j];
if (k == 1000000000) continue;
val[sz++] = (long long)k * ft[i];
}
val[sz++] = 100000000000000000LL;
unique(val, sz);
A = 0;
B = sz - 1;
while (A < B) {
C = (A + B) / 2;
CC = val[C];
flow.init(node);
for (i = 0; i < M; i++) flow.addEdge(st, i, 1, 0);
for (i = 0; i < M; i++) flow.addEdge(M + XY + XY + i, ed, 1, 0);
for (i = 0; i < XY; i++) flow.addEdge(M + i, M + XY + i, 1, 0);
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[mxy[i]][j];
if (k == 1000000000) continue;
if ((long long)k * mt[i] > CC) continue;
flow.addEdge(i, M + j, 1, 0);
}
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[fxy[i]][j];
if (k == 1000000000) continue;
if ((long long)k * ft[i] > CC) continue;
flow.addEdge(M + XY + j, M + XY + XY + i, 1, 0);
}
k = flow.solve(st, ed);
if (k == M)
B = C;
else
A = C + 1;
}
A = val[A];
if (A >= 100000000000000000LL) A = -1;
writerLn(A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
const int M = 2000000;
const long long INF = 1e12;
struct Edge {
int v, c, next;
Edge() {}
Edge(int v, int c, int next) : v(v), c(c), next(next) {}
} edge[M];
struct Point {
int x, y, dis;
Point() {}
Point(int x, int y, int dis) : x(x), y(y), dis(dis) {}
} way[N][N][N * N];
queue<pair<int, int> > q;
char ch[N][N];
int xx[2][N * N], yy[2][N * N], speed[2][N * N], p[M], edn;
int n, m, num[2], num_tot, dis[N][N], S, T, bh_in[N][N], bh_out[N][N],
bh[2][N * N], dist[M], val[N][N];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
void addedge(int u, int v, int c) {
edge[edn] = Edge(v, c, p[u]);
p[u] = edn++;
edge[edn] = Edge(u, 0, p[v]);
p[v] = edn++;
}
int bfs() {
static queue<int> q;
while (!q.empty()) q.pop();
for (int i = 1; i <= T; i++) dist[i] = -1;
dist[S] = 0;
q.push(S);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = p[cur]; i != -1; i = edge[i].next) {
int x = edge[i].v;
if (dist[x] == -1 && edge[i].c > 0) {
dist[x] = dist[cur] + 1;
q.push(x);
}
}
}
return dist[T] != -1;
}
int dfs(int a, int now) {
if (a == T) return (now);
int r = 0;
for (int i = p[a]; (~i) && r < now; i = edge[i].next) {
int x = edge[i].v;
if (edge[i].c > 0 && dist[x] == dist[a] + 1) {
int y = min(edge[i].c, now - r);
y = dfs(x, y);
r += y;
edge[i].c -= y;
edge[i ^ 1].c += y;
}
}
if (!r) dist[a] = -2;
return r;
}
bool check(long long mid) {
for (int i = 1; i <= T; i++) p[i] = -1;
edn = 0;
for (int i = 1; i <= num_tot; i++) {
addedge(S, bh[0][i], 1);
addedge(bh[1][i], T, 1);
}
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) addedge(bh_in[i][j], bh_out[i][j], 1);
for (int i = 1; i <= num_tot; i++) {
int x = xx[0][i];
int y = yy[0][i];
long long v = speed[0][i];
for (int j = 1; j <= val[x][y]; j++) {
if (v * way[x][y][j].dis > mid) break;
addedge(bh[0][i], bh_in[way[x][y][j].x][way[x][y][j].y], 1);
}
}
for (int i = 1; i <= num_tot; i++) {
int x = xx[1][i];
int y = yy[1][i];
long long v = speed[1][i];
for (int j = 1; j <= val[x][y]; j++) {
if (v * way[x][y][j].dis > mid) break;
addedge(bh_out[way[x][y][j].x][way[x][y][j].y], bh[1][i], 1);
}
}
int tot = 0, t;
while (bfs()) {
while (t = dfs(S, num_tot)) tot += t;
}
return tot == num_tot;
}
int main() {
cin >> n >> m >> num[0] >> num[1];
if (abs(num[0] - num[1]) != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < n; i++) scanf("%s", ch[i] + 1);
num_tot = max(num[0], num[1]);
if (num[0] < num[1]) {
num[0] = 1;
num[1] = 0;
scanf("%d%d%d", &xx[0][1], &yy[0][1], &speed[0][1]);
} else {
num[0] = 0;
num[1] = 1;
scanf("%d%d%d", &xx[1][1], &yy[1][1], &speed[1][1]);
}
for (int i = 0; i < 2; i++)
while (num[i] < num_tot) {
num[i]++;
scanf("%d%d%d", &xx[i][num[i]], &yy[i][num[i]], &speed[i][num[i]]);
}
for (int i = 1; i <= num_tot; i++) {
xx[0][i]--;
xx[1][i]--;
}
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '.') {
for (int ii = 0; ii < n; ii++)
for (int jj = 1; jj <= m; jj++) dis[ii][jj] = -1;
dis[i][j] = 0;
q.push(make_pair(i, j));
while (!q.empty()) {
int x = (q.front()).first;
int y = (q.front()).second;
q.pop();
int tmp = dis[x][y];
way[i][j][++val[i][j]] = Point(x, y, tmp);
for (int dir = 0; dir < 4; dir++) {
x += dx[dir];
y += dy[dir];
if (x >= 0 && x < n && y > 0 && y <= m && ch[x][y] == '.' &&
dis[x][y] == -1) {
dis[x][y] = tmp + 1;
q.push(make_pair(x, y));
}
x -= dx[dir];
y -= dy[dir];
}
}
}
long long ans = INF;
long long l = 0, r = INF;
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) {
bh_in[i][j] = i * m + j;
bh_out[i][j] = bh_in[i][j] + n * m;
}
for (int i = 1; i <= num_tot; i++) {
bh[0][i] = 2 * n * m + i;
bh[1][i] = 2 * n * m + num_tot + i;
}
S = 2 * n * m + 2 * num_tot + 1;
T = S + 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans == INF) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 22 + 2;
const long long MAXE = 5e5;
const long long MAX = 2000;
const long long INF = 1e18 + 1000;
long long n, m, x, y, ec;
char c[MAXN][MAXN];
int lvl[MAX];
int q[MAX * 5];
long long dis[MAX][MAX];
long long from[2 * MAXE], to[2 * MAXE], cap[2 * MAXE], prv[2 * MAXE];
long long head[MAX];
bool mark[MAX];
vector<pair<long long, long long>> vec, sec;
bool fit(long long a, long long b) {
return a >= 0 && a < n && b >= 0 && b < m;
}
long long hhash(long long a, long long b) { return a * m + b; }
void init() {
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
for (long long w = 0; w < n; w++)
for (long long o = 0; o < m; o++)
if (i != w || j != o) dis[hhash(i, j)][hhash(w, o)] = INF;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
if (c[i][j] == '#') continue;
long long h = hhash(i, j);
if (fit(i + 1, j) && c[i + 1][j] != '#') dis[h][hhash(i + 1, j)] = 1;
if (fit(i - 1, j) && c[i - 1][j] != '#') dis[h][hhash(i - 1, j)] = 1;
if (fit(i, j + 1) && c[i][j + 1] != '#') dis[h][hhash(i, j + 1)] = 1;
if (fit(i, j - 1) && c[i][j - 1] != '#') dis[h][hhash(i, j - 1)] = 1;
}
for (long long k = 0; k < n * m; k++)
for (long long i = 0; i < n * m; i++)
for (long long j = 0; j < n * m; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void put_edge(long long u, long long v, long long uv, long long vu = 0) {
from[ec] = u, to[ec] = v, cap[ec] = uv, prv[ec] = head[u];
head[u] = ec++;
from[ec] = v, to[ec] = u, cap[ec] = vu, prv[ec] = head[v];
head[v] = ec++;
}
void put(long long maxi) {
memset(head, -1, sizeof(head));
ec = 0;
long long source = x + y + 2 * n * m;
long long sink = source + 1;
for (long long i = 0; i < x; i++) put_edge(source, i, 1);
for (long long i = 0; i < x; i++) {
long long h = vec[i].first, v = vec[i].second;
for (long long j = 0; j < n; j++)
for (long long w = 0; w < m; w++) {
long long hh = hhash(j, w);
if (dis[h][hh] == INF) continue;
long long time = v * dis[h][hh];
if (time > maxi) continue;
put_edge(i, hh + x, 1);
}
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
long long hh = hhash(i, j);
hh += x;
put_edge(hh, hh + n * m, 1);
}
for (long long i = 0; i < y; i++) {
long long id = x + 2 * n * m + i;
long long h = sec[i].first, v = sec[i].second;
for (long long j = 0; j < n; j++)
for (long long w = 0; w < m; w++) {
long long hh = hhash(j, w);
if (dis[h][hh] == INF) continue;
long long temp = v * dis[h][hh];
if (temp > maxi) continue;
put_edge(x + hh + n * m, id, 1);
}
}
for (long long i = 0; i < y; i++) {
long long id = x + 2 * n * m + i;
put_edge(id, sink, 1);
}
}
bool bfs(int v, int des) {
memset(lvl, -1, sizeof(lvl));
lvl[v] = 0;
int h = 0, t = 0;
q[t++] = v;
while (h < t) {
v = q[h++];
for (int e = head[v]; e != -1; e = prv[e]) {
int u = to[e];
if (cap[e] && lvl[u] == -1) {
lvl[u] = lvl[v] + 1;
q[t++] = u;
}
}
}
return lvl[des] != -1;
}
long long dfs(long long v, long long sink, long long mini = INF) {
if (sink == v) return mini;
if (mark[v]) return 0;
mark[v] = 1;
for (long long e = head[v]; e != -1; e = prv[e])
if (cap[e] && lvl[to[e]] == lvl[v] + 1) {
long long xx = dfs(to[e], sink, min(mini, cap[e]));
if (xx == 0) continue;
cap[e] -= xx;
cap[e ^ 1] += xx;
return xx;
}
return 0;
}
long long max_flow(long long source, long long sink) {
long long ret = 0, xx;
while (bfs(source, sink)) {
memset(mark, 0, sizeof(mark));
while ((xx = dfs(source, sink))) {
ret += xx;
memset(mark, 0, sizeof(mark));
}
}
return ret;
}
int main() {
cin >> n >> m >> x >> y;
if ((x + y + 1) % 2) {
cout << -1 << endl;
return 0;
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> c[i][j];
init();
{
long long a, b, v;
cin >> a >> b >> v;
a--, b--;
if (x < y) {
x++;
vec.push_back({hhash(a, b), v});
} else
sec.push_back({hhash(a, b), v}), y++;
long long i = 0;
if (vec.size()) i++;
for (; i < x; i++) {
cin >> a >> b >> v;
a--, b--;
vec.push_back({hhash(a, b), v});
}
i = 0;
if (sec.size()) i++;
for (; i < y; i++) {
cin >> a >> b >> v;
a--, b--;
sec.push_back({hhash(a, b), v});
}
}
long long b = 0, e = 1e18, mid, ret = -1;
while (b <= e) {
mid = (b + e) / 2;
put(mid);
if (max_flow(x + y + 2 * n * m, x + y + 2 * n * m + 1) == x) {
e = mid - 1;
ret = mid;
} else
b = mid + 1;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAX = 141;
int n, m, male, female;
char a[MAX][MAX];
struct Ono {
int x, y, t;
Ono(){};
Ono(int x, int y, int t) : x(x), y(y), t(t){};
};
vector<Ono> males, females;
long long dm[MAX][MAX][MAX];
long long df[MAX][MAX][MAX];
long long const INF = 1e18;
struct Point {
int x, y;
long long d;
Point(int x, int y, long long d) : x(x), y(y), d(d){};
Point(){};
bool operator<(const Point &z) const {
if (d != z.d) return d < z.d;
if (x != z.x) return x < z.x;
return y < z.y;
};
};
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
bool inside(int x, int y) {
if (x < 1 || x > n) return 0;
if (y < 1 || y > m) return 0;
return 1;
}
void bfs(Ono ono, long long d[MAX][MAX]) {
for (int i = 0; i <= MAX - 1; i++) {
for (int j = 0; j <= MAX - 1; j++) {
d[i][j] = INF;
}
}
d[ono.x][ono.y] = 0;
deque<pair<int, int> > deq;
deq.push_back(make_pair(ono.x, ono.y));
while ((int)deq.size()) {
int x = deq.front().first;
int y = deq.front().second;
deq.pop_front();
for (int o = 0; o <= 3; o++) {
int nx = x + dx[o];
int ny = y + dy[o];
if (!inside(nx, ny)) continue;
if (a[nx][ny] == '#') continue;
if (d[nx][ny] != INF) continue;
d[nx][ny] = d[x][y] + ono.t;
deq.push_back(make_pair(nx, ny));
}
}
}
map<pair<int, int>, int> id;
int getid(int l, int x) {
if (id.find(make_pair(l, x)) == id.end()) {
int s = (int)id.size();
id[make_pair(l, x)] = s;
}
return id[make_pair(l, x)];
}
int const M = 1e5 + 41;
vector<int> e[M];
vector<int> flow, cap, from, to;
void clear() {
for (int i = 0; i <= M - 1; i++) {
e[i].clear();
}
flow.clear();
cap.clear();
from.clear();
to.clear();
id.clear();
}
int S, T;
void pushedge(int x, int y) {
e[x].push_back((int)flow.size());
flow.push_back(0);
cap.push_back(1);
from.push_back(x);
to.push_back(y);
e[y].push_back((int)flow.size());
flow.push_back(0);
cap.push_back(0);
from.push_back(y);
to.push_back(x);
}
int u[M];
int C;
int by[M];
bool dfs(int x) {
u[x] = C;
if (x == T) return true;
for (int z : e[x]) {
int y = to[z];
if (u[y] == C) continue;
if (flow[z] == cap[z]) continue;
by[y] = z;
if (dfs(y)) return true;
}
return false;
}
void relax() {
int v = T;
while (v != S) {
int id = by[v];
flow[id]++;
flow[(id ^ 1)]--;
v = from[id];
}
}
int maxflow(long long dist) {
clear();
S = getid(-1, -1);
T = getid(5, -1);
for (int i = 0; i <= (int)males.size() - 1; i++) {
int id = getid(0, i);
pushedge(S, id);
}
for (int i = 0; i <= (int)males.size() - 1; i++) {
int id = getid(0, i);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (dm[i][x][y] <= dist) {
int id2 = getid(1, (x - 1) * m + y);
pushedge(id, id2);
}
}
}
}
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
int id1 = getid(1, (x - 1) * m + y);
int id2 = getid(2, (x - 1) * m + y);
pushedge(id1, id2);
}
}
for (int i = 0; i <= (int)females.size() - 1; i++) {
int id = getid(3, i);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (df[i][x][y] <= dist) {
int id2 = getid(2, (x - 1) * m + y);
pushedge(id2, id);
}
}
}
}
for (int i = 0; i <= (int)females.size() - 1; i++) {
int id1 = getid(3, i);
int id2 = getid(4, i);
pushedge(id1, id2);
}
for (int i = 0; i <= (int)females.size() - 1; i++) {
int id = getid(4, i);
pushedge(id, T);
}
int res = 0;
while (1) {
C++;
if (!dfs(S)) break;
relax();
res++;
}
return res;
}
void solve() {
for (int i = 0; i <= (int)males.size() - 1; i++) {
bfs(males[i], dm[i]);
}
for (int i = 0; i <= (int)females.size() - 1; i++) {
bfs(females[i], df[i]);
}
long long l = -1;
long long r = INF * 2;
while (r - l > 1) {
long long h = (l + r) / 2;
int resp = maxflow(h);
if (resp == (int)males.size()) {
r = h;
} else {
l = h;
}
}
if (r == INF) r = -1;
printf("%lld\n", r);
}
int main() {
scanf("%d %d %d %d", &n, &m, &male, &female);
for (int i = 1; i <= n; i++) {
scanf(" %s", a[i] + 1);
}
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
if (abs(male - female) != 1) {
printf("-1\n");
return 0;
}
if (male + 1 == female) {
males.push_back(Ono(x, y, t));
} else {
females.push_back(Ono(x, y, t));
}
for (int i = 1; i <= male; i++) {
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
males.push_back(Ono(x, y, t));
}
for (int i = 1; i <= female; i++) {
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
females.push_back(Ono(x, y, t));
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = (int)1e9 + 7) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
void addmod(int& a, int val, int p = (int)1e9 + 7) {
if ((a = a + val) >= p) a -= p;
}
template <class T>
void setmin(T& a, T val) {
a = min(a, val);
}
template <class T>
void setmax(T& a, T val) {
a = max(a, val);
}
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos((long double)0);
struct Dinic {
int n, s, t, E, adj[1000010], flow[1000010], cap[1000010], next[1000010],
last[10010], run[10010], level[10010], que[10010];
void init(int _n, int _s, int _t) {
n = _n;
s = _s;
t = _t;
E = 0;
for (int i = 0; i <= n; i++) last[i] = -1;
}
void add(int u, int v, int c1, int c2) {
adj[E] = v;
flow[E] = 0;
cap[E] = c1;
next[E] = last[u];
last[u] = E++;
adj[E] = u;
flow[E] = 0;
cap[E] = c2;
next[E] = last[v];
last[v] = E++;
}
bool bfs() {
for (int i = 0; i <= n; i++) level[i] = -1;
level[s] = 0;
int qsize = 0;
que[qsize++] = s;
for (int i = 0; i < qsize; i++) {
for (int u = que[i], e = last[u]; e != -1; e = next[e]) {
int v = adj[e];
if (flow[e] < cap[e] && level[v] == -1) {
level[v] = level[u] + 1;
que[qsize++] = v;
}
}
}
return level[t] != -1;
}
int dfs(int u, int bot) {
if (u == t) return bot;
for (int& e = run[u]; e != -1; e = next[e]) {
int v = adj[e], delta = 0;
if (level[v] == level[u] + 1 && flow[e] < cap[e] &&
(delta = dfs(v, min(bot, cap[e] - flow[e]))) > 0) {
flow[e] += delta;
flow[e ^ 1] -= delta;
return delta;
}
}
return 0;
}
int maxflow() {
int total = 0;
while (bfs()) {
for (int i = 0; i <= n; i++) run[i] = last[i];
for (int delta = dfs(s, 1000000000); delta > 0;
delta = dfs(s, 1000000000))
total += delta;
}
return total;
}
} dinic;
const int maxn = 30;
int n, m, k, l;
int a[maxn][maxn];
vector<pair<int, int> > cor[2];
int id[maxn][maxn];
int dis[maxn * maxn][maxn * maxn];
void solve() {
scanf("%d%d%d%d", &n, &m, &k, &l);
if (abs(k - l) != 1) {
printf("-1");
return;
}
int d = max(k, l);
for (int i = (0); i < (n); i++) {
char s[maxn];
scanf("%s", s);
for (int j = (0); j < (m); j++) a[i][j] = s[j] == '.';
}
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) id[i][j] = i * m + j;
int r, c, t;
scanf("%d%d%d", &r, &c, &t);
r--;
c--;
if (k < l)
cor[0].push_back(make_pair(id[r][c], t));
else
cor[1].push_back(make_pair(id[r][c], t));
for (int i = (0); i < (k); i++) {
scanf("%d%d%d", &r, &c, &t);
r--;
c--;
cor[0].push_back(make_pair(id[r][c], t));
}
for (int i = (0); i < (l); i++) {
scanf("%d%d%d", &r, &c, &t);
r--;
c--;
cor[1].push_back(make_pair(id[r][c], t));
}
memset(dis, 0x3f, sizeof(dis));
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++)
if (a[i][j]) {
dis[id[i][j]][id[i][j]] = 0;
if (i && a[i - 1][j]) {
dis[id[i][j]][id[i - 1][j]] = 1;
}
if (j && a[i][j - 1]) {
dis[id[i][j]][id[i][j - 1]] = 1;
}
if (a[i + 1][j]) {
dis[id[i][j]][id[i + 1][j]] = 1;
}
if (a[i][j + 1]) {
dis[id[i][j]][id[i][j + 1]] = 1;
}
}
for (int k = (0); k < (n * m); k++)
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) {
setmin(dis[i][j], dis[i][k] + dis[k][j]);
}
long long lo = 0, hi = LINF;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
int sr = 2 * (d + n * m), sk = 2 * (d + n * m) + 1;
dinic.init(2 * (d + n * m) + 2, sr, sk);
for (int i = (0); i < (d); i++) {
dinic.add(sr, i, 1, 0);
dinic.add(i + d, sk, 1, 0);
int u = cor[0][i].first;
int x = cor[0][i].second;
int v = cor[1][i].first;
int y = cor[1][i].second;
for (int j = (0); j < (n * m); j++) {
if (dis[u][j] < 1000000000 && (long long)x * dis[u][j] <= mid) {
dinic.add(i, j + 2 * d, 1, 0);
}
if (dis[j][v] < 1000000000 && (long long)y * dis[j][v] <= mid) {
dinic.add(j + 2 * d + n * m, i + d, 1, 0);
}
}
}
for (int i = (0); i < (n * m); i++) {
dinic.add(i + 2 * d, i + 2 * d + n * m, 1, 0);
}
if (dinic.maxflow() < d)
lo = mid + 1;
else
hi = mid;
}
if (lo == LINF) lo = -1;
printf("%I64d", lo);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
struct Edge {
int from, to, flow, cap;
};
vector<Edge> edges;
int tot_flow = 0;
vector<int> g[maxn], ans[maxn], b[maxn];
int d[maxn], cur[maxn];
queue<int> q;
void add_edge(int from, int to, int cap) {
edges.push_back((Edge){from, to, 0, cap});
edges.push_back((Edge){to, from, 0, 0});
int m = edges.size();
g[from].push_back(m - 2);
g[to].push_back(m - 1);
return;
}
struct Dinic {
int s, t;
bool bfs() {
memset(d, 0, sizeof(d));
d[s] = 1;
q.push(s);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < g[x].size(); i++) {
Edge e = edges[g[x][i]];
if (e.cap == e.flow) continue;
int y = e.to;
if (d[y]) continue;
d[y] = d[x] + 1;
q.push(y);
}
}
return d[t];
}
int dfs(int x, int a) {
if (x == t || !a) return a;
int flow = 0, f;
for (int& i = cur[x]; i < g[x].size(); i++) {
Edge& e = edges[g[x][i]];
int y = e.to;
if (d[y] == d[x] + 1 && (f = dfs(y, min(a, e.cap - e.flow)))) {
flow += f;
a -= f;
e.flow += f;
edges[g[x][i] ^ 1].flow -= f;
if (!a) return flow;
}
}
return flow;
}
int maxflow(int s, int t) {
this->s = s;
this->t = t;
while (bfs()) {
memset(cur, 0, sizeof(cur));
tot_flow += dfs(s, 99999999);
}
return tot_flow;
}
} F;
char a[50][50];
int n, m;
long long dist[50][50];
int pos_r[maxn], pos_c[maxn], t[maxn];
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};
struct Node {
int from, to;
long long val;
} e[500000];
int cnt = 0;
Node make_Node(int a, int b, long long c) {
Node x;
x.from = a;
x.to = b;
x.val = c;
return x;
}
bool cmp(const Node A, const Node B) { return A.val < B.val; }
void bfs(int r, int c, int num, int t) {
q.push(r);
q.push(c);
memset(dist, -1, sizeof(dist));
dist[r][c] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
e[++cnt] = make_Node(num, (x - 1) * m + y, dist[x][y]);
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 1 || ny < 1 || nx > n || ny > m) continue;
if (a[nx][ny] == '#' || dist[nx][ny] != -1) continue;
dist[nx][ny] = dist[x][y] + t;
q.push(nx);
q.push(ny);
}
}
return;
}
int main() {
int nan, nv;
cin >> n >> m >> nan >> nv;
getchar();
int k = nan > nv ? nan : nv;
if (abs(nan - nv) != 1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) a[i][j] = getchar();
getchar();
}
if (nan < nv)
scanf("%d%d%d", &pos_r[k], &pos_c[k], &t[k]);
else
scanf("%d%d%d", &pos_r[2 * k], &pos_c[2 * k], &t[2 * k]);
for (int i = 1; i <= nan; i++) scanf("%d%d%d", &pos_r[i], &pos_c[i], &t[i]);
for (int i = 1; i <= nv; i++)
scanf("%d%d%d", &pos_r[i + k], &pos_c[i + k], &t[i + k]);
for (int i = 1; i <= k; i++) bfs(pos_r[i], pos_c[i], i, t[i]);
for (int i = k + 1; i <= 2 * k; i++) bfs(pos_r[i], pos_c[i], i, t[i]);
sort(e + 1, e + 1 + cnt, cmp);
int tot = 2 * k + n * m * 2;
for (int i = 1; i <= n * m; i++) {
int x = 2 * k + i;
int y = 2 * k + i + n * m;
add_edge(x, y, 1);
}
for (int i = 1; i <= k; i++) add_edge(0, i, 1);
for (int i = k + 1; i <= 2 * k; i++) add_edge(i, tot + 1, 1);
for (int i = 1; i <= cnt; i++) {
int x = e[i].from, y = e[i].to;
if (x <= k)
add_edge(x, 2 * k + y, 1);
else
add_edge(2 * k + n * m + y, x, 1);
if (i < cnt && e[i].val == e[i + 1].val) continue;
if (F.maxflow(0, tot + 1) == k) {
cout << e[i].val << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = -1e8;
const double Pi = acos(-1);
bool inline equ(double a, double b) { return fabs(a - b) < EPS; }
struct Maxflow {
static const int MAXV = 20010;
static const int INF = 1000000;
struct Edge {
int v, c, r;
Edge(int _v, int _c, int _r) : v(_v), c(_c), r(_r) {}
};
int s, t;
vector<Edge> G[MAXV * 2];
int iter[MAXV * 2], d[MAXV * 2], gap[MAXV * 2], tot;
void flowinit(int x) {
tot = x + 2;
s = x + 1, t = x + 2;
for (int i = 0; i <= tot; i++) {
G[i].clear();
iter[i] = d[i] = gap[i] = 0;
}
}
void addEdge(int u, int v, int c) {
G[u].push_back(Edge(v, c, (int)(G[v]).size()));
G[v].push_back(Edge(u, 0, (int)(G[u]).size() - 1));
}
int dfs(int p, int flow) {
if (p == t) return flow;
for (int &i = iter[p]; i < (int)(G[p]).size(); i++) {
Edge &e = G[p][i];
if (e.c > 0 && d[p] == d[e.v] + 1) {
int f = dfs(e.v, min(flow, e.c));
if (f) {
e.c -= f;
G[e.v][e.r].c += f;
return f;
}
}
}
if ((--gap[d[p]]) == 0)
d[s] = tot;
else {
d[p]++;
iter[p] = 0;
++gap[d[p]];
}
return 0;
}
int maxflow() {
int res = 0;
gap[0] = tot;
for (res = 0; d[s] < tot; res += dfs(s, INF))
;
return res;
}
} flow;
void fail() {
cout << "-1\n";
exit(0);
}
const int MAXN = 25;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
struct XD {
int x, y;
long long t;
void input() { cin >> x >> y >> t; }
};
int n, m, ma, fe, k;
char in[MAXN][MAXN];
XD a[MAXN * MAXN], b[MAXN * MAXN];
tuple<int, int> qu[1000000];
inline void expand(XD x, int id, long long T, bool flag) {
static long long dis[MAXN][MAXN];
static bool vis[MAXN][MAXN];
static auto ok = [&](int tx, int ty) {
return 1 <= tx && tx <= n && 1 <= ty && ty <= m && in[tx][ty] == '.' &&
!vis[tx][ty];
};
long long inc = x.t;
for (int i = (1); i <= (n); i++) fill(vis[i] + 1, vis[i] + m + 1, 0);
int ql = 0, qr = 0;
qu[qr++] = tuple<int, int>(x.x, x.y);
vis[x.x][x.y] = 1;
dis[x.x][x.y] = 0;
while (ql < qr) {
int px, py;
tie(px, py) = qu[ql++];
if (dis[px][py] > T) continue;
if (!flag)
flow.addEdge(id, k + m * (px - 1) + py, 1);
else
flow.addEdge(k + n * m + m * (px - 1) + py, id, 1);
for (int i = (0); i <= (3); i++) {
int tx, ty;
tie(tx, ty) = tuple<int, int>(px + dx[i], py + dy[i]);
if (!ok(tx, ty)) continue;
vis[tx][ty] = 1;
dis[tx][ty] = dis[px][py] + inc;
qu[qr++] = tuple<int, int>(tx, ty);
}
}
}
inline bool ok(long long T) {
flow.flowinit(n * m + n * m + k + k);
for (int i = (1); i <= (k); i++) flow.addEdge(flow.s, i, 1);
for (int i = (1); i <= (k); i++)
flow.addEdge(k + n * m + n * m + i, flow.t, 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
flow.addEdge(k + m * (i - 1) + j, k + n * m + m * (i - 1) + j, 1);
for (int i = (1); i <= (k); i++) expand(a[i], i, T, 0);
for (int i = (1); i <= (k); i++) expand(b[i], k + n * m + n * m + i, T, 1);
return flow.maxflow() == k;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> ma >> fe;
for (int i = (1); i <= (n); i++) cin >> (in[i] + 1);
if (1 + ma == fe)
a[1 + ma].input();
else if (ma == 1 + fe)
b[1 + fe].input();
else
fail();
for (int i = (1); i <= (ma); i++) a[i].input();
for (int i = (1); i <= (fe); i++) b[i].input();
k = max(ma, fe);
long long lb = 0ll, ub = 1000000000000ll, ans = -1ll;
while (lb <= ub) {
long long mid = (lb + ub) / 2ll;
if (ok(mid)) {
ub = mid - 1ll;
ans = mid;
} else
lb = mid + 1ll;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
long long in() {
char c;
bool g = false;
while (c = getchar(), c < '0' || c > '9')
if (c == '-')
g = true;
else
g = false;
long long x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return g ? -x : x;
}
void out(long long x) {
long long len = 0, data[20];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
if (data[0] != abs(data[0])) putchar('-');
while (len--) putchar(abs(data[len]) + 48);
putchar('\n');
}
void out(string s) {
long long len = 0;
while (len++ < s.size()) putchar(s[len - 1]);
putchar('\n');
}
const long long N = 1001000;
long long src = 2019, snk = 2020, ecnt, n, m, ml, fml;
char c[3030][3030];
long long from[N], to[N], cap[N], prv[N], head[3030], ptr[N];
bool vis[3030][3030];
vector<pair<pair<long long, long long>, pair<long long, long long> > > v;
void add(long long v, long long u, long long vu, long long uv) {
from[ecnt] = v, to[ecnt] = u, cap[ecnt] = vu, prv[ecnt] = head[v],
head[v] = ecnt++;
from[ecnt] = u, to[ecnt] = v, cap[ecnt] = uv, prv[ecnt] = head[u],
head[u] = ecnt++;
}
long long q[N], d[N];
bool bfs() {
for (long long i = 0; i < 3030; i++) d[i] = INF;
for (int i = 0; i < 3030; i++) ptr[i] = head[i];
d[src] = 0;
long long bg = 0, ed = 0;
q[ed++] = src;
while (ed > bg) {
long long v = q[bg++];
for (long long i = head[v]; i != -1; i = prv[i])
if (cap[i] && d[to[i]] > d[v] + 1) {
d[to[i]] = d[v] + 1;
q[ed++] = to[i];
}
}
return (d[snk] < INF);
}
long long dfs(long long v = src, long long c = 1e18) {
if (v == snk || !c) return c;
long long ans = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]])
if (d[to[ptr[v]]] == d[v] + 1) {
long long k = dfs(to[ptr[v]], min(c, cap[ptr[v]]));
ans += k;
cap[ptr[v]] -= k;
cap[ptr[v] ^ 1] += k;
c -= k;
if (!c) break;
}
return ans;
}
long long flw() {
long long mx = 0;
while (bfs()) mx += dfs();
return mx;
}
pair<pair<pair<long long, long long>, pair<long long, bool> >, long long> qq[N];
void okbfs(pair<pair<long long, long long>, pair<long long, bool> > v,
long long p, long long d) {
long long bg = 0, ed = 0;
qq[ed++] = {v, d};
while (ed > bg) {
pair<pair<long long, long long>, pair<long long, bool> > u = qq[bg].first;
long long dis = qq[bg++].second;
if (u.first.first < 0 || u.first.second < 0 || u.first.first >= n ||
u.first.second >= m || dis < 0 ||
c[u.first.first][u.first.second] == '#' ||
vis[u.first.first][u.first.second])
continue;
vis[u.first.first][u.first.second] = true;
add(u.second.second ? u.first.first * m + u.first.second + n * m : p,
u.second.second ? p : u.first.first * m + u.first.second, 0, 1);
u.first.first++;
qq[ed++] = {u, dis - u.second.first};
u.first.first -= 2;
qq[ed++] = {u, dis - u.second.first};
u.first.first++;
u.first.second++;
qq[ed++] = {u, dis - u.second.first};
u.first.second -= 2;
qq[ed++] = {u, dis - u.second.first};
u.first.second++;
}
}
int main() {
n = in(), m = in(), ml = in(), fml = in();
if (abs(ml - fml) - 1) return out(-1), 0;
for (int i = 0; i < n; i++, getchar())
for (int j = 0; j < m; j++) c[i][j] = getchar();
int r = in(), c = in(), t = in();
if (fml < ml)
v.push_back({{r - 1, c - 1}, {t, 0}});
else
v.push_back({{r - 1, c - 1}, {t, 1}});
for (long long i = 0; i < ml; i++) {
r = in();
c = in();
t = in();
v.push_back({{r - 1, c - 1}, {t, 1}});
}
for (long long i = 0; i < fml; i++) {
r = in();
c = in();
t = in();
v.push_back({{r - 1, c - 1}, {t, 0}});
}
long long lr = -1, rr = 5e11;
while (rr - lr > 1) {
ecnt = 0;
memset(head, -1, sizeof(head));
for (int i = 0; i < n * m; i++) add(i, i + n * m, 0, 1);
long long mid = (lr + rr) / 2;
for (long long i = 0; i < v.size(); i++) {
for (int i = 0; i < 33; i++)
for (int j = 0; j < 33; j++) vis[i][j] = false;
okbfs(v[i], 2 * n * m + i, mid);
add(v[i].second.second ? src : 2 * n * m + i,
v[i].second.second ? 2 * n * m + i : snk, 1, 0);
}
if (flw() - (ml + fml + 1) / 2)
lr = mid;
else
rr = mid;
}
if (rr == 5e11)
out(-1);
else
out(rr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000009;
const double eps = 1e-6;
const int mod = 1000000007;
const int mx = 23;
int di[] = {0, 0, -1, 1};
int dj[] = {-1, 1, 0, 0};
int n, m, males, females;
char mapp[mx][mx];
int mr[mx * mx], mc[mx * mx], mt[mx * mx];
int fr[mx * mx], fc[mx * mx], ft[mx * mx];
int mat[mx][mx][mx][mx];
int last_my[(4 * mx * mx + 2 + 10)], tlast_my[(4 * mx * mx + 2 + 10)],
d[(4 * mx * mx + 2 + 10)];
int c[(3 * mx * mx + 2 * mx * mx * mx * mx + 10) * 2],
ver[(3 * mx * mx + 2 * mx * mx * mx * mx + 10) * 2],
next_my[(3 * mx * mx + 2 * mx * mx * mx * mx + 10) * 2];
int ptr = 1;
void addEdge(int from, int to, int cap) {
ver[ptr] = to;
c[ptr] = cap;
next_my[ptr] = last_my[from];
last_my[from] = ptr++;
ver[ptr] = from;
c[ptr] = 0;
next_my[ptr] = last_my[to];
last_my[to] = ptr++;
}
int opp(int n) {
if (n & 1) return n + 1;
return n - 1;
}
int temp;
int dfs(int cur, int flow, int &n) {
if (cur == n) return flow;
for (int &i = last_my[cur]; i; i = next_my[i])
if (c[i] && d[cur] == (d[ver[i]] - 1) &&
(temp = dfs(ver[i], c[i] < flow ? c[i] : flow, n))) {
c[i] -= temp;
c[opp(i)] += temp;
return temp;
}
d[cur] = -1;
return 0;
}
int dinic(int S, int T) {
int ans = 0;
for (int i = 0; i <= T; i++) tlast_my[i] = last_my[i];
while (1) {
for (int i = 0; i <= T; i++) last_my[i] = tlast_my[i], d[i] = -1;
queue<int> Q;
Q.push(S);
d[S] = 0;
while (!Q.empty()) {
int cur = Q.front();
Q.pop();
for (int i = last_my[cur]; i; i = next_my[i])
if (c[i] && d[ver[i]] == -1) {
d[ver[i]] = d[cur] + 1;
Q.push(ver[i]);
}
}
if (d[T] == -1) break;
int t;
while (1) {
t = dfs(S, oo, T);
if (t)
ans += t;
else
break;
}
}
return ans;
}
int s, t, mstart, fstart, ostart, istart;
bool ok(long long prev, long long lim) {
ptr = 1;
memset(last_my, 0, sizeof(last_my));
for (int i = 0; i < (n * m); ++i) addEdge(istart + i, ostart + i, 1);
for (int i = 0; i < (males); ++i) addEdge(s, mstart + i, 1);
for (int i = 0; i < (females); ++i) addEdge(fstart + i, t, 1);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
for (int k = 0; k < (males); ++k) {
int si = mr[k], sj = mc[k];
if (mat[si][sj][i][j] >= oo) continue;
long long c = 1ll * mat[si][sj][i][j] * mt[k];
if (c <= lim) {
addEdge(mstart + k, istart + i * m + j, 1);
}
}
for (int k = 0; k < (females); ++k) {
int si = fr[k], sj = fc[k];
if (mat[si][sj][i][j] >= oo) continue;
long long c = 1ll * mat[si][sj][i][j] * ft[k];
if (c <= lim) {
addEdge(ostart + i * m + j, fstart + k, 1);
}
}
}
int flow = dinic(s, t);
return flow == males;
}
int main() {
scanf("%d %d", &n, &m);
scanf("%d %d", &males, &females);
for (int i = 0; i < (n); ++i) scanf("%s", mapp[i]);
int r, c, _t;
scanf("%d %d %d", &r, &c, &_t);
if (males < females) {
mr[males] = r;
mc[males] = c;
mt[males] = _t;
} else {
;
fr[females] = r;
fc[females] = c;
ft[females] = _t;
}
for (int i = 0; i < (males); ++i) scanf("%d %d %d", mr + i, mc + i, mt + i);
for (int i = 0; i < (females); ++i) scanf("%d %d %d", fr + i, fc + i, ft + i);
if (males < females)
++males;
else
++females;
if (males != females) {
printf("-1\n");
return 0;
}
for (int i = 0; i < (males); ++i) --mr[i], --mc[i];
for (int i = 0; i < (females); ++i) --fr[i], --fc[i];
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
for (int ji = 0; ji < (n); ++ji)
for (int jj = 0; jj < (m); ++jj) mat[i][j][ji][jj] = oo;
mat[i][j][i][j] = 0;
if (mapp[i][j] == '.') {
for (int d = 0; d < (4); ++d) {
int ni = i + di[d], nj = j + dj[d];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && mapp[ni][nj] == '.') {
mat[i][j][ni][nj] = 1;
}
}
}
}
for (int ki = 0; ki < (n); ++ki)
for (int kj = 0; kj < (m); ++kj)
for (int ii = 0; ii < (n); ++ii)
for (int ij = 0; ij < (m); ++ij)
for (int ji = 0; ji < (n); ++ji)
for (int jj = 0; jj < (m); ++jj) {
mat[ii][ij][ji][jj] =
min(mat[ii][ij][ji][jj],
mat[ii][ij][ki][kj] + mat[ki][kj][ji][jj]);
}
long long mx_s = 1ll * n * m * n * m * oo;
long long lo = 0, hi = mx_s;
s = 0;
mstart = 1;
istart = mstart + males;
ostart = istart + n * m;
fstart = ostart + n * m;
t = fstart + females;
;
long long last_mid = -oo;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (ok(last_mid, mid))
hi = mid;
else
lo = mid + 1;
last_mid = mid;
}
if (lo == mx_s) lo = -1;
printf("%lld\n", lo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
constexpr int N = 100;
int xx[] = {0, 0, 1, -1};
int yy[] = {1, -1, 0, 0};
template <class FlowT>
class MaxFlow {
public:
static const int maxn = 4007, maxm = 2e6 + 7;
static const FlowT FlowEPS = FlowT(1e-8), FlowINF = FlowT(1 << 29);
int to[maxm * 2], prv[maxm * 2], hed[maxn], dis[maxn], pos[maxn];
FlowT cap[maxm * 2];
int n, m;
inline void init(int N) {
n = N, m = 0;
memset(hed, -1, n * sizeof hed[0]);
}
private:
inline void add_single_edge(int v, int u, FlowT c) {
to[m] = u, prv[m] = hed[v], cap[m] = c, hed[v] = m++;
}
public:
inline void add_edge(int v, int u, FlowT c) {
add_single_edge(v, u, c);
add_single_edge(u, v, 0);
}
inline bool bfs(int source, int sink) {
static int qu[maxn], head, tail;
head = tail = 0;
memset(dis, -1, n * sizeof dis[0]);
dis[source] = 0;
qu[tail++] = source;
while (head < tail) {
int v = qu[head++];
for (int e = hed[v]; e + 1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == -1)
dis[to[e]] = dis[v] + 1, qu[tail++] = to[e];
if (dis[sink] + 1) break;
}
return dis[sink] + 1;
}
inline FlowT dfs(int v, int sink, FlowT cur = FlowINF) {
if (v == sink) return cur;
FlowT ans = 0;
for (int &e = pos[v]; e + 1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == dis[v] + 1) {
FlowT tmp = dfs(to[e], sink, min(cur, cap[e]));
cur -= tmp;
ans += tmp;
cap[e] -= tmp;
cap[e ^ 1] += tmp;
if (cur <= FlowEPS / 2) break;
}
return ans;
}
inline FlowT flow(int source, int sink) {
FlowT ans = 0;
while (bfs(source, sink)) {
memcpy(pos, hed, n * sizeof hed[0]);
ans += dfs(source, sink);
}
return ans;
}
};
MaxFlow<int> fl;
int dis[N][N];
bool a[N][N], vs[N][N];
int r[2][N * N], c[2][N * N], n, num[N][N];
long long t[2][N * N];
void bfs_edge(int one, bool b, long long mx) {
pair<int, int> qu[N * N] = {};
memset(vs, 0, sizeof vs);
memset(dis, 0, sizeof dis);
int head = 0, tail = 1;
qu[0] = {r[b][one], c[b][one]}, vs[r[b][one]][c[b][one]] = 1;
one = b * n + one;
while (tail > head) {
pair<int, int> x = qu[head++];
if (!b)
fl.add_edge(one, num[x.first][x.second], 1);
else
fl.add_edge(num[x.first][x.second] + 1, one, 1);
for (int i = 0; i < 4; i++) {
int ox = xx[i] + x.first, oy = yy[i] + x.second;
if (!vs[ox][oy] && !a[ox][oy] && dis[x.first][x.second] < mx) {
vs[ox][oy] = 1;
dis[ox][oy] = dis[x.first][x.second] + 1;
qu[tail++] = {ox, oy};
}
}
}
}
int32_t main() {
int X = in(), Y = in(), first = in(), M = in();
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
char c;
cin >> c;
a[i][j] = (c == '#');
}
for (int i = 0; i < N; i++) a[0][i] = a[i][0] = a[X + 1][i] = a[i][Y + 1] = 1;
n = max(first, M);
int cnt = 2 * n + 1;
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
num[i][j] = cnt;
cnt += 2;
}
if (first == M - 1)
r[0][M - 1] = in(), c[0][M - 1] = in(), t[0][M - 1] = in();
else if (M == first - 1)
r[1][first - 1] = in(), c[1][first - 1] = in(), t[1][first - 1] = in();
else
return cout << "-1\n", 0;
for (int i = 0; i < first; i++)
r[0][i] = in(), c[0][i] = in(), t[0][i] = in();
for (int i = 0; i < M; i++) r[1][i] = in(), c[1][i] = in(), t[1][i] = in();
bfs_edge(0, 0, 2);
long long s = -1, e = 1e15;
while (e - s > 1) {
fl.init(cnt + 5);
for (int i = 1; i <= X; i++)
for (int j = 1; j <= Y; j++) {
fl.add_edge(num[i][j], num[i][j] + 1, 1);
}
long long mid = (s + e) / 2;
for (int i = 0; i < n; i++) {
bfs_edge(i, 0, mid / t[0][i]);
}
for (int i = 0; i < n; i++) {
bfs_edge(i, 1, mid / t[1][i]);
}
int sou = cnt + 1, sin = cnt + 2;
for (int i = 0; i < n; i++) fl.add_edge(sou, i, 1);
for (int i = 0; i < n; i++) fl.add_edge(i + n, sin, 1);
int ans = fl.flow(sou, sin);
if (ans == n)
e = mid;
else
s = mid;
}
if (e == 1e15) return cout << "-1\n", 0;
cout << e << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int N, int Ne>
struct flow {
using F = int;
F inf = 1e9;
int n, s, t;
int ehd[N], cur[N], ev[Ne << 1], enx[Ne << 1], eid = 1;
void clear() { eid = 1, memset(ehd, 0, sizeof(ehd)); }
F ew[Ne << 1], dis[N];
void Eadd(int u, int v, F w) {
++eid, enx[eid] = ehd[u], ew[eid] = w, ev[eid] = v, ehd[u] = eid;
}
void add(int u, int v, F w) { Eadd(u, v, w), Eadd(v, u, 0); }
bool bfs() {
queue<int> q;
for (int i = (1); i <= (n); i++) dis[i] = inf, cur[i] = ehd[i];
q.push(s), dis[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = ehd[u]; i; i = enx[i])
if (ew[i] && dis[ev[i]] == inf) {
dis[ev[i]] = dis[u] + 1, q.push(ev[i]);
}
}
return dis[t] < inf;
}
F dfs(int x, F now) {
if (!now || x == t) return now;
F res = 0, f;
for (int i = cur[x]; i; i = enx[i]) {
cur[x] = i;
if (ew[i] && dis[ev[i]] == dis[x] + 1) {
f = dfs(ev[i], min(now, ew[i])), ew[i] -= f, now -= f, ew[i ^ 1] += f,
res += f;
if (!now) break;
}
}
return res;
}
F max_flow() {
F res = 0;
while (bfs()) res += dfs(s, inf);
return res;
}
};
const int N = 24, S = N * N;
int n, m, A, B;
int det[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
char s[N][N];
struct node {
int x, y, w;
int d[N][N];
void bfs() {
queue<pair<int, int> > q;
memset(d, 0x3f, sizeof(d));
q.push(make_pair(x, y)), d[x][y] = 0;
while (!q.empty()) {
int sx = q.front().first, sy = q.front().second;
q.pop();
for (int i = (0); i <= (3); i++) {
int px = sx + det[i][0], py = sy + det[i][1];
if (s[px][py] == '.' && d[px][py] > n * m)
d[px][py] = d[sx][sy] + 1, q.push(make_pair(px, py));
}
}
}
} pa[S], pb[S];
flow<S * 5, S * S * 5> a;
bool check(long long X) {
a.clear(), a.n = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 2,
a.s = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 1,
a.t = ((1) * n * m + ((n)-1) * m + (m) + A + B) + 2;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
a.add(((0) * n * m + ((i)-1) * m + (j) + A + B),
((1) * n * m + ((i)-1) * m + (j) + A + B), 1);
for (int x = (1); x <= (A); x++) {
a.add(a.s, x, 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (pa[x].d[i][j] <= n * m && (long long)pa[x].d[i][j] * pa[x].w <= X)
a.add(x, ((0) * n * m + ((i)-1) * m + (j) + A + B), 1);
}
for (int x = (1); x <= (B); x++) {
a.add(x + A, a.t, 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (pb[x].d[i][j] <= n * m && (long long)pb[x].d[i][j] * pb[x].w <= X)
a.add(((1) * n * m + ((i)-1) * m + (j) + A + B), x + A, 1);
}
return a.max_flow() == A;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> A >> B;
for (int i = (1); i <= (n); i++) cin >> (s[i] + 1);
if (abs(A - B) != 1) return cout << "-1\n", 0;
if (A < B) {
++A;
for (int i = (1); i <= (A); i++) cin >> pa[i].x >> pa[i].y >> pa[i].w;
for (int i = (1); i <= (B); i++) cin >> pb[i].x >> pb[i].y >> pb[i].w;
} else {
++B;
cin >> pb[B].x >> pb[B].y >> pb[B].w;
for (int i = (1); i <= (A); i++) cin >> pa[i].x >> pa[i].y >> pa[i].w;
for (int i = (1); i <= (B - 1); i++) cin >> pb[i].x >> pb[i].y >> pb[i].w;
}
for (int i = (1); i <= (A); i++) pa[i].bfs();
for (int i = (1); i <= (B); i++) pb[i].bfs();
long long l = 0, r = 1e13, ns = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
ns = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ns << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
struct t_edge {
int u, v, c, f;
t_edge(int u, int v, int c, int f) : u(u), v(v), c(c), f(f) {}
};
struct network {
int n;
vector<vector<int> > a;
vector<t_edge> e;
int s, t, total_f;
void reset(int n) {
this->n = n;
e.clear();
a.resize(n);
for (int i = 0; i < n; ++i) {
a[i].clear();
}
total_f = 0;
}
network() {}
network(int n) { reset(n); }
void add_edge(int u, int v, int c) {
e.push_back(t_edge(u, v, c, 0));
a[u].push_back((int)e.size() - 1);
a[v].push_back((int)e.size() - 1);
}
t_edge &get_edge(int i) { return e[i]; }
void set_source(int s) { this->s = s; }
void set_sink(int t) { this->t = t; }
inline int source() { return s; }
inline int sink() { return t; }
int get_flow_value() { return total_f; }
};
struct edmonds_karp {
vector<int> pre;
vector<int> minc;
bool find_aug_path(network &g) {
queue<int> q;
q.push(g.s);
pre.resize(g.n);
for (int u = 0; u < g.n; ++u) pre[u] = -1;
pre[g.s] = -2;
minc.resize(g.n);
minc[g.s] = 2E9L;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < g.a[u].size(); ++i) {
int t = g.a[u][i];
t_edge &e = g.e[t];
if (e.v == u) {
if (pre[e.u] == -1 && e.f > 0) {
minc[e.u] = min(minc[u], e.f);
pre[e.u] = t;
q.push(e.u);
if (e.u == g.t) return 1;
}
} else {
if (pre[e.v] == -1 && e.f < e.c) {
minc[e.v] = min(minc[u], e.c - e.f);
pre[e.v] = t;
q.push(e.v);
if (e.v == g.t) return 1;
}
}
}
}
return 0;
}
void inc_flow(network &g) {
int d = minc[g.t];
int v = g.t;
while (v != g.s) {
t_edge &e = g.e[pre[v]];
if (e.v == v) {
e.f += d;
v = e.u;
} else {
e.f -= d;
v = e.v;
}
}
g.total_f += d;
}
edmonds_karp(network &g) {
while (find_aug_path(g)) {
inc_flow(g);
}
}
bool in_cut_s(int u) { return pre[u] != -1; }
};
char board[23][23];
int row[2][23 * 23], col[2][23 * 23], speed[2][23 * 23];
int nRow, nCol, nMale, nFemale;
int dist[23][23][23][23];
int squareID[23][23], nSquare = 0;
long long best[2][23 * 23][23][23];
int idCount[2];
void addScay(int type, int r, int c, int t) {
r--;
c--;
row[type][idCount[type]] = r;
col[type][idCount[type]] = c;
speed[type][idCount[type]] = t;
idCount[type]++;
}
int main() {
cin >> nRow >> nCol >> nMale >> nFemale;
if ((nMale + nFemale) % 2 == 0) {
cout << -1;
return 0;
}
if (abs(nMale - nFemale) >= 2) {
cout << -1;
return 0;
}
for (int i = 0; i < nRow; ++i) {
cin >> board[i];
assert(strlen(board[i]) == nCol);
}
idCount[0] = idCount[1] = 0;
int r, c, t;
cin >> r >> c >> t;
if (nMale == nFemale + 1) {
addScay(1, r, c, t);
} else {
addScay(0, r, c, t);
}
for (int i = 0; i < nMale; ++i) {
cin >> r >> c >> t;
addScay(0, r, c, t);
}
for (int i = 0; i < nFemale; ++i) {
cin >> r >> c >> t;
addScay(1, r, c, t);
}
if (nMale == nFemale + 1) {
nFemale++;
} else {
nMale++;
}
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c)
for (int r2 = 0; r2 < nRow; ++r2)
for (int c2 = 0; c2 < nCol; ++c2) {
dist[r][c][r2][c2] = 2E9L;
if (r2 == r && c2 == c) {
dist[r][c][r2][c2] = 0;
} else if (abs(r2 - r) + abs(c2 - c) == 1) {
if (board[r][c] != '#' && board[r2][c2] != '#') {
dist[r][c][r2][c2] = 1;
}
}
}
for (int rk = 0; rk < nRow; ++rk)
for (int ck = 0; ck < nCol; ++ck)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c)
for (int r2 = 0; r2 < nRow; ++r2)
for (int c2 = 0; c2 < nCol; ++c2) {
int d1 = dist[r][c][rk][ck];
int d2 = dist[rk][ck][r2][c2];
if (d1 != 2E9L && d2 != 2E9L) {
dist[r][c][r2][c2] = min(dist[r][c][r2][c2], d1 + d2);
}
}
long long maxTime = -2E18L;
for (int m = 0; m < nMale; ++m)
for (int f = 0; f < nFemale; ++f) {
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
for (int m = 0; m < nMale; ++m) {
best[0][m][r][c] = 2E18L;
int dMale = dist[r][c][row[0][m]][col[0][m]];
if (dMale != 2E9L) {
long long timeMale = (long long)dMale * speed[0][m];
best[0][m][r][c] = timeMale;
maxTime = max(maxTime, timeMale);
}
}
for (int f = 0; f < nFemale; ++f) {
best[1][f][r][c] = 2E18L;
int dFemale = dist[r][c][row[1][f]][col[1][f]];
if (dFemale != 2E9L) {
long long timeFemale = (long long)dFemale * speed[1][f];
best[1][f][r][c] = timeFemale;
maxTime = max(maxTime, timeFemale);
}
}
}
}
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (board[r][c] == '.') {
squareID[r][c] = nSquare;
nSquare++;
}
}
long long left = 0, right = maxTime, mid, ret = -1;
while (left <= right) {
mid = (left + right) / 2;
int nNode = nMale + nFemale + 2 * nSquare + 2;
network g(nNode);
g.set_source(nNode - 2);
g.set_sink(nNode - 1);
for (int m = 0; m < nMale; ++m) {
g.add_edge(g.source(), m, 1);
}
for (int f = 0; f < nFemale; ++f) {
g.add_edge((nMale + f), g.sink(), 1);
}
for (int x = 0; x < nSquare; ++x) {
g.add_edge((nMale + nFemale + x), (nMale + nFemale + nSquare + x), 1);
}
for (int m = 0; m < nMale; ++m)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (best[0][m][r][c] != 2E18L && best[0][m][r][c] <= mid) {
g.add_edge(m, (nMale + nFemale + squareID[r][c]), 1);
}
}
for (int f = 0; f < nFemale; ++f)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (best[1][f][r][c] != 2E18L && best[1][f][r][c] <= mid) {
g.add_edge((nMale + nFemale + nSquare + squareID[r][c]),
(nMale + f), 1);
}
}
edmonds_karp maxflow(g);
int bestMatch = g.get_flow_value();
if (bestMatch == nMale) {
ret = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void smax(T &a, T b) {
if (a < b) a = b;
}
int V, E, src, tar;
int head[60000], work[60000], dis[60000];
int to[2000000], cap[2000000], nxt[2000000];
int q[60000], qf, qb;
void init(int n) {
memset(head, -1, sizeof(int) * n);
V = n;
E = 0;
}
void add_edge(int u, int v, int c) {
to[E] = v;
cap[E] = c;
nxt[E] = head[u];
head[u] = E++;
to[E] = u;
cap[E] = 0;
nxt[E] = head[v];
head[v] = E++;
}
bool bfs() {
memset(dis, -1, sizeof(dis));
qf = qb = 0;
q[qb++] = src;
dis[src] = 0;
while (qf < qb && dis[tar] == -1) {
int u = q[qf++];
for (int i = head[u]; i >= 0; i = nxt[i]) {
int v = to[i];
if (dis[v] == -1 && cap[i] > 0) {
dis[v] = dis[u] + 1;
q[qb++] = v;
}
}
}
return dis[tar] >= 0;
}
int dfs(int u, int &bot) {
int v, bot1, delta;
if (u == tar) return bot;
for (int &i = work[u]; i >= 0; i = nxt[i]) {
v = to[i];
if (dis[v] != dis[u] + 1 || cap[i] == 0) continue;
bot1 = min(bot, cap[i]);
if (delta = dfs(v, bot1)) {
cap[i] -= delta;
cap[i ^ 1] += delta;
bot = bot1;
return delta;
}
}
return 0;
}
int dinic() {
int ans = 0, delta, bot;
while (bfs()) {
memcpy(work, head, sizeof(int) * V);
delta = 0x3f3f3f3f;
while (delta = dfs(src, bot = 0x3f3f3f3f)) ans += delta;
}
return ans;
}
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int n, m, dst[33][33][33][33];
char grid[33][33];
int c[2], x[2][33 * 33], y[2][33 * 33], t[2][33 * 33];
bool can(long long mid) {
int A = c[0], nm = n * m;
src = A * 2 + 2 * nm, tar = src + 1;
init(tar + 10);
for (int i = (0); i < (A); i++) add_edge(src, i, 1);
for (int i = (0); i < (A); i++) add_edge(A + 2 * nm + i, tar, 1);
for (int i = (0); i < (nm); i++) add_edge(A + i, A + nm + i, 1);
for (int r = (0); r < (2); r++)
for (int k = (0); k < (A); k++)
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
if (grid[i][j] == '#') continue;
int xx = x[r][k], yy = y[r][k], tt = t[r][k];
if (dst[xx][yy][i][j] < 1000 &&
(long long)dst[xx][yy][i][j] * tt <= mid) {
if (!r)
add_edge(k, A + i * m + j, 1);
else
add_edge(A + nm + i * m + j, k + A + 2 * nm, 1);
}
}
return dinic() == A;
}
int main() {
;
scanf("%d%d%d%d", &n, &m, &c[0], &c[1]);
for (int i = (0); i < (n); i++) scanf("%s", grid[i]);
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
for (int i = (0); i < (2); i++)
for (int j = (0); j < (c[i]); j++) {
scanf("%d%d%d", &x[i][j], &y[i][j], &t[i][j]);
x[i][j]--;
y[i][j]--;
}
if (c[0] < c[1]) {
x[0][c[0]] = u;
y[0][c[0]] = v;
t[0][c[0]++] = w;
} else {
x[1][c[1]] = u;
y[1][c[1]] = v;
t[1][c[1]++] = w;
}
if (c[0] != c[1]) {
puts("-1");
return 0;
}
memset(dst, 0x3f, sizeof(dst));
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
if (grid[i][j] == '#') continue;
qb = qf = 0;
q[qb++] = i;
q[qb++] = j;
dst[i][j][i][j] = 0;
while (qb > qf) {
u = q[qf++];
v = q[qf++];
for (int k = (0); k < (4); k++) {
int uu = u + dx[k], vv = v + dy[k];
if ((uu < 0 || vv < 0 || uu >= n || vv >= m)) continue;
if (grid[uu][vv] == '#') continue;
if (dst[i][j][uu][vv] > dst[i][j][u][v] + 1) {
dst[i][j][uu][vv] = dst[i][j][u][v] + 1;
q[qb++] = uu;
q[qb++] = vv;
}
}
}
}
long long st = -1, ed = (1LL << 40), mid;
while (st + 1 < ed) {
mid = (st + ed) >> 1;
if (can(mid))
ed = mid;
else
st = mid;
}
if (ed == (1LL << 40))
puts("-1");
else
printf("%I64d\n", ed);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline bool rd(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void pt(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) pt(x / 10);
putchar(x % 10 + '0');
}
using namespace std;
const long long inf = 10000000000000L;
const int N = 1700;
const int M = 10000000;
template <class T>
struct Max_Flow {
int n;
int Q[N], sign;
int head[N], level[N], cur[N], pre[N];
int nxt[M], pnt[M], E;
T cap[M];
void Init(int n) {
this->n = n + 1;
E = 0;
std::fill(head, head + this->n, -1);
}
void add(int from, int to, T c, T rw) {
pnt[E] = to;
cap[E] = c;
nxt[E] = head[from];
head[from] = E++;
pnt[E] = from;
cap[E] = rw;
nxt[E] = head[to];
head[to] = E++;
}
bool Bfs(int s, int t) {
sign = t;
std::fill(level, level + n, -1);
int *front = Q, *tail = Q;
*tail++ = t;
level[t] = 0;
while (front < tail && level[s] == -1) {
int u = *front++;
for (int e = head[u]; e != -1; e = nxt[e]) {
if (cap[e ^ 1] > 0 && level[pnt[e]] < 0) {
level[pnt[e]] = level[u] + 1;
*tail++ = pnt[e];
}
}
}
return level[s] != -1;
}
void Push(int t, T &flow) {
T mi = inf;
int p = pre[t];
for (int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
mi = std::min(mi, cap[p]);
}
for (int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
cap[p] -= mi;
if (!cap[p]) {
sign = pnt[p ^ 1];
}
cap[p ^ 1] += mi;
}
flow += mi;
}
void Dfs(int u, int t, T &flow) {
if (u == t) {
Push(t, flow);
return;
}
for (int &e = cur[u]; e != -1; e = nxt[e]) {
if (cap[e] > 0 && level[u] - 1 == level[pnt[e]]) {
pre[pnt[e]] = e;
Dfs(pnt[e], t, flow);
if (level[sign] > level[u]) {
return;
}
sign = t;
}
}
}
T Dinic(int s, int t) {
pre[s] = -1;
T flow = 0;
while (Bfs(s, t)) {
std::copy(head, head + n, cur);
Dfs(s, t, flow);
}
return flow;
}
};
Max_Flow<long long> F;
struct node {
int x, y;
long long t;
node(int a = 0, int b = 0, long long c = 0) : x(a), y(b), t(c) {}
} AA[N], B[N], C;
int n, m, a, b;
char mp[23][23];
long long Dis[23][23][23][23];
int has1(int x) { return x - 1; }
int has2(int x, int y) { return a + (x - 1) * m + y - 1; }
int has3(int x, int y) { return a + n * m + (x - 1) * m + y - 1; }
int has4(int x) { return a + 2 * n * m + x - 1; }
bool ok(long long now) {
int from = has4(b) + 1, to = from + 1;
F.Init(to + 10);
for (int i = 1; i <= a; i++) {
F.add(from, has1(i), 1, 0);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (Dis[x][y][AA[i].x][AA[i].y] < inf &&
Dis[x][y][AA[i].x][AA[i].y] * AA[i].t <= now)
F.add(has1(i), has2(x, y), 1, 0);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == '.') F.add(has2(i, j), has3(i, j), 1, 0);
for (int i = 1; i <= b; i++) {
F.add(has4(i), to, 1, 0);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (Dis[x][y][B[i].x][B[i].y] < inf &&
Dis[x][y][B[i].x][B[i].y] * B[i].t <= now)
F.add(has3(x, y), has4(i), 1, 0);
}
return F.Dinic(from, to) == b;
}
long long solve() {
if (a != b) return -1;
long long ans = -1, l = 0, r = inf;
while (l <= r) {
long long mid = (l + r) >> 1;
if (ok(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
return ans;
}
void pre() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++) Dis[i][j][x][y] = inf;
int step[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (mp[i][j] == '*') continue;
Dis[i][j][i][j] = 0;
for (int k = 0; k < 4; k++) {
int x = i + step[k][0], y = j + step[k][1];
if (1 <= x && x <= n && 1 <= y && y <= m && mp[x][y] == '.')
Dis[i][j][x][y] = 1;
}
}
for (int x1 = 1; x1 <= n; x1++)
for (int y1 = 1; y1 <= m; y1++)
if (mp[x1][y1] == '.')
for (int x2 = 1; x2 <= n; x2++)
for (int y2 = 1; y2 <= m; y2++)
if (mp[x2][y2] == '.' && Dis[x2][y2][x1][y1] < inf)
for (int x3 = 1; x3 <= n; x3++)
for (int y3 = 1; y3 <= m; y3++)
if (mp[x3][y3] == '.')
Dis[x2][y2][x3][y3] =
min(Dis[x2][y2][x3][y3],
Dis[x2][y2][x1][y1] + Dis[x1][y1][x3][y3]);
if (a > b)
B[++b] = C;
else
AA[++a] = C;
}
void input() {
rd(n);
rd(m);
rd(a);
rd(b);
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
rd(C.x);
rd(C.y);
rd(C.t);
for (int i = 1; i <= a; i++) {
rd(AA[i].x);
rd(AA[i].y);
rd(AA[i].t);
}
for (int i = 1; i <= b; i++) {
rd(B[i].x);
rd(B[i].y);
rd(B[i].t);
}
}
int main() {
input();
pre();
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int N = 1000010;
int fin;
int ss[N], ff[N], c[N], f[N], obr[N], pred[N], last[N], st[N];
int m;
void add(int x, int y, int z, int xx, int yy) {
m++;
ss[m] = x;
ff[m] = y;
c[m] = z;
f[m] = xx;
obr[m] = yy;
}
int x[N], d[N];
bool expath() {
for (int i = 0; i <= fin; i++) d[i] = -1;
int b = 1, e = 1;
x[1] = 0;
d[0] = 0;
while (b <= e) {
int j = last[x[b]];
while (j > 0) {
if (c[j] > f[j] && d[ff[j]] == -1) {
e++;
x[e] = ff[j];
d[x[e]] = d[x[b]] + 1;
if (x[e] == fin) {
return true;
}
}
j = pred[j];
}
b++;
}
return false;
}
int rec(int v, int w) {
if (v == fin) {
return w;
}
int r = 0, j = last[v];
while (j > 0) {
last[v] = pred[j];
if (c[j] > f[j] && d[ff[j]] == d[v] + 1) {
int ww = c[j] - f[j];
if (w - r < ww) ww = w - r;
int t = rec(ff[j], ww);
if (t > 0) {
f[j] += t;
if (obr[j] != 0) f[obr[j]] -= t;
r += t;
if (r == w) break;
}
}
j = pred[j];
}
return r;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int h, w, males, females;
int mx[N], my[N], mspeed[N];
int fx[N], fy[N], fspeed[N];
int dist[42][42][42][42];
bool can(long long value) {
fin = males + 2 * h * w + females + 1;
m = 0;
for (int i = 1; i <= males; i++) {
add(0, i, 1, 0, 0);
}
for (int i = 1; i <= females; i++) {
add(males + 2 * h * w + i, fin, 1, 0, 0);
}
for (int i = 1; i <= h * w; i++) {
add(males + i, males + i + h * w, 1, 0, m + 2);
add(males + i + h * w, males + i, 0, 0, m);
}
for (int i = 1; i <= males; i++) {
for (int j = 1; j <= h * w; j++) {
int xa = mx[i - 1] - 1;
int ya = my[i - 1] - 1;
int xb = (j - 1) / w;
int yb = (j - 1) % w;
if (dist[xa][ya][xb][yb] != -1) {
if (dist[xa][ya][xb][yb] * 1LL * mspeed[i - 1] <= value) {
add(i, males + j, 1, 0, m + 2);
add(males + j, i, 0, 0, m);
}
}
}
}
for (int i = 1; i <= females; i++) {
for (int j = 1; j <= h * w; j++) {
int xa = fx[i - 1] - 1;
int ya = fy[i - 1] - 1;
int xb = (j - 1) / w;
int yb = (j - 1) % w;
if (dist[xa][ya][xb][yb] != -1) {
if (dist[xa][ya][xb][yb] * 1LL * fspeed[i - 1] <= value) {
add(males + h * w + j, males + 2 * h * w + i, 1, 0, m + 2);
add(males + 2 * h * w + i, males + h * w + j, 0, 0, m);
}
}
}
}
for (int i = 0; i <= fin; i++) {
last[i] = 0;
}
for (int i = 1; i <= m; i++) {
pred[i] = last[ss[i]];
last[ss[i]] = i;
}
for (int i = 0; i <= fin; i++) {
st[i] = last[i];
}
int ans = 0;
while (expath()) {
int t = rec(0, inf);
ans += t;
for (int i = 0; i <= fin; i++) {
last[i] = st[i];
}
}
return (ans == males);
}
char grid[42][42];
int y[N];
int main() {
scanf("%d %d %d %d", &h, &w, &males, &females);
if (abs(males - females) != 1) {
printf("%d\n", -1);
return 0;
}
for (int i = 0; i < h; i++) {
scanf("%s", grid[i]);
}
for (int ii = 0; ii < h; ii++) {
for (int jj = 0; jj < w; jj++) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
dist[ii][jj][i][j] = -1;
}
}
if (grid[ii][jj] == '#') {
continue;
}
int b = 0, e = 0;
x[0] = ii;
y[0] = jj;
dist[ii][jj][ii][jj] = 0;
while (b <= e) {
for (int q = 0; q < 4; q++) {
int xk = x[b] + dx[q];
int yk = y[b] + dy[q];
if (xk >= 0 && yk >= 0 && xk < h && yk < w) {
if (grid[xk][yk] == '.' && dist[ii][jj][xk][yk] == -1) {
e++;
x[e] = xk;
y[e] = yk;
dist[ii][jj][xk][yk] = dist[ii][jj][x[b]][y[b]] + 1;
}
}
}
b++;
}
}
}
if (males < females) {
males++;
for (int i = 0; i < males; i++) {
scanf("%d %d %d", mx + i, my + i, mspeed + i);
}
for (int i = 0; i < females; i++) {
scanf("%d %d %d", fx + i, fy + i, fspeed + i);
}
} else {
females++;
for (int i = 0; i < 1; i++) {
scanf("%d %d %d", fx + i, fy + i, fspeed + i);
}
for (int i = 0; i < males; i++) {
scanf("%d %d %d", mx + i, my + i, mspeed + i);
}
for (int i = 1; i < females; i++) {
scanf("%d %d %d", fx + i, fy + i, fspeed + i);
}
}
long long low = 0, high = (long long)1e15;
while (low < high) {
long long mid = (low + high) >> 1;
if (can(mid)) {
high = mid;
} else {
low = mid + 1;
}
}
if (low == (long long)1e15) low = -1;
cout << low << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[511];
int dist[511], visited[511];
int cur[511];
void init() {
edg.clear();
int i;
for (i = 0; i < 511; 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, 100000000000);
}
return flow;
}
};
Maxflow mf;
long long dist[511][511];
char g[511][511];
int n, m, male, female;
int in(int x) { return x * 2; }
int out(int x) { return x * 2 + 1; }
int index(int x, int y) { return x * m + y; }
void add(int x, int y, int z, int w) {
if (x < 0 || y < 0 || x >= n || y >= m || z < 0 || z >= n || w < 0 || w >= m)
return;
if (g[x][y] == '#' || g[z][w] == '#') return;
if (x == z && y == w) {
dist[index(x, y)][index(z, w)] = 0;
} else {
dist[index(x, y)][index(z, w)] = 1;
}
}
int dx[5] = {1, 0, -1, 0, 0}, dy[5] = {0, 1, 0, -1, 0};
struct people {
int r, c, speed;
};
vector<people> man, woman;
bool check(long long T) {
int i, j;
mf.init();
mf.s = 511 - 2, mf.t = 511 - 1;
for (i = 0; i < n * m; ++i) {
mf.addedge(in(i), out(i), 1);
}
int offset = 2 * n * m, sz = man.size();
for (i = 0; i < sz; ++i) {
mf.addedge(mf.s, i + offset, 1);
for (j = 0; j < n * m; ++j) {
if (dist[index(man[i].r, man[i].c)][j] >= 100000000000) continue;
if (dist[index(man[i].r, man[i].c)][j] * man[i].speed > T) continue;
mf.addedge(i + offset, in(j), 1);
}
}
for (i = 0; i < sz; ++i) {
mf.addedge(i + sz + offset, mf.t, 1);
for (j = 0; j < n * m; ++j) {
if (dist[index(woman[i].r, woman[i].c)][j] >= 100000000000) continue;
if (dist[index(woman[i].r, woman[i].c)][j] * woman[i].speed > T) continue;
mf.addedge(out(j), i + offset + sz, 1);
}
}
return mf.Dinic() == (1ll * sz);
}
int main() {
int i, j, k;
int r, c, t;
scanf("%d%d%d%d", &n, &m, &male, &female);
for (i = 0; i < n; ++i) {
scanf("%s", g[i]);
}
scanf("%d%d%d", &r, &c, &t);
r--, c--;
if (abs(male - female) != 1) {
printf("-1\n");
return 0;
}
if (male - female == 1) {
woman.push_back(people{r, c, t});
} else {
man.push_back(people{r, c, t});
}
for (i = 0; i < 511; ++i) {
for (j = 0; j < 511; ++j) {
dist[i][j] = 100000000000;
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
for (k = 0; k < 5; ++k) {
add(i, j, i + dx[k], j + dy[k]);
}
}
}
for (i = 0; i < male; ++i) {
scanf("%d%d%d", &r, &c, &t);
r--, c--;
man.push_back(people{r, c, t});
}
for (i = 0; i < female; ++i) {
scanf("%d%d%d", &r, &c, &t);
r--, c--;
woman.push_back(people{r, c, t});
}
for (k = 0; k < n * m; ++k) {
for (i = 0; i < n * m; ++i) {
for (j = 0; j < n * m; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
long long low = 0, high = 1e14;
long long ans = high;
while (low <= high) {
long long mid = (low + high) / 2;
if (check(mid)) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
printf("%I64d\n", ans != 1e14 ? ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25 * 25 * 25 * 25;
struct bian {
int from, to;
long long w;
} eg[N << 4];
int front[N], num, s, t;
void add(int x, int y, long long w) {
eg[++num].to = y;
eg[num].from = front[x];
front[x] = num;
eg[num].w = w;
swap(x, y);
eg[++num].to = y;
eg[num].from = front[x];
front[x] = num;
eg[num].w = 0;
}
int _front[N], _dis[N];
bool bfs() {
queue<int> q;
q.push(s);
memset(_dis, 0, sizeof(_dis));
_dis[s] = 1;
while (!q.empty()) {
int o = q.front();
q.pop();
for (int i = front[o]; i; i = eg[i].from) {
int to = eg[i].to;
if (eg[i].w && _dis[to] == 0) {
_dis[to] = _dis[o] + 1;
q.push(to);
}
}
}
return _dis[t] != 0;
}
long long dfs(int o, long long lim) {
if (o == t) return lim;
int mins = 0;
for (int &i = _front[o]; i; i = eg[i].from) {
int to = eg[i].to;
if (_dis[to] != _dis[o] + 1 || eg[i].w == 0) continue;
long long now = dfs(to, min(lim - mins, eg[i].w));
if (now) {
eg[i].w -= now;
eg[((i - 1) ^ 1) + 1].w += now;
mins += now;
if (mins == lim) break;
}
}
return mins;
}
long long dinic() {
int re = 0;
while (bfs()) {
memcpy(_front, front, sizeof(_front));
re += dfs(s, 1e18);
}
return re;
}
int n, m, males, females;
long long dis[25][25][25][25];
char S[25][25];
int calc(int x, int y) { return (x - 1) * m + y; }
long long x, y, v, mx[10010], my[10010], mw[10010], fx[10010], fy[10010],
fw[10010];
bool check(long long w) {
num = 0;
memset(front, 0, sizeof(front));
s = 2 * n * m + males * 2 + 1;
t = s + 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) add(calc(i, j), calc(i, j) + n * m, 1);
}
for (int i = 1; i <= males; ++i) {
add(s, 2 * n * m + i, 1);
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= m; ++k)
if (S[j][k] == '.' && dis[j][k][mx[i]][my[i]] != 1e9 &&
dis[j][k][mx[i]][my[i]] * mw[i] <= w)
add(2 * n * m + i, calc(j, k), 1);
}
}
for (int i = 1; i <= females; ++i) {
add(2 * n * m + males + i, t, 1);
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= m; ++k)
if (S[j][k] == '.' && dis[j][k][fx[i]][fy[i]] != 1e9 &&
dis[j][k][fx[i]][fy[i]] * fw[i] <= w)
add(calc(j, k) + n * m, 2 * n * m + males + i, 1);
}
}
return (dinic() == males);
}
int main() {
scanf("%d%d%d%d", &n, &m, &males, &females);
if (abs(males - females) != 1) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; ++i) {
scanf("%s", S[i] + 1);
}
for (int i = 0; i < 25; ++i) {
for (int j = 0; j < 25; ++j) {
for (int k = 0; k < 25; ++k) {
for (int l = 0; l < 25; ++l) dis[i][j][k][l] = 1e9;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (S[i][j] == '.') {
dis[i][j][i][j] = 0;
if (S[i + 1][j] == '.') dis[i][j][i + 1][j] = 1;
if (S[i - 1][j] == '.') dis[i][j][i - 1][j] = 1;
if (S[i][j + 1] == '.') dis[i][j][i][j + 1] = 1;
if (S[i][j - 1] == '.') dis[i][j][i][j - 1] = 1;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int k = 1; k <= n; ++k) {
for (int l = 1; l <= m; ++l) {
for (int o = 1; o <= n; ++o) {
for (int p = 1; p <= m; ++p) {
dis[k][l][o][p] =
min(dis[k][l][i][j] + dis[i][j][o][p], dis[k][l][o][p]);
}
}
}
}
}
}
scanf("%lld%lld%lld", &x, &y, &v);
for (int i = 1; i <= males; ++i)
scanf("%lld%lld%lld", &mx[i], &my[i], &mw[i]);
if (males < females) ++males, mx[males] = x, my[males] = y, mw[males] = v;
for (int i = 1; i <= females; ++i)
scanf("%lld%lld%lld", &fx[i], &fy[i], &fw[i]);
if (males > females)
++females, fx[females] = x, fy[females] = y, fw[females] = v;
long long l = 0, r = 1e14, ans = -1;
for (long long mid = (l + r) >> 1; l <= r; mid = (l + r) >> 1) {
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%lld\n", ans == 1e14 ? -1 : ans);
}
|
#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 long long INFFLOW = 1e18;
const long long INFCOST = 1e18;
struct MCF {
int n;
vector<long long> prio, pot;
vector<long long> curflow;
vector<int> prevedge, prevnode;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
struct edge {
int to, rev;
long long f, cap;
long long cost;
};
vector<vector<edge>> g;
MCF(int n)
: n(n), prio(n), curflow(n), prevedge(n), prevnode(n), pot(n), g(n) {}
void add_edge(int s, int t, long long cap, long long cost) {
g[s].push_back((edge){t, ((int)g[t].size()), 0, cap, cost});
g[t].push_back((edge){s, ((int)g[s].size()) - 1, 0, 0, -cost});
}
pair<long long, long long> get_flow(int s, int t) {
long long flow = 0;
long long flowcost = 0;
while (1) {
q.push({0, s});
fill(prio.begin(), prio.end(), INFCOST);
prio[s] = 0;
curflow[s] = INFFLOW;
while (!q.empty()) {
auto cur = q.top();
long long d = cur.first;
int u = cur.second;
q.pop();
if (d != prio[u]) continue;
for (int i = 0; i < ((int)g[u].size()); ++i) {
edge &e = g[u][i];
int v = e.to;
if (e.cap <= e.f) continue;
long long nprio = prio[u] + e.cost + pot[u] - pot[v];
if (prio[v] > nprio) {
prio[v] = nprio;
q.push({nprio, v});
prevnode[v] = u;
prevedge[v] = i;
curflow[v] = min(curflow[u], e.cap - e.f);
}
}
}
if (prio[t] == INFCOST) break;
for (int i = 0; i < n; i++) pot[i] += prio[i];
long long df = min(curflow[t], INFFLOW - flow);
flow += df;
for (int v = t; v != s; v = prevnode[v]) {
edge &e = g[prevnode[v]][prevedge[v]];
e.f += df;
g[v][e.rev].f -= df;
flowcost += df * e.cost;
}
}
return {flow, flowcost};
}
};
struct scayger {
long long r, c, t;
};
char board[30][30];
int n, m, males, females;
vector<scayger> male, female;
long long dist[1000][1000];
vector<pair<int, int>> moves = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
bool valid(int i, int j) {
return 0 <= i && 0 <= j && i < n && j < m && board[i][j] != '#';
}
int get(int i, int j) { return i * m + j; }
int get(scayger a) { return a.r * m + a.c; }
void bfs(int i, int j) {
int w = get(i, j);
queue<pair<int, int>> q;
q.push({w, 0});
while (!q.empty()) {
auto p = q.front();
q.pop();
if (dist[w][p.first] != -1) continue;
dist[w][p.first] = p.second;
int x = p.first / m, y = p.first % m;
for (auto move : moves) {
int nx = x + move.first, ny = y + move.second;
if (valid(nx, ny)) q.push({get(nx, ny), p.second + 1});
}
}
}
bool calc(long long med) {
int N = ((int)male.size()) + ((int)female.size()) + 2 * n * m;
MCF mcf(N + 2);
for (int i = 0; i < males; i++) mcf.add_edge(N, i, 1, 0);
for (int i = 0; i < females; i++) mcf.add_edge(males + i, N + 1, 1, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (board[i][j] != '#') {
int w = get(i, j);
int p = males + females + w;
for (int k = 0; k < males; k++) {
int v = get(male[k]);
if (dist[v][w] == -1 || dist[v][w] * male[k].t > med) continue;
mcf.add_edge(k, p, 1, dist[v][w] * male[k].t);
}
mcf.add_edge(p, p + n * m, 1, 0);
for (int k = 0; k < females; k++) {
int v = get(female[k]);
if (dist[v][w] == -1 || dist[v][w] * female[k].t > med) continue;
mcf.add_edge(p + n * m, males + k, 1, dist[v][w] * female[k].t);
}
}
auto p = mcf.get_flow(N, N + 1);
if (p.first == ((int)male.size())) return true;
return false;
}
long long solve() {
memset(dist, -1, sizeof(dist));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (board[i][j] != '#') bfs(i, j);
long long izq = 0, der = 1e12;
long long res = -1;
while (izq <= der) {
long long med = (izq + der) / 2;
if (calc(med))
res = med, der = med - 1;
else
izq = med + 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> males >> females;
for (int i = 0; i < n; i++) cin >> board[i];
int R, C, T;
cin >> R >> C >> T;
for (int i = 0; i < males; i++) {
int r, c, t;
cin >> r >> c >> t;
male.push_back({r - 1, c - 1, t});
}
for (int i = 0; i < females; i++) {
int r, c, t;
cin >> r >> c >> t;
female.push_back({r - 1, c - 1, t});
}
if (males + 1 == females)
male.push_back({R - 1, C - 1, T}), males++;
else if (females + 1 == males)
female.push_back({R - 1, C - 1, T}), females++;
else
cout << -1 << '\n', exit(0);
cout << solve() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e3 + 10;
using namespace std;
int n, m;
struct E {
int k, c;
E() {}
E(int _k, int _c) : k(_k), c(_c) {}
} es[4200010];
struct Flow {
int n, m, dis[500010];
int qq[500010], qr, ql;
vector<int> e[500010];
void init(int _n) {
n = _n;
m = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add_edge(int a, int b, int c) {
e[a].push_back(m);
es[m] = E(b, c);
m++;
e[b].push_back(m);
es[m] = E(a, 0);
m++;
}
bool BFS() {
memset(dis, -1, n * sizeof(int));
ql = qr = 0;
qq[qr++] = 0;
dis[0] = 0;
while (ql != qr && dis[n - 1] == -1) {
int p = qq[ql++];
for (__typeof((e[p]).begin()) it = (e[p]).begin(); it != (e[p]).end();
it++) {
E ee = es[*it];
if (ee.c == 0 || dis[ee.k] != -1) continue;
dis[ee.k] = dis[p] + 1;
qq[qr++] = ee.k;
}
}
return dis[n - 1] != -1;
}
long long go(int p, long long c) {
if (p == n - 1) return c;
long long ret = 0, tmp;
for (__typeof((e[p]).begin()) it = (e[p]).begin(); it != (e[p]).end();
it++) {
E &ee = es[*it];
if (ee.c == 0 || dis[p] + 1 != dis[ee.k]) continue;
tmp = go(ee.k, min(c - ret, (long long)ee.c));
ret += tmp;
ee.c -= tmp;
es[(*it) ^ 1].c += tmp;
if (ret == c) break;
}
if (ret == 0) dis[p] = -1;
return ret;
}
long long maxflow() {
long long ret = 0;
while (BFS()) ret += go(0, 1LL << 60);
return ret;
}
} flow;
char s[24][24];
int id[24][24];
struct data {
int x, y, t;
void scan() {
scanf("%d%d%d", &(x), &(y), &(t));
x--;
y--;
}
} males[300], females[300];
int tt, used[24][24];
long long dis[24][24];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
bool Out(int x, int y) { return x < 0 || y < 0 || x >= n || y >= m; }
void BFS(int x, int y, int me, int ty, long long bound, int v) {
queue<pair<int, int> > bfs;
used[x][y] = tt;
dis[x][y] = 0;
bfs.push(make_pair(x, y));
while (((int)(bfs).size())) {
x = bfs.front().first;
y = bfs.front().second;
if (ty) {
flow.add_edge(id[x][y] + 1, me, 1);
} else {
flow.add_edge(me, id[x][y], 1);
}
bfs.pop();
for (int k = 0; k < (4); ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (Out(nx, ny)) continue;
if (s[nx][ny] == '#') continue;
if (used[nx][ny] == tt) continue;
used[nx][ny] = tt;
dis[nx][ny] = dis[x][y] + v;
if (dis[nx][ny] <= bound) {
bfs.push(make_pair(nx, ny));
}
}
}
}
bool valid(long long v, int N, int flowN) {
flow.init(flowN);
for (int i = (2 * N + 1); i < (flowN - 1); ++i) {
flow.add_edge(i, i + 1, 1);
i++;
}
for (int i = 0; i < (N); ++i) {
flow.add_edge(0, i + 1, 1);
flow.add_edge(i + 1 + N, flowN - 1, 1);
}
for (int i = 0; i < (N); ++i) {
tt++;
BFS(males[i].x, males[i].y, i + 1, 0, v, males[i].t);
tt++;
BFS(females[i].x, females[i].y, i + N + 1, 1, v, females[i].t);
}
return flow.maxflow() == N;
}
int main() {
scanf("%d%d", &(n), &(m));
int malesN, femalesN;
scanf("%d%d", &malesN, &femalesN);
if (abs(malesN - femalesN) != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < (n); ++i) scanf("%s", (s[i]));
if (malesN < femalesN)
males[malesN].scan();
else
females[femalesN].scan();
for (int i = 0; i < (malesN); ++i) males[i].scan();
for (int i = 0; i < (femalesN); ++i) females[i].scan();
int N = max(malesN, femalesN);
int flowN;
{
int now = 2 * N + 1;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
if (s[i][j] == '.') {
id[i][j] = now;
now += 2;
}
}
flowN = now + 1;
}
long long ll = 0, rr = 4e12;
while (ll < rr) {
long long mm = (ll + rr) >> 1;
if (valid(mm, N, flowN))
rr = mm;
else
ll = mm + 1;
}
if (ll == (long long)(4e12)) ll = -1;
cout << ll << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
template <typename T>
std::istream& operator>>(std::istream& input, std::pair<T, T>& data) {
input >> data.first >> data.second;
return input;
}
template <typename T>
std::istream& operator>>(std::istream& input, std::vector<T>& data) {
for (T& first : data) input >> first;
return input;
}
template <typename T>
std::ostream& operator<<(std::ostream& output, const pair<T, T>& data) {
output << "(" << data.first << "," << data.second << ")";
return output;
}
template <typename T>
std::ostream& operator<<(std::ostream& output, const std::vector<T>& data) {
for (const T& first : data) output << first << " ";
return output;
}
std::ostream& operator<<(std::ostream& output, const __int128& first) {
__int128 n = first;
if (n == 0) {
output << "0";
return output;
}
if (n < 0) {
n = -n;
output << "-";
}
string s;
while (n) {
s += '0' + (n % 10);
n /= 10;
}
reverse(s.begin(), s.end());
cout << s;
return output;
}
long long div_up(long long a, long long b) {
return a / b + ((a ^ b) > 0 && a % b);
}
long long div_down(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
long long math_mod(long long a, long long b) { return a - b * div_down(a, b); }
template <class T>
using V = vector<T>;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
long long gcd(long long a, long long b) {
while (b) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
long long Bit(long long mask, long long bit) { return (mask >> bit) & 1; }
const long long N = 23, INF = 1e18;
string greed[N];
struct Chel {
long long first, second, t;
};
V<pair<long long, long long> > v = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
struct Dinic {
struct edge {
long long to, flow, cap;
};
const static long long N = 23 * 23 * 4;
vector<edge> e;
vector<long long> g[N + 7];
long long dp[N + 7];
long long ptr[N + 7];
void clear() {
for (long long i = 0; i < N + 7; i++) g[i].clear();
e.clear();
}
void addEdge(long long a, long long b, long long cap) {
g[a].push_back(e.size());
e.push_back({b, 0, cap});
g[b].push_back(e.size());
e.push_back({a, 0, 0});
}
long long minFlow, start, finish;
bool bfs() {
for (long long i = 0; i < N; i++) dp[i] = -1;
dp[start] = 0;
vector<long long> st;
long long uk = 0;
st.push_back(start);
while (uk < st.size()) {
long long v = st[uk++];
for (long long to : g[v]) {
auto ed = e[to];
if (ed.cap - ed.flow >= minFlow && dp[ed.to] == -1) {
dp[ed.to] = dp[v] + 1;
st.push_back(ed.to);
}
}
}
return dp[finish] != -1;
}
long long dfs(long long v, long long flow) {
if (v == finish) return flow;
for (; ptr[v] < g[v].size(); ptr[v]++) {
long long to = g[v][ptr[v]];
edge ed = e[to];
if (ed.cap - ed.flow >= minFlow && dp[ed.to] == dp[v] + 1) {
long long add = dfs(ed.to, min(flow, ed.cap - ed.flow));
if (add) {
e[to].flow += add;
e[to ^ 1].flow -= add;
return add;
}
}
}
return 0;
}
long long dinic(long long start, long long finish) {
Dinic::start = start;
Dinic::finish = finish;
long long flow = 0;
for (minFlow = (1 << 30); minFlow; minFlow >>= 1) {
while (bfs()) {
for (long long i = 0; i < N; i++) ptr[i] = 0;
while (long long now = dfs(start, (long long)2e9 + 7)) flow += now;
}
}
return flow;
}
} dinic;
long long n, m;
void bfs(long long first, long long second, long long dist[N][N]) {
for (long long i = (0); i < (N); ++i) {
for (long long j = (0); j < (N); ++j) {
dist[i][j] = INF;
}
}
if (greed[first][second] == '#') {
return;
}
queue<pair<long long, long long> > q;
q.push(make_pair(first, second));
dist[first][second] = 0;
while (q.size()) {
auto p = q.front();
q.pop();
long long i = p.first, j = p.second;
for (auto& e : v) {
long long first = i + e.first, second = j + e.second;
if (0 <= first && first < n && 0 <= second && second < m &&
greed[first][second] == '.') {
if (ckmin(dist[first][second], dist[i][j] + 1)) {
q.push(make_pair(first, second));
}
}
}
}
}
long long dist[N][N][N][N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long males, females;
cin >> n >> m >> males >> females;
for (long long i = (0); i < (n); ++i) {
cin >> greed[i];
}
long long first, second, t;
cin >> first >> second >> t;
first--;
second--;
if (abs(males - females) != 1) {
cout << -1 << '\n';
exit(0);
}
V<Chel> a(males), b(females);
for (long long i = (0); i < (males); ++i) {
cin >> a[i].first >> a[i].second >> a[i].t;
a[i].first--;
a[i].second--;
}
for (long long i = (0); i < (females); ++i) {
cin >> b[i].first >> b[i].second >> b[i].t;
b[i].first--;
b[i].second--;
}
if (males > females) {
b.push_back({first, second, t});
} else {
a.push_back({first, second, t});
}
for (long long i = (0); i < (n); ++i) {
for (long long j = (0); j < (m); ++j) {
bfs(i, j, dist[i][j]);
}
}
assert(a.size() == b.size());
long long k = a.size();
auto num = [&](long long first, long long second) {
return first * m + second;
};
auto check = [&](long long Tim) {
dinic.clear();
const long long S = dinic.N - 2;
const long long T = dinic.N - 1;
for (long long i = (0); i < (k); ++i) {
dinic.addEdge(S, i, 1);
for (long long first = (0); first < (n); ++first) {
for (long long second = (0); second < (m); ++second) {
long long d = dist[a[i].first][a[i].second][first][second];
if (d != INF) {
if (d * a[i].t <= Tim) {
dinic.addEdge(i, 2 * k + num(first, second), 1);
}
}
}
}
}
for (long long first = (0); first < (n); ++first) {
for (long long second = (0); second < (m); ++second) {
if (greed[first][second] == '.') {
dinic.addEdge(2 * k + num(first, second),
2 * k + n * m + num(first, second), 1);
}
}
}
for (long long i = (0); i < (k); ++i) {
dinic.addEdge(i + k, T, 1);
for (long long first = (0); first < (n); ++first) {
for (long long second = (0); second < (m); ++second) {
long long d = dist[b[i].first][b[i].second][first][second];
if (d != INF) {
if (d * b[i].t <= Tim) {
dinic.addEdge(2 * k + n * m + num(first, second), i + k, 1);
}
}
}
}
}
return dinic.dinic(S, T) == k;
};
long long l = -1, r = INF;
if (!check(r)) {
cout << -1 << '\n';
exit(0);
}
while (l < r - 1) {
long long m = (l + r) / 2;
if (check(m)) {
r = m;
} else {
l = m;
}
}
cout << r << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int U = 22;
namespace G {
const int N = 2e3 + 5;
const int M = 1e6 + 5;
const int INF = 0x3f3f3f3f;
int head[N], E = 1;
int Head[N];
struct Edge {
int to, next, flow;
} e[M];
inline void addEdge(int u, int v, int flow) {
e[++E] = (Edge){v, head[u], flow};
head[u] = E;
}
inline void addE(int u, int v, int flow) {
addEdge(u, v, flow);
addEdge(v, u, 0);
}
int dis[N];
int S, T;
inline bool bfs() {
memset(dis, 0x3f, sizeof(int) * (T + 1));
copy(Head, Head + T + 1, head);
queue<int> q;
dis[S] = 0;
q.emplace(S);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u], v, w; v = e[i].to, w = e[i].flow, i; i = e[i].next) {
if (dis[v] == INF && w != 0) {
dis[v] = dis[u] + 1;
q.emplace(v);
}
}
}
return dis[T] != INF;
}
int dfs(int u, int flow) {
if (u == T || flow == 0) {
return flow;
}
int res = 0;
for (int &i = head[u], v, w; v = e[i].to, w = e[i].flow, i; i = e[i].next) {
if (w != 0 && dis[v] == dis[u] + 1) {
w = dfs(v, std::min(flow, w));
if (w != 0) {
flow -= w;
res += w;
e[i].flow -= w;
e[i ^ 1].flow += w;
if (flow == 0) {
break;
}
}
}
}
if (!res) {
dis[u] = -1;
}
return res;
}
inline int dinic() {
int res = 0;
while (bfs()) {
res += dfs(S, INF);
}
return res;
}
} // namespace G
const int P = U + 5;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int n, m, male, female;
char mp[P][P];
struct Scayger {
int dis[P][P];
int x, y, speed;
inline void calc() {
for (int i = 1; i <= n; ++i) {
memset(dis[i] + 1, 0x3f, sizeof(int) * m);
}
dis[x][y] = 0;
queue<tuple<int, int, int>> q;
q.emplace(0, x, y);
int w, lx, ly, nx, ny;
while (!q.empty()) {
auto t = q.front();
q.pop();
tie(w, lx, ly) = t;
if (w == dis[lx][ly]) {
for (int i = 0; i < 4; ++i) {
nx = lx + dx[i], ny = ly + dy[i];
if (mp[nx][ny] == '.') {
if (dis[nx][ny] > w + 1) {
dis[nx][ny] = w + 1;
q.emplace(dis[nx][ny], nx, ny);
}
}
}
}
}
}
};
Scayger M[P * P], F[P * P];
inline void buildGraph(long long tim) {
using G::addE;
using G::E;
using G::head;
using G::Head;
using G::S;
using G::T;
memset(head, 0, sizeof(head));
E = 1;
S = 0, T = male + female + 2 * n * m + 1;
for (int u = 1; u <= male; ++u) {
addE(S, (u), 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (M[u].dis[i][j] != G::INF &&
(long long)M[u].dis[i][j] * M[u].speed <= tim) {
addE((u), (male + female + (i - 1) * m + (j)), 1);
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
addE((male + female + (i - 1) * m + (j)),
(male + female + n * m + (i - 1) * m + (j)), 1);
}
}
for (int u = 1; u <= female; ++u) {
addE((male + (u)), T, 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (F[u].dis[i][j] != G::INF &&
(long long)F[u].dis[i][j] * F[u].speed <= tim) {
addE((male + female + n * m + (i - 1) * m + (j)), (male + (u)), 1);
}
}
}
}
copy(head, head + T + 1, Head);
}
int main() {
read(n), read(m), read(male), read(female);
for (int i = 1; i <= n; ++i) {
scanf("%s", mp[i] + 1);
}
if (male - female == -1) {
++male;
for (int i = 1; i <= male; ++i) {
read(M[i].x), read(M[i].y), read(M[i].speed);
}
for (int i = 1; i <= female; ++i) {
read(F[i].x), read(F[i].y), read(F[i].speed);
}
} else if (male - female == 1) {
++female;
read(F[1].x), read(F[1].y), read(F[1].speed);
for (int i = 1; i <= male; ++i) {
read(M[i].x), read(M[i].y), read(M[i].speed);
}
for (int i = 2; i <= female; ++i) {
read(F[i].x), read(F[i].y), read(F[i].speed);
}
} else {
puts("-1");
return 0;
}
for (int i = 1; i <= male; ++i) {
M[i].calc();
}
for (int i = 1; i <= female; ++i) {
F[i].calc();
}
long long l = 0, r = 1LL << 40, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
buildGraph(mid);
if (G::dinic() == male) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,abm,mmx,avx,avx2,popcnt")
using namespace std;
struct mycomplex {
double re, im;
mycomplex(double a, double b) { re = a, im = b; }
mycomplex() {}
};
mycomplex operator*(const mycomplex& a, const mycomplex& b) {
return {a.re * b.re - a.im * b.im, a.im * b.re + a.re * b.im};
}
mycomplex operator-(const mycomplex& a, const mycomplex& b) {
return {a.re - b.re, a.im - b.im};
}
mycomplex operator+(const mycomplex& a, const mycomplex& b) {
return {a.re + b.re, a.im + b.im};
}
const long long INF = 1e18;
const long double PI = acos(-1);
const long double EPS = 1e-11;
const int MOD7 = 1000000007;
const int MOD9 = 1000000009;
long long mod = 998244353;
const int inf = 1e9;
mt19937 rnd(time(0) + 11239);
const int MAXN = 2e3;
struct edge {
int a, b, cap;
};
vector<edge> e;
vector<int> g[MAXN];
int distp[MAXN];
void addedge(int a, int b, int cap) {
g[a].push_back(e.size());
e.push_back({a, b, cap});
g[b].push_back(e.size());
e.push_back({b, a, 0});
}
int s, t;
bool bfs() {
fill(distp, distp + MAXN, inf);
distp[s] = 0;
queue<int> q;
q.push(s);
while (q.size()) {
int v = q.front();
q.pop();
for (int i : g[v]) {
if (e[i].cap > 0) {
int b = e[i].b;
if (distp[b] > distp[v] + 1) {
distp[b] = distp[v] + 1;
q.push(b);
}
}
}
}
return distp[t] != inf;
}
int ptr[MAXN];
int dfs(int v, int flow) {
if (v == t) return flow;
if (!flow) return 0;
int sum = 0;
for (; ptr[v] < g[v].size(); ++ptr[v]) {
int b = e[g[v][ptr[v]]].b;
int cap = e[g[v][ptr[v]]].cap;
if (cap <= 0) continue;
if (distp[b] != distp[v] + 1) continue;
int x = dfs(b, min(flow, cap));
int id = g[v][ptr[v]];
e[id].cap -= x;
e[id ^ 1].cap += x;
flow -= x;
sum += x;
}
return sum;
}
int dinic() {
int ans = 0;
while (1) {
if (!bfs()) break;
fill(ptr, ptr + MAXN, 0);
int x = dfs(s, 1e9);
if (!x) break;
ans += x;
}
return ans;
}
int n, m, male, female;
vector<vector<char>> a;
const int MAXX = 22;
vector<pair<pair<int, int>, int>> ml, fml;
int d[MAXX][MAXX][MAXX][MAXX];
vector<int> dx{1, -1, 0, 0};
vector<int> dy{0, 0, 1, -1};
int getnum(int i, int j) { return ml.size() + fml.size() + 5 + i * m + j + 1; }
bool check(long long r) {
for (int i = 0; i < MAXN; ++i) g[i].clear();
e.clear();
s = 0, t = 1;
vector<vector<int>> mem(n, vector<int>(m));
for (int ti = 0; ti < n; ++ti) {
for (int tj = 0; tj < m; ++tj) {
addedge(getnum(ti, tj), getnum(ti, tj) + n * m, 1);
}
}
for (int i = 0; i < ml.size(); ++i) {
addedge(s, i + 2, 1);
for (int ti = 0; ti < n; ++ti) {
for (int tj = 0; tj < m; ++tj) {
if (d[ml[i].first.first][ml[i].first.second][ti][tj] == inf) continue;
if ((long long)d[ml[i].first.first][ml[i].first.second][ti][tj] *
ml[i].second <=
r) {
addedge(i + 2, getnum(ti, tj), 1);
}
}
}
}
for (int j = 0; j < fml.size(); ++j) {
addedge(ml.size() + 2 + j + 1, t, 1);
for (int ti = 0; ti < n; ++ti) {
for (int tj = 0; tj < m; ++tj) {
if (d[fml[j].first.first][fml[j].first.second][ti][tj] == inf) continue;
if ((long long)d[fml[j].first.first][fml[j].first.second][ti][tj] *
fml[j].second <=
r) {
addedge(getnum(ti, tj) + n * m, j + 1 + ml.size() + 2, 1);
}
}
}
}
return dinic() == max(male, female);
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
srand(time(NULL));
cin >> n >> m >> male >> female;
a.resize(n, vector<char>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
if (abs(male - female) != 1) {
cout << -1;
return 0;
}
int r, c, t;
cin >> r >> c >> t;
if (male < female)
ml.push_back({{r, c}, t});
else
fml.push_back({{r, c}, t});
for (int j = 0; j < male; ++j) {
cin >> r >> c >> t;
ml.push_back({{r, c}, t});
}
for (int j = 0; j < female; ++j) {
cin >> r >> c >> t;
fml.push_back({{r, c}, t});
}
for (int i = 0; i < ml.size(); ++i) {
ml[i].first.first--;
ml[i].first.second--;
fml[i].first.first--;
fml[i].first.second--;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') continue;
queue<pair<int, int>> q;
fill(*d[i][j], *d[i][j] + MAXX * MAXX, inf);
d[i][j][i][j] = 0;
q.push({i, j});
while (q.size()) {
auto v = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int nx = v.first + dx[k], ny = v.second + dy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && a[nx][ny] == '.' &&
d[i][j][nx][ny] > d[i][j][v.first][v.second] + 1) {
d[i][j][nx][ny] = d[i][j][v.first][v.second] + 1;
q.push({nx, ny});
}
}
}
}
}
long long l = -1, rr = 1e12 + 229;
while (rr - l > 1) {
long long mm = (l + rr) / 2;
if (check(mm))
rr = mm;
else
l = mm;
}
check(2);
if (rr > 1e12)
cout << -1;
else
cout << rr;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;
bool space[25][25], vis[25][25];
int dist[600][600];
int make_label(int x, int y) { return x * m + y; }
void bfs(int x, int y) {
memset(vis, 0, sizeof(vis));
queue<pair<pair<int, int>, int>> que;
que.push({{x, y}, 0});
vis[x][y] = 1;
int s = make_label(x, y);
while (!que.empty()) {
auto cur = que.front();
que.pop();
dist[s][make_label(cur.first.first, cur.first.second)] = cur.second;
for (auto &dir : directions) {
pair<int, int> next_step = {cur.first.first + dir.first,
cur.first.second + dir.second};
if (next_step.first >= 0 && next_step.first < n &&
next_step.second >= 0 && next_step.second < m &&
!vis[next_step.first][next_step.second] &&
space[next_step.first][next_step.second]) {
que.push({next_step, cur.second + 1});
vis[next_step.first][next_step.second] = 1;
}
}
}
}
struct edge {
int u, v, w;
edge() {}
edge(int u, int v, int w) {
this->u = u;
this->v = v;
this->w = w;
}
};
struct dinic {
int n, m;
vector<edge> edge_set;
vector<vector<int>> graph;
dinic() {}
dinic(int n) {
this->n = n;
this->m = 0;
graph.resize(n);
}
void add_directed_edge(int u, int v, int w) {
edge_set.push_back({u, v, w});
graph[u].push_back(m);
m++;
edge_set.push_back({v, u, 0});
graph[v].push_back(m);
m++;
}
bool bfs(vector<int> &layer) {
queue<pair<int, int>> que;
que.push({0, 0});
layer[0] = 0;
while (!que.empty()) {
auto cur = que.front();
que.pop();
if (cur.first == n - 1) {
return 1;
}
for (int e : graph[cur.first]) {
if (edge_set[e].w > 0 && layer[edge_set[e].v] == -1) {
que.push({edge_set[e].v, cur.second + 1});
layer[edge_set[e].v] = cur.second + 1;
}
}
}
return 0;
}
bool dfs(vector<int> &path, vector<int> &layer, int u) {
if (u == n - 1) {
int min_value = 0;
for (int e : path) {
if (min_value == 0 || min_value > edge_set[e].w) {
min_value = edge_set[e].w;
}
}
for (int e : path) {
edge_set[e].w -= min_value;
edge_set[e ^ 1].w += min_value;
}
return 1;
}
if (layer[u] >= layer[n - 1]) {
return 0;
}
for (int e : graph[u]) {
if (edge_set[e].w > 0 && layer[edge_set[e].v] == layer[u] + 1) {
path.push_back(e);
if (dfs(path, layer, edge_set[e].v)) {
return 1;
}
path.pop_back();
}
}
return 0;
}
int max_flow() {
vector<int> layer(n, -1);
while (bfs(layer)) {
vector<int> path;
while (dfs(path, layer, 0)) {
path.clear();
}
layer.assign(n, -1);
}
int flow = 0;
for (int e : graph[0]) {
flow += edge_set[e ^ 1].w;
}
return flow;
}
};
int main() {
int male, female;
cin >> n >> m >> male >> female;
string s;
vector<pair<int, int>> valid_point;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
space[i][j] = s[j] == '.';
if (space[i][j]) {
valid_point.push_back({i, j});
}
}
}
memset(dist, 0x3f, sizeof(dist));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (space[i][j]) {
bfs(i, j);
}
}
}
vector<pair<pair<int, int>, int>> males, females;
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
if (male == female + 1) {
females.push_back({{x, y}, t});
} else if (male == female - 1) {
males.push_back({{x, y}, t});
} else {
cout << "-1" << endl;
exit(0);
}
for (int i = 0; i < male; i++) {
cin >> x >> y >> t;
x--;
y--;
males.push_back({{x, y}, t});
}
for (int i = 0; i < female; i++) {
cin >> x >> y >> t;
x--;
y--;
females.push_back({{x, y}, t});
}
male = females.size();
female = females.size();
long long lower = 0, upper = 1e11;
while (lower < upper) {
long long mid = (lower + upper) / 2;
int label1 = male + 1, label2 = label1 + valid_point.size(),
label3 = label2 + valid_point.size(), label4 = label3 + female;
dinic solver(label4 + 1);
for (int i = 1; i <= male; i++) {
solver.add_directed_edge(0, i, 1);
}
for (int i = 1; i <= male; i++) {
for (int j = label1; j < label2; j++) {
if (dist[make_label(males[i - 1].first.first,
males[i - 1].first.second)]
[make_label(valid_point[j - label1].first,
valid_point[j - label1].second)] < 100 &&
1ll *
dist[make_label(males[i - 1].first.first,
males[i - 1].first.second)]
[make_label(valid_point[j - label1].first,
valid_point[j - label1].second)] *
males[i - 1].second <=
mid) {
solver.add_directed_edge(i, j, 1);
}
}
}
for (int i = label1; i < label2; i++) {
solver.add_directed_edge(i, i + valid_point.size(), 1);
}
for (int i = label2; i < label3; i++) {
for (int j = label3; j < label4; j++) {
if (dist[make_label(valid_point[i - label2].first,
valid_point[i - label2].second)]
[make_label(females[j - label3].first.first,
females[j - label3].first.second)] < 100 &&
1ll *
dist[make_label(valid_point[i - label2].first,
valid_point[i - label2].second)]
[make_label(females[j - label3].first.first,
females[j - label3].first.second)] *
females[j - label3].second <=
mid) {
solver.add_directed_edge(i, j, 1);
}
}
}
for (int i = label3; i < label4; i++) {
solver.add_directed_edge(i, label4, 1);
}
if (solver.max_flow() == male) {
upper = mid;
} else {
lower = mid + 1;
}
}
cout << (lower == 1e11 ? -1 : lower) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 2000;
const int MAXE = 500000;
const int INF = (int)1e7 + 10;
struct E {
int to, co;
E(int t = 0, int c = 0) : to(t), co(c) {}
} eg[2 * MAXE];
struct Flow {
vector<int> e[MAXV];
int ei, v;
void init(int n) {
v = n;
ei = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add(int a, int b, int c) {
eg[ei] = E(b, c);
e[a].push_back(ei);
ei++;
eg[ei] = E(a, 0);
e[b].push_back(ei);
ei++;
}
int d[MAXV], qu[MAXV], ql, qr;
bool BFS() {
memset(d, -1, v * sizeof(int));
ql = qr = 0;
qu[qr++] = 0;
d[0] = 0;
while (ql < qr && d[v - 1] == -1) {
int n = qu[ql++];
vector<int> &v = e[n];
for (int i = v.size() - 1; i >= 0; i--) {
int u = v[i];
if (d[eg[u].to] == -1 && eg[u].co > 0) {
d[eg[u].to] = d[n] + 1;
qu[qr++] = eg[u].to;
}
}
}
return d[v - 1] != -1;
}
int ptr[MAXV];
int go(int n, int p) {
if (n == v - 1) return p;
vector<int> &u = e[n];
int temp;
for (int i = ptr[n]; i < ((int)(u).size()); i++) {
if (d[n] + 1 != d[eg[u[i]].to] || eg[u[i]].co == 0) continue;
if ((temp = go(eg[u[i]].to, min(p, eg[u[i]].co))) == 0) continue;
eg[u[i]].co -= temp;
eg[u[i] ^ 1].co += temp;
ptr[n] = i;
return temp;
}
ptr[n] = ((int)(u).size());
return 0;
}
int max_flow() {
int ans = 0, temp;
while (BFS()) {
for (int i = 0; i < v; i++) ptr[i] = 0;
while ((temp = go(0, INF)) > 0) ans += temp;
}
return ans;
}
} flow;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
char s[25][25];
int num[25][25];
int d[25][25];
vector<pair<pair<int, int>, int> > man, wom;
int n, m, space;
bool check(long long c) {
int sink = 1 + ((int)(man).size()) + space + space + ((int)(wom).size());
flow.init(sink + 1);
for (int i = 0; i < ((int)(man).size()); i++) {
memset(d, -1, sizeof(d));
queue<pair<int, int> > que;
d[man[i].first.first][man[i].first.second] = 0;
que.push(man[i].first);
while (!que.empty()) {
pair<int, int> t = que.front();
que.pop();
int nd = d[t.first][t.second] + 1;
flow.add(
i + 1,
num[t.first][t.second] + ((int)(man).size()) + ((int)(man).size()),
1);
for (int j = 0; j < 4; j++) {
int nx = t.first + dx[j], ny = t.second + dy[j];
if (num[nx][ny] && d[nx][ny] == -1 && 1ll * nd * man[i].second <= c) {
d[nx][ny] = nd;
que.push(make_pair(nx, ny));
}
}
}
}
for (int i = 0; i < ((int)(wom).size()); i++) {
memset(d, -1, sizeof(d));
queue<pair<int, int> > que;
d[wom[i].first.first][wom[i].first.second] = 0;
que.push(wom[i].first);
while (!que.empty()) {
pair<int, int> t = que.front();
que.pop();
int nd = d[t.first][t.second] + 1;
flow.add(((int)(man).size()) + ((int)(man).size()) + space +
num[t.first][t.second],
((int)(man).size()) + i + 1, 1);
for (int j = 0; j < 4; j++) {
int nx = t.first + dx[j], ny = t.second + dy[j];
if (num[nx][ny] && d[nx][ny] == -1 && 1ll * nd * wom[i].second <= c) {
d[nx][ny] = nd;
que.push(make_pair(nx, ny));
}
}
}
}
for (int i = 1; i <= ((int)(man).size()); i++)
flow.add(0, i, 1), flow.add(((int)(man).size()) + i, sink, 1);
for (int i = 1; i <= space; i++)
flow.add(((int)(man).size()) + ((int)(man).size()) + i,
((int)(man).size()) + ((int)(man).size()) + space + i, 1);
return flow.max_flow() >= ((int)(man).size());
}
int main() {
int boy, girl, r, c, t, max_t = -1;
scanf("%d%d%d%d", &n, &m, &boy, &girl);
if (!(boy == girl - 1 || girl == boy - 1)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '.') num[i][j] = ++space;
if (space < max(boy, girl)) {
puts("-1");
return 0;
}
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
if (boy == girl - 1)
man.push_back(make_pair(make_pair(r, c), t));
else
wom.push_back(make_pair(make_pair(r, c), t));
for (int i = 0; i < boy; i++) {
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
man.push_back(make_pair(make_pair(r, c), t));
}
for (int i = 0; i < girl; i++) {
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
wom.push_back(make_pair(make_pair(r, c), t));
}
assert(((int)(man).size()) == ((int)(wom).size()));
long long L = 0, R = 1ll * max_t * n * m, M;
while (L <= R) {
M = (L + R) / 2;
if (check(M))
R = M - 1;
else
L = M + 1;
}
if (L > 1ll * max_t * n * m)
puts("-1");
else
printf("%I64d\n", L);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (~0ULL) >> 1;
namespace flow {
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int a, int b, long long c, long long f) {
u = a, v = b, cap = c, flow = f;
}
};
vector<int> adj[30010];
vector<struct Edge> E;
int n, s, t, ptr[30010], len[30010], dis[30010], Q[30010];
inline void init(int nodes, int source, int sink) {
memset(len, 0, sizeof(len));
E.clear();
n = nodes, s = source, t = sink;
for (int i = 0; i < 30010; i++) adj[i].clear();
}
inline void addEdge(int a, int b, long long c) {
adj[a].push_back(E.size());
E.push_back(Edge(a, b, c, 0));
len[a]++;
adj[b].push_back(E.size());
E.push_back(Edge(b, a, 0, 0));
len[b]++;
}
inline bool bfs() {
int i, j, k, id, f = 0, l = 0;
memset(dis, -1, sizeof(dis[0]) * n);
dis[s] = 0, Q[l++] = s;
while (f < l && dis[t] == -1) {
i = Q[f++];
for (k = 0; k < len[i]; k++) {
id = adj[i][k];
if (dis[E[id].v] == -1 && E[id].flow < E[id].cap) {
Q[l++] = E[id].v;
dis[E[id].v] = dis[i] + 1;
}
}
}
return (dis[t] != -1);
}
long long dfs(int i, long long f) {
if (i == t || !f) return f;
while (ptr[i] < len[i]) {
int id = adj[i][ptr[i]];
if (dis[E[id].v] == dis[i] + 1) {
long long x = dfs(E[id].v, min(f, E[id].cap - E[id].flow));
if (x) {
E[id].flow += x, E[id ^ 1].flow -= x;
return x;
}
}
ptr[i]++;
}
return 0;
}
long long dinic() {
long long res = 0;
while (bfs()) {
memset(ptr, 0, n * sizeof(ptr[0]));
while (long long f = dfs(s, INF)) {
res += f;
}
}
return res;
}
} // namespace flow
const int N = 23, NN = N * N;
string g[N];
int dis[NN][NN];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool isvalid(int x, int y, int n, int m) {
return 0 <= x && x < n && 0 <= y && y < m && g[x][y] == '.';
}
vector<vector<pair<int, long long>>> dm, df;
int n, m, a, b;
void process(vector<vector<pair<int, long long>>> &d) {
int x, y, v;
cin >> x >> y >> v;
x--;
y--;
int id = x * m + y;
d.emplace_back();
for (int i = 0; i < n * m; i++) {
if (dis[id][i] >= NN) continue;
d.back().push_back({i, 1LL * v * dis[id][i]});
}
}
int main() {
cin >> n >> m >> a >> b;
for (int i = 0; i < NN; i++) {
for (int j = 0; j < NN; j++) dis[i][j] = NN;
dis[i][i] = 0;
}
for (int i = 0; i < n; i++) cin >> g[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] == '#') continue;
for (int dd = 0; dd < 4; dd++) {
int nx = i + dx[dd];
int ny = j + dy[dd];
if (isvalid(nx, ny, n, m)) dis[i * m + j][nx * m + ny] = 1;
}
}
}
for (int k = 0; k < n * m; k++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
if (a == b + 1)
process(df);
else if (b == a + 1)
process(dm);
else {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < a; i++) process(dm);
for (int i = 0; i < b; i++) process(df);
assert(df.size() == dm.size());
a = df.size();
const long long INF = 1e12;
long long lo = 0, hi = INF;
while (lo < hi) {
long long mid = (lo + hi) / 2;
int sz = 2 * n * m + a + a + 2;
int sink = sz - 1, source = sz - 2;
flow::init(sz, source, sink);
for (int i = 0; i < a; i++) {
flow::addEdge(source, 2 * n * m + i, 1);
for (auto pr : dm[i]) {
if (pr.second > mid) continue;
flow::addEdge(2 * n * m + i, pr.first, 1);
}
}
for (int i = 0; i < a; i++) {
flow::addEdge(2 * n * m + a + i, sink, 1);
for (auto pr : df[i]) {
if (pr.second > mid) continue;
flow::addEdge(n * m + pr.first, 2 * n * m + a + i, 1);
}
}
for (int i = 0; i < n * m; i++) flow::addEdge(i, n * m + i, 1);
int ff = flow::dinic();
if (ff == a)
hi = mid;
else
lo = mid + 1;
}
if (lo == INF) lo = -1;
cout << lo << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000009;
const double eps = 1e-6;
const int mod = 1000000007;
const int mx = 22;
int di[] = {0, 0, -1, 1};
int dj[] = {-1, 1, 0, 0};
int n, m, males, females;
char mapp[mx][mx];
int mr[mx * mx], mc[mx * mx], mt[mx * mx];
int fr[mx * mx], fc[mx * mx], ft[mx * mx];
int mat[mx][mx][mx][mx];
int last_my[(3 * mx * mx + 2)], tlast_my[(3 * mx * mx + 2)],
d[(3 * mx * mx + 2)];
int c[(3 * mx * mx * mx * mx) * 2], ver[(3 * mx * mx * mx * mx) * 2],
next_my[(3 * mx * mx * mx * mx) * 2];
int ptr = 1;
void addEdge(int from, int to, int cap) {
ver[ptr] = to;
c[ptr] = cap;
next_my[ptr] = last_my[from];
last_my[from] = ptr++;
ver[ptr] = from;
c[ptr] = 0;
next_my[ptr] = last_my[to];
last_my[to] = ptr++;
}
int opp(int n) {
if (n & 1) return n + 1;
return n - 1;
}
int temp;
int dfs(int cur, int flow, int &n) {
if (cur == n) return flow;
for (int &i = last_my[cur]; i; i = next_my[i])
if (c[i] && d[cur] == (d[ver[i]] - 1) &&
(temp = dfs(ver[i], c[i] < flow ? c[i] : flow, n))) {
c[i] -= temp;
c[opp(i)] += temp;
return temp;
}
d[cur] = -1;
return 0;
}
int dinic(int S, int T) {
int ans = 0;
for (int i = 0; i <= T; i++) tlast_my[i] = last_my[i];
while (1) {
for (int i = 0; i <= T; i++) last_my[i] = tlast_my[i], d[i] = -1;
queue<int> Q;
Q.push(S);
d[S] = 0;
while (!Q.empty()) {
int cur = Q.front();
Q.pop();
for (int i = last_my[cur]; i; i = next_my[i])
if (c[i] && d[ver[i]] == -1) {
d[ver[i]] = d[cur] + 1;
Q.push(ver[i]);
}
}
if (d[T] == -1) break;
int t;
while (1) {
t = dfs(S, oo, T);
if (t)
ans += t;
else
break;
}
}
return ans;
}
int s, t, mstart, fstart, ostart, istart;
bool ok(long long prev, long long lim) {
ptr = 1;
memset(last_my, 0, sizeof(last_my));
for (int i = 0; i < (n * m); ++i) addEdge(istart + i, ostart + i, 1);
for (int i = 0; i < (males); ++i) addEdge(s, mstart + i, 1);
for (int i = 0; i < (females); ++i) addEdge(fstart + i, t, 1);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
for (int k = 0; k < (males); ++k) {
int si = mr[k], sj = mc[k];
if (mat[si][sj][i][j] >= oo) continue;
long long c = 1ll * mat[si][sj][i][j] * mt[k];
if (c <= lim) {
addEdge(mstart + k, istart + i * m + j, 1);
}
}
for (int k = 0; k < (females); ++k) {
int si = fr[k], sj = fc[k];
if (mat[si][sj][i][j] >= oo) continue;
long long c = 1ll * mat[si][sj][i][j] * ft[k];
if (c <= lim) {
addEdge(ostart + i * m + j, fstart + k, 1);
}
}
}
int flow = dinic(s, t);
return flow == males;
}
int main() {
scanf("%d %d", &n, &m);
scanf("%d %d", &males, &females);
for (int i = 0; i < (n); ++i) scanf("%s", mapp[i]);
int r, c, _t;
scanf("%d %d %d", &r, &c, &_t);
if (males < females) {
mr[males] = r;
mc[males] = c;
mt[males] = _t;
} else {
;
fr[females] = r;
fc[females] = c;
ft[females] = _t;
}
for (int i = 0; i < (males); ++i) scanf("%d %d %d", mr + i, mc + i, mt + i);
for (int i = 0; i < (females); ++i) scanf("%d %d %d", fr + i, fc + i, ft + i);
if (males < females)
++males;
else
++females;
if (males != females) {
printf("-1\n");
return 0;
}
for (int i = 0; i < (males); ++i) --mr[i], --mc[i];
for (int i = 0; i < (females); ++i) --fr[i], --fc[i];
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
for (int ji = 0; ji < (n); ++ji)
for (int jj = 0; jj < (m); ++jj) mat[i][j][ji][jj] = oo;
mat[i][j][i][j] = 0;
if (mapp[i][j] == '.') {
for (int d = 0; d < (4); ++d) {
int ni = i + di[d], nj = j + dj[d];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && mapp[ni][nj] == '.') {
mat[i][j][ni][nj] = 1;
}
}
}
}
for (int ki = 0; ki < (n); ++ki)
for (int kj = 0; kj < (m); ++kj)
for (int ii = 0; ii < (n); ++ii)
for (int ij = 0; ij < (m); ++ij)
for (int ji = 0; ji < (n); ++ji)
for (int jj = 0; jj < (m); ++jj) {
mat[ii][ij][ji][jj] =
min(mat[ii][ij][ji][jj],
mat[ii][ij][ki][kj] + mat[ki][kj][ji][jj]);
}
long long mx_s = 1ll * n * m * n * m * oo;
long long lo = 0, hi = mx_s;
s = 0;
mstart = 1;
istart = mstart + males;
ostart = istart + n * m;
fstart = ostart + n * m;
t = fstart + females;
long long last_mid = -oo;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (ok(last_mid, mid))
hi = mid;
else
lo = mid + 1;
last_mid = mid;
}
if (lo == mx_s) lo = -1;
printf("%lld\n", lo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1500, E = N * N * 2, INF = 1e9 + 7, TINF = 1e12, T = N - 3;
char s[500][500];
int from[E], to[E], cap[E], prv[E], e;
long long head[N], ptr[N], q[N], d[N];
long long n, m, x1, x2, num, Num[500][500], dis[500][500];
vector<pair<pair<int, int>, long long>> v1, v2;
void add_edge(int u, int v, int uv, int vu = 0) {
from[e] = u, to[e] = v, cap[e] = uv, prv[e] = head[u], head[u] = e++;
from[e] = v, to[e] = u, cap[e] = vu, prv[e] = head[v], head[v] = e++;
}
bool bfs(int source, int sink) {
memset(d, 63, sizeof d);
d[source] = 0;
int h = 0, t = 0;
q[t++] = source;
while (h < t) {
int v = q[h++];
for (int i = head[v]; i != -1; i = prv[i]) {
int u = to[i];
if (cap[i] && d[u] > d[v] + 1) {
q[t++] = u;
d[u] = d[v] + 1;
}
}
}
return (d[sink] < 1e9);
}
int dfs(int v, int sink, int flow = INF) {
if (v == sink || flow == 0) return flow;
int ans = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]]) {
int i = ptr[v], u = to[i];
if (d[u] == d[v] + 1) {
int x = dfs(u, sink, min(flow, cap[i]));
cap[i] -= x;
cap[i ^ 1] += x;
flow -= x;
ans += x;
if (flow == 0) break;
}
}
return ans;
}
int max_flow(int source, int sink) {
int ans = 0;
while (bfs(source, sink)) {
memcpy(ptr, head, sizeof head);
ans += dfs(source, sink);
}
return ans;
}
void make(long long mid) {
int source = N - 1, sink = N - 2;
memset(head, -1, sizeof head);
e = 0;
for (int i = 0; i < num; i++) add_edge(i, T - i, 1);
for (int i = 0; i < x1; i++) add_edge(source, num + i, 1);
for (int i = 0; i < x2; i++) add_edge(i + x1 + num, sink, 1);
for (int i = 0; i < x1; i++) {
for (int r = 1; r <= n; r++) {
for (int c = 1; c <= m; c++) {
if (s[r][c] == '#') continue;
if (dis[Num[v1[i].first.first][v1[i].first.second]][Num[r][c]] !=
dis[499][498] &&
dis[Num[v1[i].first.first][v1[i].first.second]][Num[r][c]] *
v1[i].second <=
mid) {
add_edge(num + i, Num[r][c], 1);
}
}
}
}
for (int i = 0; i < x2; i++) {
for (int r = 1; r <= n; r++) {
for (int c = 1; c <= m; c++) {
if (s[r][c] == '#') continue;
if (dis[Num[v2[i].first.first][v2[i].first.second]][Num[r][c]] !=
dis[499][498] &&
dis[Num[v2[i].first.first][v2[i].first.second]][Num[r][c]] *
v2[i].second <=
mid) {
add_edge(T - Num[r][c], num + x1 + i, 1);
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> x1 >> x2;
int source = N - 1, sink = N - 2;
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) s[i][j] = '#';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> s[i][j];
int X[] = {0, 1, 0, -1}, Y[] = {1, 0, -1, 0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) Num[i][j] = num++;
memset(dis, 63, sizeof dis);
for (int i = 0; i < 500; i++) dis[i][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 4; k++)
if (s[i][j] != '#' && s[i + X[k]][j + Y[k]] != '#')
dis[Num[i][j]][Num[i + X[k]][j + Y[k]]] = 1;
for (int k = 0; k < num; k++)
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++)
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
int f1, f2, f3;
cin >> f1 >> f2 >> f3;
for (int i = 0; i < x1; i++) {
int x, y, z;
cin >> x >> y >> z;
v1.push_back({{x, y}, z});
}
for (int i = 0; i < x2; i++) {
int x, y, z;
cin >> x >> y >> z;
v2.push_back({{x, y}, z});
}
if (x1 < x2) {
x1++;
v1.push_back({{f1, f2}, f3});
} else {
x2++;
v2.push_back({{f1, f2}, f3});
}
if (v2.size() != v1.size()) {
cout << "-1" << endl;
return 0;
}
long long l = -1, r = TINF, MXF;
while (r - l > 1) {
long long mid = (r + l) / 2;
make(mid);
MXF = max_flow(source, sink);
if (MXF == x1)
r = mid;
else
l = mid;
}
if (r == TINF) {
cout << "-1" << endl;
return 0;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
class MaximumFlow {
int s, f;
public:
struct edge {
int u, v;
int capacity, flow;
edge() { u = v = capacity = flow = 0; }
edge(int u_, int v_, int capacity_, int flow_)
: u(u_), v(v_), capacity(capacity_), flow(flow_) {}
};
vector<edge> edges;
vector<vector<int> > graph;
vector<int> ptr, level;
queue<int> q;
int n;
MaximumFlow() {}
MaximumFlow(int number) {
n = number;
graph.resize(n);
ptr.assign(n, 0);
level.resize(n);
}
void addEdge(int u, int v, int capacity) {
int sz = (int)(edges.size());
edges.push_back(edge(u, v, capacity, 0));
edges.push_back(edge(v, u, 0, 0));
graph[u].push_back(sz);
graph[v].push_back(sz + 1);
}
void updateLevels() {
level.assign(n, -1);
q.push(s);
level[s] = 0;
while (!q.empty()) {
int topq = q.front();
q.pop();
for (int index = 0; index < graph[topq].size(); ++index) {
int i = graph[topq][index];
int to = edges[i].v;
if (edges[i].capacity - edges[i].flow == 0) {
continue;
}
if (level[to] == -1) {
level[to] = level[topq] + 1;
q.push(to);
}
}
}
}
int pushFlow(int v, int flow) {
if (v == f || flow == 0) {
return flow;
}
for (; ptr[v] < graph[v].size(); ++ptr[v]) {
int index = graph[v][ptr[v]];
int to = edges[index].v;
if (level[v] + 1 == level[to]) {
int pushed =
pushFlow(to, min(flow, edges[index].capacity - edges[index].flow));
if (pushed > 0) {
edges[index].flow += pushed;
edges[index ^ 1].flow -= pushed;
return pushed;
}
}
}
return 0;
}
int dinicFlow(int start, int finish) {
s = start, f = finish;
int result = 0;
while (true) {
updateLevels();
if (level[f] == -1) {
break;
}
while (true) {
int pushed = pushFlow(start, inf);
if (pushed == 0) {
break;
}
result += pushed;
}
ptr.assign(n, 0);
}
return result;
}
};
char tab[25][25];
int n, m, females, males, frees;
int d_females[25 * 25][25][25], v_females[25 * 25], x_females[25 * 25],
y_females[25 * 25];
int d_males[25 * 25][25][25], v_males[25 * 25], x_males[25 * 25],
y_males[25 * 25];
bool check(long long time) {
int tot = females + males + n * m * 2 + 2;
int source = tot - 2, sink = tot - 1;
MaximumFlow solve(tot);
for (int i = 0; i < females; ++i) {
solve.addEdge(source, i, 1);
}
for (int i = 0; i < males; ++i) {
solve.addEdge(females + i, sink, 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (tab[i][j] == '#') {
continue;
}
solve.addEdge(females + males + i * m + j,
females + males + i * m + j + n * m, 1);
for (int k = 0; k < females; ++k) {
if (d_females[k][i][j] != -1 &&
(long long)v_females[k] * d_females[k][i][j] <= time) {
solve.addEdge(k, females + males + i * m + j, inf);
}
}
for (int k = 0; k < males; ++k) {
if (d_males[k][i][j] != -1 &&
(long long)v_males[k] * d_males[k][i][j] <= time) {
solve.addEdge(females + males + i * m + j + n * m, females + k, inf);
}
}
}
}
return solve.dinicFlow(source, sink) == females;
}
bool valid(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && tab[x][y] == '.';
}
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void init() {
for (int i = 0; i < females; ++i) {
memset(d_females[i], -1, sizeof d_females[i]);
queue<pair<int, int> > q;
q.push({x_females[i], y_females[i]});
d_females[i][x_females[i]][y_females[i]] = 0;
while (!q.empty()) {
pair<int, int> where = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int xnew = where.first + dx[k];
int ynew = where.second + dy[k];
if (!valid(xnew, ynew)) {
continue;
}
if (d_females[i][xnew][ynew] == -1) {
d_females[i][xnew][ynew] =
1 + d_females[i][where.first][where.second];
q.push({xnew, ynew});
}
}
}
}
for (int i = 0; i < males; ++i) {
memset(d_males[i], -1, sizeof d_males[i]);
queue<pair<int, int> > q;
q.push({x_males[i], y_males[i]});
d_males[i][x_males[i]][y_males[i]] = 0;
while (!q.empty()) {
pair<int, int> where = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int xnew = where.first + dx[k];
int ynew = where.second + dy[k];
if (!valid(xnew, ynew)) {
continue;
}
if (d_males[i][xnew][ynew] == -1) {
d_males[i][xnew][ynew] = 1 + d_males[i][where.first][where.second];
q.push({xnew, ynew});
}
}
}
}
}
int main() {
cin >> n >> m >> males >> females;
for (int i = 0; i < n; ++i) {
cin >> tab[i];
}
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
for (int i = 0; i < males; ++i) {
cin >> x_males[i] >> y_males[i] >> v_males[i];
x_males[i]--;
y_males[i]--;
}
for (int i = 0; i < females; ++i) {
cin >> x_females[i] >> y_females[i] >> v_females[i];
x_females[i]--;
y_females[i]--;
}
if (females < males) {
x_females[females] = x;
y_females[females] = y;
v_females[females++] = t;
} else {
x_males[males] = x;
y_males[males] = y;
v_males[males++] = t;
}
init();
if (females != males || !check(500000000000LL)) {
cout << -1 << endl;
return 0;
}
long long low = -1, high = 500000000000LL;
while (high - low > 1) {
long long mid = (low + high) / 2;
if (check(mid)) {
high = mid;
} else {
low = mid;
}
}
cout << high << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int a1[4] = {0, 0, 1, -1}, a2[4] = {1, -1, 0, 0};
struct ww {
int x, y, t;
inline void read() { scanf("%d%d%d", &x, &y, &t); }
} d1[2000], d2[2000], O;
int i, j, k, n, m, n1, n2, s, num, S, T, t;
int dis[30][30][30][30];
char p[30][30];
pair<int, int> e[2000];
map<pair<int, int>, int> d;
int bi[600000], liu[600000], ne[600000], he[2000], g[2000], F[2000], gg[2000];
inline void add(int x, int y, int z) {
bi[++t] = y, liu[t] = z, ne[t] = he[x], he[x] = t;
bi[++t] = x, liu[t] = 0, ne[t] = he[y], he[y] = t;
}
inline bool bfs() {
int l, r, v;
g[l = r = 1] = S;
gg[S] = 0;
F[S] = ++num;
for (; l <= r; l++) {
int A = g[l];
for (v = he[A]; v; v = ne[v])
if (liu[v] && F[bi[v]] != num) {
F[bi[v]] = num, g[++r] = bi[v], gg[bi[v]] = gg[A] + 1;
if (bi[v] == T) return 1;
}
}
return 0;
}
int dfs(int x, int y) {
if (x == T) return y;
int w = 0, v, re;
for (v = he[x]; v && w < y; v = ne[v]) {
int A = bi[v];
if (liu[v] && F[A] == num && gg[A] == gg[x] + 1 &&
(re = dfs(A, min(y - w, liu[v]))))
liu[v] -= re, liu[v ^ 1] += re, w += re;
}
if (!w) gg[x] = 0;
return w;
}
inline void fail() {
printf("-1\n");
exit(0);
}
inline void bfs(int x, int y) {
int l, r, i;
d.clear();
e[l = r = 1] = make_pair(x, y);
d[make_pair(x, y)] = 0;
for (; l <= r; l++) {
pair<int, int> A = e[l];
dis[x][y][A.first][A.second] = d[A];
for (i = 0; i <= 3; i++) {
int x = A.first + a1[i], y = A.second + a2[i];
if (x && y && x <= n && y <= m && p[x][y] == '.' &&
!d.count(make_pair(x, y))) {
e[++r] = make_pair(x, y);
d[make_pair(x, y)] = d[A] + 1;
}
}
}
}
inline int C(int x, int y, int z) { return z * n * m + (x - 1) * m + y - 1; }
inline bool ju(long long ti) {
int i, j, u, r, an = 0;
S = n * m * 4 + 1, T = S + 1, t = 1;
for (i = 0; i <= T; i++) he[i] = 0;
for (i = 1; i <= n1; i++) {
add(S, i - 1, 1);
long long ci = ti / d1[i].t;
for (u = 1; u <= n; u++)
for (r = 1; r <= m; r++) {
int A = dis[d1[i].x][d1[i].y][u][r];
if (A < 0 || A > ci) continue;
add(i - 1, C(u, r, 1), 1);
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) add(C(i, j, 1), C(i, j, 2), 1);
for (i = 1; i <= n2; i++) {
add(n * m * 3 + i - 1, T, 1);
long long ci = ti / d2[i].t;
for (u = 1; u <= n; u++)
for (r = 1; r <= m; r++) {
int A = dis[d2[i].x][d2[i].y][u][r];
if (A < 0 || A > ci) continue;
add(C(u, r, 2), n * m * 3 + i - 1, 1);
}
}
for (; bfs(); an += dfs(S, 2000))
;
return an == n1;
}
int main() {
scanf("%d%d%d%d", &n, &m, &n1, &n2);
if ((n1 + n2) % 2 == 0) fail();
for (i = 1; i <= n; i++) {
scanf("%s", p[i] + 1);
for (j = 1; j <= m; j++) s += p[i][j] == '.';
}
O.read();
for (i = 1; i <= n1; i++) d1[i].read();
for (i = 1; i <= n2; i++) d2[i].read();
if (n1 > n2) {
for (i = 1; i <= n1; i++) swap(d1[i], d2[i]);
swap(n1, n2);
}
if (n1 + 1 != n2 || s < n2) fail();
d1[++n1] = O;
memset(dis, 255, sizeof(dis));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (p[i][j] == '.') bfs(i, j);
long long l = 0, r = (long long)1e18, mid;
for (; l <= r;) {
mid = (l + r) / 2;
if (ju(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", r > 1e17 ? -1 : r + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int a, b, cap, flow;
};
struct MaxFlow {
int n, s, t;
vector<int> d, ptr, q;
vector<Edge> e;
vector<vector<int> > g;
MaxFlow(int n) : n(n), d(n), ptr(n), g(n), q(n) {
e.clear();
for (int _n(n - 1), i(0); i <= _n; i++) {
g[i].clear();
ptr[i] = 0;
}
}
void addEdge(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);
}
int getMaxFlow(int _s, int _t) {
s = _s;
t = _t;
int flow = 0;
for (;;) {
if (!bfs()) break;
for (int _n(n - 1), i(0); i <= _n; i++) ptr[i] = 0;
while (int pushed = dfs(s, 1011111111)) flow += pushed;
}
return flow;
}
private:
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
for (int _n(n - 1), i(0); i <= _n; i++) d[i] = -1;
d[s] = 0;
while (qh < qt && d[t] == -1) {
int v = q[qh++];
for (int _n((int)g[v].size() - 1), i(0); i <= _n; 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;
}
};
int m, n, males, females;
char a[33][33];
pair<pair<int, int>, long long> x[2][33 * 33];
long long d[33][33][33][33], g[33][33];
const int di[] = {-1, 1, 0, 0};
const int dj[] = {0, 0, -1, 1};
void bfs(int u, int v) {
queue<pair<int, int> > qu;
qu.push(make_pair(u, v));
memset(g, -1, sizeof g);
g[u][v] = 0;
while (!qu.empty()) {
int u = qu.front().first, v = qu.front().second;
qu.pop();
for (int _n(4 - 1), dir(0); dir <= _n; dir++) {
int uu = u + di[dir], vv = v + dj[dir];
if (uu < 1 || uu > m || vv < 1 || vv > n || g[uu][vv] >= 0) continue;
if (a[uu][vv] == '#') continue;
g[uu][vv] = g[u][v] + 1;
qu.push(make_pair(uu, vv));
}
}
}
int getId1(int i, int j) { return males + females + (i - 1) * n + j; }
int getId2(int i, int j) { return males + females + m * n + (i - 1) * n + j; }
bool solve(long long mid) {
int source = 0, sink = getId2(m, n) + 1;
MaxFlow flow(sink + 1);
for (int _n(males), i(1); i <= _n; i++) flow.addEdge(0, i, 1);
for (int _n(females), i(1); i <= _n; i++) flow.addEdge(males + i, sink, 1);
for (int _n(males), i(1); i <= _n; i++)
for (int _n(m), u(1); u <= _n; u++)
for (int _n(n), v(1); v <= _n; v++)
if (a[u][v] != '#' &&
d[x[0][i].first.first][x[0][i].first.second][u][v] >= 0 &&
d[x[0][i].first.first][x[0][i].first.second][u][v] *
x[0][i].second <=
mid)
flow.addEdge(i, getId1(u, v), 1);
for (int _n(m), u(1); u <= _n; u++)
for (int _n(n), v(1); v <= _n; v++)
if (a[u][v] != '#') flow.addEdge(getId1(u, v), getId2(u, v), 1);
for (int _n(females), i(1); i <= _n; i++)
for (int _n(m), u(1); u <= _n; u++)
for (int _n(n), v(1); v <= _n; v++) {
if (a[u][v] != '#' &&
d[x[1][i].first.first][x[1][i].first.second][u][v] >= 0 &&
d[x[1][i].first.first][x[1][i].first.second][u][v] *
x[1][i].second <=
mid) {
flow.addEdge(getId2(u, v), males + i, 1);
}
}
auto res = flow.getMaxFlow(source, sink);
if (res == males)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
while (cin >> m >> n >> males >> females) {
for (int _n(m), i(1); i <= _n; i++)
for (int _n(n), j(1); j <= _n; j++) cin >> a[i][j];
int rt, ct, tt;
cin >> rt >> ct >> tt;
for (int _n(males), i(1); i <= _n; i++)
cin >> x[0][i].first.first >> x[0][i].first.second >> x[0][i].second;
for (int _n(females), i(1); i <= _n; i++)
cin >> x[1][i].first.first >> x[1][i].first.second >> x[1][i].second;
if (males < females) {
++males;
x[0][males] = make_pair(make_pair(rt, ct), tt);
} else {
++females;
x[1][females] = make_pair(make_pair(rt, ct), tt);
}
if (males != females)
cout << -1 << endl;
else {
for (int _n(m), i(1); i <= _n; i++)
for (int _n(n), j(1); j <= _n; j++)
if (a[i][j] != '#') {
bfs(i, j);
for (int _n(m), u(1); u <= _n; u++)
for (int _n(n), v(1); v <= _n; v++)
if (a[u][v] != '#') {
d[i][j][u][v] = g[u][v];
}
}
long long l = 0, r = 1000111000111000LL, res = r;
while (l <= r) {
long long mid = (l + r) >> 1;
if (solve(mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (res == 1000111000111000LL) res = -1;
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 25;
const long long INF = (long long)1e18;
int n, m, male, female;
char cell[maxN][maxN];
struct skeiger {
int r, c, t;
skeiger(int _r, int _c, int _t) : r(_r), c(_c), t(_t) {}
};
vector<skeiger> all[2];
int dist[maxN][maxN][maxN][maxN];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void find_dist(int x, int y) {
if (cell[x][y] == '#') return;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[x][y][i][j] = -1;
}
}
dist[x][y][x][y] = 0;
queue<pair<int, int> > q;
q.push(make_pair(x, y));
while (!q.empty()) {
auto t = q.front();
q.pop();
int i = t.first;
int j = t.second;
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (ni < 1 || ni > n || nj < 1 || nj > m || cell[ni][nj] == '#') continue;
if (dist[x][y][ni][nj] != -1) continue;
dist[x][y][ni][nj] = dist[x][y][i][j] + 1;
q.push(make_pair(ni, nj));
}
}
}
void cals_dists() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
find_dist(i, j);
}
}
}
struct edge {
int from, to, cap, flow;
edge(int _from, int _to, int _cap, int _flow)
: from(_from), to(_to), cap(_cap), flow(_flow) {}
};
vector<int> g[maxN * maxN * maxN];
int id[maxN][maxN];
vector<edge> edges;
int ptr[maxN * maxN * maxN];
int s, t, num;
void add_edge(int from, int to, int cap) {
g[from].push_back(edges.size());
edges.emplace_back(edge(from, to, cap, 0));
g[to].push_back(edges.size());
edges.emplace_back(edge(to, from, cap, cap));
}
void init() {
edges.clear();
for (int i = 0; i <= t; i++) g[i].clear();
}
int d[maxN * maxN * maxN];
bool bfs() {
for (int i = 0; i <= t; i++) {
d[i] = -1;
}
d[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
int id = g[v][i];
if (d[edges[id].to] != -1) continue;
if (edges[id].flow < edges[id].cap) {
d[edges[id].to] = d[v] + 1;
q.push(edges[id].to);
}
}
}
return (d[t] != -1);
}
int dfs(int from, int flow) {
if (flow == 0) return 0;
if (from == t) return flow;
for (; ptr[from] < g[from].size(); ptr[from]++) {
int id = g[from][ptr[from]];
int to = edges[id].to;
if (d[to] != d[from] + 1) continue;
int pushed = dfs(to, min(flow, edges[id].cap - edges[id].flow));
if (pushed) {
edges[id].flow += pushed;
edges[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
int go_flow() {
int flow = 0;
while (true) {
if (!bfs()) break;
for (int i = 0; i <= t; i++) ptr[i] = 0;
while (true) {
int pushed = dfs(s, (int)1e9);
if (pushed) {
flow += pushed;
} else
break;
}
}
return flow;
}
bool can(long long lim) {
num = all[0].size();
assert(all[0].size() == all[1].size());
s = 0;
t = 2 * n * m + 2 * num + 1;
init();
for (int i = 0; i < 2; i++) {
for (int j = 0; j < all[i].size(); j++) {
int r = all[i][j].r;
int c = all[i][j].c;
int tt = all[i][j].t;
if (i == 0) {
add_edge(s, 2 * n * m + 1 + j, 1);
} else {
add_edge(2 * n * m + 1 + j + num, t, 1);
}
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (dist[r][c][x][y] == -1) continue;
if (1LL * dist[r][c][x][y] * tt > lim) continue;
if (i == 0)
add_edge(2 * n * m + 1 + j, id[x][y], 1);
else
add_edge(id[x][y] + n * m, 2 * n * m + 1 + j + num, 1);
}
}
}
}
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
add_edge(id[x][y], id[x][y] + n * m, 1);
}
}
return go_flow() == num;
}
void solve() {
long long l = 0;
long long r = INF;
if (can(l)) {
cout << 0;
return;
} else if (!can(r)) {
cout << -1;
return;
}
while (r - l > 1) {
long long mid = (l + r) / 2;
if (can(mid))
r = mid;
else
l = mid;
}
cout << r;
}
int main() {
srand(239);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> male >> female;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> cell[i][j];
id[i][j] = (i - 1) * m + j;
}
}
if (abs(male - female) != 1) {
cout << -1;
return 0;
}
int x, y, t;
cin >> x >> y >> t;
if (male > female) {
all[1].emplace_back(x, y, t);
} else {
all[0].emplace_back(x, y, t);
}
for (int i = 1; i <= male; i++) {
int x, y, t;
cin >> x >> y >> t;
all[0].emplace_back(x, y, t);
}
for (int i = 1; i <= female; i++) {
int x, y, t;
cin >> x >> y >> t;
all[1].emplace_back(x, y, t);
}
cals_dists();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2000, E = N * N * 2, INF = 1e9 + 7, TINF = 1e12, T = N - 3;
char s[500][500];
int from[E], to[E], cap[E], prv[E], e;
long long head[N], ptr[N], q[N], d[N];
long long n, m, x1, x2, num, Num[500][500], dis[500][500];
vector<pair<pair<int, int>, long long>> v1, v2;
void add_edge(int u, int v, int uv, int vu = 0) {
from[e] = u, to[e] = v, cap[e] = uv, prv[e] = head[u], head[u] = e++;
from[e] = v, to[e] = u, cap[e] = vu, prv[e] = head[v], head[v] = e++;
}
bool bfs(int source, int sink) {
memset(d, 63, sizeof d);
d[source] = 0;
int h = 0, t = 0;
q[t++] = source;
while (h < t) {
int v = q[h++];
for (int i = head[v]; i != -1; i = prv[i]) {
int u = to[i];
if (cap[i] && d[u] > d[v] + 1) {
q[t++] = u;
d[u] = d[v] + 1;
}
}
}
return (d[sink] < 1e9);
}
int dfs(int v, int sink, int flow = INF) {
if (v == sink || flow == 0) return flow;
int ans = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]]) {
int i = ptr[v], u = to[i];
if (d[u] == d[v] + 1) {
int x = dfs(u, sink, min(flow, cap[i]));
cap[i] -= x;
cap[i ^ 1] += x;
flow -= x;
ans += x;
if (flow == 0) break;
}
}
return ans;
}
int max_flow(int source, int sink) {
int ans = 0;
while (bfs(source, sink)) {
memcpy(ptr, head, sizeof head);
ans += dfs(source, sink);
}
return ans;
}
void make(long long mid) {
int source = N - 1, sink = N - 2;
memset(head, -1, sizeof head);
e = 0;
for (int i = 0; i < num; i++) add_edge(i, T - i, 1);
for (int i = 0; i < x1; i++) add_edge(source, num + i, 1);
for (int i = 0; i < x2; i++) add_edge(i + x1 + num, sink, 1);
for (int i = 0; i < x1; i++) {
for (int r = 1; r <= n; r++) {
for (int c = 1; c <= m; c++) {
if (s[r][c] == '#') continue;
if (dis[Num[v1[i].first.first][v1[i].first.second]][Num[r][c]] !=
dis[499][498] &&
dis[Num[v1[i].first.first][v1[i].first.second]][Num[r][c]] *
v1[i].second <=
mid) {
add_edge(num + i, Num[r][c], 1);
}
}
}
}
for (int i = 0; i < x2; i++) {
for (int r = 1; r <= n; r++) {
for (int c = 1; c <= m; c++) {
if (s[r][c] == '#') continue;
if (dis[Num[v2[i].first.first][v2[i].first.second]][Num[r][c]] !=
dis[499][498] &&
dis[Num[v2[i].first.first][v2[i].first.second]][Num[r][c]] *
v2[i].second <=
mid) {
add_edge(T - Num[r][c], num + x1 + i, 1);
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> x1 >> x2;
int source = N - 1, sink = N - 2;
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) s[i][j] = '#';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> s[i][j];
int X[] = {0, 1, 0, -1}, Y[] = {1, 0, -1, 0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) Num[i][j] = num++;
memset(dis, 63, sizeof dis);
for (int i = 0; i < 500; i++) dis[i][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 4; k++)
if (s[i][j] != '#' && s[i + X[k]][j + Y[k]] != '#')
dis[Num[i][j]][Num[i + X[k]][j + Y[k]]] = 1;
for (int k = 0; k < num; k++)
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++)
dis[i][j] = min(dis[i][k] + dis[k][j], dis[i][j]);
int f1, f2, f3;
cin >> f1 >> f2 >> f3;
for (int i = 0; i < x1; i++) {
int x, y, z;
cin >> x >> y >> z;
v1.push_back({{x, y}, z});
}
for (int i = 0; i < x2; i++) {
int x, y, z;
cin >> x >> y >> z;
v2.push_back({{x, y}, z});
}
if (x1 < x2) {
x1++;
v1.push_back({{f1, f2}, f3});
} else {
x2++;
v2.push_back({{f1, f2}, f3});
}
if (v2.size() != v1.size()) {
cout << "-1" << endl;
return 0;
}
long long l = -1, r = TINF, MXF;
while (r - l > 1) {
long long mid = (r + l) / 2;
make(mid);
MXF = max_flow(source, sink);
if (MXF == x1)
r = mid;
else
l = mid;
}
if (r == TINF) {
cout << "-1" << endl;
return 0;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF2 = (int)1e6;
const long long INF = (long long)1e13;
const int TA = 24;
const int N = TA * TA;
const int V = 4 * N + 20;
const int E = 6 * N * N + 10;
char str[TA];
bool table[TA][TA];
int n, m, w, h;
long long distances[2][N][TA][TA];
const int DX[4] = {0, -1, 0, 1};
const int DY[4] = {-1, 0, 1, 0};
int S, T;
struct Edge {
int v, to;
int cap, flow;
Edge() : v(), to(), cap(), flow() {}
Edge(int _v, int _to, int _cap) : v(_v), to(_to), cap(_cap), flow(0) {}
};
int edSz;
Edge ed[E];
vector<int> g[V];
struct Item {
int x, y;
long long vel;
Item() : x(), y(), vel() {}
void scan() {
scanf("%d%d%I64d", &x, &y, &vel);
x--;
y--;
}
};
vector<Item> a[2];
void read() {
scanf("%d%d%d%d", &w, &h, &n, &m);
if (abs(n - m) != 1) {
printf("-1\n");
exit(0);
}
for (int i = 0; i < w; i++) {
scanf(" %s ", str);
for (int j = 0; j < h; j++) table[i][j] = str[j] == '.';
}
Item tmp;
tmp.scan();
if (n < m)
a[0].push_back(tmp);
else
a[1].push_back(tmp);
for (int i = 0; i < n; i++) {
tmp.scan();
a[0].push_back(tmp);
}
for (int i = 0; i < m; i++) {
tmp.scan();
a[1].push_back(tmp);
}
n = (int)a[0].size();
m = 2 * n + 2 * w * h;
S = m;
T = m + 1;
m += 2;
return;
}
bool checkCoords(int x, int y) {
if (!(x >= 0 && x < w && y >= 0 && y < h)) return false;
return table[x][y];
}
long long tmpDist[TA][TA];
int qSz = 0;
int qu[N][2];
void precalcDistForOne(Item per) {
for (int x = 0; x < w; x++)
for (int y = 0; y < h; y++) tmpDist[x][y] = INF;
tmpDist[per.x][per.y] = 0;
qSz = 1;
qu[0][0] = per.x;
qu[0][1] = per.y;
for (int k = 0; k < qSz; k++) {
int x = qu[k][0], y = qu[k][1];
long long w = tmpDist[x][y] + 1;
for (int dir = 0; dir < 4; dir++) {
int nx = x + DX[dir], ny = y + DY[dir];
if (!checkCoords(nx, ny)) continue;
if (tmpDist[nx][ny] <= w) continue;
tmpDist[nx][ny] = w;
qu[qSz][0] = nx;
qu[qSz][1] = ny;
qSz++;
}
}
for (int x = 0; x < w; x++)
for (int y = 0; y < h; y++)
if (tmpDist[x][y] != INF) tmpDist[x][y] *= per.vel;
return;
}
void precalcDist() {
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++) {
precalcDistForOne(a[i][j]);
for (int x = 0; x < w; x++) {
for (int y = 0; y < h; y++) {
distances[i][j][x][y] = tmpDist[x][y];
}
}
}
return;
}
void clearGraph() {
edSz = 0;
for (int i = 0; i < m; i++) g[i].clear();
return;
}
void addEdge(int v, int to, int cap) {
g[v].push_back(edSz);
ed[edSz++] = Edge(v, to, cap);
g[to].push_back(edSz);
ed[edSz++] = Edge(to, v, 0);
return;
}
void buildGraph(long long val) {
clearGraph();
for (int i = 0; i < n; i++) {
addEdge(S, i, 1);
addEdge(n + i, T, 1);
}
for (int x = 0; x < w; x++)
for (int y = 0; y < h; y++) {
int v = 2 * n + x * h + y;
addEdge(v, v + w * h, 1);
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++) {
int v = i * n + j;
for (int x = 0; x < w; x++)
for (int y = 0; y < h; y++) {
if (distances[i][j][x][y] > val) continue;
int to = 2 * n + x * h + y;
if (i == 0)
addEdge(v, to, 1);
else
addEdge(to + w * h, v, 1);
}
}
return;
}
int dist[V];
int q[V];
int qS;
bool bfs() {
for (int i = 0; i < m; i++) dist[i] = INF2;
dist[S] = 0;
qS = 1;
q[0] = S;
for (int k = 0; k < qS; k++) {
int v = q[k];
for (int i = 0; i < (int)g[v].size(); i++) {
Edge e = ed[g[v][i]];
if (e.cap == e.flow) continue;
int to = e.to;
if (dist[to] <= dist[v] + 1) continue;
dist[to] = dist[v] + 1;
q[qS++] = to;
}
}
return dist[T] != INF2;
}
int idx[V];
int dfs(int v, int pushFlow) {
if (v == T || pushFlow == 0) return pushFlow;
int res = 0;
for (; idx[v] < (int)g[v].size(); idx[v]++) {
int id = g[v][idx[v]];
Edge e = ed[id];
if (e.cap == e.flow) continue;
int to = e.to;
if (dist[to] != dist[v] + 1) continue;
int dF = dfs(to, min(pushFlow, e.cap - e.flow));
pushFlow -= dF;
res += dF;
ed[id].flow += dF;
ed[id ^ 1].flow -= dF;
if (pushFlow == 0) return res;
}
return res;
}
int getFlow() {
int res = 0;
while (bfs()) {
for (int i = 0; i < m; i++) idx[i] = 0;
res += dfs(S, INF2);
}
return res;
}
bool solve2(long long val) {
buildGraph(val);
return (getFlow() == n);
}
void solve() {
long long L = -1;
long long R = INF;
while (R - L > 1) {
long long val = (L + R) / 2;
if (solve2(val))
R = val;
else
L = val;
}
if (R == INF)
printf("-1\n");
else
printf("%I64d\n", R);
return;
}
int main() {
read();
precalcDist();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
bool solve(int);
int main() {
int test = 0;
while (solve(test)) {
++test;
}
return 0;
}
const int N = 24;
struct guy {
int first, second, speed;
};
guy readGuy() {
guy res;
assert(scanf("%d%d%d", &res.first, &res.second, &res.speed) == 3);
--res.first;
--res.second;
return res;
}
int n, m, mal, fem;
guy mals[N * N], fems[N * N];
bool f[N][N];
int dst[N][N][N][N];
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
void bfs(int dst[N][N], int i, int j) {
queue<pair<int, int> > q;
for (int first = int(0); first < int(n); ++first)
for (int second = int(0); second < int(m); ++second)
dst[first][second] = -1;
dst[i][j] = 0;
q.push(pair<int, int>(i, j));
while (!q.empty()) {
i = q.front().first, j = q.front().second;
q.pop();
for (int d = int(0); d < int(4); ++d) {
int first = i + dx[d], second = j + dy[d];
if (first < 0 || first >= n || second < 0 || second >= m ||
f[first][second])
continue;
if (dst[first][second] == -1) {
dst[first][second] = dst[i][j] + 1;
q.push(pair<int, int>(first, second));
}
}
}
}
const int V = 1000500;
struct edge {
int to, f, c, rev;
};
vector<edge> g[V];
int s, t;
int szVs = 0;
int newVertex() {
g[szVs].clear();
return szVs++;
}
void addEdge(int a, int b) {
edge e1 = {b, 0, 1, int((g[b]).size())};
edge e2 = {a, 0, 0, int((g[a]).size())};
g[a].push_back(e1);
g[b].push_back(e2);
}
int p[V];
int pe[V];
bool enlarge() {
for (int i = int(0); i < int(szVs); ++i) p[i] = -1;
queue<int> q;
p[s] = s;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = int(0); i < int(int((g[v]).size())); ++i) {
if (g[v][i].f == g[v][i].c) continue;
int to = g[v][i].to;
if (p[to] == -1) {
p[to] = v;
pe[to] = i;
q.push(to);
}
}
}
if (p[t] == -1) return false;
int v = t;
while (v != s) {
int pv = p[v];
--g[v][g[pv][pe[v]].rev].f;
++g[pv][pe[v]].f;
v = pv;
}
return true;
}
int vs1[N * N], vs2[N * N];
bool can(long long tm) {
szVs = 0;
s = newVertex();
t = newVertex();
int pars = max(mal, fem);
for (int i = int(0); i < int(pars); ++i) {
vs1[i] = newVertex();
vs2[i] = newVertex();
addEdge(s, vs1[i]);
addEdge(vs2[i], t);
}
for (int first = int(0); first < int(n); ++first)
for (int second = int(0); second < int(m); ++second) {
int v1 = newVertex();
int v2 = newVertex();
addEdge(v1, v2);
for (int i = int(0); i < int(pars); ++i) {
long long d = dst[mals[i].first][mals[i].second][first][second];
if (d == -1 || d * mals[i].speed > tm) continue;
addEdge(vs1[i], v1);
}
for (int i = int(0); i < int(pars); ++i) {
long long d = dst[fems[i].first][fems[i].second][first][second];
if (d == -1 || d * fems[i].speed > tm) continue;
addEdge(v2, vs2[i]);
}
}
int flow = 0;
while (enlarge()) ++flow;
return flow == pars;
}
bool solve(int) {
if (scanf("%d%d%d%d", &n, &m, &mal, &fem) != 4) return false;
for (int i = int(0); i < int(n); ++i)
for (int j = int(0); j < int(m); ++j) {
char c;
assert(scanf(" %c", &c) == 1);
f[i][j] = c != '.';
}
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
bfs(dst[i][j], i, j);
}
}
bool bad = false;
if (mal + 1 == fem)
mals[mal] = readGuy();
else if (fem + 1 == mal)
fems[fem] = readGuy();
else {
readGuy();
bad = true;
}
for (int i = int(0); i < int(mal); ++i) mals[i] = readGuy();
for (int i = int(0); i < int(fem); ++i) fems[i] = readGuy();
if (bad) {
puts("-1");
return true;
}
const long long INF = 1e18 + 300;
int pars = max(mal, fem);
vector<long long> poss;
for (int t = int(0); t < int(pars); ++t) {
int i = mals[t].first, j = mals[t].second;
for (int first = int(0); first < int(n); ++first)
for (int second = int(0); second < int(m); ++second) {
if (dst[i][j][first][second] == -1) continue;
poss.push_back(dst[i][j][first][second] * 1LL * mals[t].speed);
}
}
for (int t = int(0); t < int(pars); ++t) {
int i = fems[t].first, j = fems[t].second;
for (int first = int(0); first < int(n); ++first)
for (int second = int(0); second < int(m); ++second) {
if (dst[i][j][first][second] == -1) continue;
poss.push_back(dst[i][j][first][second] * 1LL * fems[t].speed);
}
}
poss.push_back(0);
poss.push_back(INF);
sort((poss).begin(), (poss).end());
poss.erase(unique((poss).begin(), (poss).end()), poss.end());
int lf = -1, rg = int((poss).size()) - 1;
while (rg - lf > 1) {
int mid = (lf + rg) / 2;
if (can(poss[mid]))
rg = mid;
else
lf = mid;
}
poss.back() = -1;
cout << poss[rg] << endl;
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 11 + 4;
const long long MAXE = 2e5;
const long long MAX = 1000;
const long long INF = 1e18 + 1000;
long long n, m, x, y, ec;
char c[MAXN][MAXN];
long long dis[MAX][MAX];
long long from[2 * MAXE], to[2 * MAXE], cap[2 * MAXE], prv[2 * MAXE];
long long head[MAX];
bool mark[MAX];
vector<pair<long long, long long>> vec, sec;
bool fit(long long a, long long b) {
return a >= 0 && a < n && b >= 0 && b < m;
}
long long hhash(long long a, long long b) { return a * m + b; }
void init() {
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
for (long long w = 0; w < n; w++)
for (long long o = 0; o < m; o++)
if (i != w || j != o) dis[hhash(i, j)][hhash(w, o)] = INF;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
if (c[i][j] == '#') continue;
long long h = hhash(i, j);
if (fit(i + 1, j) && c[i + 1][j] != '#') dis[h][hhash(i + 1, j)] = 1;
if (fit(i - 1, j) && c[i - 1][j] != '#') dis[h][hhash(i - 1, j)] = 1;
if (fit(i, j + 1) && c[i][j + 1] != '#') dis[h][hhash(i, j + 1)] = 1;
if (fit(i, j - 1) && c[i][j - 1] != '#') dis[h][hhash(i, j - 1)] = 1;
}
for (long long k = 0; k < n * m; k++)
for (long long i = 0; i < n * m; i++)
for (long long j = 0; j < n * m; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void put_edge(long long u, long long v, long long uv, long long vu = 0) {
from[ec] = u, to[ec] = v, cap[ec] = uv, prv[ec] = head[u];
head[u] = ec++;
from[ec] = v, to[ec] = u, cap[ec] = vu, prv[ec] = head[v];
head[v] = ec++;
}
void put(long long maxi) {
memset(head, -1, sizeof(head));
ec = 0;
long long source = x + y + 2 * n * m;
long long sink = source + 1;
for (long long i = 0; i < x; i++) put_edge(source, i, 1);
for (long long i = 0; i < x; i++) {
long long h = vec[i].first, v = vec[i].second;
for (long long j = 0; j < n; j++)
for (long long w = 0; w < m; w++) {
long long hh = hhash(j, w);
if (dis[h][hh] == INF) continue;
long long time = v * dis[h][hh];
if (time > maxi) continue;
put_edge(i, hh + x, 1);
}
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
long long hh = hhash(i, j);
hh += x;
put_edge(hh, hh + n * m, 1);
}
for (long long i = 0; i < y; i++) {
long long id = x + 2 * n * m + i;
long long h = sec[i].first, v = sec[i].second;
for (long long j = 0; j < n; j++)
for (long long w = 0; w < m; w++) {
long long hh = hhash(j, w);
if (dis[h][hh] == INF) continue;
long long temp = v * dis[h][hh];
if (temp > maxi) continue;
put_edge(x + hh + n * m, id, 1);
}
}
for (long long i = 0; i < y; i++) {
long long id = x + 2 * n * m + i;
put_edge(id, sink, 1);
}
}
long long dfs(long long v, long long sink, long long mini = INF) {
if (sink == v) return mini;
if (mark[v]) return 0;
mark[v] = 1;
for (long long e = head[v]; e != -1; e = prv[e])
if (cap[e]) {
long long xx = dfs(to[e], sink, min(mini, cap[e]));
if (xx == 0) continue;
cap[e] -= xx;
cap[e ^ 1] += xx;
return xx;
}
return 0;
}
long long max_flow(long long source, long long sink) {
memset(mark, 0, sizeof(mark));
long long ret = 0, xx;
while ((xx = dfs(source, sink))) {
ret += xx;
memset(mark, 0, sizeof(mark));
}
return ret;
}
int main() {
cin >> n >> m >> x >> y;
if ((x + y + 1) % 2) {
cout << -1 << endl;
return 0;
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> c[i][j];
init();
{
long long a, b, v;
cin >> a >> b >> v;
a--, b--;
if (x < y) {
x++;
vec.push_back({hhash(a, b), v});
} else
sec.push_back({hhash(a, b), v}), y++;
long long i = 0;
if (vec.size()) i++;
for (; i < x; i++) {
cin >> a >> b >> v;
a--, b--;
vec.push_back({hhash(a, b), v});
}
i = 0;
if (sec.size()) i++;
for (; i < y; i++) {
cin >> a >> b >> v;
a--, b--;
sec.push_back({hhash(a, b), v});
}
}
long long b = 0, e = 1e18, mid, ret = -1;
while (b <= e) {
mid = (b + e) / 2;
put(mid);
if (max_flow(x + y + 2 * n * m, x + y + 2 * n * m + 1) == x) {
e = mid - 1;
ret = mid;
} else
b = mid + 1;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Counter {
static int k;
Counter() { k++; }
~Counter() { k--; }
};
int Counter::k = 0;
template <typename T>
void pr(const string& name, T t) {
cout << name << " = " << t << endl;
}
template <typename T, typename... Types>
void pr(const string& names, T t, Types... rest) {
auto comma_pos = names.find(',');
cout << names.substr(0, comma_pos) << " = " << t << ", ";
auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1);
pr(string(names, next_name_pos), rest...);
}
void mod(long long& a, long long b) {
a %= b;
if (a < 0) a += b;
}
const long long MOD = 1000000007;
int Cap[1005][1005], D[555], H, W, N, K, M, F, Seen[1005], From[1005];
queue<int> Q;
string B;
vector<int> E[1005];
vector<pair<int, int>> MaleDist[555], FemaleDist[555], Males, Females;
void bfs(int st, vector<pair<int, int>>& v) {
for (int i = (0); i <= (N - 1); i++) D[i] = 999;
D[st] = 0;
Q.push(st);
while (!Q.empty()) {
int n = Q.front();
Q.pop();
if (n >= W && D[n - W] > D[n] + 1 && B[n - W] == '.') {
D[n - W] = D[n] + 1;
Q.push(n - W);
}
if (n + W < N && D[n + W] > D[n] + 1 && B[n + W] == '.') {
D[n + W] = D[n] + 1;
Q.push(n + W);
}
if (n % W < W - 1 && D[n + 1] > D[n] + 1 && B[n + 1] == '.') {
D[n + 1] = D[n] + 1;
Q.push(n + 1);
}
if (n % W > 0 && D[n - 1] > D[n] + 1 && B[n - 1] == '.') {
D[n - 1] = D[n] + 1;
Q.push(n - 1);
}
}
for (int i = (0); i <= (N - 1); i++)
if (D[i] < 999) v.push_back({D[i], i});
sort(v.begin(), v.end(), greater<pair<int, int>>());
}
bool ok(long long limit) {
int s = 2 * N + 2 * K;
int t = 2 * N + 2 * K + 1;
for (int i = (0); i <= (t); i++) E[i].clear();
for (int i = (2 * N); i <= (2 * N + K - 1); i++)
E[s].push_back(i), E[i].push_back(s), Cap[s][i] = 1, Cap[i][s] = 0;
for (int i = (0); i <= (N - 1); i++)
E[i].push_back(i + N), E[i + N].push_back(i), Cap[i][i + N] = 1,
Cap[i + N][i] = 0;
for (int i = (2 * N + K); i <= (2 * N + 2 * K - 1); i++)
E[i].push_back(t), E[t].push_back(i), Cap[i][t] = 1, Cap[t][i] = 0;
for (int i = (0); i <= (K - 1); i++) {
long long t = Males[i].second;
for (int p = (((int)MaleDist[i].size()) - 1); p >= (0); p--)
if (t * MaleDist[i][p].first <= limit) {
int n1 = 2 * N + i;
int n2 = MaleDist[i][p].second;
Cap[n1][n2] = 1, Cap[n2][n1] = 0;
E[n1].push_back(n2), E[n2].push_back(n1);
}
}
for (int i = (0); i <= (K - 1); i++) {
long long t = Females[i].second;
for (int p = (((int)FemaleDist[i].size()) - 1); p >= (0); p--)
if (t * FemaleDist[i][p].first <= limit) {
int n1 = N + FemaleDist[i][p].second;
int n2 = 2 * N + K + i;
Cap[n1][n2] = 1, Cap[n2][n1] = 0;
E[n1].push_back(n2), E[n2].push_back(n1);
}
}
for (int i = (0); i <= (t); i++) Seen[i] = -1;
int flow = 0;
while (true) {
Seen[s] = flow;
Q.push(s);
while (!Q.empty()) {
int n = Q.front();
Q.pop();
if (n == t) {
while (!Q.empty()) Q.pop();
break;
}
for (int v : E[n])
if (Cap[n][v] && Seen[v] < flow) {
From[v] = n;
Seen[v] = flow;
Q.push(v);
}
}
if (Seen[t] < flow) break;
int n = t;
while (n != s) {
Cap[From[n]][n]--, Cap[n][From[n]]++;
n = From[n];
}
flow++;
}
return flow == K;
}
int main() {
cin >> H >> W >> M >> F;
N = H * W;
for (int i = (0); i <= (H - 1); i++) {
string s;
cin >> s;
B += s;
}
if (M != F + 1 && M != F - 1) {
cout << "-1";
return 0;
}
int i, j, t;
cin >> i >> j >> t;
i--, j--;
if (M < F)
Males.push_back({i * W + j, t});
else
Females.push_back({i * W + j, t});
K = min(M, F) + 1;
for (int x = (1); x <= (M); x++) {
int i, j, t;
cin >> i >> j >> t;
i--, j--;
Males.push_back({i * W + j, t});
}
for (int x = (1); x <= (F); x++) {
int i, j, t;
cin >> i >> j >> t;
i--, j--;
Females.push_back({i * W + j, t});
}
for (int i = (0); i <= (K - 1); i++) bfs(Males[i].first, MaleDist[i]);
for (int i = (0); i <= (K - 1); i++) bfs(Females[i].first, FemaleDist[i]);
long long a = 0, b = 242000000000;
while (b - a > 1) {
long long p = (a + b) / 2;
if (ok(p))
b = p;
else
a = p;
}
if (ok(a))
cout << a;
else if (ok(b))
cout << b;
else
cout << "-1";
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
class Dinic {
int n, m, head[10009], level[10009], s, t, work[10009];
struct edge {
int v, c, f, nxt;
edge() {}
edge(int v, int c, int f, int nxt) : v(v), c(c), f(f), nxt(nxt) {}
} e[1000009];
bool _bfs() {
static int q[10009];
memset(level, -1, sizeof(int) * n);
int le = 0, ri = 0;
q[ri++] = s;
level[s] = 0;
while (le < ri) {
for (int k = q[le++], i = head[k]; i != -1; i = e[i].nxt) {
if (e[i].f < e[i].c && level[e[i].v] == -1) {
level[e[i].v] = level[k] + 1;
q[ri++] = e[i].v;
}
}
}
return (level[t] != -1);
}
int _dfs(int u, int f) {
if (u == t) return f;
for (int& i = work[u]; i != -1; i = e[i].nxt) {
if (e[i].f < e[i].c && level[u] + 1 == level[e[i].v]) {
int minf = _dfs(e[i].v, min(f, e[i].c - e[i].f));
if (minf > 0) {
e[i].f += minf;
e[i ^ 1].f -= minf;
return minf;
}
}
}
return 0;
}
public:
void init(int nn, int src, int dst) {
n = nn;
s = src;
t = dst;
m = 0;
memset(head, -1, sizeof(int) * n);
}
void addEdge(int u, int v, int c, int rc) {
assert(u < n);
assert(v < n);
e[m] = edge(v, c, 0, head[u]);
head[u] = m++;
e[m] = edge(u, rc, 0, head[v]);
head[v] = m++;
assert(m < 1000009);
}
long long maxFlow() {
long long ret = 0;
while (_bfs()) {
memcpy(work, head, sizeof(int) * n);
while (true) {
int delta = _dfs(s, 1000000009);
if (delta == 0) break;
ret = ret + delta;
}
}
return ret;
}
};
Dinic d;
int n, m, a, b;
const int mn = 30;
string s[mn];
const int ms = 500;
int nm;
long long w[ms][ms];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
pair<int, pair<int, int> > leader;
vector<pair<long long, pair<int, int> > > vm, vw;
bool build(long long lim) {
int u, v, nx, ny;
long long c;
int so = 2 * nm + a + b;
int si = so + 1;
d.init(si + 1, so, si);
for (int i = 0; i < nm; i++) {
d.addEdge(i, nm + i, 1, 0);
}
for (int j = 0; j < a; j++) {
c = vm[j].first;
nx = vm[j].second.first;
ny = vm[j].second.second;
v = nx * m + ny;
d.addEdge(so, 2 * nm + j, 1, 0);
for (int u = 0; u < nm; u++) {
if (w[u][v] >= 1e9) continue;
if (w[u][v] * c > lim) continue;
d.addEdge(2 * nm + j, u, 1, 0);
}
}
for (int j = 0; j < b; j++) {
c = vw[j].first;
nx = vw[j].second.first;
ny = vw[j].second.second;
v = nx * m + ny;
d.addEdge(2 * nm + a + j, si, 1, 0);
for (int u = 0; u < nm; u++) {
if (w[u][v] >= 1e9) continue;
if (w[u][v] * c > lim) continue;
d.addEdge(nm + u, 2 * nm + a + j, 1, 0);
}
}
int res = d.maxFlow();
if (res == a) return 1;
return 0;
}
long long solve() {
long long lo = 0;
long long hi = 1e18;
long long mi;
bool fmi;
if (!build(hi)) return -1;
while (hi - lo > 2) {
mi = (hi + lo) / 2;
fmi = build(mi);
if (fmi) {
hi = mi;
} else {
lo = mi;
}
}
while (1) {
if (build(lo)) return lo;
lo++;
}
}
int main() {
scanf("%d", &(n));
scanf("%d", &(m));
scanf("%d", &(a));
scanf("%d", &(b));
for (int i = 0; i < n; i++) {
cin >> s[i];
}
nm = n * m;
for (int i = 0; i < ms; i++) {
for (int j = 0; j < ms; j++) {
w[i][j] = i == j ? 0 : 1e9;
}
}
int u, v, nx, ny;
long long c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') continue;
u = i * m + j;
for (int k = 0; k < 4; k++) {
nx = i + dx[k];
ny = j + dy[k];
if (!valid(nx, ny) || s[nx][ny] == '#') continue;
v = nx * m + ny;
w[u][v] = 1;
}
}
}
cin >> u >> v >> c;
u--;
v--;
leader = make_pair(c, make_pair(u, v));
for (int i = 0; i < a; i++) {
cin >> u >> v >> c;
u--;
v--;
vm.push_back(make_pair(c, make_pair(u, v)));
}
for (int i = 0; i < b; i++) {
cin >> u >> v >> c;
u--;
v--;
vw.push_back(make_pair(c, make_pair(u, v)));
}
if (a < b) {
vm.push_back(leader);
a++;
} else {
vw.push_back(leader);
b++;
}
if (a != b) {
cout << -1 << endl;
return 0;
}
for (int k = 0; k < nm; k++) {
for (int i = 0; i < nm; i++) {
for (int j = 0; j < nm; j++) {
w[i][j] = min(w[i][j], w[i][k] + w[k][j]);
}
}
}
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 2000 + 5;
const int maxM = 1400 * 1000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 500;
int head[maxN], cap[maxM], nex[maxM], to[maxM], cnt;
void add(int v, int u, int c) {
nex[cnt] = head[v];
cap[cnt] = c;
to[cnt] = u;
head[v] = cnt++;
nex[cnt] = head[u];
cap[cnt] = 0;
to[cnt] = v;
head[u] = cnt++;
}
int h[maxN], itr[maxN];
int source, sink;
int dfs(int v, int flow = mod) {
if (v == sink) return flow;
int ans = 0;
while (itr[v] != -1) {
int e = itr[v];
if (cap[e] == 0 || h[to[e]] != h[v] + 1) {
itr[v] = nex[itr[v]];
continue;
}
int tmp = dfs(to[e], min(cap[e], flow));
cap[e] -= tmp;
cap[e ^ 1] += tmp;
ans += tmp;
flow -= tmp;
if (flow == 0) break;
itr[v] = nex[itr[v]];
}
return ans;
}
int que[maxN];
bool bfs() {
int st = 0, en = 0;
que[en++] = source;
memset(h, 0, sizeof h);
h[source] = 1;
while (st < en) {
int v = que[st++];
for (int e = head[v]; e != -1; e = nex[e])
if (cap[e] && h[to[e]] == 0) {
h[to[e]] = h[v] + 1;
que[en++] = to[e];
}
}
if (h[sink] == 0) return false;
return true;
}
int get_max_flow() {
int res = 0;
while (bfs()) {
memcpy(itr, head, sizeof head);
res += dfs(source);
}
return res;
}
long long dis[2][500][22][22];
char a[22][22];
pair<int, int> q[500];
int n, m;
bool is_ok(int x, int y) {
if (x < 0 || y < 0 || n <= x || m <= y) return false;
return true;
}
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
vector<pair<pair<int, int>, int> > v[2];
bool check(long long t) {
memset(head, -1, sizeof head);
cnt = 0;
source = 0;
sink = 2 * n * m + v[0].size() + v[1].size() + 1;
for (int i = 1; i < (int)v[0].size() + 1; i++) add(source, i, 1);
for (int i = 1; i < (int)v[1].size() + 1; i++)
add(v[0].size() + 2 * n * m + i, sink, 1);
for (int i = 0; i < (int)v[0].size(); i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (dis[0][i][j][k] < 2000 &&
(1LL) * dis[0][i][j][k] * v[0][i].second <= t)
add(i + 1, v[0].size() + 1 + j * m + k, 1);
for (int i = 0; i < (int)v[1].size(); i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (dis[1][i][j][k] < 2000 &&
(1LL) * dis[1][i][j][k] * v[1][i].second <= t)
add(v[0].size() + n * m + 1 + j * m + k,
v[0].size() + 2 * n * m + i + 1, 1);
for (int i = 1; i < n * m + 1; i++)
add(v[0].size() + i, v[0].size() + n * m + i, 1);
int res = get_max_flow();
if (res == (int)v[0].size()) return true;
return false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int male, female;
cin >> n >> m >> male >> female;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int bx, by, bt;
cin >> bx >> by >> bt;
bx--;
by--;
for (int i = 0; i < male; i++) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
v[0].push_back({{x, y}, t});
}
for (int i = 0; i < female; i++) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
v[1].push_back({{x, y}, t});
}
if (v[0].size() > v[1].size())
v[1].push_back({{bx, by}, bt});
else
v[0].push_back({{bx, by}, bt});
if (v[0].size() != v[1].size()) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < (int)v[i].size(); j++) {
int x = v[i][j].first.first, y = v[i][j].first.second;
int st = 0, en = 0;
q[en++] = {x, y};
for (int xx = 0; xx < n; xx++)
for (int yy = 0; yy < m; yy++) dis[i][j][xx][yy] = 2000;
dis[i][j][x][y] = 0;
while (st < en) {
int x0 = q[st].first, y0 = q[st].second;
st++;
for (int k = 0; k < 4; k++) {
int vv = x0 + dx[k], u = y0 + dy[k];
if (is_ok(vv, u) && a[vv][u] == '.' && dis[i][j][vv][u] == 2000) {
dis[i][j][vv][u] = dis[i][j][x0][y0] + 1;
q[en++] = {vv, u};
}
}
}
}
long long lo = -1, hi = 1000LL * mod;
while (hi - lo > 1) {
long long mid = (hi + lo) >> 1;
if (check(mid))
hi = mid;
else
lo = mid;
}
if (hi == 1000LL * mod) {
cout << -1 << endl;
return 0;
}
cout << hi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 1600 + 5;
const int maxM = 1000 * 1000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 500;
int head[maxN], cap[maxM], nex[maxM], to[maxM], cnt;
void add(int v, int u, int c) {
nex[cnt] = head[v];
cap[cnt] = c;
to[cnt] = u;
head[v] = cnt++;
nex[cnt] = head[u];
cap[cnt] = 0;
to[cnt] = v;
head[u] = cnt++;
}
int h[maxN], itr[maxN];
int source, sink;
int dfs(int v, int flow = mod) {
if (v == sink) return flow;
int ans = 0;
while (itr[v] != -1) {
int e = itr[v];
if (cap[e] == 0 || h[to[e]] != h[v] + 1) {
itr[v] = nex[itr[v]];
continue;
}
int tmp = dfs(to[e], min(cap[e], flow));
cap[e] -= tmp;
cap[e ^ 1] += tmp;
ans += tmp;
flow -= tmp;
if (flow == 0) break;
itr[v] = nex[itr[v]];
}
return ans;
}
int que[maxN];
bool bfs() {
int st = 0, en = 0;
que[en++] = source;
memset(h, 0, sizeof h);
h[source] = 1;
while (st < en) {
int v = que[st++];
for (int e = head[v]; e != -1; e = nex[e])
if (cap[e] && h[to[e]] == 0) {
h[to[e]] = h[v] + 1;
que[en++] = to[e];
}
}
if (h[sink] == 0) return false;
return true;
}
int get_max_flow() {
int res = 0;
while (bfs()) {
memcpy(itr, head, sizeof head);
res += dfs(source);
}
return res;
}
long long dis[2][500][22][22];
char a[22][22];
pair<int, int> q[500];
int n, m;
bool is_ok(int x, int y) {
if (x < 0 || y < 0 || n <= x || m <= y) return false;
return true;
}
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
vector<pair<pair<int, int>, int> > v[2];
bool check(long long t) {
memset(head, -1, sizeof head);
cnt = 0;
source = 0;
sink = 2 * n * m + v[0].size() + v[1].size() + 1;
for (int i = 1; i < (int)v[0].size() + 1; i++) add(source, i, 1);
for (int i = 1; i < (int)v[1].size() + 1; i++)
add(v[0].size() + 2 * n * m + i, sink, 1);
for (int i = 0; i < (int)v[0].size(); i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (dis[0][i][j][k] < 2000 &&
(1LL) * dis[0][i][j][k] * v[0][i].second <= t)
add(i + 1, v[0].size() + 1 + j * m + k, 1);
for (int i = 0; i < (int)v[1].size(); i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (dis[1][i][j][k] < 2000 &&
(1LL) * dis[1][i][j][k] * v[1][i].second <= t)
add(v[0].size() + n * m + 1 + j * m + k,
v[0].size() + 2 * n * m + i + 1, 1);
for (int i = 1; i < n * m + 1; i++)
add(v[0].size() + i, v[0].size() + n * m + i, 1);
int res = get_max_flow();
if (res == (int)v[0].size()) return true;
return false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int male, female;
cin >> n >> m >> male >> female;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int bx, by, bt;
cin >> bx >> by >> bt;
bx--;
by--;
for (int i = 0; i < male; i++) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
v[0].push_back({{x, y}, t});
}
for (int i = 0; i < female; i++) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
v[1].push_back({{x, y}, t});
}
if (v[0].size() > v[1].size())
v[1].push_back({{bx, by}, bt});
else
v[0].push_back({{bx, by}, bt});
if (v[0].size() != v[1].size()) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < (int)v[i].size(); j++) {
int x = v[i][j].first.first, y = v[i][j].first.second;
int st = 0, en = 0;
q[en++] = {x, y};
for (int xx = 0; xx < n; xx++)
for (int yy = 0; yy < m; yy++) dis[i][j][xx][yy] = 2000;
dis[i][j][x][y] = 0;
while (st < en) {
int x0 = q[st].first, y0 = q[st].second;
st++;
for (int k = 0; k < 4; k++) {
int vv = x0 + dx[k], u = y0 + dy[k];
if (is_ok(vv, u) && a[vv][u] == '.' && dis[i][j][vv][u] == 2000) {
dis[i][j][vv][u] = dis[i][j][x0][y0] + 1;
q[en++] = {vv, u};
}
}
}
}
long long lo = -1, hi = 1000LL * mod;
while (hi - lo > 1) {
long long mid = (hi + lo) >> 1;
if (check(mid))
hi = mid;
else
lo = mid;
}
if (hi == 1000LL * mod) {
cout << -1 << endl;
return 0;
}
cout << hi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
struct MCMF {
int fst[(2000 + 10)], nxt[(4100000 + 10)], vv[(4100000 + 10)],
from[(4100000 + 10)], cost[(4100000 + 10)], cap[(4100000 + 10)],
flow[(4100000 + 10)], e;
int d[(2000 + 10)], a[(2000 + 10)], p[(2000 + 10)], in[(2000 + 10)];
void init() {
memset(fst, -1, sizeof fst);
e = 0;
}
void add(int u, int v, int c, int d) {
from[e] = u, vv[e] = v, nxt[e] = fst[u], cost[e] = d, cap[e] = c,
flow[e] = 0, fst[u] = e++;
from[e] = v, vv[e] = u, nxt[e] = fst[v], cost[e] = -d, cap[e] = 0,
flow[e] = 0, fst[v] = e++;
}
int spfa(int s, int t, int &mf, int &mc) {
memset(d, 0x3f, sizeof d);
d[s] = p[s] = 0;
a[s] = 0x3f3f3f3f;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
in[u] = 0;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i], c = cost[i];
if (cap[i] > flow[i] && d[v] > d[u] + c) {
d[v] = d[u] + c;
a[v] = min(a[u], cap[i] - flow[i]);
p[v] = i;
if (!in[v]) in[v] = 1, q.push(v);
}
}
}
if (d[t] == 0x3f3f3f3f) return 0;
mf += a[t], mc += a[t] * d[t];
int u = t;
while (u != s) {
flow[p[u]] += a[t];
flow[p[u] ^ 1] -= a[t];
u = from[p[u]];
}
return 1;
}
int gao(int s, int t, int tot) {
int ret = 0, mf = 0, mc = 0;
while (spfa(s, t, mf, mc))
;
if (tot != mf) return -1;
return mc;
}
};
struct dinic {
int fst[(2000 + 10)], vv[(4100000 + 10)], nxt[(4100000 + 10)], e,
cap[(4100000 + 10)], flow[(4100000 + 10)];
int s, t;
int d[(2000 + 10)], cur[(2000 + 10)];
void init() {
memset(fst, -1, sizeof fst);
e = 0;
}
void add(int u, int v, int w) {
vv[e] = v, nxt[e] = fst[u], cap[e] = w, flow[e] = 0, fst[u] = e++;
vv[e] = u, nxt[e] = fst[v], cap[e] = 0, flow[e] = 0, fst[v] = e++;
}
bool bfs() {
queue<int> que;
memset(d, -1, sizeof d);
que.push(s);
d[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (d[v] == -1 && cap[i] > flow[i]) {
d[v] = d[u] + 1;
que.push(v);
}
}
}
return d[t] != -1;
}
int dfs(int u, int a) {
if (u == t || a == 0) return a;
int f, ret = 0;
for (int &i = cur[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (d[v] == d[u] + 1 && (f = dfs(v, min(cap[i] - flow[i], a))) > 0) {
ret += f;
a -= f;
flow[i] += f;
flow[i ^ 1] -= f;
if (a == 0) break;
}
}
return ret;
}
int gao(int S, int T) {
s = S, t = T;
int ans = 0;
while (bfs()) {
memcpy(cur, fst, sizeof fst);
ans += dfs(s, 0x3f3f3f3f);
}
return ans;
}
} go;
int r, c, ma, fe;
int k;
int base;
char s[25][25];
long long disa[500][25][25], disb[500][25][25];
struct node {
int x, y, t;
int id;
void input() {
scanf("%d%d%d", &x, &y, &t);
--x, --y;
}
} a[(2000 + 10)], b[(2000 + 10)], tmp;
int get(int x, int y) { return x * c + y; }
bool check(long long mid) {
go.init();
int s = r * c * 2 + 1 + 2 * k, t = s + 1;
for (int i = 0; i < k; ++i) {
go.add(s, a[i].id, 1);
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y)
if (disa[i][x][y] <= mid) go.add(a[i].id, get(x, y), 1);
go.add(b[i].id, t, 1);
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y)
if (disb[i][x][y] <= mid) go.add(get(x, y) + base, b[i].id, 1);
}
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j) {
go.add(get(i, j), get(i, j) + base, 1);
}
int res = go.gao(s, t);
return res == k;
}
int que[(4100000 + 10)];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool out(int x, int y) { return x < 0 || x >= r || y < 0 || y >= c; }
void bfs(long long dis[25][25], int x, int y, int t) {
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j) dis[i][j] = (long long)1e16;
int head = 0, tail = 0;
que[tail++] = x, que[tail++] = y;
dis[x][y] = 0;
while (head < tail) {
x = que[head++], y = que[head++];
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (out(nx, ny) || s[nx][ny] == '#') continue;
if (dis[nx][ny] > dis[x][y] + t) {
dis[nx][ny] = dis[x][y] + t;
que[tail++] = nx, que[tail++] = ny;
}
}
}
}
int main() {
scanf("%d%d%d%d", &r, &c, &ma, &fe);
if (abs(ma - fe) != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < r; ++i) scanf("%s", s[i]);
k = max(ma, fe);
base = r * c;
tmp.input();
for (int i = 0; i < ma; ++i) a[i].input();
for (int i = 0; i < fe; ++i) b[i].input();
if (ma < k)
a[ma] = tmp;
else
b[fe] = tmp;
int tid = r * c * 2;
for (int i = 0; i < k; ++i) a[i].id = tid++, b[i].id = tid++;
for (int i = 0; i < k; ++i)
bfs(disa[i], a[i].x, a[i].y, a[i].t), bfs(disb[i], b[i].x, b[i].y, b[i].t);
long long l = 0, r = 1e15;
while (l < r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == (long long)1e15)
puts("-1");
else
printf("%I64d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
const int V = N * N * 4 + 7;
const int E = V * N * N;
const int INF = 1e9 + 7;
int from[E], to[E], cap[E], prv[E];
int head[V], ptr[V], ecnt;
int d[V], q[V];
string s[N];
int r[V], c[V], t[V];
int dr[] = {1, -1, 0, 0};
int dc[] = {0, 0, 1, -1};
int dis[N][N][N][N];
int n, m, M, F;
void add_edge(int u, int v, int uv, int vu = 0) {
from[ecnt] = u, to[ecnt] = v, cap[ecnt] = uv, prv[ecnt] = head[u],
head[u] = ecnt++;
from[ecnt] = v, to[ecnt] = u, cap[ecnt] = vu, prv[ecnt] = head[v],
head[v] = ecnt++;
}
bool bfs(int source, int sink) {
memset(d, 63, sizeof d);
d[source] = 0;
int h = 0, t = 0;
q[t++] = source;
while (h < t) {
int v = q[h++];
for (int i = head[v]; i != -1; i = prv[i])
if (cap[i] && d[to[i]] > d[v] + 1) {
d[to[i]] = d[v] + 1;
q[t++] = to[i];
}
}
return d[sink] <= 1e9;
}
int dfs(int v, int sink, int f = INF) {
if (v == sink) return f;
int out = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]])
if (d[to[ptr[v]]] == d[v] + 1) {
int x = dfs(to[ptr[v]], sink, min(f, cap[ptr[v]]));
cap[ptr[v]] -= x;
cap[ptr[v] ^ 1] += x;
out += x;
f -= x;
if (f == 0) break;
}
return out;
}
int maxflow(int source, int sink) {
int out = 0;
while (bfs(source, sink)) {
memcpy(ptr, head, sizeof head);
out += dfs(source, sink);
}
return out;
}
bool valid(int r, int c) {
return r >= 0 && r < n && c >= 0 && c < m && s[r][c] == '.';
}
void floyd() {
memset(dis, 63, sizeof dis);
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++)
if (valid(r, c)) {
dis[r][c][r][c] = 0;
for (int i = 0; i < 4; i++) {
int R = r + dr[i];
int C = c + dc[i];
if (valid(R, C)) dis[r][c][R][C] = 1;
}
}
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++)
if (valid(r, c))
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (valid(i, j))
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (valid(x, y))
dis[i][j][x][y] =
min(dis[i][j][x][y], dis[i][j][r][c] + dis[r][c][x][y]);
}
bool isaac(long long k) {
int source = V - 1, sink = V - 2;
memset(head, -1, sizeof head);
ecnt = 0;
for (int i = 0; i < F + M; i++) {
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (valid(x, y) && dis[r[i]][c[i]][x][y] <= 1e9 &&
1LL * dis[r[i]][c[i]][x][y] * t[i] <= k) {
if (i < M)
add_edge(i, F + M + 2 * (x * m + y), 1);
else
add_edge(F + M + ((2 * (x * m + y)) ^ 1), i, 1);
}
if (i < M)
add_edge(source, i, 1);
else
add_edge(i, sink, 1);
}
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
add_edge(F + M + 2 * (x * m + y), F + M + ((2 * (x * m + y)) ^ 1), 1);
return maxflow(source, sink) == M;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> M >> F;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < M + F + 1; i++) {
cin >> r[i] >> c[i] >> t[i];
r[i]--, c[i]--;
}
if (M == F + 1) {
swap(r[0], r[M]);
swap(c[0], c[M]);
swap(t[0], t[M]);
F++;
} else if (F == M + 1)
M++;
else {
cout << "-1\n";
return 0;
}
floyd();
long long lb = -1, ub = 1e12;
while (ub - lb > 1) {
long long mid = (lb + ub) / 2;
if (isaac(mid))
ub = mid;
else
lb = mid;
}
cout << (ub < 1e12 ? ub : -1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int xi[4] = {0, 0, -1, 1};
const int yi[4] = {-1, 1, 0, 0};
int i, j, m, n, p, k, tot, id[33][33], st, ed, male, famale, x, y, z,
id_[33][33];
int fox[3005], que[3005], dis[3005], k1 = 1, Dis[33][33], Vis[33][33];
struct Queue {
int x, y;
} Q[5555];
char c[33][33];
struct Time {
int x, y, t;
} M[1000];
Time F[1000];
struct Node {
int ed, before, flow;
} s[200001];
inline int bfs() {
int i, j, p, k, l, r;
memset(dis, -1, sizeof(dis));
l = r = 1;
dis[st] = 0;
que[1] = st;
while (l <= r) {
p = que[l];
for (i = fox[p]; i; i = s[i].before)
if (s[i].flow > 0)
if (dis[s[i].ed] == -1) {
que[++r] = s[i].ed;
dis[s[i].ed] = dis[p] + 1;
}
l++;
}
if (dis[ed] == -1) return 0;
return 1;
}
void add(int p1, int p2, int p3) {
s[++k1].ed = p2;
s[k1].flow = p3;
s[k1].before = fox[p1];
fox[p1] = k1;
s[++k1].ed = p1;
s[k1].flow = 0;
s[k1].before = fox[p2];
fox[p2] = k1;
}
int dfs(int num, int flow) {
int i, p;
int a, nowans = 0;
if (num == ed) return flow;
for (i = fox[num]; i && flow; i = s[i].before)
if (s[i].flow > 0 && dis[s[i].ed] == dis[num] + 1)
if (a = dfs(s[i].ed, min(s[i].flow, flow))) {
s[i].flow -= a;
s[i ^ 1].flow += a;
flow -= a;
nowans += a;
}
if (!nowans) dis[num] = (int)1e9;
return nowans;
}
int maxflow() {
int i, j;
int ans = 0;
while (bfs()) {
j = dfs(st, (int)1e9);
while (j) ans += j, j = dfs(st, (int)1e9);
}
return ans;
}
void bfs(int x, int y) {
int l = 1, r = 1, i, j, X, Y;
Q[1].x = x;
Q[1].y = y;
memset(Dis, 60, sizeof(Dis));
Dis[x][y] = 0;
for (; l <= r; l++) {
X = Q[l].x;
Y = Q[l].y;
for (i = 0; i < 4; i++)
if (X + xi[i] > 0 && Y + yi[i] > 0 && X + xi[i] <= n && Y + yi[i] <= m &&
Dis[X + xi[i]][Y + yi[i]] > (int)1e9 &&
c[X + xi[i]][Y + yi[i] - 1] != '#') {
Dis[X + xi[i]][Y + yi[i]] = Dis[X][Y] + 1;
Q[++r].x = X + xi[i];
Q[r].y = Y + yi[i];
}
}
}
bool check(long long x) {
int i, j, p, k;
memset(fox, 0, sizeof(fox));
k1 = 1;
for (i = 1; i <= male; i++) add(st, i, 1);
for (i = 1; i <= famale; i++) add(male + i, ed, 1);
for (i = 1; i <= male; i++) {
bfs(M[i].x, M[i].y);
for (j = 1; j <= n; j++)
for (k = 1; k <= m; k++)
if (Dis[j][k] < 10000 && (long long)1ll * Dis[j][k] * M[i].t <= x)
add(i, id[j][k], 1);
}
for (i = 1; i <= famale; i++) {
bfs(F[i].x, F[i].y);
for (j = 1; j <= n; j++)
for (k = 1; k <= m; k++)
if (Dis[j][k] < 10000 && (long long)1ll * Dis[j][k] * F[i].t <= x)
add(id_[j][k], i + male, 1);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) add(id[i][j], id_[i][j], 1);
if (maxflow() == male) return 1;
return 0;
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &famale);
if (abs(male - famale) != 1) {
printf("-1\n");
return 0;
}
for (i = 1; i <= n; i++) scanf("%s", &c[i]);
tot = 2 * max(male, famale);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) id[i][j] = ++tot;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) id_[i][j] = ++tot;
st = tot + 1;
ed = st + 1;
scanf("%d%d%d", &x, &y, &z);
for (i = 1; i <= male; i++) scanf("%d%d%d", &M[i].x, &M[i].y, &M[i].t);
for (i = 1; i <= famale; i++) scanf("%d%d%d", &F[i].x, &F[i].y, &F[i].t);
if (male < famale)
male++, M[male].x = x, M[male].y = y, M[male].t = z;
else
famale++, F[famale].x = x, F[famale].y = y, F[famale].t = z;
long long l = 0, r = (long long)1e15, mid = 0;
for (; (l + r) >> 1 != mid;) {
mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
if (r == (long long)1e15)
printf("-1\n");
else
printf("%I64d\n", r);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long l;
int e, n;
} e[2000020 << 1];
int hd[2000020], cur[2000020], cnt = 1;
void add(int a, int b, long long l) {
e[++cnt].e = b;
e[cnt].l = l;
e[cnt].n = hd[a];
hd[a] = cnt;
e[++cnt].e = a;
e[cnt].l = 0;
e[cnt].n = hd[b];
hd[b] = cnt;
}
long long inf = 1e15;
int n, m, s, t;
int dep[2000020];
queue<int> Q;
long long dfs(int p, long long flow) {
if (p == t) return flow;
int i;
for (i = cur[p]; i; i = e[i].n) {
int q = e[i].e;
cur[p] = i;
if (dep[q] > dep[p] && e[i].l) {
long long ans = dfs(q, min(flow, e[i].l));
if (ans) {
e[i].l -= ans;
e[i ^ 1].l += ans;
return ans;
}
}
}
return 0;
}
int bfs() {
memset(dep, 0, sizeof(dep));
Q.push(s);
dep[s] = 1;
int i;
while (!Q.empty()) {
int p = Q.front();
Q.pop();
for (i = hd[p]; i; i = e[i].n) {
int q = e[i].e;
if (!dep[q] && e[i].l) dep[q] = dep[p] + 1, Q.push(q);
}
}
return dep[t];
}
long long dinic() {
int i;
long long d, ans = 0;
while (bfs()) {
for (i = 0; i <= t; i++) cur[i] = hd[i];
while ((d = dfs(s, inf))) ans += d;
}
return ans;
}
char a[25][25];
int sign[25][25];
struct Per {
int x, y;
long long v;
} boy[2000020], gir[2000020];
int boyn, girn;
struct QUEUE {
int x, y;
long long time;
};
int vis[25][25];
int num;
int in(int flag, int NUM, int x, int y) {
if (!vis[x][y] && x >= 0 && y >= 0 && x < n && y < m && a[x][y] == '.') {
vis[x][y] = 1;
if (flag)
add(NUM, sign[x][y] + boyn + girn, 1);
else
add(sign[x][y] + boyn + girn + num, NUM, 1);
return 1;
}
return 0;
}
int jud(long long tim) {
int i, j;
int now = 0;
memset(hd, 0, sizeof(hd));
cnt = 1;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] == '.') {
sign[i][j] = ++now;
add(boyn + girn + now, boyn + girn + num + now, 1);
}
for (i = 0; i < boyn; i++) add(s, i + 1, 1);
for (i = 0; i < girn; i++) add(i + 1 + boyn, t, 1);
for (i = 0; i < boyn; i++) {
int p = i + 1;
memset(vis, 0, sizeof(vis));
queue<QUEUE> Q;
while (!Q.empty()) Q.pop();
in(1, p, boy[i].x - 1, boy[i].y - 1);
Q.push({boy[i].x - 1, boy[i].y - 1, 0});
while (!Q.empty()) {
int x = Q.front().x, y = Q.front().y;
long long t = Q.front().time;
Q.pop();
if (t + boy[i].v > tim) break;
if (in(1, p, x + 1, y)) Q.push({x + 1, y, t + boy[i].v});
if (in(1, p, x - 1, y)) Q.push({x - 1, y, t + boy[i].v});
if (in(1, p, x, y + 1)) Q.push({x, y + 1, t + boy[i].v});
if (in(1, p, x, y - 1)) Q.push({x, y - 1, t + boy[i].v});
}
}
for (i = 0; i < girn; i++) {
int p = i + 1 + boyn;
memset(vis, 0, sizeof(vis));
queue<QUEUE> Q;
while (!Q.empty()) Q.pop();
in(0, p, gir[i].x - 1, gir[i].y - 1);
Q.push({gir[i].x - 1, gir[i].y - 1, 0});
while (!Q.empty()) {
int x = Q.front().x, y = Q.front().y;
long long t = Q.front().time;
Q.pop();
if (t + gir[i].v > tim) break;
if (in(0, p, x + 1, y)) Q.push({x + 1, y, t + gir[i].v});
if (in(0, p, x - 1, y)) Q.push({x - 1, y, t + gir[i].v});
if (in(0, p, x, y + 1)) Q.push({x, y + 1, t + gir[i].v});
if (in(0, p, x, y - 1)) Q.push({x, y - 1, t + gir[i].v});
}
}
return dinic() == (boyn + girn) / 2;
}
int main() {
int i, j, u, v, girnum = 0, boynum = 0;
scanf("%d%d%d%d", &n, &m, &boyn, &girn);
for (i = 0; i < n; i++) {
scanf("%s", a[i]);
for (j = 0; j < m; j++)
if (a[i][j] == '.') num++;
}
if (num < (boyn + girn + 1) / 2 || (boyn - girn != 1 && girn - boyn != 1))
return printf("-1"), 0;
long long l = 0, r = 1e18, ans = 1e18;
if (boyn - girn == 1)
scanf("%d%d%I64d", &gir[girnum].x, &gir[girnum].y, &gir[girnum].v),
girnum++, girn++;
else
scanf("%d%d%I64d", &boy[boynum].x, &boy[boynum].y, &boy[boynum].v),
boynum++, boyn++;
while (boynum < boyn)
scanf("%d%d%I64d", &boy[boynum].x, &boy[boynum].y, &boy[boynum].v),
boynum++;
while (girnum < girn)
scanf("%d%d%I64d", &gir[girnum].x, &gir[girnum].y, &gir[girnum].v),
girnum++;
s = 0;
t = boyn + girn + num * 2 + 2;
while (l <= r) {
long long mid = (l + r) >> 1;
if (jud(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%I64d", ans < 1e18 ? ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cap[1000000], flow[1000000];
int to[1000000], _prev[1000000], last[10000], used[10000], level[10000];
struct MaxFlow {
int V, E;
MaxFlow(int n) {
int i;
V = n;
E = 0;
for ((i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
}
void add_edge(int x, int y, int 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 ((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);
}
int dfs(int v, int t, int 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]) {
int 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;
}
int maxflow(int s, int t) {
int i;
while (bfs(s, t)) {
for ((i) = 0; (i) < (int)(V); (i)++) used[i] = last[i];
while (dfs(s, t, (1 << 29)) != 0)
;
}
int ans = 0;
for (i = last[s]; i >= 0; i = _prev[i]) ans += flow[i];
return ans;
}
};
const int MAXSIZE = 25;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int n, m, male, female;
char graph[MAXSIZE][MAXSIZE];
int br, bc, bt;
int mr[MAXSIZE * MAXSIZE], mc[MAXSIZE * MAXSIZE], mt[MAXSIZE * MAXSIZE];
int fr[MAXSIZE * MAXSIZE], fc[MAXSIZE * MAXSIZE], ft[MAXSIZE * MAXSIZE];
int dis[MAXSIZE][MAXSIZE][MAXSIZE][MAXSIZE];
queue<int> Q;
void bfs(int x, int y) {
int i;
if (graph[x][y] == '#') {
return;
}
dis[x][y][x][y] = 0;
Q.push(x), Q.push(y);
while (!Q.empty()) {
int nx = Q.front();
Q.pop();
int ny = Q.front();
Q.pop();
for ((i) = 0; (i) < (int)(4); (i)++) {
int tx = nx + dx[i];
int ty = ny + dy[i];
if (0 <= tx && tx < n && 0 <= ty && ty < m && dis[x][y][tx][ty] < 0 &&
graph[tx][ty] == '.') {
dis[x][y][tx][ty] = dis[x][y][nx][ny] + 1;
Q.push(tx), Q.push(ty);
}
}
}
}
bool check(long long val) {
int i, j, k;
MaxFlow mf(2 * male + 2 * n * m + 2);
int V = 2 * male + 2 * n * m + 2;
for ((i) = 0; (i) < (int)(male); (i)++) mf.add_edge(V - 2, i, 1);
for ((i) = 0; (i) < (int)(n * m); (i)++)
mf.add_edge(male + i, male + n * m + i, 1);
for ((i) = 0; (i) < (int)(male); (i)++)
mf.add_edge(male + 2 * n * m + i, V - 1, 1);
for ((i) = 0; (i) < (int)(n); (i)++) {
for ((j) = 0; (j) < (int)(m); (j)++) {
if (graph[i][j] == '#') continue;
for ((k) = 0; (k) < (int)(male); (k)++) {
int d1 = dis[mr[k]][mc[k]][i][j];
if (d1 >= 0 && 1ll * mt[k] * d1 <= val) {
mf.add_edge(k, male + i * m + j, 1);
}
int d2 = dis[fr[k]][fc[k]][i][j];
if (d2 >= 0 && 1ll * ft[k] * d2 <= val) {
mf.add_edge(male + n * m + i * m + j, male + 2 * n * m + k, 1);
}
}
}
}
int flow = mf.maxflow(V - 2, V - 1);
return (flow == male);
}
int MAIN() {
int i, j;
scanf("%d%d%d%d", &n, &m, &male, &female);
for ((i) = 0; (i) < (int)(n); (i)++) scanf("%s", graph[i]);
scanf("%d%d%d", &br, &bc, &bt);
br--, bc--;
for ((i) = 0; (i) < (int)(male); (i)++)
scanf("%d%d%d", &mr[i], &mc[i], &mt[i]);
for ((i) = 0; (i) < (int)(female); (i)++)
scanf("%d%d%d", &fr[i], &fc[i], &ft[i]);
for ((i) = 0; (i) < (int)(male); (i)++) {
mr[i]--, mc[i]--;
}
for ((i) = 0; (i) < (int)(female); (i)++) {
fr[i]--, fc[i]--;
}
if (abs(male - female) != 1) {
printf("-1\n");
return 0;
}
if (male < female) {
mr[male] = br, mc[male] = bc, mt[male++] = bt;
} else {
fr[female] = br, fc[female] = bc, ft[female++] = bt;
}
memset(dis, -1, sizeof(dis));
for ((i) = 0; (i) < (int)(n); (i)++) {
for ((j) = 0; (j) < (int)(m); (j)++) bfs(i, j);
}
long long l = 0, r = (long long)1e12;
while (l < r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == (long long)1e12) {
printf("-1\n");
} else {
printf("%lld\n", l);
}
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, mel, fel;
int dis[1005][505];
char mp[25][25];
struct Node {
int x, y, vi;
} a[1005];
int dir[][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int tot, head[3010];
struct Edge {
int to, w, next;
} edge[2000005];
int id[2][25][25];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w) {
edge[tot].to = v;
edge[tot].w = w;
edge[tot].next = head[u];
head[u] = tot++;
edge[tot].to = u;
edge[tot].w = 0;
edge[tot].next = head[v];
head[v] = tot++;
}
void get_bfs(int k) {
queue<Node> Q;
Node u, v;
u.x = a[k].x;
u.y = a[k].y;
u.vi = 0;
dis[k][(u.x - 1) * m + u.y] = 0;
Q.push(u);
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int x = u.x + dir[i][0];
int y = u.y + dir[i][1];
if (x < 1 || x > n || y < 1 || y > m || mp[x][y] == '#' ||
dis[k][(x - 1) * m + y] != -1)
continue;
dis[k][(x - 1) * m + y] = u.vi + 1;
v.x = x;
v.y = y;
v.vi = u.vi + 1;
Q.push(v);
}
}
}
int st, ed;
int d[3010], cur[3010], gap[3010];
void BFS() {
memset(gap, 0, sizeof(gap));
memset(d, -1, sizeof(d));
gap[d[ed] = 0]++;
for (int i = st; i <= ed; i++) cur[i] = head[i];
queue<int> Q;
Q.push(ed);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = head[x]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (d[v] == -1) {
gap[d[v] = d[x] + 1]++;
Q.push(v);
}
}
}
}
int DFS(int x, int w) {
if (x == ed || w == 0) return w;
int f, ret = 0;
for (int &i = cur[x]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (d[x] == d[v] + 1 && (f = DFS(v, min(w, edge[i].w)))) {
edge[i].w -= f;
edge[i ^ 1].w += f;
ret += f;
w -= f;
if (!w) return ret;
}
}
if (!(--gap[d[x]])) d[st] = ed;
gap[++d[x]]++;
cur[x] = head[x];
return ret;
}
int ISAP() {
BFS();
int flow = 0;
while (d[st] < ed) {
flow += DFS(st, INF);
}
return flow;
}
void build(long long x) {
init();
st = 0, ed = 1 + mel + fel + 2 * n * m + 10;
for (int i = 1; i <= mel; i++) addedge(st, 1 + i, 1);
for (int i = 1; i <= fel; i++) addedge(1 + mel + i, ed, 1);
if (mel < fel)
addedge(st, 1, 1);
else
addedge(1, ed, 1);
for (int i = 2; i <= mel + 1; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (dis[i][(j - 1) * m + k] == -1) continue;
if ((long long)dis[i][(j - 1) * m + k] * a[i].vi <= x)
addedge(i, id[0][j][k], 1);
}
}
}
for (int i = mel + 2; i <= 1 + mel + fel; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (dis[i][(j - 1) * m + k] == -1) continue;
if ((long long)dis[i][(j - 1) * m + k] * a[i].vi <= x)
addedge(id[1][j][k], i, 1);
}
}
}
if (mel < fel) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (dis[1][(j - 1) * m + k] == -1) continue;
if ((long long)dis[1][(j - 1) * m + k] * a[1].vi <= x)
addedge(1, id[0][j][k], 1);
}
}
} else {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
if (dis[1][(j - 1) * m + k] == -1) continue;
if ((long long)dis[1][(j - 1) * m + k] * a[1].vi <= x)
addedge(id[1][j][k], 1, 1);
}
}
}
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
addedge(id[0][j][k], id[1][j][k], 1);
}
}
}
bool ok(long long x) {
build(x);
int sum = (1 + mel + fel) / 2;
if (sum == ISAP())
return true;
else
return false;
}
void work() {
memset(dis, -1, sizeof(dis));
for (int i = 1; i <= mel + fel + 1; i++) get_bfs(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
id[0][i][j] = 1 + mel + fel + (i - 1) * m + j;
id[1][i][j] = 1 + mel + fel + n * m + (i - 1) * m + j;
}
}
long long ans = -1, l = 0, r = 1e12;
while (l <= r) {
long long mid = (l + r) >> 1;
if (ok(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%lld\n", ans);
}
int main() {
scanf("%d%d%d%d", &n, &m, &mel, &fel);
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
for (int i = 1; i <= mel + fel + 1; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].vi);
}
if (min(fel, mel) + 1 == max(fel, mel))
work();
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
struct P {
int from, to, flow, cap;
};
struct Dinic {
vector<P> edge;
vector<int> v[maxn];
int n, st, ed;
void init(int Max) {
n = Max;
for (int i = 0; i <= n; i++) v[i].clear();
edge.clear();
}
void add_edge(int from, int to, int cap) {
edge.push_back((P){from, to, 0, cap});
edge.push_back((P){to, from, 0, 0});
int m = edge.size();
v[from].push_back(m - 2);
v[to].push_back(m - 1);
}
bool vis[maxn];
int d[maxn];
bool BFS() {
fill(vis, vis + n + 1, 0);
queue<int> q;
d[st] = 0;
q.push(st);
vis[st] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto i : v[u]) {
P &e = edge[i];
if (!vis[e.to] && e.cap > e.flow) {
vis[e.to] = 1;
d[e.to] = d[u] + 1;
q.push(e.to);
}
}
}
return vis[ed];
}
int cur[maxn];
int DFS(int x, int a) {
if (x == ed || a == 0) return a;
int Flow = 0, f;
for (int &i = cur[x]; i < v[x].size(); i++) {
P &e = edge[v[x][i]];
if (d[e.to] == d[x] + 1 && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
Flow += f;
e.flow += f;
edge[v[x][i] ^ 1].flow -= f;
a -= f;
if (a == 0) break;
}
}
return Flow;
}
int MaxFlow(int st, int ed) {
this->st = st;
this->ed = ed;
int Flow = 0;
while (BFS()) {
fill(cur, cur + n + 1, 0);
Flow += DFS(st, 1000000000);
}
return Flow;
}
} dinic;
struct Scay {
int x, y, t;
void scan() {
scanf("%d%d%d", &x, &y, &t);
x--;
y--;
}
} a[maxn], b[maxn];
char G[25][25];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int n, m;
void BFS(int st, int *d) {
fill(d, d + n * m, 1000000000);
queue<int> q;
q.push(st);
d[st] = 0;
while (!q.empty()) {
int u = q.front(), x = u / m, y = u % m;
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (G[nx][ny] == '#' || d[nx * m + ny] != 1000000000) continue;
d[nx * m + ny] = d[u] + 1;
q.push(nx * m + ny);
}
}
}
struct Q {
int x, y;
long long val;
bool operator<(const Q &rhs) const { return val < rhs.val; }
};
vector<Q> E;
int d[maxn][maxn];
int gx[maxn], gy[maxn];
int main() {
int p, q;
scanf("%d%d%d%d", &n, &m, &p, &q);
if (p != q + 1 && q != p + 1) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) scanf("%s", G[i]);
int k = max(p, q);
for (int i = 1; i <= k; i++) a[i].scan();
for (int i = 1; i <= k; i++) b[i].scan();
if (p > q) swap(a[1], b[1]);
int num = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (G[i][j] == '.')
num++, gx[num] = i, gy[num] = j, BFS(i * m + j, d[i * m + j]);
int source = 2 * k + 2 * num + 1, sink = 2 * k + 2 * num + 2;
for (int i = 1; i <= num; i++) E.push_back((Q){k + i, k + num + i, -1});
for (int i = 1; i <= k; i++)
E.push_back((Q){source, i, -1}),
E.push_back((Q){k + 2 * num + i, sink, -1});
for (int i = 1; i <= k; i++)
for (int j = 1; j <= num; j++) {
int x = m * a[i].x + a[i].y, y = m * gx[j] + gy[j];
if (d[x][y] != 1000000000)
E.push_back((Q){i, k + j, (long long)d[x][y] * a[i].t});
x = m * b[i].x + b[i].y;
if (d[x][y] != 1000000000)
E.push_back(
(Q){k + num + j, k + 2 * num + i, (long long)d[x][y] * b[i].t});
}
sort(E.begin(), E.end());
int l = num + 2 * k - 2, r = E.size();
while (r - l > 1) {
int mid = (r + l) / 2;
dinic.init(2 * k + 2 * num + 2);
for (int i = 0; i <= mid; i++) dinic.add_edge(E[i].x, E[i].y, 1);
if (dinic.MaxFlow(source, sink) == k)
r = mid;
else
l = mid;
}
printf("%I64d\n", r == E.size() ? -1 : E[r].val);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
long long in() {
char c;
bool g = false;
while (c = getchar(), c < '0' || c > '9')
if (c == '-')
g = true;
else
g = false;
long long x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return g ? -x : x;
}
void out(long long x) {
long long len = 0, data[20];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
if (data[0] != abs(data[0])) putchar('-');
while (len--) putchar(abs(data[len]) + 48);
putchar('\n');
}
void out(string s) {
long long len = 0;
while (len++ < s.size()) putchar(s[len - 1]);
putchar('\n');
}
const long long N = 1001000;
long long src = 2019, snk = 2020, ecnt, n, m, ml, fml;
char c[1010][1010];
long long from[N], to[N], cap[N], prv[N], head[N], ptr[N];
bool vis[1010][1010];
vector<pair<pair<long long, long long>, pair<long long, long long> > > v;
void add(long long v, long long u, long long vu, long long uv) {
from[ecnt] = v, to[ecnt] = u, cap[ecnt] = vu, prv[ecnt] = head[v],
head[v] = ecnt++;
from[ecnt] = u, to[ecnt] = v, cap[ecnt] = uv, prv[ecnt] = head[u],
head[u] = ecnt++;
}
long long q[N], d[N];
bool bfs() {
for (long long i = 0; i < N; i++) d[i] = INF;
for (int i = 0; i < N; i++) ptr[i] = head[i];
d[src] = 0;
long long bg = 0, ed = 0;
q[ed++] = src;
while (ed > bg) {
long long v = q[bg++];
for (long long i = head[v]; i != -1; i = prv[i])
if (cap[i] && d[to[i]] > d[v] + 1) {
d[to[i]] = d[v] + 1;
q[ed++] = to[i];
}
}
return (d[snk] < INF);
}
long long dfs(long long v = src, long long c = 1e18) {
if (v == snk || !c) return c;
long long ans = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]])
if (d[to[ptr[v]]] == d[v] + 1) {
long long k = dfs(to[ptr[v]], min(c, cap[ptr[v]]));
ans += k;
cap[ptr[v]] -= k;
cap[ptr[v] ^ 1] += k;
c -= k;
if (!c) break;
}
return ans;
}
long long flw() {
long long mx = 0;
while (bfs()) mx += dfs();
return mx;
}
pair<pair<pair<long long, long long>, pair<long long, bool> >, long long> qq[N];
void okbfs(pair<pair<long long, long long>, pair<long long, bool> > v,
long long p, long long d) {
long long bg = 0, ed = 0;
qq[ed++] = {v, d};
while (ed > bg) {
pair<pair<long long, long long>, pair<long long, bool> > u = qq[bg].first;
long long dis = qq[bg++].second;
if (u.first.first < 0 || u.first.second < 0 || u.first.first >= n ||
u.first.second >= m || dis < 0 ||
c[u.first.first][u.first.second] == '#' ||
vis[u.first.first][u.first.second])
continue;
vis[u.first.first][u.first.second] = true;
add(u.second.second ? u.first.first * m + u.first.second + n * m : p,
u.second.second ? p : u.first.first * m + u.first.second, 0, 1);
u.first.first++;
qq[ed++] = {u, dis - u.second.first};
u.first.first -= 2;
qq[ed++] = {u, dis - u.second.first};
u.first.first++;
u.first.second++;
qq[ed++] = {u, dis - u.second.first};
u.first.second -= 2;
qq[ed++] = {u, dis - u.second.first};
u.first.second++;
}
}
int main() {
n = in(), m = in(), ml = in(), fml = in();
if (abs(ml - fml) - 1) return out(-1), 0;
for (int i = 0; i < n; i++, getchar())
for (int j = 0; j < m; j++) c[i][j] = getchar();
int r = in(), c = in(), t = in();
if (fml < ml)
v.push_back({{r - 1, c - 1}, {t, 0}});
else
v.push_back({{r - 1, c - 1}, {t, 1}});
for (long long i = 0; i < ml; i++) {
r = in();
c = in();
t = in();
v.push_back({{r - 1, c - 1}, {t, 1}});
}
for (long long i = 0; i < fml; i++) {
r = in();
c = in();
t = in();
v.push_back({{r - 1, c - 1}, {t, 0}});
}
long long lr = -1, rr = 5e11;
while (rr - lr > 1) {
ecnt = 0;
memset(head, -1, sizeof(head));
for (int i = 0; i < n * m; i++) add(i, i + n * m, 0, 1);
long long mid = (lr + rr) / 2;
for (long long i = 0; i < v.size(); i++) {
for (int i = 0; i < 33; i++)
for (int j = 0; j < 33; j++) vis[i][j] = false;
okbfs(v[i], 2 * n * m + i, mid);
add(v[i].second.second ? src : 2 * n * m + i,
v[i].second.second ? 2 * n * m + i : snk, 1, 0);
}
if (flw() - (ml + fml + 1) / 2)
lr = mid;
else
rr = mid;
}
if (rr == 5e11)
out(-1);
else
out(rr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t, X[1010], Y[1010], Z[1010], dis[50][50][50][50],
dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
char g[50][50];
queue<pair<int, int> > q;
void bfs(int xx, int yy) {
dis[xx][yy][xx][yy] = 0, q.push(make_pair(xx, yy));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
if (x + dx[i] > n || y + dy[i] > m || x + dx[i] < 1 || y + dy[i] < 1 ||
g[x + dx[i]][y + dy[i]] == '#' ||
dis[xx][yy][x + dx[i]][y + dy[i]] != -1)
continue;
dis[xx][yy][x + dx[i]][y + dy[i]] = dis[xx][yy][x][y] + 1,
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
}
namespace MaxFlow {
const int N = 2010, M = 2001000;
int head[N], cur[N], dep[N], cnt, S, T, res;
struct node {
int to, next, val;
} edge[M];
void ae(int u, int v, int w) {
edge[cnt].next = head[u], edge[cnt].to = v, edge[cnt].val = w,
head[u] = cnt++;
edge[cnt].next = head[v], edge[cnt].to = u, edge[cnt].val = 0,
head[v] = cnt++;
}
queue<int> q;
inline bool bfs() {
memset(dep, 0, sizeof(dep)), q.push(S), dep[S] = 1;
while (!q.empty()) {
register int x = q.front();
q.pop();
for (register int i = cur[x] = head[x]; i != -1; i = edge[i].next)
if (edge[i].val && !dep[edge[i].to])
dep[edge[i].to] = dep[x] + 1, q.push(edge[i].to);
}
return dep[T] > 0;
}
bool reach;
inline int dfs(int x, int flow) {
if (x == T) {
res += flow, reach = true;
return flow;
}
int used = 0;
for (register int &i = cur[x]; i != -1; i = edge[i].next) {
if (!edge[i].val || dep[edge[i].to] != dep[x] + 1) continue;
register int ff = dfs(edge[i].to, min(edge[i].val, flow - used));
if (ff) {
edge[i].val -= ff, edge[i ^ 1].val += ff, used += ff;
if (used == flow) break;
}
}
return used;
}
inline void Dinic() {
while (bfs()) {
reach = true;
while (reach) reach = false, dfs(S, 0x3f3f3f3f);
}
}
} // namespace MaxFlow
using namespace MaxFlow;
bool che(long long ip) {
memset(head, -1, sizeof(head)), cnt = res = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++) {
for (int i = 1; i <= s; i++) {
if (dis[X[i]][Y[i]][x][y] == -1) continue;
if (1ll * dis[X[i]][Y[i]][x][y] * Z[i] > ip) continue;
ae(2 * n * m + i, (x - 1) * m + y, 1);
}
for (int j = 1; j <= t; j++) {
if (dis[X[s + j]][Y[s + j]][x][y] == -1) continue;
if (1ll * dis[X[s + j]][Y[s + j]][x][y] * Z[s + j] > ip) continue;
ae(n * m + (x - 1) * m + y, 2 * n * m + s + j, 1);
}
}
for (int i = 1; i <= s; i++) ae(S, 2 * n * m + i, 1);
for (int i = 1; i <= t; i++) ae(2 * n * m + s + i, T, 1);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (g[x][y] != '#') ae((x - 1) * m + y, n * m + (x - 1) * m + y, 1);
Dinic();
return res == s;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t), memset(dis, -1, sizeof(dis));
for (int i = 1; i <= n; i++) scanf("%s", g[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (g[i][j] != '#') bfs(i, j);
if (abs(s - t) != 1) {
puts("-1");
return 0;
}
if (s < t)
scanf("%d%d%d", &X[s + 1], &Y[s + 1], &Z[s + 1]);
else
scanf("%d%d%d", &X[s + t + 1], &Y[s + t + 1], &Z[s + t + 1]);
for (int i = 1; i <= s; i++) scanf("%d%d%d", &X[i], &Y[i], &Z[i]);
if (s <= t) s++;
for (int i = 1; i <= t; i++) scanf("%d%d%d", &X[s + i], &Y[s + i], &Z[s + i]);
if (t <= s) t++;
S = 2 * n * m + s + t + 1, T = 2 * n * m + s + t + 2;
long long l = 0, r = 1e12;
while (l < r) {
long long mid = (l + r) >> 1;
if (che(mid))
r = mid;
else
l = mid + 1;
}
if (!che(r))
puts("-1");
else
printf("%lld\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
struct Network {
struct Edge {
int u, v;
int f, c;
};
vector<Edge> edgeList;
vector<vector<int> > adj;
void addEdge(int u, int v, int c) {
Edge e = {u, v, 0, c};
adj[u].push_back((int)edgeList.size());
adj[v].push_back((int)edgeList.size());
edgeList.push_back(e);
}
int n() { return (int)adj.size(); }
void resetFlow() {
for (auto &pe : edgeList) pe.f = 0;
}
void init(int n) {
edgeList.clear();
adj.resize(n);
for (auto &au : adj) au.clear();
}
Network(int n) { init(n); }
};
class Dinic {
Network &g;
int s, t;
vector<int> dist;
vector<bool> block;
bool computeDist() {
queue<int> q;
q.push(t);
fill(dist.begin(), dist.end(), -1);
dist[t] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto pi : g.adj[u]) {
Network::Edge &e = g.edgeList[pi];
if (e.v == u && e.f < e.c) {
if (dist[e.u] == -1) {
dist[e.u] = dist[u] + 1;
q.push(e.u);
if (e.u == s) return true;
}
} else if (e.u == u && e.f > 0) {
if (dist[e.v] == -1) {
dist[e.v] = dist[u] + 1;
q.push(e.v);
if (e.v == s) return true;
}
}
}
}
return dist[s] != -1;
}
int findAugmentingPath(int u, int delta) {
if (u == t) return delta;
int inc;
for (auto pi : g.adj[u]) {
Network::Edge &e = g.edgeList[pi];
if (e.u == u && e.f < e.c) {
if (!block[e.v] && dist[u] == dist[e.v] + 1 &&
(inc = findAugmentingPath(e.v, min(delta, e.c - e.f)))) {
e.f += 1 * inc;
return inc;
}
} else if (e.v == u && e.f > 0) {
if (!block[e.u] && dist[u] == dist[e.u] + 1 &&
(inc = findAugmentingPath(e.u, min(delta, e.f)))) {
e.f += -1 * inc;
return inc;
}
}
}
block[u] = true;
return 0;
}
public:
int totalFlow;
Dinic(Network &g, int s, int t) : g(g), s(s), t(t) {
g.resetFlow();
totalFlow = 0;
dist.resize(g.n());
block.resize(g.n());
}
int run() {
while (computeDist()) {
fill(block.begin(), block.end(), false);
while (int inc = findAugmentingPath(s, 2E9L)) totalFlow += inc;
}
return totalFlow;
}
};
char board[23][23];
int row[2][23 * 23], col[2][23 * 23], speed[2][23 * 23];
int nRow, nCol, nMale, nFemale;
int dist[23][23][23][23];
int squareID[23][23], nSquare = 0;
long long best[2][23 * 23][23][23];
int idCount[2];
void addScay(int type, int r, int c, int t) {
r--;
c--;
row[type][idCount[type]] = r;
col[type][idCount[type]] = c;
speed[type][idCount[type]] = t;
idCount[type]++;
}
int main() {
cin >> nRow >> nCol >> nMale >> nFemale;
if ((nMale + nFemale) % 2 == 0) {
cout << -1;
return 0;
}
if (abs(nMale - nFemale) >= 2) {
cout << -1;
return 0;
}
for (int i = 0; i < nRow; ++i) {
cin >> board[i];
assert(strlen(board[i]) == nCol);
}
idCount[0] = idCount[1] = 0;
int r, c, t;
cin >> r >> c >> t;
if (nMale == nFemale + 1) {
addScay(1, r, c, t);
} else {
addScay(0, r, c, t);
}
for (int i = 0; i < nMale; ++i) {
cin >> r >> c >> t;
addScay(0, r, c, t);
}
for (int i = 0; i < nFemale; ++i) {
cin >> r >> c >> t;
addScay(1, r, c, t);
}
if (nMale == nFemale + 1) {
nFemale++;
} else {
nMale++;
}
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c)
for (int r2 = 0; r2 < nRow; ++r2)
for (int c2 = 0; c2 < nCol; ++c2) {
dist[r][c][r2][c2] = 2E9L;
if (r2 == r && c2 == c) {
dist[r][c][r2][c2] = 0;
} else if (abs(r2 - r) + abs(c2 - c) == 1) {
if (board[r][c] != '#' && board[r2][c2] != '#') {
dist[r][c][r2][c2] = 1;
}
}
}
for (int rk = 0; rk < nRow; ++rk)
for (int ck = 0; ck < nCol; ++ck)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c)
for (int r2 = 0; r2 < nRow; ++r2)
for (int c2 = 0; c2 < nCol; ++c2) {
int d1 = dist[r][c][rk][ck];
int d2 = dist[rk][ck][r2][c2];
if (d1 != 2E9L && d2 != 2E9L) {
dist[r][c][r2][c2] = min(dist[r][c][r2][c2], d1 + d2);
}
}
long long maxTime = -2E18L;
for (int m = 0; m < nMale; ++m)
for (int f = 0; f < nFemale; ++f) {
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
for (int m = 0; m < nMale; ++m) {
best[0][m][r][c] = 2E18L;
int dMale = dist[r][c][row[0][m]][col[0][m]];
if (dMale != 2E9L) {
long long timeMale = (long long)dMale * speed[0][m];
best[0][m][r][c] = timeMale;
maxTime = max(maxTime, timeMale);
}
}
for (int f = 0; f < nFemale; ++f) {
best[1][f][r][c] = 2E18L;
int dFemale = dist[r][c][row[1][f]][col[1][f]];
if (dFemale != 2E9L) {
long long timeFemale = (long long)dFemale * speed[1][f];
best[1][f][r][c] = timeFemale;
maxTime = max(maxTime, timeFemale);
}
}
}
}
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (board[r][c] == '.') {
squareID[r][c] = nSquare;
nSquare++;
}
}
long long left = 0, right = maxTime, mid, ret = -1;
while (left <= right) {
mid = (left + right) / 2;
int nNode = nMale + nFemale + 2 * nSquare + 2;
Network g(nNode);
int source = nNode - 2;
int sink = nNode - 1;
for (int m = 0; m < nMale; ++m) {
g.addEdge(source, m, 1);
}
for (int f = 0; f < nFemale; ++f) {
g.addEdge((nMale + f), sink, 1);
}
for (int x = 0; x < nSquare; ++x) {
g.addEdge((nMale + nFemale + x), (nMale + nFemale + nSquare + x), 1);
}
for (int m = 0; m < nMale; ++m)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (best[0][m][r][c] != 2E18L && best[0][m][r][c] <= mid) {
g.addEdge(m, (nMale + nFemale + squareID[r][c]), 1);
}
}
for (int f = 0; f < nFemale; ++f)
for (int r = 0; r < nRow; ++r)
for (int c = 0; c < nCol; ++c) {
if (best[1][f][r][c] != 2E18L && best[1][f][r][c] <= mid) {
g.addEdge((nMale + nFemale + nSquare + squareID[r][c]), (nMale + f),
1);
}
}
int bestMatch = Dinic(g, source, sink).run();
if (bestMatch == nMale) {
ret = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
struct Edge {
int a, b, cap, flow;
};
struct MaxFlow {
int n, s, t;
vector<int> d, ptr, q;
vector<Edge> e;
vector<vector<int> > g;
MaxFlow(int n) : n(n), d(n), ptr(n), g(n), q(n) {
e.clear();
for (int i = 0, _a = (n); i < _a; i++) {
g[i].clear();
ptr[i] = 0;
}
}
void addEdge(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);
}
int getMaxFlow(int _s, int _t) {
s = _s;
t = _t;
int flow = 0;
for (;;) {
if (!bfs()) break;
for (int i = 0, _a = (n); i < _a; i++) ptr[i] = 0;
while (int pushed = dfs(s, INF)) flow += pushed;
}
return flow;
}
private:
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
for (int i = 0, _a = (n); i < _a; i++) d[i] = -1;
d[s] = 0;
while (qh < qt && d[t] == -1) {
int v = q[qh++];
for (int i = 0, _a = (g[v].size()); i < _a; 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;
}
};
string board[30];
int d[600][600];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
long long inf = (1e6);
int src, sink, sz;
MaxFlow G(1);
int n, m, males, females;
int allSz;
struct deer {
long long x, y, spd;
deer(int xx, int yy, int spdd) : x(xx), y(yy), spd(spdd) {}
};
vector<deer> maleList, femaleList;
void addMale(int x, int y, long long spd, long long bound) {
x--;
y--;
G.addEdge(src, sz, 1);
int now = x * m + y;
for (int i = 0; i < n * m; ++i) {
if (d[now][i] != inf) {
if (d[now][i] * spd <= bound) {
G.addEdge(sz, i, 1);
}
}
}
sz++;
}
void addFemale(int x, int y, long long spd, long long bound) {
x--;
y--;
G.addEdge(sz, sink, 1);
int now = x * m + y;
for (int i = 0; i < n * m; ++i) {
if (d[now][i] != inf) {
if (d[now][i] * spd <= bound) G.addEdge(allSz - i - 1, sz, 1);
}
}
sz++;
}
bool visited[30][30];
int main() {
cin >> n >> m >> males >> females;
if (abs(males - females) != 1) {
cout << -1;
return 0;
}
for (int i = 0; i < 600; ++i) {
for (int j = 0; j < 600; ++j) d[i][j] = inf;
}
for (int i = 0; i < n; ++i) cin >> board[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (board[i][j] == '#') {
continue;
}
d[i * m + j][i * m + j] = 0;
for (int dir = 0; dir < 4; ++dir) {
int x = i + dx[dir];
int y = j + dy[dir];
if (x < 0 || x >= n || y < 0 || y >= m) continue;
if (board[x][y] == '.') d[i * m + j][x * m + y] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
memset(visited, 0, sizeof(visited));
if (board[i][j] == '.') {
queue<pair<int, pair<int, int> > > q;
q.push({0, {i, j}});
visited[i][j] = 1;
while (!q.empty()) {
auto cur = q.front();
d[i * m + j][cur.second.first * m + cur.second.second] = cur.first;
q.pop();
for (int dir = 0; dir < 4; ++dir) {
int x = cur.second.first + dx[dir];
int y = cur.second.second + dy[dir];
if (x < 0 || x >= n || y < 0 || y >= m) continue;
if (board[x][y] == '.' && !visited[x][y]) {
visited[x][y] = 1;
q.push({cur.first + 1, {x, y}});
}
}
}
}
}
}
src = n * m;
sink = n * m + 1;
long long x, y, spd;
cin >> x >> y >> spd;
if (males < females) {
maleList.push_back(deer(x, y, spd));
} else {
femaleList.push_back(deer(x, y, spd));
}
for (int i = 0; i < males; ++i) {
cin >> x >> y >> spd;
maleList.push_back(deer(x, y, spd));
}
for (int i = 0; i < females; ++i) {
cin >> x >> y >> spd;
femaleList.push_back(deer(x, y, spd));
}
int req = males + females + 1;
req /= 2;
long long mAns = -1;
long long bs = 0, be = (1LL << 40);
while (bs <= be) {
G = MaxFlow(2 + males + females + 1 + n * m * 2 + 5);
allSz = 2 + males + females + 1 + n * m * 2 + 5;
for (int i = 0; i < n * m; ++i) {
G.addEdge(i, allSz - i - 1, 1);
}
sz = n * m + 2;
long long mid = (bs + be) / 2;
for (int i = 0; i < maleList.size(); ++i) {
addMale(maleList[i].x, maleList[i].y, maleList[i].spd, mid);
}
for (int i = 0; i < femaleList.size(); ++i) {
addFemale(femaleList[i].x, femaleList[i].y, femaleList[i].spd, mid);
}
int ans = G.getMaxFlow(src, sink);
if (ans == req) {
mAns = mid;
be = mid - 1;
} else {
bs = mid + 1;
}
}
cout << mAns << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ma, fa;
int tab[30][30];
char wcz[25];
vector<pair<long long, pair<int, int> > > wek;
pair<int, int> v;
long long t;
long long odl[30][30];
queue<pair<int, int> > bfs;
int n1;
vector<int> graf[2007];
int mac[2007][2007];
int bylo[2007];
int wyn;
void czys() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
odl[i][j] = -1;
}
}
}
void czysb() {
for (int i = 1; i <= n1; i++) {
bylo[i] = 0;
}
}
void bbbfs() {
while (!bfs.empty()) {
v = bfs.front();
bfs.pop();
if (!tab[v.first - 1][v.second] && odl[v.first - 1][v.second] == -1) {
odl[v.first - 1][v.second] = odl[v.first][v.second] + 1;
v.first--;
bfs.push(v);
v.first++;
}
if (!tab[v.first + 1][v.second] && odl[v.first + 1][v.second] == -1) {
odl[v.first + 1][v.second] = odl[v.first][v.second] + 1;
v.first++;
bfs.push(v);
v.first--;
}
if (!tab[v.first][v.second - 1] && odl[v.first][v.second - 1] == -1) {
odl[v.first][v.second - 1] = odl[v.first][v.second] + 1;
v.second--;
bfs.push(v);
v.second++;
}
if (!tab[v.first][v.second + 1] && odl[v.first][v.second + 1] == -1) {
odl[v.first][v.second + 1] = odl[v.first][v.second] + 1;
v.second++;
bfs.push(v);
v.second--;
}
}
}
int dfs(int u) {
bylo[u] = 1;
if (u == n1) {
return 1;
}
for (int i = 0; i < graf[u].size(); i++) {
if (!bylo[graf[u][i]] && mac[u][graf[u][i]] && dfs(graf[u][i])) {
mac[u][graf[u][i]]--;
mac[graf[u][i]][u]++;
return 1;
}
}
return 0;
}
int main() {
scanf("%d%d%d%d", &n, &m, &ma, &fa);
if (max(fa - ma, ma - fa) != 1) {
printf("-1");
return 0;
}
for (int i = 0; i <= 25; i++) {
for (int j = 0; j <= 25; j++) {
tab[i][j] = 1;
}
}
for (int i = 1; i <= n; i++) {
scanf("%s", &wcz);
for (int j = 1; j <= m; j++) {
if (wcz[j - 1] == '.') {
tab[i][j] = 0;
}
}
}
if (ma < fa) {
ma++;
for (int i = 1; i <= ma; i++) {
czys();
scanf("%d%d%lld", &v.first, &v.second, &t);
odl[v.first][v.second] = 0;
bfs.push(v);
bbbfs();
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (odl[ii][jj] >= 0) {
wek.push_back(make_pair(
odl[ii][jj] * t, make_pair(i + 1, 1 + ma + (ii - 1) * m + jj)));
}
}
}
}
for (int i = 1; i <= fa; i++) {
czys();
scanf("%d%d%lld", &v.first, &v.second, &t);
odl[v.first][v.second] = 0;
bfs.push(v);
bbbfs();
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (odl[ii][jj] >= 0) {
wek.push_back(make_pair(
odl[ii][jj] * t, make_pair(1 + ma + n * m + (ii - 1) * m + jj,
1 + ma + 2 * n * m + i)));
}
}
}
}
} else {
fa++;
for (int i = 1; i <= 1; i++) {
czys();
scanf("%d%d%lld", &v.first, &v.second, &t);
odl[v.first][v.second] = 0;
bfs.push(v);
bbbfs();
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (odl[ii][jj] >= 0) {
wek.push_back(make_pair(
odl[ii][jj] * t, make_pair(i + 1, 1 + ma + (ii - 1) * m + jj)));
}
}
}
}
for (int i = 1; i <= fa; i++) {
czys();
scanf("%d%d%lld", &v.first, &v.second, &t);
odl[v.first][v.second] = 0;
bfs.push(v);
bbbfs();
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (odl[ii][jj] >= 0) {
wek.push_back(make_pair(
odl[ii][jj] * t, make_pair(1 + ma + n * m + (ii - 1) * m + jj,
1 + ma + 2 * n * m + i)));
}
}
}
}
for (int i = 2; i <= ma; i++) {
czys();
scanf("%d%d%lld", &v.first, &v.second, &t);
odl[v.first][v.second] = 0;
bfs.push(v);
bbbfs();
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (odl[ii][jj] >= 0) {
wek.push_back(make_pair(
odl[ii][jj] * t, make_pair(i + 1, 1 + ma + (ii - 1) * m + jj)));
}
}
}
}
}
n1 = 1 + ma + n * m + n * m + fa + 1;
sort(wek.begin(), wek.end());
for (int i = 2; i <= ma + 1; i++) {
graf[1].push_back(i);
graf[i].push_back(1);
mac[1][i] = 1;
}
for (int i = 1 + ma + n * m * 2 + 1; i <= 1 + ma + n * m * 2 + fa; i++) {
graf[i].push_back(n1);
graf[n1].push_back(i);
mac[i][n1] = 1;
}
for (int i = 1 + ma + 1; i <= 1 + ma + n * m; i++) {
graf[i].push_back(i + n * m);
graf[i + n * m].push_back(i);
mac[i][i + n * m] = 1;
}
for (int i = 0; i < wek.size(); i++) {
czysb();
graf[wek[i].second.first].push_back(wek[i].second.second);
graf[wek[i].second.second].push_back(wek[i].second.first);
mac[wek[i].second.first][wek[i].second.second] = 1;
while (dfs(1)) {
wyn++;
czysb();
}
if (wyn == ma) {
printf("%lld", wek[i].first);
return 0;
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-8;
const int maxn = 2050;
const int inf = 1e9;
struct Edge {
int to, cap, fl;
Edge(int to, int cap, int fl) : to(to), cap(cap), fl(fl) {}
};
vector<Edge> edges;
vector<int> g[maxn];
int d[maxn], p[maxn], q[maxn];
void addedge(int from, int to, int cap = 1) {
g[from].push_back(edges.size());
edges.push_back(Edge(to, cap, 0));
g[to].push_back(edges.size());
edges.push_back(Edge(from, 0, 0));
}
bool dfs(int v, int fin, int lim) {
if (v == fin) return true;
while (p[v] < (int)g[v].size()) {
int num = g[v][p[v]];
Edge ed = edges[num];
if (d[ed.to] == d[v] + 1 && ed.cap - ed.fl >= lim) {
if (dfs(ed.to, fin, lim)) {
edges[num].fl += lim;
edges[num ^ 1].fl -= lim;
return true;
}
}
p[v]++;
}
return false;
}
void bfs(int st, int lim, int n) {
fill(d, d + n + 1, inf);
q[0] = st;
d[st] = 0;
int head = 0, tail = 1;
while (head < tail) {
int v = q[head++];
for (int i = 0; i < (int)(g[v].size()); ++i) {
Edge ed = edges[g[v][i]];
if (ed.cap - ed.fl >= lim && d[ed.to] > d[v] + 1) {
d[ed.to] = d[v] + 1;
q[tail++] = ed.to;
}
}
}
}
int calcFlow(int n, int st, int fin) {
int lim = 1e9, ans = 0;
while (lim) {
while (true) {
bfs(st, lim, n);
if (d[fin] == inf) break;
fill(p, p + n + 1, 0);
while (dfs(st, fin, lim)) ans += lim;
}
lim /= 2;
}
return ans;
}
int SG = 0;
void init() {
SG = 0;
for (int i = 0; i < (int)(maxn); ++i) g[i].clear();
edges.clear();
}
int newV() { return SG++; }
const int N = 30;
char field[N][N];
const int NDIR = 4;
const int di[4] = {0, 1, 0, -1};
const int dj[4] = {1, 0, -1, 0};
int a[N * N][3];
int b[N * N][3];
vector<vector<int> > dist[N][N];
int n, m;
vector<vector<int> > bfs(int i, int j) {
vector<vector<int> > d(n + 1, vector<int>(m + 1, inf));
queue<pair<int, int> > q;
q.push(make_pair(i, j));
d[i][j] = 0;
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int dir = 0; dir < (int)(NDIR); ++dir) {
pair<int, int> nex(cur.first + di[dir], cur.second + dj[dir]);
if (field[nex.first][nex.second] && d[nex.first][nex.second] == inf) {
d[nex.first][nex.second] = d[cur.first][cur.second] + 1;
q.push(nex);
}
}
}
return d;
}
int q0, q1;
int cells[N][N][2];
bool can(long long T0) {
assert(q0 == q1);
init();
for (int i = 1; i <= (int)(n); ++i)
for (int j = 1; j <= (int)(m); ++j) {
for (int t = 0; t < (int)(2); ++t) cells[i][j][t] = newV();
addedge(cells[i][j][0], cells[i][j][1]);
}
int st = newV();
int fin = newV();
for (int t = 0; t < (int)(q0); ++t) {
int cur = newV();
addedge(st, cur);
long long s = T0 / a[t][2];
int i0 = a[t][0], j0 = a[t][1];
for (int i = 1; i <= (int)(n); ++i)
for (int j = 1; j <= (int)(m); ++j)
if (dist[i0][j0][i][j] != inf && dist[i0][j0][i][j] <= s)
addedge(cur, cells[i][j][0]);
}
for (int t = 0; t < (int)(q1); ++t) {
int cur = newV();
long long s = T0 / b[t][2];
int i0 = b[t][0], j0 = b[t][1];
for (int i = 1; i <= (int)(n); ++i)
for (int j = 1; j <= (int)(m); ++j)
if (dist[i0][j0][i][j] != inf && dist[i0][j0][i][j] <= s)
addedge(cells[i][j][1], cur);
addedge(cur, fin);
}
int f = calcFlow(SG, st, fin);
return (f == q0);
}
int main() {
cin >> n >> m >> q0 >> q1;
for (int i = 1; i <= (int)(n); ++i)
for (int j = 1; j <= (int)(m); ++j) {
char c;
cin >> c;
field[i][j] = (c == '.');
}
if (abs(q0 - q1) != 1) {
cout << "-1\n";
return 0;
}
if (q0 == q1 + 1) {
for (int i = 0; i < (int)(3); ++i) cin >> b[q1][i];
} else {
for (int i = 0; i < (int)(3); ++i) cin >> a[q0][i];
}
for (int i = 0; i < (int)(q0); ++i)
for (int j = 0; j < (int)(3); ++j) cin >> a[i][j];
for (int i = 0; i < (int)(q1); ++i)
for (int j = 0; j < (int)(3); ++j) cin >> b[i][j];
if (q0 == q1 + 1)
q1++;
else
q0++;
for (int i = 1; i <= (int)(n); ++i)
for (int j = 1; j <= (int)(m); ++j)
if (field[i][j]) dist[i][j] = bfs(i, j);
long long l = -1, r = 1e18;
if (!can(r)) {
cout << "-1" << endl;
return 0;
}
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (can(mid))
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
const int K = 55;
const int mod = 1000000007;
const int inf = 1000000000;
const long long INF = 1000000000000000LL;
class MaximumFlow {
int s, f;
public:
struct edge {
int u, v;
long long capacity, flow;
edge() { u = v = capacity = flow = 0; }
edge(int u_, int v_, long long capacity_, long long flow_)
: u(u_), v(v_), capacity(capacity_), flow(flow_) {}
};
vector<edge> edges;
vector<vector<int> > graph;
vector<int> ptr, level;
queue<int> q;
int n;
MaximumFlow() {}
MaximumFlow(int number) {
n = number;
graph.resize(n);
ptr.assign(n, 0);
level.resize(n);
}
void addEdge(int u, int v, long long capacity) {
int sz = (int)(edges.size());
edges.push_back(edge(u, v, capacity, 0));
edges.push_back(edge(v, u, 0, 0));
graph[u].push_back(sz);
graph[v].push_back(sz + 1);
}
void updateLevels() {
level.assign(n, -1);
q.push(s);
level[s] = 0;
while (!q.empty()) {
int topq = q.front();
q.pop();
for (int index = 0; index < graph[topq].size(); ++index) {
int i = graph[topq][index];
int to = edges[i].v;
if (edges[i].capacity - edges[i].flow == 0) {
continue;
}
if (level[to] == -1) {
level[to] = level[topq] + 1;
q.push(to);
}
}
}
}
long long pushFlow(int v, long long flow) {
if (v == f || flow == 0) {
return flow;
}
for (; ptr[v] < graph[v].size(); ++ptr[v]) {
int index = graph[v][ptr[v]];
int to = edges[index].v;
if (level[v] + 1 == level[to]) {
long long pushed =
pushFlow(to, min(flow, edges[index].capacity - edges[index].flow));
if (pushed > 0) {
edges[index].flow += pushed;
edges[index ^ 1].flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long dinicFlow(int start, int finish) {
s = start, f = finish;
long long result = 0;
while (true) {
updateLevels();
if (level[f] == -1) {
break;
}
while (true) {
long long pushed = pushFlow(start, INF);
if (pushed == 0) {
break;
}
result += pushed;
}
ptr.assign(n, 0);
}
return result;
}
};
char tab[25][25];
int n, m, females, males, frees;
int d_females[25 * 25][25][25], v_females[25 * 25], x_females[25 * 25],
y_females[25 * 25];
int d_males[25 * 25][25][25], v_males[25 * 25], x_males[25 * 25],
y_males[25 * 25];
bool check(long long time) {
int tot = females + males + n * m * 2 + 2;
int source = tot - 2, sink = tot - 1;
MaximumFlow solve(tot);
for (int i = 0; i < females; ++i) {
solve.addEdge(source, i, 1);
}
for (int i = 0; i < males; ++i) {
solve.addEdge(females + i, sink, 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (tab[i][j] == '#') {
continue;
}
solve.addEdge(females + males + i * m + j,
females + males + i * m + j + n * m, 1);
for (int k = 0; k < females; ++k) {
if (d_females[k][i][j] != -1 &&
(long long)v_females[k] * d_females[k][i][j] <= time) {
solve.addEdge(k, females + males + i * m + j, INF);
}
}
for (int k = 0; k < males; ++k) {
if (d_males[k][i][j] != -1 &&
(long long)v_males[k] * d_males[k][i][j] <= time) {
solve.addEdge(females + males + i * m + j + n * m, females + k, INF);
}
}
}
}
return solve.dinicFlow(source, sink) == females;
}
bool valid(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && tab[x][y] == '.';
}
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void init() {
for (int i = 0; i < females; ++i) {
memset(d_females[i], -1, sizeof d_females[i]);
queue<pair<int, int> > q;
q.push({x_females[i], y_females[i]});
d_females[i][x_females[i]][y_females[i]] = 0;
while (!q.empty()) {
pair<int, int> where = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int xnew = where.first + dx[k];
int ynew = where.second + dy[k];
if (!valid(xnew, ynew)) {
continue;
}
if (d_females[i][xnew][ynew] == -1) {
d_females[i][xnew][ynew] =
1 + d_females[i][where.first][where.second];
q.push({xnew, ynew});
}
}
}
}
for (int i = 0; i < males; ++i) {
memset(d_males[i], -1, sizeof d_males[i]);
queue<pair<int, int> > q;
q.push({x_males[i], y_males[i]});
d_males[i][x_males[i]][y_males[i]] = 0;
while (!q.empty()) {
pair<int, int> where = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int xnew = where.first + dx[k];
int ynew = where.second + dy[k];
if (!valid(xnew, ynew)) {
continue;
}
if (d_males[i][xnew][ynew] == -1) {
d_males[i][xnew][ynew] = 1 + d_males[i][where.first][where.second];
q.push({xnew, ynew});
}
}
}
}
}
int main() {
cin >> n >> m >> males >> females;
for (int i = 0; i < n; ++i) {
cin >> tab[i];
}
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
for (int i = 0; i < males; ++i) {
cin >> x_males[i] >> y_males[i] >> v_males[i];
x_males[i]--;
y_males[i]--;
}
for (int i = 0; i < females; ++i) {
cin >> x_females[i] >> y_females[i] >> v_females[i];
x_females[i]--;
y_females[i]--;
}
if (females < males) {
x_females[females] = x;
y_females[females] = y;
v_females[females++] = t;
} else {
x_males[males] = x;
y_males[males] = y;
v_males[males++] = t;
}
init();
if (females != males || !check(INF)) {
cout << -1 << endl;
return 0;
}
long long low = -1, high = INF;
while (high - low > 1) {
long long mid = (low + high) / 2;
if (check(mid)) {
high = mid;
} else {
low = mid;
}
}
cout << high << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void mx(T& x, const T& y) {
if (x < y) x = y;
}
template <typename T>
inline void mn(T& x, const T& y) {
if (y < x) x = y;
}
const int di[] = {-1, 0, +1, 0};
const int dj[] = {0, +1, 0, -1};
const int K = 22 * 22;
const int N = 1 + K + K + K + K + 1;
const int M = 2 * (K + K * K + K + K * K + K);
int fieldSize = 0;
int peopleSize = 0;
int nodes;
int edges;
int S;
int T;
int head[N], dhead[N], linke[M], cap[M], dest[M], lvl[N];
int q[N];
inline void addArc(int u, int v, int c) {
cap[edges] = c;
dest[edges] = v;
linke[edges] = head[u];
head[u] = edges++;
cap[edges] = 0;
dest[edges] = u;
linke[edges] = head[v];
head[v] = edges++;
}
bool bfs() {
fill(lvl, lvl + nodes, -1);
int qh = 0, qt = 0;
lvl[S] = 0;
q[qt++] = S;
while (qh != qt) {
int u = q[qh++];
for (int arc = head[u]; arc != -1; arc = linke[arc]) {
int v = dest[arc];
if (cap[arc] > 0 && lvl[v] == -1) {
lvl[v] = lvl[u] + 1;
q[qt++] = v;
}
}
}
return lvl[T] != -1;
}
inline int dfs(int u, int f) {
if (u == T || f == 0) {
return f;
}
for (int& arc = dhead[u]; arc != -1; arc = linke[arc]) {
int v = dest[arc];
if (cap[arc] > 0 && lvl[v] == lvl[u] + 1) {
int pushed = dfs(v, min(f, cap[arc]));
if (pushed > 0) {
cap[arc] -= pushed;
cap[arc ^ 1] += pushed;
return pushed;
}
}
}
return 0;
}
inline int maleIndex(int i) { return i; }
inline int fieldInputIndex(int i) { return peopleSize + i; }
inline int fieldOutputIndex(int i) { return peopleSize + fieldSize + i; }
inline int femaleIndex(int i) { return peopleSize + fieldSize + fieldSize + i; }
bool can(const vector<vector<int>>& g, const vector<bool>& good,
const vector<pair<int, int>>& males,
const vector<pair<int, int>>& females, const long long& reqTime) {
fieldSize = g.size();
peopleSize = males.size();
S = 2 * (peopleSize + fieldSize);
T = S + 1;
nodes = T + 1;
edges = 0;
fill(head, head + nodes, -1);
for (int i = 0; i < (peopleSize); ++i) {
addArc(S, maleIndex(i), 1);
int u = males[i].first;
for (int v = 0; v < (fieldSize); ++v) {
if (good[v] && g[u][v] < 1000000) {
long long t = 1LL * males[i].second * g[u][v];
if (t <= reqTime) {
addArc(maleIndex(i), fieldInputIndex(v), 1);
}
}
}
}
for (int i = 0; i < (fieldSize); ++i) {
if (good[i]) {
addArc(fieldInputIndex(i), fieldOutputIndex(i), 1);
}
}
for (int i = 0; i < (peopleSize); ++i) {
addArc(femaleIndex(i), T, 1);
int u = females[i].first;
for (int v = 0; v < (fieldSize); ++v) {
if (good[v] && g[u][v] < 1000000) {
long long t = 1LL * females[i].second * g[u][v];
if (t <= reqTime) {
addArc(fieldOutputIndex(v), femaleIndex(i), 1);
}
}
}
}
int f = 0;
while (bfs()) {
copy(head, head + nodes, dhead);
int pushed;
while ((pushed = dfs(S, peopleSize)) > 0) {
f += pushed;
}
}
return f == peopleSize;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, nMales, nFemales;
cin >> n >> m >> nMales >> nFemales;
if (abs(nMales - nFemales) != 1) {
cout << -1 << endl;
return 0;
}
vector<string> a(n);
for (int i = 0; i < (n); ++i) {
cin >> a[i];
}
vector<vector<int>> g(n * m, vector<int>(n * m, 1000000));
vector<bool> good(n * m, false);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j)
if (a[i][j] == '.') {
g[i * m + j][i * m + j] = 0;
good[i * m + j] = true;
for (int k = 0; k < (4); ++k) {
int ii = i + di[k];
int jj = j + dj[k];
if (0 <= ii && ii < n && 0 <= jj && j < m && a[ii][jj] == '.') {
g[i * m + j][ii * m + jj] = 1;
}
}
}
for (int k = 0; k < (n * m); ++k) {
for (int i = 0; i < (n * m); ++i) {
for (int j = 0; j < (n * m); ++j) {
mn(g[i][j], g[i][k] + g[k][j]);
}
}
}
auto readPlace = [&] {
int r, c, t;
cin >> r >> c >> t;
--r, --c;
return make_pair(r * m + c, t);
};
vector<pair<int, int>> males;
vector<pair<int, int>> females;
((nMales < nFemales) ? males : females).push_back(readPlace());
for (int i = 0; i < (nMales); ++i) males.push_back(readPlace());
for (int i = 0; i < (nFemales); ++i) females.push_back(readPlace());
int maxDist = 0;
for (int i = 0; i < (n * m); ++i)
for (int j = 0; j < (n * m); ++j)
if (g[i][j] < 1000000) mx(maxDist, g[i][j]);
long long maxT = 1000000000LL * maxDist;
long long l = -1;
long long r = maxT + 1;
while (r - l > 1) {
long long m = (l + r) / 2;
if (can(g, good, males, females, m)) {
r = m;
} else {
l = m;
}
}
if (r == maxT + 1) {
r = -1;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
const static long long INF = std::numeric_limits<long long>::max() / 2 - 1;
struct DinicFlow {
struct edge {
long long a, b;
long long flow, cap;
edge* rev;
edge(const long long& _a, const long long& _b, const long long& _flow,
const long long& _cap, edge* _rev = nullptr)
: a(_a), b(_b), flow(_flow), cap(_cap), rev(_rev) {}
};
typedef std::vector<std::vector<edge*>> adj_list;
std::vector<char> blocked;
std::vector<long long> distances;
adj_list graph;
long long n;
long long source;
long long sink;
DinicFlow(const long long& _n) : n(_n) {
source = n++;
sink = n++;
blocked.assign(n, false);
distances.assign(n, INF);
graph.assign(n, std::vector<edge*>());
}
~DinicFlow(void) {
for (auto& row : graph) {
for (auto& e : row) {
delete e;
}
}
}
edge* add_edge(const long long& a, const long long& b, const long long& cap,
const long long& flow = 0) {
edge* normal = new edge(a, b, flow, cap);
edge* reverse = normal->rev = new edge(b, a, 0, 0, normal);
graph[a].push_back(normal);
graph[b].push_back(reverse);
return normal;
}
bool bfs(void) {
distances.assign(n, INF);
distances[sink] = 0;
std::queue<long long> order;
order.push(sink);
while (!order.empty()) {
long long best = order.front();
order.pop();
if (best == source) return true;
for (edge* neigh : graph[best]) {
if (neigh->rev->cap > neigh->rev->flow &&
distances[neigh->b] > 1 + distances[best]) {
distances[neigh->b] = 1 + distances[best];
order.push(neigh->b);
}
}
}
return false;
}
long long dfs(const long long& pos, const long long& min) {
if (pos == sink) {
return min;
}
long long flow = 0;
for (edge* e : graph[pos]) {
long long curr = 0;
if (!blocked[e->b] && distances[e->b] == distances[pos] - 1 &&
e->cap > e->flow) {
curr = dfs(e->b, std::min(min - flow, e->cap - e->flow));
e->flow += curr;
e->rev->flow = -(e->flow);
flow += curr;
}
if (flow == min) return flow;
}
blocked[pos] = flow != min;
return flow;
}
long long flow(void) {
for (auto& row : graph) {
for (edge* e : row) e->flow = 0;
}
long long ret = 0;
while (bfs()) {
blocked.assign(blocked.size(), false);
ret += dfs(source, INF);
}
return ret;
}
};
struct bg_scayger {
long long r, c;
long long t;
} boys[485], girls[485];
const long long INF2 = 0x3f3f3f3f3f3f;
const long long MAX_BOIS = 22 * 22 + 7;
long long n, m, males, females;
std::string grid[22];
long long mat[MAX_BOIS][MAX_BOIS];
DinicFlow::edge* edges[2][MAX_BOIS][MAX_BOIS];
long long get_coord(const long long& row, const long long& col) {
return row * m + col;
}
void sub(bg_scayger* arr, const long long& len) {
for (long long i = 0; i < len; ++i) {
--arr[i].r;
--arr[i].c;
}
}
void floyd_warshall(void) {
const long long all = n * m;
memset(mat, 0x3f, sizeof(mat));
for (long long i = 0; i < all; ++i) mat[i][i] = 0;
for (long long i = 0; i < n; ++i)
for (long long j = 0; j + 1 < m; ++j)
if (grid[i][j] != '#' && grid[i][j + 1] != '#') {
const long long tmp_a = get_coord(i, j), tmp_b = get_coord(i, j + 1);
mat[tmp_a][tmp_b] = mat[tmp_b][tmp_a] = 1;
}
for (long long j = 0; j < m; ++j)
for (long long i = 0; i + 1 < n; ++i)
if (grid[i][j] != '#' && grid[i + 1][j] != '#') {
const long long tmp_a = get_coord(i, j), tmp_b = get_coord(i + 1, j);
mat[tmp_a][tmp_b] = mat[tmp_b][tmp_a] = 1;
}
for (long long k = 0; k < all; ++k)
for (long long i = 0; i < all; ++i)
for (long long j = i + 1; j < all; ++j)
if (mat[i][k] < INF2 && mat[k][j] < INF2)
mat[i][j] = mat[j][i] = std::min(
mat[i][j], static_cast<long long>(mat[i][k] + mat[k][j]));
}
bool doit(const long long& limit, DinicFlow& myflow) {
for (long long loc = 0; loc < n * m; ++loc) {
for (long long i = 0; i < males; ++i) {
const long long boi = get_coord(boys[i].r, boys[i].c);
const long long gur = get_coord(girls[i].r, girls[i].c);
if (mat[loc][boi] < INF2) {
edges[0][i][loc]->cap = (boys[i].t * mat[loc][boi]) <= limit;
} else {
edges[0][i][loc]->cap = 0;
}
if (mat[loc][gur] < INF2) {
edges[1][i][loc]->cap = (girls[i].t * mat[loc][gur]) <= limit;
} else {
edges[1][i][loc]->cap = 0;
}
}
}
return myflow.flow() >= males;
}
int main(void) {
std::cin >> n >> m >> males >> females;
for (long long i = 0; i < n; ++i) std::cin >> grid[i];
if (std::abs(males - females) != 1) {
std::cout << "-1\n";
return 0;
}
if (males < females)
std::cin >> boys[males].r >> boys[males].c >> boys[males].t;
else
std::cin >> girls[females].r >> girls[females].c >> girls[females].t;
for (long long i = 0; i < males; ++i)
std::cin >> boys[i].r >> boys[i].c >> boys[i].t;
for (long long i = 0; i < females; ++i)
std::cin >> girls[i].r >> girls[i].c >> girls[i].t;
if (males < females)
++males;
else
++females;
assert(males == females);
sub(boys, males);
sub(girls, females);
floyd_warshall();
DinicFlow myflow(males + females + n * m + n * m);
for (long long i = 0; i < males; ++i) {
myflow.add_edge(myflow.source, i, 1);
myflow.add_edge(males + i, myflow.sink, 1);
}
for (long long loc = 0; loc < n * m; ++loc) {
myflow.add_edge(males + females + loc, males + females + n * m + loc, 1);
for (long long i = 0; i < males; ++i) {
edges[0][i][loc] = myflow.add_edge(i, males + females + loc, 1);
edges[1][i][loc] =
myflow.add_edge(males + females + n * m + loc, males + i, 1);
}
}
long long lo = 0, hi = 5e16;
while (lo < hi) {
const long long mid = lo + (hi - lo) / 2;
if (doit(mid, myflow)) {
if (!doit(mid - 1, myflow)) {
lo = hi = mid;
break;
}
hi = mid - 1;
} else {
lo = mid + 1;
}
}
if (lo >= static_cast<long long>(5e16)) lo = -1;
std::cout << lo << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, sign = 1;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (int)(c - '0'), c = getchar();
return sign * r;
}
template <typename T>
inline void print(T *a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
struct edge {
int next, node, w;
} e[(1500000 << 1) + 5];
int head[2000 + 1], S, T, tot = 1;
int d[2000 + 1], q[2000 + 1];
inline void addedge(int a, int b, int w) {
e[++tot].next = head[a];
head[a] = tot, e[tot].node = b, e[tot].w = w;
e[++tot].next = head[b];
head[b] = tot, e[tot].node = a, e[tot].w = 0;
}
bool bfs() {
int h = 0, t = 0;
memset(d, 0, sizeof d);
d[S] = 1;
q[t++] = S;
while (h < t) {
int cur = q[h++];
for (int i = head[cur]; i; i = e[i].next)
if (e[i].w > 0 && !d[e[i].node]) {
d[e[i].node] = d[cur] + 1;
q[t++] = e[i].node;
}
}
return d[T];
}
int dfs(int x, int inflow) {
if (x == T) return inflow;
if (!inflow) return 0;
int ret = inflow, flow;
for (int i = head[x]; i; i = e[i].next) {
if (d[e[i].node] != d[x] + 1) continue;
flow = dfs(e[i].node, min(ret, e[i].w));
if (!flow) continue;
e[i].w -= flow, e[i ^ 1].w += flow, ret -= flow;
if (!ret) return inflow;
}
if (ret == inflow) d[x] = -1;
return inflow - ret;
}
int maxFlow() {
int ans = 0LL;
while (bfs()) ans += dfs(S, 123456789);
return ans;
}
int n, m, male, female, dist[30 + 1][30 + 1];
long long pdist[30 * 30 + 1];
long long mdist[30 * 30 + 1][30 * 30 + 1];
long long fdist[30 * 30 + 1][30 * 30 + 1];
bool wall[30 + 1][30 + 1];
char s[100];
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
inline bool valid(int x, int y) { return x > 0 && x <= n && y > 0 && y <= m; }
void Bfs(int x, int y) {
memset(dist, 0, sizeof dist);
queue<pair<int, int> > q;
dist[x][y] = 1;
q.push(make_pair(x, y));
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
int x = cur.first + dir[i][0], y = cur.second + dir[i][1];
if (!valid(x, y) || dist[x][y] || wall[x][y]) continue;
dist[x][y] = dist[cur.first][cur.second] + 1;
q.push(make_pair(x, y));
}
}
}
void prepare(long long *d) {
int x, y, t;
scanf("%d%d%d", &x, &y, &t);
Bfs(x, y);
for (int a = 1; a <= n; ++a)
for (int b = 1; b <= m; ++b)
if (dist[a][b]) {
d[(a - 1) * m + b] = (long long)(dist[a][b] - 1) * t;
} else
d[(a - 1) * m + b] = 1234567890123456LL;
}
bool check(long long val) {
tot = 1;
memset(head, 0, sizeof head);
for (int i = 1; i <= n * m; ++i) addedge(i, n * m + i, 1);
for (int i = 1; i <= male; ++i) {
addedge(S, n * m * 2 + i, 1);
for (int j = 1; j <= n * m; ++j)
if (mdist[i][j] <= val) addedge(n * m * 2 + i, j, 1);
}
for (int i = 1; i <= female; ++i) {
addedge(n * m * 2 + male + i, T, 1);
for (int j = 1; j <= n * m; ++j)
if (fdist[i][j] <= val) addedge(n * m + j, n * m * 2 + male + i, 1);
}
if (maxFlow() >= (male + female >> 1)) return true;
return false;
}
int main(int argc, char *argv[]) {
scanf("%d%d%d%d", &n, &m, &male, &female);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
for (int j = 1; j <= m; ++j) wall[i][j] = s[j - 1] == '#';
}
if (abs(male - female) != 1) {
printf("-1\n");
return 0;
}
long long l = 0LL, r = 1e9 * (long long)n * m;
S = 0, T = n * m * 2 + male + female + 2;
if (male < female)
prepare(mdist[male + 1]);
else
prepare(fdist[female + 1]);
for (int i = 1; i <= male; ++i) prepare(mdist[i]);
for (int i = 1; i <= female; ++i) prepare(fdist[i]);
if (male < female)
++male;
else
++female;
if (!check(r + 1))
printf("-1\n");
else {
while (l < r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l << endl;
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
const int M = 13;
const int V = 1e6;
const int E = 1e6;
int eb[V], peb[V], e[E * 2], es[E * 2], ed = 1;
int ef[E * 2], ec[E * 2];
int S, T, v;
int d[V], o[V], r[V];
void init(int v) {
memset(eb, 0, sizeof(eb[0]) * v);
ed = 1;
}
void add_e(int v, int u, long long maxflow) {
++ed;
e[ed] = u;
ef[ed] = 0;
ec[ed] = maxflow;
es[ed] = eb[v];
eb[v] = ed;
++ed;
e[ed] = v;
ef[ed] = 0;
ec[ed] = 0;
es[ed] = eb[u];
eb[u] = ed;
}
int dfs(int v, int flow) {
if (!flow || v == T) return flow;
for (int& k = peb[v]; k; k = es[k]) {
int u = e[k];
if (d[v] != d[u] - 1) continue;
long long push = dfs(u, min(flow, ec[k] - ef[k]));
if (push) {
ef[k] += push;
ef[k ^ 1] -= push;
return push;
}
}
return 0;
}
bool bfs() {
memset(d, 0, v * sizeof(d[0]));
int h = 0, l = 0;
o[h++] = S;
d[S] = 1;
while (l < h) {
int v = o[l++];
for (int u, k = eb[v]; k; k = es[k]) {
u = e[k];
if (!d[u] && ec[k] > ef[k]) {
d[u] = d[v] + 1;
o[h++] = u;
}
}
}
return d[T];
}
int dinic() {
int flow = 0, inf = 1e9, pushed;
while (bfs()) {
memcpy(peb, eb, v * sizeof(eb[0]));
do {
pushed = dfs(S, inf);
flow += pushed;
} while (pushed);
}
return flow;
}
int dist[M][M][M][M];
char s[M][M];
void ff(int n, int m) {
for (int X = 1; X <= n; ++X)
for (int Y = 1; Y <= m; ++Y) {
vector<pair<int, int>> q;
dist[X][Y][X][Y] = 0;
q.push_back({X, Y});
for (int k = 0; k < q.size(); ++k) {
int x = q[k].first;
int y = q[k].second;
for (int dx = -1; dx < 2; ++dx)
for (int dy = -1; dy < 2; ++dy)
if (abs(dx) + abs(dy) == 1) {
int i = x + dx;
int j = y + dy;
if (i < 1 || i > n || j < 1 || j > m || s[i][j] == '#') continue;
if (dist[X][Y][i][j] > dist[X][Y][x][y] + 1) {
q.push_back({i, j});
dist[X][Y][i][j] = dist[X][Y][x][y] + 1;
}
}
}
}
}
int main() {
int n, m;
int c1, c2;
cin >> n >> m >> c1 >> c2;
if (abs(c1 - c2) != 1) return cout << -1, 0;
for (int i = 1; i <= n; ++i) cin >> (s[i] + 1);
vector<pair<int, int>> p1, p2;
vector<int> t1, t2;
int x, y, tm;
cin >> x >> y >> tm;
if (c1 + 1 == c2) {
t1.push_back(tm);
p1.push_back({x, y});
} else {
t2.push_back(tm);
p2.push_back({x, y});
}
for (int i = 0; i < c1; ++i) {
cin >> x >> y >> tm;
t1.push_back(tm);
p1.push_back({x, y});
}
for (int i = 0; i < c2; ++i) {
cin >> x >> y >> tm;
t2.push_back(tm);
p2.push_back({x, y});
}
memset(dist, 63, sizeof dist);
ff(n, m);
c1 = t1.size();
c2 = t2.size();
if (c1 > n * m) return cout << -1, 0;
long long ans = -1;
long long tl = 0, tr = 1e12;
while (tl < tr) {
long long t = (tl + tr) >> 1;
S = 0;
T = 1 + c1 + c2 + n * m * 2;
v = T + 1;
for (int i = 0; i < c1; ++i) add_e(S, i + 1, 1);
for (int i = 0; i < c1; ++i) add_e(i + 1 + c1 + n * m * 2, T, 1);
for (int x = 1; x <= n; ++x)
for (int y = 1; y <= m; ++y)
if (s[x][y] == '.') {
add_e(((x - 1) * m + y - 1) * 2 + 1 + c1,
((x - 1) * m + y - 1) * 2 + 1 + 1 + c1, 1);
}
for (int x = 1; x <= n; ++x)
for (int y = 1; y <= m; ++y)
if (s[x][y] == '.') {
for (int i = 0; i < c1; ++i) {
int ax = p1[i].first;
int ay = p1[i].second;
if (dist[x][y][ax][ay] > 1e9 ||
1LL * t1[i] * dist[x][y][ax][ay] > t)
continue;
add_e(i + 1, ((x - 1) * m + y - 1) * 2 + 1 + c1, 1);
}
for (int j = 0; j < c2; ++j) {
int bx = p2[j].first;
int by = p2[j].second;
if (dist[x][y][bx][by] > 1e9 ||
1LL * t2[j] * dist[x][y][bx][by] > t)
continue;
add_e(((x - 1) * m + y - 1) * 2 + 1 + 1 + c1,
j + 1 + c1 + n * m * 2, 1);
}
}
long long f = dinic();
if (f == c1) {
tr = t;
ans = t;
} else
tl = t + 1;
init(v);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
template <class T, class S>
struct maxflow {
int node, st, ed, *es, *emem, **edge, **rev, *level, *queue;
T **flow, eps;
void malloc(int N) {
int i;
es = (int *)std::malloc(N * sizeof(int));
emem = (int *)std::malloc(N * sizeof(int));
level = (int *)std::malloc(N * sizeof(int));
queue = (int *)std::malloc(N * sizeof(int));
edge = (int **)std::malloc(N * sizeof(int *));
rev = (int **)std::malloc(N * sizeof(int *));
flow = (T **)std::malloc(N * sizeof(T *));
for (i = 0; i < N; i++)
emem[i] = 0, edge[i] = rev[i] = NULL, flow[i] = NULL;
}
void *malloc(int N, void *mem) {
int i;
es = (int *)mem;
emem = es + N;
level = emem + N;
queue = level + N;
edge = (int **)(queue + N);
rev = edge + N;
flow = (T **)(rev + N);
for (i = 0; i < N; i++)
emem[i] = 0, edge[i] = rev[i] = NULL, flow[i] = NULL;
return (void *)(flow + N);
}
void levelize(void) {
int i, j, k, t, s = 0, e = 1;
for (i = 0; i < node; i++) level[i] = -1;
level[st] = 0;
queue[0] = st;
while (s != e) {
i = queue[s++];
t = level[i] + 1;
for (j = 0; j < es[i]; j++)
if (flow[i][j] > eps) {
k = edge[i][j];
if (level[k] != -1) continue;
level[k] = t;
queue[e++] = k;
if (k == ed) return;
}
}
}
S pushflow(int i, S lim) {
int j, k, l;
S s, t, r = 0;
if (i == ed) return lim;
for (j = 0; j < es[i]; j++)
if (flow[i][j] > eps) {
k = edge[i][j];
if (level[k] != level[i] + 1) continue;
s = min(lim, (S)flow[i][j]);
t = pushflow(k, s);
if (!t) continue;
r += t;
lim -= t;
l = rev[i][j];
flow[i][j] -= t;
flow[k][l] += t;
if (!lim) break;
}
if (lim) level[i] = -1;
return r;
}
S solve(int st_, int ed_) {
S r = 0;
st = st_;
ed = ed_;
for (;;) {
levelize();
if (level[ed] == -1) break;
r += pushflow(st, numeric_limits<S>::max());
}
return r;
}
void init(int N) {
int i;
node = N;
for (i = 0; i < N; i++) es[i] = 0;
eps = (T)1e-9;
}
void memoryExpand(int i, int sz) {
if (sz <= emem[i]) return;
sz = max(sz, max(3, emem[i] * 2));
edge[i] = (int *)realloc(edge[i], sz * sizeof(int));
rev[i] = (int *)realloc(rev[i], sz * sizeof(int));
flow[i] = (T *)realloc(flow[i], sz * sizeof(T));
}
void addEdge(int n1, int n2, T f1, T f2) {
int s1 = es[n1]++, s2 = es[n2]++;
if (s1 >= emem[n1]) memoryExpand(n1, es[n1]);
if (s2 >= emem[n2]) memoryExpand(n2, es[n2]);
edge[n1][s1] = n2;
edge[n2][s2] = n1;
flow[n1][s1] = f1;
flow[n2][s2] = f2;
rev[n1][s1] = s2;
rev[n2][s2] = s1;
}
void addEdgeAdv(int n1, int n2, T f1, T f2) {
int s1 = es[n1]++, s2 = es[n2]++;
edge[n1][s1] = n2;
edge[n2][s2] = n1;
flow[n1][s1] = f1;
flow[n2][s2] = f2;
rev[n1][s1] = s2;
rev[n2][s2] = s1;
}
void setGraph(int N, int M, int n1[], int n2[], int f1[], int f2[]) {
int i;
node = N;
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) es[n1[i]]++, es[n2[i]]++;
for (i = 0; i < N; i++) memoryExpand(i, es[i]);
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) addEdgeAdv(n1[i], n2[i], f1[i], f2[i]);
eps = (T)1e-9;
}
void *setGraph(int N, int M, int n1[], int n2[], T f1[], T f2[], void *mem) {
int i, j, k;
node = N;
for (i = 0; i < N; i++) es[i] = emem[i] = 0;
for (i = 0; i < M; i++) es[n1[i]]++, es[n2[i]]++;
edge[0] = (int *)mem;
for (i = 1; i < N; i++) edge[i] = edge[i - 1] + es[i - 1];
rev[0] = edge[N - 1] + es[N - 1];
for (i = 1; i < N; i++) rev[i] = rev[i - 1] + es[i - 1];
flow[0] = (T *)(rev[N - 1] + es[N - 1]);
for (i = 1; i < N; i++) flow[i] = flow[i - 1] + es[i - 1];
mem = (void *)(flow[N - 1] + es[N - 1]);
for (i = 0; i < N; i++) es[i] = 0;
for (i = 0; i < M; i++) addEdgeAdv(n1[i], n2[i], f1[i], f2[i]);
eps = (T)1e-9;
return mem;
}
};
char memarr[17000000];
void *mem = memarr;
int X, Y, XY;
char mp[22][22];
int dist[444][444];
int M, F;
int mx[1000], my[1000], mt[1000], mxy[1000];
int fx[1000], fy[1000], ft[1000], fxy[1000];
int main() {
int i, j, k;
int bx, by, bt;
int node, st, ed;
long long A, B, C;
maxflow<int, int> flow;
reader(&X, &Y, &M, &F);
XY = X * Y;
if (!(M + 1 == F || M == F + 1)) {
writerLn(-1);
return 0;
}
for (i = 0; i < X; i++) reader(mp[i]);
reader(&bx, &by, &bt);
for (i = 0; i < M; i++) reader(mx + i, my + i, mt + i);
for (i = 0; i < F; i++) reader(fx + i, fy + i, ft + i);
if (M < F)
mx[M] = bx, my[M] = by, mt[M] = bt, M++;
else
fx[F] = bx, fy[F] = by, ft[F] = bt, F++;
for (i = 0; i < XY; i++)
for (j = 0; j < XY; j++) dist[i][j] = 1000000000;
for (i = 0; i < XY; i++) dist[i][i] = 0;
for (i = 0; i < X; i++)
for (j = 0; j < Y; j++)
if (mp[i][j] == '.') {
if (i && mp[i - 1][j] == '.') {
dist[i * Y + j][(i - 1) * Y + j] = 1;
dist[(i - 1) * Y + j][i * Y + j] = 1;
}
if (j && mp[i][j - 1] == '.') {
dist[i * Y + j][i * Y + (j - 1)] = 1;
dist[i * Y + (j - 1)][i * Y + j] = 1;
}
}
for (k = 0; k < XY; k++)
for (i = 0; i < XY; i++)
for (j = 0; j < XY; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
node = M + F + XY + XY;
st = node++;
ed = node++;
flow.malloc(node);
for (i = 0; i < M; i++) mxy[i] = (mx[i] - 1) * Y + (my[i] - 1);
for (i = 0; i < F; i++) fxy[i] = (fx[i] - 1) * Y + (fy[i] - 1);
A = 0;
B = 1000000000000000LL;
while (A < B) {
C = (A + B) / 2;
flow.init(node);
for (i = 0; i < M; i++) flow.addEdge(st, i, 1, 0);
for (i = 0; i < M; i++) flow.addEdge(M + XY + XY + i, ed, 1, 0);
for (i = 0; i < XY; i++) flow.addEdge(M + i, M + XY + i, 1, 0);
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[mxy[i]][j];
if (k == 1000000000) continue;
if ((long long)k * mt[i] > C) continue;
flow.addEdge(i, M + j, 1, 0);
}
for (i = 0; i < M; i++)
for (j = 0; j < XY; j++) {
k = dist[fxy[i]][j];
if (k == 1000000000) continue;
if ((long long)k * ft[i] > C) continue;
flow.addEdge(M + XY + j, M + XY + XY + i, 1, 0);
}
k = flow.solve(st, ed);
if (k == M)
B = C;
else
A = C + 1;
}
if (A >= 1000000000000000LL) A = -1;
writerLn(A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25, M = 505;
char mp[N][N];
int n, m, A, B, nd;
int d[M][M], id[N][N];
int xa[M], ya[M], va[M];
int xb[M], yb[M], vb[M];
int head[M * 4], tot, S, T;
int dis[M * 4], q[M * 4], cur[N * 4];
struct edge {
int to, next, f, v;
} e[M * M * 10];
void add(int x, int y, int f) {
e[++tot] = (edge){y, head[x], f};
head[x] = tot;
e[++tot] = (edge){x, head[y], 0};
head[y] = tot;
}
bool bfs() {
for (int i = (int)(1); i <= (int)(T); i++) dis[i] = -1;
int h = 0, t = 1;
q[1] = S;
dis[S] = 0;
while (h != t) {
int x = q[++h];
for (int i = head[x]; i; i = e[i].next)
if (dis[e[i].to] == -1 && e[i].f) {
dis[e[i].to] = dis[x] + 1;
q[++t] = e[i].to;
if (e[i].to == T) return 1;
}
}
return 0;
}
int dfs(int x, int flow) {
if (x == T) return flow;
int k, rest = flow;
for (int i = head[x]; i; i = e[i].next)
if (dis[e[i].to] == dis[x] + 1 && e[i].f) {
k = dfs(e[i].to, min(rest, e[i].f));
e[i].f -= k;
e[i ^ 1].f += k;
rest -= k;
if (!rest) break;
}
if (rest) dis[x] = -1;
return flow - rest;
}
bool check(long long v) {
tot = 1;
memset(head, 0, sizeof(head));
if (A > nd) return 0;
S = 2 * (nd + A) + 1;
T = S + 1;
for (int i = (int)(1); i <= (int)(A); i++) add(S, i, 1);
for (int i = (int)(1); i <= (int)(A); i++) add(i + A + nd + nd, T, 1);
for (int i = (int)(1); i <= (int)(nd); i++) add(A + i, A + nd + i, 1);
for (int i = (int)(1); i <= (int)(A); i++) {
int p = id[xa[i]][ya[i]];
for (int j = (int)(1); j <= (int)(nd); j++)
if (d[p][j] <= 500 && 1ll * d[p][j] * va[i] <= v) add(i, A + j, 1);
}
for (int i = (int)(1); i <= (int)(A); i++) {
int p = id[xb[i]][yb[i]];
for (int j = (int)(1); j <= (int)(nd); j++)
if (d[p][j] <= 500 && 1ll * d[p][j] * vb[i] <= v)
add(A + nd + j, A + nd + nd + i, 1);
}
int sum = 0;
for (; bfs();) {
sum += dfs(S, 1 << 30);
}
return sum == A;
}
int main() {
scanf("%d%d%d%d", &n, &m, &A, &B);
if (abs(A - B) != 1) return puts("-1"), 0;
for (int i = (int)(1); i <= (int)(n); i++) scanf("%s", mp[i] + 1);
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++)
if (mp[i][j] == '.') id[i][j] = ++nd;
for (int i = (int)(1); i <= (int)(nd); i++)
for (int j = (int)(1); j <= (int)(nd); j++) d[i][j] = 1 << 29;
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++) {
if (id[i][j] && id[i][j + 1]) {
d[id[i][j]][id[i][j + 1]] = 1;
d[id[i][j + 1]][id[i][j]] = 1;
}
if (id[i][j] && id[i + 1][j]) {
d[id[i][j]][id[i + 1][j]] = 1;
d[id[i + 1][j]][id[i][j]] = 1;
}
}
for (int i = (int)(1); i <= (int)(nd); i++) d[i][i] = 0;
for (int k = (int)(1); k <= (int)(nd); k++)
for (int i = (int)(1); i <= (int)(nd); i++)
for (int j = (int)(1); j <= (int)(nd); j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
if (A < B)
scanf("%d%d%d", &xa[B], &ya[B], &va[B]);
else
scanf("%d%d%d", &xb[A], &yb[A], &vb[A]);
for (int i = (int)(1); i <= (int)(A); i++)
scanf("%d%d%d", &xa[i], &ya[i], &va[i]);
for (int i = (int)(1); i <= (int)(B); i++)
scanf("%d%d%d", &xb[i], &yb[i], &vb[i]);
A = max(A, B);
if (!check(n * m * (1ll << 30))) return puts("-1"), 0;
long long l = 0, r = n * m * (1ll << 30), ans = -233;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int females, males;
int N, M;
string cell[30];
int cap[500][500], flow[500][500];
int vis[500], par[500];
vector<vector<int> > adj;
int max_flow;
int S = 498, T = 499, INF = 123456;
bool possible;
int augment_path(int v, int mf) {
if (v == S) return mf;
int u = par[v];
bool backedge = false;
if (flow[v][u] > 0) {
backedge = true;
}
if (backedge) {
mf = min(mf, flow[v][u]);
} else {
mf = min(mf, cap[u][v] - flow[u][v]);
}
mf = augment_path(u, mf);
if (backedge) {
flow[v][u] -= mf;
} else {
flow[u][v] += mf;
}
return mf;
}
bool edmondskarp() {
max_flow = 0;
while (1) {
bool augmented = false;
queue<int> q;
for (int i = 0; i < 500; ++i) {
vis[i] = 0;
}
q.push(S);
vis[S] = 1;
vis[T] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (vis[v]) continue;
if (cap[u][v] - flow[u][v] > 0 || flow[v][u] > 0) {
vis[v] = 1;
par[v] = u;
if (v == T) {
augmented = true;
int f = augment_path(T, INF);
max_flow += f;
break;
} else {
q.push(v);
}
}
}
if (augmented) break;
}
if (!augmented) break;
}
return (max_flow == males);
}
long long dist[500][500], DINF = (long long)1e14;
int bfs[30][30];
int Q, R;
void next_bfs(int x, int y, int d, queue<pair<pair<int, int>, int> > &q) {
if (x < 0 || y < 0 || x >= N || y >= M) return;
if (cell[x][y] != '#' && !bfs[x][y]) {
bfs[x][y] = 1;
q.push(make_pair(make_pair(x, y), d + 1));
}
}
void get_dist(int i, int r, int c, int t) {
--r;
--c;
for (int i = 0; i < 30; ++i)
for (int j = 0; j < 30; ++j) bfs[i][j] = 0;
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(r, c), 0));
bfs[r][c] = 1;
while (!q.empty()) {
int x = q.front().first.first;
int y = q.front().first.second;
int d = q.front().second;
q.pop();
dist[i][x * M + y + Q] = 1LL * d * t;
next_bfs(x - 1, y, d, q);
next_bfs(x, y - 1, d, q);
next_bfs(x + 1, y, d, q);
next_bfs(x, y + 1, d, q);
}
}
bool solve(long long max_dist) {
for (int i = 0; i < 500; ++i) {
for (int j = 0; j < 500; ++j) {
cap[i][j] = flow[i][j] = 0;
}
}
adj = vector<vector<int> >(503);
for (int i = Q; i < R; ++i) {
adj[i].push_back(i + M * N);
adj[i + M * N].push_back(i);
cap[i][i + M * N] = 1;
}
for (int i = 0; i < Q; ++i) {
if (i < males) {
cap[S][i] = 1;
adj[S].push_back(i);
adj[i].push_back(S);
} else {
cap[i][T] = 1;
adj[i].push_back(T);
adj[T].push_back(i);
}
for (int j = Q; j < R; ++j) {
if (dist[i][j] <= max_dist) {
if (i < males) {
cap[i][j] = 1;
adj[i].push_back(j);
adj[j].push_back(i);
} else {
cap[j + M * N][i] = 1;
adj[j + M * N].push_back(i);
adj[i].push_back(j + M * N);
}
}
}
}
return edmondskarp();
}
int main() {
possible = false;
int r, c, t;
scanf("%d%d%d%d", &N, &M, &males, &females);
if (males + 1 != females && females + 1 != males) {
printf("-1\n");
return 0;
}
bool is_male = false;
if (males < females) {
++males;
is_male = true;
} else {
++females;
}
Q = males + females;
R = Q + N * M;
for (int i = 0; i < N; ++i) {
cin >> cell[i];
}
for (int i = 0; i < 500; ++i) {
for (int j = 0; j < 500; ++j) {
dist[i][j] = DINF;
}
}
scanf("%d%d%d", &r, &c, &t);
if (is_male) {
get_dist(0, r, c, t);
} else {
get_dist(males, r, c, t);
}
for (int i = (is_male ? 1 : 0); i < males; ++i) {
scanf("%d%d%d", &r, &c, &t);
get_dist(i, r, c, t);
}
for (int i = (is_male ? males : males + 1); i < males + females; ++i) {
scanf("%d%d%d", &r, &c, &t);
get_dist(i, r, c, t);
}
long long lo = 0, hi = (long long)1e13, mid;
while (lo <= hi) {
mid = (lo + hi) / 2LL;
if (solve(mid)) {
possible = true;
hi = mid - 1LL;
} else {
lo = mid + 1LL;
}
}
if (possible)
cout << lo << endl;
else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int U = 22;
namespace G {
const int N = 1e3 + 5;
const int M = 1e6 + 5;
const int INF = 0x3f3f3f3f;
int head[N], E = 1;
struct Edge {
int to, next, flow;
} e[M];
inline void addEdge(int u, int v, int flow) {
e[++E] = (Edge){v, head[u], flow};
head[u] = E;
}
inline void addE(int u, int v, int flow) {
addEdge(u, v, flow);
addEdge(v, u, 0);
}
int dis[N];
int S, T;
inline bool bfs() {
memset(dis, 0x3f, sizeof(dis));
queue<int> q;
dis[S] = 0;
q.emplace(S);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u], v, w; v = e[i].to, w = e[i].flow, i; i = e[i].next) {
if (dis[v] == INF && w != 0) {
dis[v] = dis[u] + 1;
q.emplace(v);
}
}
}
return dis[T] != INF;
}
int dfs(int u, int flow) {
if (u == T || flow == 0) {
return flow;
}
int res = 0;
for (int i = head[u], v, w; v = e[i].to, w = e[i].flow, i; i = e[i].next) {
if (w != 0 && dis[v] == dis[u] + 1) {
w = dfs(v, std::min(flow, w));
if (w != 0) {
flow -= w;
res += w;
e[i].flow -= w;
e[i ^ 1].flow += w;
if (flow == 0) {
break;
}
}
}
}
if (!res) {
dis[u] = -1;
}
return res;
}
inline int dinic() {
int res = 0;
while (bfs()) {
res += dfs(S, INF);
}
return res;
}
} // namespace G
const int P = U + 5;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int n, m, male, female;
char mp[P][P];
struct Scayger {
int dis[P][P];
int x, y, speed;
inline void calc() {
memset(dis, 0x3f, sizeof(dis));
dis[x][y] = 0;
queue<tuple<int, int, int>> q;
q.emplace(0, x, y);
int w, lx, ly, nx, ny;
while (!q.empty()) {
auto t = q.front();
q.pop();
tie(w, lx, ly) = t;
if (w == dis[lx][ly]) {
for (int i = 0; i < 4; ++i) {
nx = lx + dx[i], ny = ly + dy[i];
if (mp[nx][ny] == '.') {
if (dis[nx][ny] > w + 1) {
dis[nx][ny] = w + 1;
q.emplace(dis[nx][ny], nx, ny);
}
}
}
}
}
}
};
Scayger M[P * P], F[P * P];
inline void buildGraph(long long tim) {
using G::addE;
using G::E;
using G::head;
using G::S;
using G::T;
memset(head, 0, sizeof(head));
E = 1;
S = 0, T = male + female + 2 * n * m + 1;
for (int u = 1; u <= male; ++u) {
addE(S, (u), 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (M[u].dis[i][j] != G::INF &&
(long long)M[u].dis[i][j] * M[u].speed <= tim) {
addE((u), (male + female + (i - 1) * m + (j)), 1);
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
addE((male + female + (i - 1) * m + (j)),
(male + female + n * m + (i - 1) * m + (j)), 1);
}
}
for (int u = 1; u <= female; ++u) {
addE((male + (u)), T, 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (F[u].dis[i][j] != G::INF &&
(long long)F[u].dis[i][j] * F[u].speed <= tim) {
addE((male + female + n * m + (i - 1) * m + (j)), (male + (u)), 1);
}
}
}
}
}
int main() {
read(n), read(m), read(male), read(female);
for (int i = 1; i <= n; ++i) {
scanf("%s", mp[i] + 1);
}
if (male - female == -1) {
++male;
for (int i = 1; i <= male; ++i) {
read(M[i].x), read(M[i].y), read(M[i].speed);
}
for (int i = 1; i <= female; ++i) {
read(F[i].x), read(F[i].y), read(F[i].speed);
}
} else if (male - female == 1) {
++female;
read(F[1].x), read(F[1].y), read(F[1].speed);
for (int i = 1; i <= male; ++i) {
read(M[i].x), read(M[i].y), read(M[i].speed);
}
for (int i = 2; i <= female; ++i) {
read(F[i].x), read(F[i].y), read(F[i].speed);
}
} else {
puts("-1");
return 0;
}
for (int i = 1; i <= male; ++i) {
M[i].calc();
}
for (int i = 1; i <= female; ++i) {
F[i].calc();
}
long long l = 0, r = 1LL << 40, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
buildGraph(mid);
if (G::dinic() == male) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char Map[25][25];
int id[25][25];
struct sss {
int x, y, v;
} G[500], B[500], X;
int n, m, g, b, p;
int st, ed;
pair<int, int> space[500];
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};
struct edge {
int to, rev;
int cap, flo;
edge() {}
edge(int t, int r, int c) : to(t), rev(r), cap(c), flo(0) {}
long long int rem() { return cap - flo; }
};
int lev[2000], nxt[2000];
vector<edge> _G[2000];
struct maxflow {
int N, second, T;
long long int flow;
maxflow(int N, int second = 0, int T = -1)
: N(N), second(second), T(T < 0 ? N + T : T) {
flow = 0;
for (int i = 0; i <= N; i++) _G[i].clear();
}
void addedge(int A, int B, int C) {
_G[A].push_back(edge(B, _G[B].size(), C)),
_G[B].push_back(edge(A, _G[A].size() - 1, 0));
}
void flood() {
while (BFS()) flow += DFS(second, 10000000);
}
bool BFS() {
fill(nxt, nxt + N, 0);
fill(lev, lev + N, -1);
queue<int> q;
lev[second] = 0, q.push(second);
while (q.size()) {
int i = q.front();
q.pop();
for (int j = 0; j < _G[i].size(); j++)
if (_G[i][j].rem() != 0 && lev[_G[i][j].to] == -1)
lev[_G[i][j].to] = lev[i] + 1, q.push(_G[i][j].to);
}
return lev[T] != -1;
}
long long int DFS(int i, long long int rem) {
if (i == T) return rem;
long long int all = rem;
for (int j = nxt[i]; j < _G[i].size(); j++, nxt[i]++) {
if (_G[i][j].rem() == 0 || lev[i] >= lev[_G[i][j].to]) continue;
long long int add = DFS(_G[i][j].to, min(rem, _G[i][j].rem()));
_G[i][j].flo += add, rem -= add;
_G[_G[i][j].to][_G[i][j].rev].flo -= add;
if (rem == 0) break;
}
return all - rem;
}
};
int check(long long int t) {
int i, j, k;
st = 0, ed = b + g + p + p + 1;
maxflow mf(ed + 1, st, ed);
for (i = 0; i < b; i++) {
mf.addedge(st, i + 1, 1);
}
for (i = 0; i < g; i++) {
mf.addedge(i + b + 1, ed, 1);
}
for (i = 0; i < b; i++) {
long long int vis[25][25];
for (j = 0; j < n; j++)
for (k = 0; k < m; k++) vis[j][k] = -1;
int nx = B[i].x, ny = B[i].y;
queue<pair<int, int> > q;
q.push(make_pair(nx, ny));
mf.addedge(i + 1, id[nx][ny] + 1 + b + g, 1);
vis[nx][ny] = 0;
while (!q.empty() && vis[nx][ny] <= t) {
nx = q.front().first;
ny = q.front().second;
q.pop();
for (j = 0; j < 4; j++) {
int mx = nx + dx[j], my = ny + dy[j];
if (mx < 0 || mx >= n || my < 0 || my > m || Map[mx][my] == '#' ||
vis[mx][my] != -1)
continue;
q.push(make_pair(mx, my));
vis[mx][my] = vis[nx][ny] + B[i].v;
if (vis[mx][my] <= t) mf.addedge(i + 1, id[mx][my] + 1 + b + g, 1);
}
}
}
for (i = 0; i < g; i++) {
long long int vis[25][25];
for (j = 0; j < n; j++)
for (k = 0; k < m; k++) vis[j][k] = -1;
int nx = G[i].x, ny = G[i].y;
queue<pair<int, int> > q;
q.push(make_pair(nx, ny));
mf.addedge(id[nx][ny] + 1 + p + b + g, i + b + 1, 1);
vis[nx][ny] = 0;
while (!q.empty() && vis[nx][ny] <= t) {
nx = q.front().first;
ny = q.front().second;
q.pop();
for (j = 0; j < 4; j++) {
int mx = nx + dx[j], my = ny + dy[j];
if (mx < 0 || mx >= n || my < 0 || my > m || Map[mx][my] == '#' ||
vis[mx][my] != -1)
continue;
q.push(make_pair(mx, my));
vis[mx][my] = vis[nx][ny] + G[i].v;
if (vis[mx][my] <= t)
mf.addedge(id[mx][my] + 1 + p + b + g, i + b + 1, 1);
}
}
}
for (i = 0; i < p; i++) {
int xx = space[i].first, yy = space[i].second;
mf.addedge(id[xx][yy] + 1 + b + g, id[xx][yy] + 1 + b + g + p, 1);
}
mf.flood();
if (mf.flow == g) return 1;
return 0;
}
int main(void) {
scanf("%d%d%d%d", &n, &m, &b, &g);
int i, j;
p = 0;
for (i = 0; i < n; i++) {
char s[25];
scanf("%s", s);
for (j = 0; j < m; j++) {
Map[i][j] = s[j];
if (Map[i][j] == '.') {
space[p].first = i, space[p].second = j, id[i][j] = p, p++;
}
}
}
scanf("%d%d%d", &X.x, &X.y, &X.v);
X.x--, X.y--;
for (i = 0; i < b; i++) {
scanf("%d%d%d", &B[i].x, &B[i].y, &B[i].v);
B[i].x--, B[i].y--;
}
for (i = 0; i < g; i++) {
scanf("%d%d%d", &G[i].x, &G[i].y, &G[i].v);
G[i].x--, G[i].y--;
}
if (g + 1 == b) {
G[g] = X;
g++;
} else if (b + 1 == g) {
B[b] = X;
b++;
} else {
printf("-1\n");
return 0;
}
long long int l = 0, r = 500000000000LL;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
if (l >= 500000000000LL)
printf("-1\n");
else
printf("%I64d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int MAXN = 24;
const int MAXA = 514;
const int INF = 1029384756;
class Isap {
public:
static const int MXN = MAXA * 4;
class Edge {
public:
int v, f, re;
Edge() { v = f = re = -1; }
Edge(int _v, int _f, int _r) {
v = _v;
f = _f;
re = _r;
}
};
int n, s, t, h[MXN], gap[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, int f) {
E[u].push_back(Edge(v, f, E[v].size()));
E[v].push_back(Edge(u, 0, E[u].size() - 1));
}
int DFS(int u, int nf, int res = 0) {
if (u == t) return nf;
for (auto &it : E[u]) {
if (h[u] == h[it.v] + 1 && it.f > 0) {
int tf = DFS(it.v, min(nf, it.f));
res += tf;
nf -= tf;
it.f -= tf;
E[it.v][it.re].f += tf;
if (nf == 0) return res;
}
}
if (nf) {
if (--gap[h[u]] == 0) h[s] = n;
gap[++h[u]]++;
}
return res;
}
int flow(int res = 0) {
memset((h), 0, sizeof(h));
memset((gap), 0, sizeof(gap));
gap[0] = n;
while (h[s] < n) res += DFS(s, 2147483647);
return res;
}
} flow;
int N, M, L;
bool arr[MAXN][MAXN];
int r[MAXA * 2], c[MAXA * 2];
long long t[MAXA * 2];
int no[MAXN][MAXN];
int dis[MAXA][MAXA];
vector<int> edge[MAXA];
void dijk() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (!arr[i][j]) continue;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx >= 0 && nx < N && ny >= 0 && ny < M && arr[nx][ny])
edge[no[i][j]].push_back(no[nx][ny]);
}
}
}
for (int i = 0; i < N * M; i++)
for (int j = 0; j < N * M; j++) dis[i][j] = INF;
for (int i = 0; i < N * M; i++) dis[i][i] = 0;
for (int i = 0; i < N * M; i++) {
queue<int> q;
q.push(i);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto u : edge[v]) {
if (dis[i][u] == INF) {
dis[i][u] = dis[i][v] + 1;
q.push(u);
}
}
}
}
}
bool test(long long m) {
int n = 2 * L + 2 * N * M + 2;
int ss = n - 2, tt = n - 1;
flow.init(n, ss, tt);
for (int i = 0; i < 2 * L; i++) {
int x = r[i], y = c[i];
int v = no[x][y];
if (i < L)
flow.add_edge(ss, i, 1);
else
flow.add_edge(i, tt, 1);
for (int u = 0; u < N * M; u++) {
if (dis[v][u] == INF || t[i] * dis[v][u] > m) continue;
if (i < L)
flow.add_edge(i, 2 * L + u, 1);
else
flow.add_edge(2 * L + N * M + u, i, 1);
}
}
for (int i = 0; i < N * M; i++)
flow.add_edge(2 * L + i, 2 * L + N * M + i, 1);
int res = flow.flow();
return res == L;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int male, female;
cin >> N >> M >> male >> female;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < M; j++) arr[i][j] = (s[j] == '.');
}
L = max(male, female);
if (male == female - 1)
cin >> r[L - 1] >> c[L - 1] >> t[L - 1];
else if (male == female + 1)
cin >> r[2 * L - 1] >> c[2 * L - 1] >> t[2 * L - 1];
else {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < male; i++) cin >> r[i] >> c[i] >> t[i];
for (int i = 0; i < female; i++) cin >> r[L + i] >> c[L + i] >> t[L + i];
for (int i = 0; i < 2 * L; i++) {
r[i]--;
c[i]--;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) no[i][j] = i * M + j;
dijk();
long long mx = 1E12;
long long lb = 0, rb = mx;
while (lb < rb) {
long long mb = (lb + rb) / 2;
if (test(mb))
rb = mb;
else
lb = mb + 1;
}
long long ans = lb;
if (ans == mx) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long flow;
long long cap;
long long next;
long long inv;
};
const long long N = 1100000;
const long long inf = (long long)1e9;
vector<edge> v[N];
bool vis[N];
long long from[N];
long long RES_FLOW = 0;
vector<pair<long long, pair<long long, long long> > > edges;
vector<pair<long long, long long> > ness_edges;
void add_edge(long long x1, long long x2, long long x3) {
edge x;
x.flow = 0;
x.cap = x3;
x.next = x2;
x.inv = v[x2].size();
v[x1].push_back(x);
x.flow = 0;
x.cap = 0;
x.next = x1;
x.inv = v[x1].size() - 1;
v[x2].push_back(x);
}
void init() {
for (long long i = 0; i < N; i++) v[i].clear();
RES_FLOW = 0;
for (long long i = 0; i < ness_edges.size(); i++)
add_edge(ness_edges[i].first, ness_edges[i].second, 1);
}
string a[50];
long long females[500][3];
long long males[500][3];
vector<pair<long long, pair<long long, long long> > > v2[800];
long long maxflow(long long n) {
long long res_flow = 0;
while (true) {
queue<long long> q;
for (long long i = 0; i < n; i++) {
vis[i] = false;
}
q.push(0);
while (!q.empty()) {
long long x = q.front();
q.pop();
for (long long i = 0; i < v[x].size(); i++)
if (!vis[v[x][i].next] && v[x][i].cap > v[x][i].flow) {
q.push(v[x][i].next);
vis[v[x][i].next] = true;
from[v[x][i].next] = v[x][i].inv;
}
}
if (!vis[n - 1]) break;
long long dflow = inf;
long long x = n - 1;
while (x != 0) {
long long a = v[x][from[x]].next;
long long b = v[x][from[x]].inv;
dflow = min(dflow, v[a][b].cap - v[a][b].flow);
x = a;
}
x = n - 1;
while (x != 0) {
long long a = v[x][from[x]].next;
long long b = v[x][from[x]].inv;
v[a][b].flow += dflow;
v[x][from[x]].flow -= dflow;
x = a;
}
res_flow += dflow;
}
RES_FLOW += res_flow;
return RES_FLOW;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
long long x1, x2, cm, cf;
cin >> x1 >> x2 >> cm >> cf;
for (long long i = 0; i < x1; i++) cin >> a[i];
if (abs(cm - cf) != 1) {
cout << "-1";
return 0;
}
long long a1, a2, a3;
cin >> a1 >> a2 >> a3;
long long maxt = a3;
for (long long i = 0; i < cm; i++) {
cin >> males[i][0] >> males[i][1] >> males[i][2];
maxt = max(maxt, males[i][2]);
}
for (long long i = 0; i < cf; i++) {
cin >> females[i][0] >> females[i][1] >> females[i][2];
maxt = max(maxt, females[i][2]);
}
if (cm == cf + 1) {
females[cf][0] = a1;
females[cf][1] = a2;
females[cf][2] = a3;
cf = cm;
} else {
males[cm][0] = a1;
males[cm][1] = a2;
males[cm][2] = a3;
cm = cf;
}
long long left = -1;
long long right = maxt * 2 * (x1 + x2) + 1;
for (long long i = 0; i < cm; i++) {
ness_edges.push_back(make_pair(0, i + 1));
}
for (long long j = 0; j < x1; j++)
for (long long k = 0; k < x2; k++) {
ness_edges.push_back(
make_pair(j * x2 + k + cm + 1, j * x2 + k + cm + 1 + x1 * x2));
}
for (long long i = 0; i < cm + cf; i++) {
long long x3;
long long x4;
long long t;
if (i < cm) {
x3 = males[i][0];
x4 = males[i][1];
t = males[i][2];
} else {
x3 = females[i - cm][0];
x4 = females[i - cm][1];
t = females[i - cm][2];
}
x3--;
x4--;
queue<pair<pair<long long, long long>, long long> > q;
q.push(make_pair(make_pair(x3, x4), 0));
vector<pair<long long, long long> > dir;
dir.push_back(make_pair(0, -1));
dir.push_back(make_pair(0, 1));
dir.push_back(make_pair(1, 0));
dir.push_back(make_pair(-1, 0));
bool visited[50][50];
for (long long j = 0; j < x1; j++)
for (long long k = 0; k < x2; k++) visited[j][k] = false;
visited[x3][x4] = true;
while (!q.empty()) {
long long x3 = q.front().first.first;
long long x4 = q.front().first.second;
long long dd = q.front().second;
if (i < cm) {
edges.push_back(
make_pair(dd * t, make_pair(i + 1, x3 * x2 + x4 + cm + 1)));
} else {
edges.push_back(
make_pair(dd * t, make_pair(x3 * x2 + x4 + cm + 1 + x1 * x2,
x1 * x2 * 2 + cm + 1 + i - cm)));
}
q.pop();
for (long long j = 0; j < 4; j++) {
long long nx3 = x3 + dir[j].first;
long long nx4 = x4 + dir[j].second;
if (nx3 >= 0 && nx3 < x1 && nx4 >= 0 && nx4 < x2)
if (!visited[nx3][nx4] && a[nx3][nx4] == '.') {
visited[nx3][nx4] = true;
q.push(make_pair(make_pair(nx3, nx4), dd + 1));
}
}
}
}
for (long long i = 0; i < cf; i++) {
ness_edges.push_back(make_pair(x1 * x2 * 2 + cf + cm + 1 + i - cm,
x1 * x2 * 2 + cm + 1 + cf * 2 - cm));
}
long long n = x1 * x2 * 2 + cm + 1 + cf * 2 - cm + 1;
sort(edges.begin(), edges.end());
long long now = 0;
long long now2 = 0;
while (now < edges.size()) {
long long buf = edges[now].first;
while (now < edges.size() && edges[now].first == buf) {
v2[now2].push_back(edges[now]);
now++;
}
if (v2[now2].size() >= 700) now2++;
}
now2++;
long long sum = 0;
for (long long i = 0; i < now2; i++) {
sum += v2[i].size();
}
init();
long long gr = 0;
for (long long i = 0; i < now2; i++) {
for (long long j = 0; j < v2[i].size(); j++)
add_edge(v2[i][j].second.first, v2[i][j].second.second, 1);
long long fl = maxflow(n);
gr = i;
if (fl == cf) break;
}
init();
for (long long i = 0; i < gr; i++) {
for (long long j = 0; j < v2[i].size(); j++)
add_edge(v2[i][j].second.first, v2[i][j].second.second, 1);
}
now = 0;
while (now < v2[gr].size()) {
long long buf = v2[gr][now].first;
while (now < v2[gr].size() && v2[gr][now].first == buf) {
add_edge(v2[gr][now].second.first, v2[gr][now].second.second, 1);
now++;
}
long long fl = maxflow(n);
if (fl == cf) {
cout << buf;
return 0;
}
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
double pi = acos((double)-1);
const int MOD = 1000000007;
const int INF = 1000000007;
const double EPS = 1e-9;
const long long LLONG_INF = 1223372036854775807LL;
const int MAXN = 22 + 1;
const int MAX_GRAPH_N = 2000;
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << endl;
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
int field[MAXN][MAXN];
long long times[MAXN][MAXN];
struct scayger {
int r, c, t;
};
struct edge {
long long time;
int from, to;
friend bool operator<(const edge& e1, const edge& e2) {
return e1.time < e2.time;
}
friend bool operator>(const edge& e1, const edge& e2) {
return e1.time > e2.time;
}
};
int graph[MAX_GRAPH_N][MAX_GRAPH_N];
int r_graph[MAX_GRAPH_N][MAX_GRAPH_N];
long long graph_times[MAX_GRAPH_N][MAX_GRAPH_N];
void bfs(int x, int y, int t, long long time, int n, int m) {
times[x][y] = time;
bool changed = true;
while (changed) {
changed = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx >= 0 && nx < MAXN && ny >= 0 && ny < MAXN && field[nx][ny]) {
if (times[i][j] + t < times[nx][ny]) {
times[nx][ny] = times[i][j] + t;
changed = true;
}
}
}
}
}
}
}
void init_times() {
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < MAXN; k++) times[j][k] = LLONG_INF;
}
class QuickSort {
void random_shuffle(vector<edge>& a) {
srand(time(0));
for (int i = a.size() - 1; i > 0; i--) {
int j = rand() % (i + 1);
swap(a[i], a[j]);
}
}
int partition(vector<edge>& a, int lo, int hi) {
int i = lo, j = hi + 1;
edge v = a[lo];
while (true) {
while (a[++i] > v) {
if (i == hi) break;
}
while (a[--j] < v) {
if (j == lo) break;
}
if (i >= j) break;
swap(a[i], a[j]);
}
swap(a[lo], a[j]);
return j;
}
void quicksort(vector<edge>& a, int lo, int hi) {
if (lo >= hi) return;
int j = partition(a, lo, hi);
quicksort(a, lo, j - 1);
quicksort(a, j + 1, hi);
}
void quicksort(vector<edge>& a) {
random_shuffle(a);
quicksort(a, 0, a.size() - 1);
}
public:
QuickSort(vector<edge>& a) { quicksort(a); }
};
class FordFulkerson {
char* visited;
int* p;
long long time;
long long add_edges_to_graph(int size, vector<edge>& new_edges) {
long long time = new_edges.back().time;
while (new_edges.size()) {
auto e = new_edges.back();
if (e.time > time) break;
graph[e.from][e.to] = 1;
r_graph[e.from][e.to] = 1;
graph_times[e.from][e.to] = e.time;
new_edges.pop_back();
}
return time;
}
bool has_augmenting_path(int size) {
for (int i = 0; i < size; i++) visited[i] = false;
int s = 0, t = size - 1;
deque<int> nodes_to_visit;
nodes_to_visit.push_back(s);
visited[s] = true;
p[s] = -1;
while (!nodes_to_visit.empty()) {
int v = nodes_to_visit.front();
nodes_to_visit.pop_front();
for (int i = 0; i < size; i++) {
int to = i;
if (!visited[to] && r_graph[v][to] > 0) {
p[to] = v;
visited[to] = true;
nodes_to_visit.push_back(to);
}
}
}
return visited[t];
}
long long ford_fulkerson(int size, vector<edge>& new_edges, int k) {
long long time = 0;
long long value = 0;
while (!new_edges.empty()) {
time = add_edges_to_graph(size, new_edges);
int s = 0, t = size - 1;
while (has_augmenting_path(size)) {
int bottle = INF;
for (int v = t; v != s; v = p[v]) {
bottle = min(bottle, r_graph[p[v]][v]);
}
for (int v = t; v != s; v = p[v]) {
r_graph[p[v]][v] -= bottle;
r_graph[v][p[v]] += bottle;
}
value += bottle;
}
if (value >= k) break;
}
if (value < k || time >= LLONG_INF)
return -1;
else
return time;
}
public:
long long get_time() { return time; }
FordFulkerson(int size, vector<edge>& new_edges, int k) {
p = new int[size];
visited = new char[size];
time = ford_fulkerson(size, new_edges, k);
}
};
int main() {
ios_base::sync_with_stdio(0);
clock_t tStart = clock();
int tests = 1;
for (int test = 1; test <= tests; test++) {
int n, m, males_count, females_count;
cin >> n >> m >> males_count >> females_count;
int cell_counter = 1;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < str.size(); j++) {
if (str[j] == '.')
field[i][j] = cell_counter++;
else
field[i][j] = 0;
}
}
cell_counter--;
vector<scayger> males, females;
int r, c, t;
cin >> r >> c >> t;
r--;
c--;
if (males_count <= females_count)
males.push_back(scayger{r, c, t});
else
females.push_back(scayger{r, c, t});
for (int i = 0; i < males_count; i++) {
cin >> r >> c >> t;
r--;
c--;
males.push_back(scayger{r, c, t});
}
for (int i = 0; i < females_count; i++) {
cin >> r >> c >> t;
r--;
c--;
females.push_back(scayger{r, c, t});
}
if (males.size() != females.size()) {
cout << -1 << endl;
continue;
}
int size = 2 * cell_counter + males.size() + females.size() + 2;
int females_start = size - 1 - females.size();
int cell_start = males.size() + 1;
int cell_index;
vector<edge> new_edges;
for (int i = 0; i < males.size(); i++) {
assert(field[males[i].r][males[i].c]);
init_times();
bfs(males[i].r, males[i].c, males[i].t, 0, n, m);
cell_index = 0;
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (field[j][k]) {
long long time = times[j][k];
int from = i + 1, to = cell_start + cell_index;
new_edges.push_back(edge{time, from, to});
cell_index++;
}
}
for (int i = 0; i < females.size(); i++) {
assert(field[females[i].r][females[i].c]);
init_times();
bfs(females[i].r, females[i].c, females[i].t, 0, n, m);
cell_index = 0;
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if (field[j][k]) {
long long time = times[j][k];
int from = cell_start + cell_counter + cell_index,
to = females_start + i;
new_edges.push_back(edge{time, from, to});
cell_index++;
}
}
new QuickSort(new_edges);
memset(graph, 0, sizeof(graph[0][0]) * MAX_GRAPH_N * MAX_GRAPH_N);
memset(r_graph, 0, sizeof(r_graph[0][0]) * MAX_GRAPH_N * MAX_GRAPH_N);
for (int i = 0; i < MAX_GRAPH_N; i++) {
for (int j = 0; j < MAX_GRAPH_N; j++) {
graph_times[i][j] = LLONG_INF;
}
}
for (int i = 0; i < males.size(); i++) {
graph[0][i + 1] = 1;
r_graph[0][i + 1] = 1;
graph_times[0][i + 1] = 0;
graph[females_start + i][size - 1] = 1;
r_graph[females_start + i][size - 1] = 1;
graph_times[females_start + i][size - 1] = 0;
}
for (int i = 0; i < cell_counter; i++) {
int from = cell_start + i, to = cell_start + cell_counter + i;
graph[from][to] = 1;
r_graph[from][to] = 1;
graph_times[from][to] = 0;
}
auto ff = FordFulkerson(size, new_edges, males.size());
long long answer = ff.get_time();
cout << answer << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 120002, MAXE = 155000, INF = 10000;
template <typename T>
struct Dinic {
int V, source, sink;
int eind, eadj[2 * MAXE], eprev[2 * MAXE], elast[MAXV], start[MAXV];
int front, back, q[MAXV], dist[MAXV];
T CAPINF, ecap[2 * MAXE];
int dfscount;
inline Dinic() {
V = -1;
CAPINF = numeric_limits<T>::max();
}
inline void init(int v) {
V = v;
eind = 0;
memset(elast, -1, V * sizeof(int));
dfscount = 0;
}
inline void addedge(int a, int b, T cap1, T cap2) {
eadj[eind] = b;
ecap[eind] = cap1;
eprev[eind] = elast[a];
elast[a] = eind++;
eadj[eind] = a;
ecap[eind] = cap2;
eprev[eind] = elast[b];
elast[b] = eind++;
}
bool bfs() {
memset(dist, 63, V * sizeof(int));
front = back = 0;
q[back++] = source;
dist[source] = 0;
while (front < back) {
int top = q[front++];
for (int i = elast[top]; i != -1; i = eprev[i])
if (ecap[i] > 0 && dist[top] + 1 < dist[eadj[i]]) {
dist[eadj[i]] = dist[top] + 1;
q[back++] = eadj[i];
}
}
return dist[sink] < INF;
}
T dfs(int num, T pcap) {
dfscount++;
if (num == sink) return pcap;
T total = 0;
for (int& i = start[num]; i != -1; i = eprev[i])
if (ecap[i] > 0 && dist[num] + 1 == dist[eadj[i]]) {
T p = dfs(eadj[i], min(pcap, ecap[i]));
ecap[i] -= p;
ecap[i ^ 1] += p;
pcap -= p;
total += p;
if (pcap == 0) break;
}
return total;
}
T flow(int _source, int _sink) {
if (V == -1) return -INF;
source = _source;
sink = _sink;
T total = 0;
while (bfs()) {
memcpy(start, elast, V * sizeof(int));
total += dfs(source, CAPINF);
}
return total;
}
};
int n, m, male, female;
int absolute(int A) {
if (A < 0) return -A;
return A;
}
bool ismale[500];
int r[500], c[500];
long long t[500];
int scnt;
void read(int idx, bool is_male) {
scanf("%d%d%lld", r + idx, c + idx, t + idx);
ismale[idx] = is_male;
}
bool Free[25][25];
bool vis[25][25];
bool check(long long tim) {
Dinic<long long>* dinic = new Dinic<long long>;
dinic->init(scnt + 2 + n * m * 2 + 10);
for (int id = 1; id <= scnt; id++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) vis[i][j] = false;
}
queue<pair<int, int> > bfs;
bfs.push(make_pair(r[id], c[id]));
vis[r[id]][c[id]] = true;
for (int round = 1; round <= tim / t[id]; round++) {
int found = 0;
int siz = (int)bfs.size();
for (int i = 1; i <= siz; i++) {
pair<int, int> cur = bfs.front();
bfs.pop();
pair<int, int> left = make_pair(cur.first, cur.second - 1);
pair<int, int> right = make_pair(cur.first, cur.second + 1);
pair<int, int> up = make_pair(cur.first - 1, cur.second);
pair<int, int> down = make_pair(cur.first + 1, cur.second);
if ((left.first >= 1 && left.first <= n && left.second >= 1 &&
left.second <= m && Free[left.first][left.second] &&
!vis[left.first][left.second])) {
do {
bfs.push(left);
vis[left.first][left.second] = true;
} while (0);
found++;
}
if ((right.first >= 1 && right.first <= n && right.second >= 1 &&
right.second <= m && Free[right.first][right.second] &&
!vis[right.first][right.second])) {
do {
bfs.push(right);
vis[right.first][right.second] = true;
} while (0);
found++;
}
if ((up.first >= 1 && up.first <= n && up.second >= 1 &&
up.second <= m && Free[up.first][up.second] &&
!vis[up.first][up.second])) {
do {
bfs.push(up);
vis[up.first][up.second] = true;
} while (0);
found++;
}
if ((down.first >= 1 && down.first <= n && down.second >= 1 &&
down.second <= m && Free[down.first][down.second] &&
!vis[down.first][down.second])) {
do {
bfs.push(down);
vis[down.first][down.second] = true;
} while (0);
found++;
}
}
if (!found) break;
}
if (ismale[id]) {
dinic->addedge(1, id + 2, 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (vis[i][j]) {
dinic->addedge(id + 2, scnt + 2 + ((i - 1) * m + j) * 2 - 1, 1, 0);
}
}
}
} else {
dinic->addedge(id + 2, 2, 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (vis[i][j]) {
dinic->addedge(scnt + 2 + ((i - 1) * m + j) * 2, id + 2, 1, 0);
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dinic->addedge(scnt + 2 + ((i - 1) * m + j) * 2 - 1,
scnt + 2 + ((i - 1) * m + j) * 2, 1, 0);
}
}
int res = dinic->flow(1, 2);
delete dinic;
if (res > scnt / 2) abort();
return res == scnt / 2;
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &female);
if (absolute(male - female) != 1) {
printf("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
char s[50];
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) {
Free[i][j] = s[j] == '.';
}
}
scnt = 2 * max(male, female);
for (int i = 1; i <= scnt; i++) {
if (i == 1) {
read(i, male < female);
} else if (i <= male + 1) {
read(i, true);
} else {
read(i, false);
}
}
long long l = 0;
long long R = 500000000000LL;
while (l < R) {
long long mid = (l + R) / 2;
if (check(mid)) {
R = mid;
} else {
l = mid + 1;
}
}
if (!check(l)) {
printf("-1");
} else {
printf("%lld", l);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, h, w, tmp_h, tmp_w;
cin >> h >> w;
for (i = 0;; i++) {
if ((long long)(1 << i) > h || (long long)(1 << i) > (5 * w) / 4) {
i--;
break;
}
}
for (j = 0;; j++) {
if ((long long)(1 << j) > w || (long long)(1 << j) > (5 * h) / 4) {
j--;
break;
}
}
i = 1 << i;
j = 1 << j;
tmp_h = min(j * 5 / 4, h);
tmp_w = min(i * 5 / 4, w);
if (i * tmp_w > j * tmp_h)
cout << i << " " << tmp_w << endl;
else if (i * tmp_w < j * tmp_h)
cout << tmp_h << " " << j << endl;
else
cout << max(i, tmp_h) << " " << min(j, tmp_w) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long h, w;
cin >> h >> w;
long long h1 = 1, w1;
while (h1 <= h && h1 <= w * 5 / 4) h1 <<= 1;
h1 >>= 1;
if (h1 * 5 / 4 <= w)
w1 = h1 * 5 / 4;
else
w1 = w;
long long h2, w2 = 1;
while (w2 <= w && w2 <= h * 5 / 4) w2 <<= 1;
w2 >>= 1;
if (w2 * 5 / 4 <= h)
h2 = w2 * 5 / 4;
else
h2 = h;
if (h1 * w1 < h2 * w2 || h1 * w1 == h2 * w2 && h1 < h2) {
h1 = h2;
w1 = w2;
}
cout << h1 << ' ' << w1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long h, w, A, t, sh, sw;
bool ok(long long x, long long y) {
if (y > x) y ^= x ^= y ^= x;
double xx = x, yy = y;
return (xx / yy) >= 0.8 && (xx / yy) <= 1.25;
}
long long x8(long long a) { return (long long)(0.8 * (double)a); }
long long x5(long long a) { return (long long)(1.25 * (double)a); }
int main() {
scanf("%lld%lld", &h, &w);
for (t = 0; (1 << t) <= h; t++)
;
t--;
A = 0;
while (t >= 0) {
long long q = 1 << t;
long long r = min(x5(q), w);
if (ok(q, r) && q * r > A) {
A = q * r;
sh = q;
sw = r;
} else if (ok(q, r) && q * r == A) {
if (q > sh) {
A = q * r;
sh = q;
sw = r;
}
}
t--;
}
for (t = 0; (1 << t) <= w; t++)
;
t--;
while (t > 0) {
long long r = 1 << t;
long long q = min(x5(r), h);
if (ok(q, r) && q * r > A) {
A = q * r;
sh = q;
sw = r;
} else if (ok(q, r) && q * r == A) {
if (q > sh) {
A = q * r;
sh = q;
sw = r;
}
}
t--;
}
cout << sh << " " << sw;
}
|
#include <bits/stdc++.h>
long long h, w;
int main() {
scanf("%lld%d", &h, &w);
long long a = 1;
while (a << 1 <= h && a << 1 <= w) a <<= 1;
long long m = std::min(h, a * 5 / 4);
long long n = std::min(w, a * 5 / 4);
if (m >= n)
printf("%lld %lld\n", m, a);
else
printf("%lld %lld\n", a, n);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int H, W;
std::cin >> H >> W;
long long best = 1;
int bestH = 1;
int bestW = 1;
for (long long w = 1; w <= W; w *= 2) {
long long left = 0;
long long right = H;
while (left <= right) {
long long mid = (left + right) / 2;
if (8 * w > 10 * mid) {
left = mid + 1;
} else if (125 * w < 100 * mid) {
right = mid - 1;
} else {
if (best < mid * w) {
best = mid * w;
bestH = mid;
bestW = w;
} else if (best == mid * w) {
if (bestH < mid) {
bestH = mid;
bestW = w;
}
}
left = mid + 1;
}
}
}
for (long long h = 1; h <= H; h *= 2) {
long long left = 0;
long long right = W;
while (left <= right) {
long long mid = (left + right) / 2;
if (8 * mid > 10 * h) {
right = mid - 1;
} else if (125 * mid < 100 * h) {
left = mid + 1;
} else {
if (best < h * mid) {
best = h * mid;
bestH = h;
bestW = mid;
} else if (best == h * mid) {
if (bestH < h) {
bestH = h;
bestW = mid;
}
}
left = mid + 1;
}
}
}
std::cout << bestH << " " << bestW << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long bigHeight, bigWidth;
cin >> bigHeight >> bigWidth;
pair<long long, pair<long long, long long> > max;
make_pair(0, make_pair(0, 0));
long long h = 1;
while (h <= bigHeight) {
long long w = min(ceil(h * 100 / 80), 1.0 * bigWidth);
pair<long long, pair<long long, long long> > temp;
temp = make_pair(h * w, make_pair(h, w));
if (double(h) * 100 / (w) <= 125 && double(h) * 100 / (w) >= 80 &&
temp > max)
max = temp;
h <<= 1;
}
long long w = 1;
while (w <= bigWidth) {
long long h = min(1.0 * bigHeight, floor(w * 125 / 100));
pair<long long, pair<long long, long long> > temp;
temp = make_pair(h * w, make_pair(h, w));
if (double(h) * 100 / (w) >= 80 && temp > max && double(h) * 100 / w <= 125)
max = temp;
w <<= 1;
}
cout << max.second.first << ' ' << max.second.second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int i, j, k, l, m, h, w, x, y, maxx, maxy, p;
int main() {
{
cin >> h >> w;
maxx = 1;
maxy = 1;
double q;
long long int step = 1, pp = 0;
for (i = 1; i < 1000; i++) {
step *= 2;
if (step <= w) {
pp = int(1.25 * step);
if (pp <= h) {
if (maxx * maxy == step * pp && maxy < pp) {
{
maxx = step;
maxy = pp;
}
}
if (maxx * maxy < step * pp) {
maxx = step;
maxy = pp;
}
} else {
q = double(step) / double(h);
if ((q - 0.8) > 0.000000001 && (q) < 1.25000001) {
if (maxx * maxy == step * h && maxy < h) {
{
maxx = step;
maxy = h;
}
}
if (maxx * maxy < step * h) {
maxx = step;
maxy = h;
}
}
}
}
if (step <= h) {
pp = int(1.25 * step);
if (pp <= w) {
if (maxx * maxy == step * pp && maxy < step) {
{
maxx = pp;
maxy = step;
}
}
if (maxx * maxy < step * pp) {
maxx = pp;
maxy = step;
}
} else {
q = double(step) / double(w);
p = double(w) / double(step);
if ((q - 0.8) > 0.000001 && (q) < 1.25000001) {
if (maxx * maxy == step * w && maxy < step) {
{
maxx = w;
maxy = step;
}
}
if (maxx * maxy < step * w) {
maxx = w;
maxy = step;
}
}
}
}
}
cout << maxy << " " << maxx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2);
sq *= sq;
if (p % 2) sq *= b;
return sq;
}
const int N = 302, M = (N << 1);
double H, W, h, w, hh, ww;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> W >> H;
for (hh = 1; hh <= H; hh *= 2) {
ww = min(int(1.25 * hh), int(W));
if (ww / hh >= 0.8 && ww * hh > w * h) {
w = ww;
h = hh;
}
}
for (ww = 1; ww <= W; ww *= 2) {
hh = min(int(1.25 * ww), int(H));
if (hh / ww >= 0.8 && ww * hh > w * h) {
w = ww;
h = hh;
}
}
cout << (int)w << " " << (int)h;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mul(long long int a, long long int b) {
return ((a % int(1e9 + 7)) * (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int add(long long int a, long long int b) {
return ((a % int(1e9 + 7)) + (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int sub(long long int a, long long int b) {
long long int ans = ((a % int(1e9 + 7)) - (b % int(1e9 + 7))) % int(1e9 + 7);
ans %= int(1e9 + 7);
ans = (ans + int(1e9 + 7)) % int(1e9 + 7);
return ans;
}
long long int mpow(long long int a, long long int b) {
long long int ans = 1;
long long int po = a;
while (b != 0) {
if (b % 2) {
ans = ((ans % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
}
po = ((po % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
b /= 2;
}
return ans;
}
void solve() {
long long int h, w;
cin >> h >> w;
long long int ans = 0, ffh, ffw;
for (int i = 0; i < 2; i++) {
if (i) swap(w, h);
if (i) swap(ffw, ffh);
long long int fh = 1LL << (long long int)floor(log2(h) + 1e-6);
while (w < fh / 1.25) {
fh /= 2;
}
long long int fw = min(w, (long long int)(fh / .8 + 1e-6));
if (ans < fh * fw) {
ans = fh * fw;
ffh = fh;
ffw = fw;
} else if (ans == fh * fw) {
if (i == 0 and fh > ffh) {
ffh = fh;
ffw = fw;
} else if (i == 1 and fw > ffw) {
ffh = fh;
ffw = fw;
}
}
if (i) {
swap(w, h);
swap(ffw, ffh);
}
}
cout << ffh << ' ' << ffw << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
long long h, w, t, p = 1, a, b;
int main() {
cin >> h >> w;
for (int i = 0; i < 30; i++) {
if (p <= h && 4 * p <= 5 * w) {
t = min(w, 5 * p / 4);
if (p * t > a * b || (p * t == a * b && a < p)) {
a = p, b = t;
}
}
if (p <= w && 4 * p <= 5 * h) {
t = min(h, 5 * p / 4);
if (p * t > a * b || (p * t == a * b && a < t)) {
a = t, b = p;
}
}
p *= 2;
}
cout << a << " " << b;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1001000];
scanf("%s", ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const long long maxn = 1000 + 10;
const long long base = 29;
const long long MAX_LG = 21;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long maxq = 2e5 + 10;
pair<long long, long long> vc;
long long best = 0;
int32_t main() {
long long h = in(), w = in();
vc = {0, 0};
for (long long i = 1; i <= w; i *= 2) {
long long j = i + i / 4;
j = min(j, h);
if (j < (double)i - i / 5.0) continue;
if ((long long)i * j > best || ((long long)i * j == best && j > vc.first)) {
best = (long long)i * j;
vc = {j, i};
}
}
for (long long i = 1; i <= h; i *= 2) {
long long j = i + i / 4;
j = min(j, w);
if (j < (double)i - i / 5.0) continue;
if ((long long)i * j > best || ((long long)i * j == best && i > vc.first)) {
best = (long long)i * j;
vc = {i, j};
}
}
cout << vc.first << " " << vc.second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000 + 10;
const int INF = 0x7f7f7f7f;
const double eps = 1e-8;
const double pi = 3.1415926535897932384626433832795;
int main() {
double t1;
long long hh, ww, h1, w1, h2, w2, t2;
cin >> hh >> ww;
for (int i = 30; i >= 0; i--)
if (hh >= (1 << i)) {
h1 = 1 << i;
t1 = h1 / 1.25;
t2 = h1 * 5 / 4;
if (ww - t1 < -eps) continue;
w1 = min(ww, t2);
break;
}
for (int i = 30; i >= 0; i--)
if (ww >= (1 << i)) {
w2 = 1 << i;
t1 = w2 / 1.25;
t2 = w2 * 5 / 4;
if (hh - t1 < -eps) continue;
h2 = min(hh, t2);
break;
}
if (h1 * w1 > h2 * w2)
cout << h1 << " " << w1 << endl;
else if (h1 * w1 < h2 * w2)
cout << h2 << " " << w2 << endl;
else if (h1 > h2)
cout << h1 << " " << w1 << endl;
else
cout << h2 << " " << w2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int h, w, bh, bw, th, tw;
long long ar, ba;
bh = bw = ba = 0;
scanf("%d %d", &h, &w);
int tmp;
for (int i = 30; i >= 0; i--) {
tmp = (1 << i);
if (tmp <= w) {
long long x = (long long)tmp * 8;
long long y = (long long)tmp * 125;
if (x % 10 != 0)
x = x / 10 + 1;
else
x = x / 10;
y /= 100;
if (y <= h) {
th = y;
tw = tmp;
ar = (long long)th * (long long)tw;
if (ar > ba || ar == ba && th > bh) {
bh = th;
bw = tw;
ba = (long long)bh * (long long)bw;
}
} else if (x <= h) {
th = h;
tw = tmp;
ar = (long long)th * (long long)tw;
if (ar > ba || ar == ba && th > bh) {
bh = th;
bw = tw;
ba = (long long)bh * (long long)bw;
}
}
}
}
for (int i = 30; i >= 0; i--) {
tmp = (1 << i);
if (tmp <= h) {
int x = (int)((double)tmp / 1.25);
int y = (int)((double)tmp / 0.8);
if ((double)y * 0.8 < (double)tmp) y++;
if ((double)x * 1.25 > (double)tmp) x--;
if (y <= w) {
th = tmp;
tw = y;
ar = (long long)th * (long long)tw;
if (ar > ba || ar == ba && th > bh) {
bh = th;
bw = tw;
ba = (long long)bh * (long long)bw;
}
} else if (x < w) {
th = tmp;
tw = w;
ar = (long long)th * (long long)tw;
if (ar > ba || ar == ba && th > bh) {
bh = th;
bw = tw;
ba = (long long)bh * (long long)bw;
}
}
}
}
if (bw > bh && bw <= h) std::swap(bw, bh);
printf("%d %d\n", bh, bw);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A, B, H, W;
long long getNext(long long x) {
long long k = 1;
while (k <= x) k *= 2;
return k;
}
long long getPrevious(long long x) {
long long k = 1;
while (k * 2ll <= x) k *= 2;
return k;
}
int main() {
long long ret1 = 0, ret2 = 0, area = 0;
scanf("%I64d %I64d", &A, &B);
H = A, W = B;
if (A < B) swap(A, B);
long long n = getNext(B);
long long m = B;
if (n <= A && n * 4 <= m * 5) {
ret1 = n;
ret2 = m;
area = n * m;
}
n = getPrevious(B);
m = min(n * 5 / 4, A);
if (n < m) swap(n, m);
if (area < n * m) ret1 = n, ret2 = m;
if (ret1 > H || ret2 > W) swap(ret1, ret2);
printf("%I64d %I64d\n", ret1, ret2);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t = 1;
vector<long long int> a(31);
a[0] = 1;
for (long long int i = 1; i < 31; i++) a[i] = a[i - 1] * 2;
while (t--) {
long long int h, w;
cin >> h >> w;
long long int j = 0;
while (a[j] <= h && a[j] <= w) j++;
long long int h1 = min(h, (long long int)(1.25 * a[j - 1]));
long long int w1 = min(w, (long long int)(1.25 * a[j - 1]));
if (h1 >= w1)
cout << h1 << " " << a[j - 1];
else
cout << a[j - 1] << " " << w1;
}
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...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long a = log2(n);
if (pow(2, a + 1) == n) a++;
vector<long long> b(3);
for (;;) {
long long x = pow(2, a--);
long long y = min(5 * x / 4, m);
if (5 * y >= (4 * x)) {
b[0] = x * y;
b[1] = x;
b[2] = y;
break;
}
}
a = log2(m);
if (pow(2, a + 1) == m) a++;
vector<long long> c(3);
for (;;) {
long long x = pow(2, a--);
long long y = min(5 * x / 4, n);
if (5 * y >= (4 * x)) {
c[0] = x * y;
c[1] = y;
c[2] = x;
break;
}
}
if (b[0] > c[0]) {
cout << b[1] << " " << b[2];
} else if (c[0] > b[0]) {
cout << c[1] << " " << c[2];
} else {
if (b[1] > c[1])
cout << b[1] << " " << b[2];
else {
cout << c[1] << " " << c[2];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int h, w, a = 1;
cin >> h >> w;
while (a * 2 <= h && a * 2 <= w) a *= 2;
h = min(h, 5 * a / 4);
w = min(w, 5 * a / 4);
if (h >= w)
cout << h << " " << a << "\n";
else
cout << a << " " << w << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
};
long long int largest_power(long long int N) {
N = N | (N >> 1);
N = N | (N >> 2);
N = N | (N >> 4);
N = N | (N >> 8);
N = N | (N >> 16);
N = N | (N >> 32);
N = N | (N >> 64);
return (N + 1) >> 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int h, w;
cin >> h >> w;
long long int maxarea = 0, hh, ww;
for (long long int i = largest_power(h); i >= 1; i = i / 2) {
if (((1.0) * i / w) <= 1.25) {
if (1.0 * i / w >= 0.8) {
maxarea = i * w;
hh = i;
ww = w;
} else {
hh = i;
ww = (long long int)floor(1.25 * i);
maxarea = hh * ww;
}
break;
}
}
long long int maxarea1 = 0, hh1, ww1;
for (long long int i = largest_power(w); i >= 1; i = i / 2) {
if (((1.0) * i / h) <= 1.25) {
if (1.0 * i / h >= 0.8) {
maxarea1 = i * h;
hh1 = h;
ww1 = i;
} else {
hh1 = (long long int)floor(1.25 * i);
ww1 = i;
maxarea1 = hh1 * ww1;
}
break;
}
}
if (maxarea > maxarea1)
cout << hh << " " << ww;
else if (maxarea1 > maxarea) {
cout << hh1 << " " << ww1;
} else {
if (hh > hh1)
cout << hh << " " << ww;
else
cout << hh1 << " " << ww1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(long long h, long long w) {
long long resX = 1, resY = 1;
for (long long x = 1; x <= h; x *= 2) {
long long y = min(w, (x * 5) / 4);
if (5 * y >= 4 * x) {
if (x * y > resX * resY) {
resX = x;
resY = y;
} else if (x * y == resX * resY && x > resX) {
resX = x;
resY = y;
}
}
}
for (long long y = 1; y <= w; y *= 2) {
long long x = min(h, (y * 5) / 4);
if (5 * x >= 4 * y) {
if (x * y > resX * resY) {
resX = x;
resY = y;
} else if (x * y == resX * resY && x > resX) {
resX = x;
resY = y;
}
}
}
cout << resX << ' ' << resY;
}
int main() {
long long h, w;
cin >> h >> w;
solve(h, w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long h, w, i, j, h1 = 1, h2, w1, w2 = 1;
cin >> h >> w;
h2 = h;
w1 = w;
while (h1 <= h && w > 0.8 * h1) h1 *= 2;
h1 /= 2;
if (w > 1.25 * h1) w1 = 1.25 * h1;
while (w2 <= w && h > 0.8 * w2) w2 *= 2;
w2 /= 2;
if (h > 1.25 * w2) h2 = 1.25 * w2;
if (h1 * w1 > h2 * w2 || (h1 * w1 == h2 * w2 && h1 > h2))
cout << h1 << ' ' << w1;
else
cout << h2 << ' ' << w2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
vector<pair<long long, pair<long long, long long> > > v;
long long h, w;
cin >> h >> w;
for (long long hh = 1; hh <= h; hh <<= 1) {
long long ww = min((hh * 5 + 3) / 4, w);
if (hh * 4 <= 5 * ww)
v.push_back(make_pair(min(ww, w) * hh, make_pair(hh, min(ww, w))));
}
for (long long ww = 1; ww <= w; ww <<= 1) {
long long hh = min(ww * 5 / 4, h);
if (hh * 5 >= 4 * ww)
v.push_back(make_pair(min(hh, h) * ww, make_pair(min(hh, h), ww)));
}
sort(v.begin(), v.end());
cout << v[((long long)v.size()) - 1].second.first << " "
<< v[((long long)v.size()) - 1].second.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int maxn = 100010;
const int mod = 1000000007;
long long p[64];
int main() {
ios::sync_with_stdio(false);
p[0] = 1;
for (int i = 1; i <= 30; i++) {
p[i] = p[i - 1] * 2;
}
long long a, b, x, y;
long long s = 0;
cin >> a >> b;
for (int i = 0; i <= 30; i++) {
if (p[i] <= a) {
if (p[i] * 5 <= 4 * b) {
if (s < p[i] * p[i] * 5 / 4) {
s = p[i] * p[i] * 5 / 4;
x = p[i];
y = p[i] * 5 / 4;
}
} else if (p[i] * 4 <= 5 * b) {
if (s < p[i] * b) {
s = p[i] * b;
x = p[i];
y = b;
}
}
}
}
for (int i = 0; i <= 30; i++) {
if (p[i] <= b) {
if (a * 4 >= 5 * p[i]) {
if (s < p[i] * p[i] * 5 / 4 ||
s == p[i] * p[i] * 5 / 4 && x < p[i] * 5 / 4) {
s = p[i] * p[i] * 5 / 4;
x = p[i] * 5 / 4;
y = p[i];
}
} else if (a * 5 >= 4 * b) {
if (s < p[i] * a) {
s = p[i] * a;
x = a;
y = p[i];
}
}
}
}
cout << x << " " << y << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
if (v) return;
int *ass;
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
void TL(const bool v) {
if (v) return;
int *ass;
ass = new int[250];
for (;;) {
for (int i = 0; i < 250; i++) ass[i] = rand();
}
}
void PE(const bool v) {
if (v) return;
puts("ass 1 2 3 4 5 6 fuck");
exit(0);
}
struct node {
long long x, y;
long long s() const { return x * y; }
bool operator>(const node &v) const {
if (s() != v.s()) return s() > v.s();
return x > v.x;
}
bool operator<=(const node &v) const { return x <= v.x && y <= v.y; }
node() { x = y = 0; }
void read() { cin >> x >> y; }
bool good() const {
if (!(x * 4 / 5 <= y && y <= x * 5 / 4)) return false;
if (!(y * 4 / 5 <= x && x <= y * 5 / 4)) return false;
return true;
}
};
node res;
node v;
void LoAd() { v.read(); }
void SoLvE() {
node tmp;
tmp.x = 1;
tmp.y = 1;
while (tmp <= v) {
if (tmp > res) res = tmp;
tmp.x *= 2;
tmp.y = min(tmp.x * 5 / 4, v.y);
if (!tmp.good()) break;
}
tmp.x = 1;
tmp.y = 1;
while (tmp <= v) {
if (tmp > res) res = tmp;
tmp.y *= 2;
tmp.x = min(tmp.y * 5 / 4, v.x);
if (!tmp.good()) break;
}
cout << res.x << " " << res.y;
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.