text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
static const int MAX = 100001;
int n, k, m, cur;
vector<vector<int> > v;
int ans[MAX];
int main() {
scanf("%d", &n);
vector<int> vv;
v.assign(MAX, vv);
for (int i = 0; i < n; ++i) {
scanf("%d", &k);
v[k].push_back(i);
}
m = 1;
for (int i = 1; i < MAX - 1; ++i) {
if (v[i].size() < v[i + 1].size()) {
printf("-1");
return 0;
}
if (v[i + 1].size() != 0) m = i + 1;
}
cur = 1;
while (v[1].size() != 0) {
while (v[m].size() == 0) --m;
int t = m;
while (t != 0) {
ans[*(--(v[t].end()))] = cur;
v[t].pop_back();
--t;
}
++cur;
}
printf("%d\n", cur - 1);
for (int i = 0; i < n; ++i) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int main(void) {
int n;
cin >> n;
int c[100001] = {0};
vector<int> a(n);
for (int i = (0); i < (int)(n); ++i) {
int tmp;
cin >> tmp;
a[i] = tmp;
c[tmp]++;
}
bool ans = true;
for (int i = (1); i < (int)(100000); ++i) {
if (c[i + 1] - c[i] > 0) ans = false;
}
if (ans) {
cout << c[1] << endl;
bool f = false;
for (int i = (0); i < (int)(n); ++i) {
if (f)
cout << " ";
else
f = true;
cout << c[a[i]]--;
}
cout << endl;
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, last = 1, a[N], ans[N];
vector<int> vec[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vec[a[i]].push_back(i);
}
for (int i = N - 1; i; i--)
while (vec[i].size()) {
ans[vec[i].back()] = last;
vec[i].pop_back();
for (int j = i - 1; j; j--)
if (vec[j].empty()) {
cout << -1;
return 0;
} else {
ans[vec[j].back()] = last;
vec[j].pop_back();
}
last++;
}
cout << last - 1 << '\n';
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const long long inf = 1LL << 20;
const int maxn = 22 + 2;
int n, m, males, females;
int N;
char s[maxn][maxn];
long long dis[maxn * maxn][maxn * maxn];
vector<int> e;
vector<pair<int, int> > p, q;
pair<int, int> read() {
int r, c, t;
cin >> r >> c >> t;
r--, c--;
return {r * m + c, t};
}
template <class FlowT>
struct MaxFlow {
static const int maxn = 10000;
static const int maxm = 2000000;
static const FlowT FlowEPS = FlowT(1e-7);
static const FlowT FlowINF = FlowT(1 << 29);
int n, m;
int to[2 * maxm], prv[2 * maxm], hed[maxn];
FlowT cap[2 * maxm];
int dis[maxn], pos[maxn];
void init(int _n) {
n = _n, m = 0;
memset(hed, -1, n * sizeof hed[0]);
}
inline void add_edge(int x, int y, FlowT c) {
to[m] = y, cap[m] = c, prv[m] = hed[x], hed[x] = m++;
to[m] = x, cap[m] = 0, prv[m] = hed[y], hed[y] = m++;
}
bool bfs(int source, int sink) {
static int que[maxn], head, tail;
memset(dis, -1, n * sizeof dis[0]);
head = tail = 0;
dis[source] = 0;
que[tail++] = source;
while (head < tail) {
int u = que[head++];
for (int e = hed[u]; e != -1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == -1)
dis[to[e]] = dis[u] + 1, que[tail++] = to[e];
if (dis[sink] != -1) break;
}
return dis[sink] != -1;
}
FlowT dfs(int u, int sink, FlowT add = FlowINF) {
if (u == sink) return add;
FlowT res = 0;
for (int &e = pos[u]; e != -1; e = prv[e])
if (cap[e] > FlowEPS && dis[to[e]] == dis[u] + 1) {
FlowT cur = dfs(to[e], sink, min(add, cap[e]));
cap[e] -= cur, cap[e ^ 1] += cur, add -= cur, res += cur;
if (add <= FlowEPS / 2) break;
}
return res;
}
FlowT getflow(int source, int sink) {
FlowT flow = 0;
while (bfs(source, sink)) {
memcpy(pos, hed, n * sizeof hed[0]);
flow += dfs(source, sink);
}
return flow;
}
};
MaxFlow<int> g;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> males >> females;
if (abs(males - females) != 1) {
cout << -1 << endl;
return 0;
}
int N = n * m;
for (int i = 0, _n = (int)(n); i < _n; i++) cin >> s[i];
for (int i = 0, _n = (int)(N); i < _n; i++)
for (int j = 0, _n = (int)(N); j < _n; j++) dis[i][j] = inf;
for (int i = 0, _n = (int)(N); i < _n; i++) dis[i][i] = 0;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (s[i][j] == '.')
for (int ii = 0, _n = (int)(n); ii < _n; ii++)
for (int jj = 0, _n = (int)(m); jj < _n; jj++)
if (s[ii][jj] == '.')
if (abs(i - ii) + abs(j - jj) == 1)
dis[i * m + j][ii * m + jj] = 1;
for (int k = 0, _n = (int)(N); k < _n; k++)
if (s[k / m][k % m] == '.')
for (int i = 0, _n = (int)(N); i < _n; i++)
for (int j = 0, _n = (int)(N); j < _n; j++)
smin(dis[i][j], dis[i][k] + dis[k][j]);
(males < females ? p : q).push_back(read());
for (int i = 0, _n = (int)(males); i < _n; i++) p.push_back(read());
for (int i = 0, _n = (int)(females); i < _n; i++) q.push_back(read());
smax(males, females);
smax(females, males);
long long lo = -1, hi = (1LL << 30) * maxn * maxn;
int add = 2 * N;
int tot = 2 + add + males + females;
int src = tot - 2;
int snk = tot - 1;
while (hi - lo > 1) {
long long md = (lo + hi) / 2;
g.init(tot);
for (int i = 0, _n = (int)(males); i < _n; i++) g.add_edge(src, add + i, 1);
for (int i = 0, _n = (int)(females); i < _n; i++)
g.add_edge(add + males + i, snk, 1);
for (int i = 0, _n = (int)(N); i < _n; i++)
if (s[i / m][i % m] == '.') {
g.add_edge(2 * i + 0, 2 * i + 1, 1);
for (int j = 0, _n = (int)(males); j < _n; j++)
if (dis[p[j].first][i] != inf &&
dis[p[j].first][i] * p[j].second <= md)
g.add_edge(add + j, 2 * i + 0, 1);
for (int j = 0, _n = (int)(females); j < _n; j++)
if (dis[q[j].first][i] != inf &&
dis[q[j].first][i] * q[j].second <= md)
g.add_edge(2 * i + 1, add + males + j, 1);
}
if (g.getflow(src, snk) == males)
hi = md;
else
lo = md;
}
cout << (hi < (1LL << 30) * maxn * maxn ? hi : -1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[2010][2010];
int pla1[2010][2], spe1[2010], pla2[2010][2], spe2[2010], r, c,
dist[2010][2010];
int head[2010], cur[2010], nxt[2010 * 2010], to[2010 * 2010], val[2010 * 2010],
idx = 1, cnt, n, m, s, t, many, sum, dis[2010];
long long L, R;
void add(int a, int b, int c) {
nxt[++idx] = head[a], to[idx] = b, val[idx] = c, head[a] = idx;
}
bool bfs() {
queue<int> q;
memset(dis, -1, sizeof dis), dis[s] = 0, q.push(s);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = head[p]; i; i = nxt[i])
if (dis[to[i]] == -1 && val[i]) dis[to[i]] = dis[p] + 1, q.push(to[i]);
}
return dis[t] != -1;
}
int dfs(int p, int flow) {
if (p == t) return flow;
int now, temp = flow;
for (int i = cur[p]; i; i = nxt[i])
if (dis[to[i]] == dis[p] + 1 && val[i]) {
now = dfs(to[i], min(temp, val[i]));
if (!now) dis[to[i]] = -1;
val[i] -= now, temp -= now, val[i ^ 1] += now;
if (val[i]) cur[p] = i;
if (!temp) break;
}
return flow - temp;
}
bool check(long long x) {
s = n + m + r * c * 2 + 1, t = n + m + r * c * 2 + 2,
memset(head, 0, sizeof head), idx = 1;
for (int i = 1; i <= n; i++) add(s, i, 1), add(i, s, 0);
for (int i = 1; i <= m; i++) add(i + n, t, 1), add(t, i + n, 0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= r * c; j++)
if (dist[(pla1[i][0] - 1) * c + pla1[i][1]][j] < 1000000000 &&
1ll * dist[(pla1[i][0] - 1) * c + pla1[i][1]][j] * spe1[i] <= x)
add(i, j + n + m, 1), add(j + n + m, i, 0);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= r * c; j++)
if (dist[(pla2[i][0] - 1) * c + pla2[i][1]][j] < 1000000000 &&
1ll * dist[(pla2[i][0] - 1) * c + pla2[i][1]][j] * spe2[i] <= x)
add(j + n + m + r * c, i + n, 1), add(i + n, j + n + m + r * c, 0);
for (int i = 1; i <= r * c; i++)
add(i + n + m, i + n + m + r * c, 1), add(i + n + m + r * c, i + n + m, 0);
sum = 0;
while (bfs()) memcpy(cur, head, sizeof head), sum += dfs(s, 1000000000);
return sum == n;
}
int main() {
scanf("%d%d%d%d", &r, &c, &n, &m);
for (int i = 1; i <= r; i++) scanf("%s", str[i] + 1);
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
if (str[i][j] == '.') many++;
for (int i = 1; i <= r * c; i++)
for (int j = 1; j <= r * c; j++)
if (i != j) dist[i][j] = 1000000000;
for (int i = 1; i < r; i++)
for (int j = 1; j <= c; j++)
if (str[i][j] == '.' && str[i + 1][j] == '.')
dist[(i - 1) * c + j][i * c + j] = dist[i * c + j][(i - 1) * c + j] = 1;
for (int i = 1; i <= r; i++)
for (int j = 1; j < c; j++)
if (str[i][j] == '.' && str[i][j + 1] == '.')
dist[(i - 1) * c + j + 1][(i - 1) * c + j] =
dist[(i - 1) * c + j][(i - 1) * c + j + 1] = 1;
for (int k = 1; k <= r * c; k++)
for (int i = 1; i <= r * c; i++)
for (int j = 1; j <= r * c; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
if (abs(n - m) != 1 || many * 2 < n + m + 1) printf("-1\n"), exit(0);
if (n > m)
scanf("%d%d%d", &pla2[m + 1][0], &pla2[m + 1][1], &spe2[m + 1]);
else
scanf("%d%d%d", &pla1[n + 1][0], &pla1[n + 1][1], &spe1[n + 1]);
for (int i = 1; i <= n; i++)
scanf("%d%d%d", &pla1[i][0], &pla1[i][1], &spe1[i]);
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &pla2[i][0], &pla2[i][1], &spe2[i]);
if (n > m)
m++;
else
n++;
L = 0, R = 1ll * 1000000000 * 1000000000;
while (L < R) {
long long mid = (L + R) >> 1;
if (check(mid))
R = mid;
else
L = mid + 1;
}
printf("%lld\n", L == 1ll * 1000000000 * 1000000000 ? -1 : L);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long p = 1e9 + 7;
const int MAXN = 25;
const int INF = 1e9;
int n, m, males;
vector<long long> vals;
char b[MAXN][MAXN];
int v = 0;
int scx, scy, sct;
vector<long long> ma[3], fe[3];
int source, sink;
long long dist[MAXN][MAXN][MAXN][MAXN];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
bool vis[MAXN][MAXN];
vector<int> adj[4 * MAXN * MAXN];
int res[4 * MAXN * MAXN][4 * MAXN * MAXN];
int h[4 * MAXN * MAXN];
queue<int> frontier;
int visited[4 * MAXN * MAXN];
int N;
bool level(int source, int sink) {
for (int i = 0; i <= N; 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 source, int sink) {
if (x == sink) return 1;
visited[x] = 1;
int num = 0;
for (int i : adj[x]) {
if (!visited[i] && h[i] == h[x] + 1 && res[x][i] && dfs(i, source, sink)) {
res[x][i] -= 1;
res[i][x] += 1;
num += 1;
if (x != source) return num;
}
}
return num;
}
int maxflow(int source, int sink) {
int flow = 0;
while (true) {
if (!level(source, sink)) break;
for (int i = 0; i <= N; i++) visited[i] = 0;
flow += dfs(source, source, sink);
}
return flow;
}
bool chk(long long v) {
memset(res, 0, sizeof(res));
for (int i = 0; i <= N; ++i) adj[i].clear();
for (int i = 1; i <= males; ++i) {
adj[i].push_back(source);
adj[source].push_back(i);
res[source][i] = 1;
}
for (int i = males + 1; i <= 2 * males; ++i) {
adj[i].push_back(sink);
adj[sink].push_back(i);
res[i][sink] = 1;
}
for (int i = 1; i <= males; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k) {
int xd = ma[0][i - 1], yd = ma[1][i - 1];
if (dist[xd][yd][j][k] * ma[2][i - 1] > v) continue;
adj[i].push_back(j * m + k + 2 * males + 1);
adj[j * m + k + 2 * males + 1].push_back(i);
res[i][j * m + k + 2 * males + 1] = 1;
}
for (int i = 1; i <= males; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k) {
int xd = fe[0][i - 1], yd = fe[1][i - 1];
if (dist[xd][yd][j][k] * fe[2][i - 1] > v) continue;
adj[i + males].push_back(m * n + j * m + k + 2 * males + 1);
adj[m * n + j * m + k + 2 * males + 1].push_back(i + males);
res[m * n + j * m + k + 2 * males + 1][i + males] = 1;
}
for (int i = 2 * males + 1; i <= 2 * males + m * n; ++i) {
adj[i].push_back(i + m * n);
adj[i + m * n].push_back(i);
res[i][i + m * n] = 1;
}
return (maxflow(source, sink) >= males);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int mx, nx;
cin >> n >> m >> nx >> mx;
vals.push_back(0);
if ((nx - mx != 1) && (mx - nx != 1)) {
cout << "-1\n";
return 0;
}
males = max(nx, mx);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> b[i][j];
cin >> scx >> scy >> sct;
scx--;
scy--;
if (nx - mx == 1) {
fe[0].push_back(scx), fe[1].push_back(scy), fe[2].push_back(sct);
} else {
ma[0].push_back(scx), ma[1].push_back(scy), ma[2].push_back(sct);
}
for (int i = 0; i < nx; ++i) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
ma[0].push_back(x);
ma[1].push_back(y);
ma[2].push_back(t);
}
source = 0, sink = 2 * m * n + 2 * males + 1;
N = sink;
for (int i = 0; i < mx; ++i) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
fe[0].push_back(x);
fe[1].push_back(y);
fe[2].push_back(t);
}
assert(ma[0].size() == fe[0].size());
for (int i = 0; i < ma[2].size(); ++i) {
for (int j = 1; j <= n * m; ++j)
vals.push_back(1LL * j * ma[2][i]), vals.push_back(1LL * j * fe[2][i]);
}
sort(vals.begin(), vals.end());
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int a = 0; a < n; ++a)
for (int b = 0; b < m; ++b) dist[i][j][a][b] = 1e9;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
memset(vis, 0, sizeof(vis));
if (b[i][j] == '#') continue;
queue<pair<int, int> > q;
pair<int, int> t = pair<int, int>(i, j);
dist[i][j][i][j] = 0;
q.push(t);
vis[i][j] = true;
while (!q.empty()) {
pair<int, int> t1 = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int i1 = t1.first + dx[k], j1 = t1.second + dy[k];
if (i1 < 0 || i1 >= n || j1 < 0 || j1 >= m) continue;
if (vis[i1][j1] == 1) continue;
if (b[i1][j1] == '#') continue;
dist[i][j][i1][j1] = dist[i][j][t1.first][t1.second] + 1;
vis[i1][j1] = 1;
q.push(pair<int, int>(i1, j1));
}
}
}
int lo = 0, hi = vals.size();
while (lo != hi) {
long long mid = (lo + hi) / 2;
if (chk(vals[mid])) {
hi = mid;
} else
lo = mid + 1;
}
if (hi == vals.size()) {
cout << "-1\n";
} else
cout << vals[lo] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const long long _INF = 100000000007;
vector<int> edge[2000];
int cap[2000][2000], flow, dist[2000], p[2000];
int _src, _snk;
void augment(int u, int minEdge) {
if (u == _src) {
flow = minEdge;
return;
}
if (p[u] != -1) {
augment(p[u], min(minEdge, cap[p[u]][u]));
cap[p[u]][u] -= flow;
cap[u][p[u]] += flow;
}
return;
}
int maxflow(int src, int snk) {
_src = src, _snk = snk;
int ret = 0;
while (1) {
flow = 0;
queue<int> q;
q.push(src);
for (int i = 0; i < 2000; i++) {
dist[i] = INF;
p[i] = -1;
}
dist[src] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == snk) break;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (cap[u][v] > 0 && dist[v] == INF) {
dist[v] = dist[u] + 1;
q.push(v);
p[v] = u;
}
}
}
augment(snk, INF);
if (flow == 0) break;
ret += flow;
}
return ret;
}
void addEdge(int u, int v, int w, int x = 0) {
edge[u].push_back(v);
edge[v].push_back(u);
cap[u][v] += w;
cap[v][u] += x;
}
int n, m, males, females;
char grid[25][25];
pair<int, int> cellid[25][25];
struct Scayger {
int id, sx, sy;
long long tm;
Scayger(int id, int x, int y, long long t) : id(id), sx(x), sy(y), tm(t) {}
};
vector<Scayger> male, female;
long long movingTime[2 * 25 * 25][25][25];
int dr[] = {0, 0, -1, 1};
int dc[] = {-1, 1, 0, 0};
void bfs(Scayger& sc) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
movingTime[sc.id][i][j] = _INF;
}
}
movingTime[sc.id][sc.sx][sc.sy] = 0;
queue<pair<int, int> > q;
q.push(make_pair(sc.sx, sc.sy));
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int x = u.first + dr[i];
int y = u.second + dc[i];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
if (grid[x][y] == '#') continue;
if (movingTime[sc.id][x][y] >
movingTime[sc.id][u.first][u.second] + sc.tm) {
movingTime[sc.id][x][y] = movingTime[sc.id][u.first][u.second] + sc.tm;
q.push(make_pair(x, y));
}
}
}
}
bool ok(long long tm) {
for (int i = 0; i < 2000; i++) {
edge[i].clear();
}
memset(cap, 0, sizeof cap);
int src = 2000 - 2, snk = 2000 - 1;
for (int i = 0; i < female.size(); i++) {
addEdge(src, female[i].id, 1);
}
for (int i = 0; i < male.size(); i++) {
addEdge(male[i].id, snk, 1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
addEdge(cellid[i][j].first, cellid[i][j].second, 1);
}
}
for (int i = 0; i < female.size(); i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
if (movingTime[female[i].id][j][k] <= tm) {
addEdge(female[i].id, cellid[j][k].first, 1);
}
}
}
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
for (int l = 0; l < male.size(); l++) {
if (movingTime[male[l].id][j][k] <= tm) {
addEdge(cellid[j][k].second, male[l].id, 1);
}
}
}
}
int flows = maxflow(src, snk);
return flows == int(male.size());
}
long long solve(bool flag, Scayger& boss) {
if (!flag) {
male.push_back(boss);
} else {
female.push_back(boss);
}
long long l = 0, r = _INF;
bool possible = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (ok(mid)) {
possible = 1;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (!flag) {
male.pop_back();
} else {
female.pop_back();
}
if (possible) return r + 1;
return _INF;
}
int main() {
cin >> n >> m >> males >> females;
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
int bx, by;
long long bt;
cin >> bx >> by >> bt;
bx--;
by--;
Scayger boss = Scayger(0, bx, by, bt);
bfs(boss);
int id = 1;
for (int i = 0; i < males; i++) {
int x, y;
long long t;
cin >> x >> y >> t;
x--, y--;
male.push_back(Scayger(id, x, y, t));
id++;
bfs(male[male.size() - 1]);
}
for (int i = 0; i < females; i++) {
int x, y;
long long t;
cin >> x >> y >> t;
x--, y--;
female.push_back(Scayger(id, x, y, t));
id++;
bfs(female[female.size() - 1]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cellid[i][j].first = id++;
cellid[i][j].second = id++;
}
}
long long res = _INF;
if ((males < females) && (males + 1 == females)) {
res = solve(0, boss);
} else if ((females < males) && (females + 1 == males)) {
res = solve(1, boss);
}
if (res == _INF) {
cout << "-1\n";
} else {
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
char grid[33][33];
int N, M, nf, nm;
int E, V, src, tar, head[11111], dis[11111], work[11111], to[1111111],
nxt[1111111], cap[1111111];
int qf, qb, q[1111111];
int dst[33][33][33][33];
int fu[11111], fv[11111], mu[11111], mv[11111], ft[11111], mt[11111];
void init(int n, int s, int t) {
memset(head, -1, sizeof(int) * n);
V = n;
E = 0;
src = s;
tar = t;
}
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 can(long long mid) {
src = 2 * nf + 2 * N * M;
tar = src + 1;
init(tar + 1, src, tar);
int i, u, v, ii, jj;
for (i = 0; i < nf; i++) {
u = fu[i];
v = fv[i];
add_edge(src, i, 1);
for (ii = 0; ii < N; ii++)
for (jj = 0; jj < M; jj++) {
if (dst[u][v][ii][jj] > 0x3f3f3f3f - 10) continue;
if (mid >= (long long)ft[i] * dst[u][v][ii][jj]) {
add_edge(i, nf + ii * M + jj, 1);
}
}
}
for (i = 0; i < nm; i++) {
u = mu[i];
v = mv[i];
add_edge(i + nf + 2 * N * M, tar, 1);
for (ii = 0; ii < N; ii++)
for (jj = 0; jj < M; jj++) {
if (dst[u][v][ii][jj] > 0x3f3f3f3f - 10) continue;
if (mid >= (long long)mt[i] * dst[u][v][ii][jj]) {
add_edge(nf + ii * M + jj + N * M, i + nf + 2 * N * M, 1);
}
}
}
for (i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
add_edge(i * M + j + nf, i * M + j + nf + N * M, 1);
}
if (dinic() == nf) return 1;
return 0;
}
int main() {
int i, j, u, v, bu, bv, bt, k;
int uu, vv;
long long st, ed, mid;
scanf("%d%d%d%d", &N, &M, &nm, &nf);
for (i = 0; i < N; i++) scanf("%s", grid[i]);
scanf("%d%d%d", &bu, &bv, &bt);
bu--;
bv--;
for (i = 0; i < nm; i++) {
scanf("%d%d%d", &mu[i], &mv[i], &mt[i]);
mu[i]--;
mv[i]--;
}
for (i = 0; i < nf; i++) {
scanf("%d%d%d", &fu[i], &fv[i], &ft[i]);
fu[i]--;
fv[i]--;
}
if (abs(nm - nf) != 1) {
puts("-1");
return 0;
}
if (nm < nf) {
mu[nm] = bu;
mv[nm] = bv;
mt[nm] = bt;
nm++;
} else {
fu[nf] = bu;
fv[nf] = bv;
ft[nf] = bt;
nf++;
}
memset(dst, 0x3f, sizeof(dst));
for (i = 0; i < N; i++)
for (j = 0; j < M; j++) {
if (grid[i][j] == '#') continue;
dst[i][j][i][j] = 0;
qf = qb = 0;
q[qb++] = i;
q[qb++] = j;
while (qf < qb) {
u = q[qf++];
v = q[qf++];
for (k = 0; k < 4; k++) {
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;
}
}
}
}
st = 0;
ed = 0x3f3f3f3f3f3f3f3fLL;
while (ed - st > 1) {
mid = (st + ed) / 2;
if (can(mid))
ed = mid;
else
st = mid;
}
if (ed > 0x3f3f3f3f3f3f3f3fLL - 10) {
puts("-1");
return 0;
}
if (can(st))
printf("%I64d\n", st);
else
printf("%I64d\n", ed);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 10, S = N - 2, T = N - 1, INF = 0x3f3f3f3f;
struct edge {
int to, w, next;
edge(int to = 0, int w = 0, int next = 0) : to(to), w(w), next(next) {}
} e[N];
int head[N], dep[N], vis[N], cur[N], cnt = 1;
queue<int> Q;
int bfs(int n) {
for (int i = 1; i <= n; ++i) dep[i] = INF, vis[i] = 0, cur[i] = head[i];
dep[S] = INF, vis[S] = 0, cur[S] = head[S];
dep[T] = INF, vis[T] = 0, cur[T] = head[T];
dep[S] = 0, Q.push(S);
while (Q.size()) {
int u = Q.front();
Q.pop();
for (int i = head[u]; i; i = e[i].next) {
if (dep[e[i].to] > dep[u] + 1 && e[i].w) {
dep[e[i].to] = dep[u] + 1;
Q.push(e[i].to);
}
}
}
return dep[T] != INF;
}
int dfs(int first, int w) {
if (first == T) return w;
int used = 0;
for (int i = cur[first]; i; i = e[i].next) {
cur[first] = i;
if (dep[e[i].to] == dep[first] + 1 && e[i].w) {
int f = dfs(e[i].to, min(w - used, e[i].w));
if (f) used += f, e[i].w -= f, e[i ^ 1].w += f;
if (used == w) break;
}
}
return used;
}
int dinic(int n) {
int ans = 0;
while (bfs(n)) ans += dfs(S, INF);
return ans;
}
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;
}
int n, m, first, second;
struct _ {
int first, second, t;
} h, a[N], b[N];
char s[33][33];
int v[33][33];
int ID(int first, int second) { return (first - 1) * m + second; }
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
int chk(long long tot) {
cnt = 1;
for (int i = 1; i <= 2 * first + 2 * n * m; ++i) head[i] = 0;
head[S] = head[T] = 0;
queue<_> q;
for (int i = 1; i <= first; ++i) {
add(S, i, 1);
q.push({a[i].first, a[i].second, 0});
memset(v, 0, sizeof v);
while (q.size()) {
_ u = q.front();
q.pop();
if (s[u.first][u.second] == '#' || v[u.first][u.second]) continue;
if (a[i].t && u.t > tot / a[i].t) continue;
v[u.first][u.second] = 1;
for (int k = 0; k <= 3; ++k) {
int xx = u.first + dx[k], yy = u.second + dy[k];
if (1 <= xx && xx <= n && 1 <= yy && yy <= m) {
q.push({xx, yy, u.t + 1});
}
}
}
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= m; ++k)
if (v[j][k]) add(i, ID(j, k) + 2 * first, 1);
}
for (int i = 1; i <= first; ++i) {
add(i + first, T, 1);
q.push({b[i].first, b[i].second, 0});
memset(v, 0, sizeof v);
while (q.size()) {
_ u = q.front();
q.pop();
if (s[u.first][u.second] == '#' || v[u.first][u.second]) continue;
if (b[i].t && u.t > tot / b[i].t) continue;
v[u.first][u.second] = 1;
for (int k = 0; k <= 3; ++k) {
int xx = u.first + dx[k], yy = u.second + dy[k];
if (1 <= xx && xx <= n && 1 <= yy && yy <= m) {
q.push({xx, yy, u.t + 1});
}
}
}
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= m; ++k)
if (v[j][k]) add(ID(j, k) + 2 * first + n * m, i + first, 1);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (s[i][j] != '#')
add(ID(i, j) + 2 * first, ID(i, j) + 2 * first + n * m, 1);
return dinic(2 * first + 2 * n * m) == first;
}
int main() {
scanf("%d%d%d%d", &n, &m, &first, &second);
if (abs(first - second) != 1) return puts("-1"), 0;
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
scanf("%d%d%d", &h.first, &h.second, &h.t);
for (int i = 1; i <= first; ++i)
scanf("%d%d%d", &a[i].first, &a[i].second, &a[i].t);
for (int i = 1; i <= second; ++i)
scanf("%d%d%d", &b[i].first, &b[i].second, &b[i].t);
if (first > second)
b[++second] = h;
else
a[++first] = h;
long long l = 0, r = 1e18, ans = -1;
while (l <= r) {
if (chk(((l + r) >> 1)))
ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30, K = 510;
struct Input {
int n, m, mn, wmn;
char c[N][N];
int xmn[K], ymn[K], tmn[K];
int xwmn[K], ywmn[K], twmn[K];
int x, y, t;
bool read() {
if (scanf("%d %d %d %d", &n, &m, &mn, &wmn) != 4) return 0;
for (int i = int(0); i < int(n); ++i) {
string qwe;
getline(cin, qwe);
for (int j = int(0); j < int(m); ++j) {
scanf("%c", &c[i][j]);
}
}
scanf("%d %d %d", &x, &y, &t);
x--, y--;
for (int i = int(0); i < int(mn); ++i) {
scanf("%d %d %d", &xmn[i], &ymn[i], &tmn[i]);
xmn[i]--, ymn[i]--;
}
for (int i = int(0); i < int(wmn); ++i) {
scanf("%d %d %d", &xwmn[i], &ywmn[i], &twmn[i]);
xwmn[i]--, ywmn[i]--;
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
bool ok;
long long ans;
void write() {
if (ok) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
const int C = 4 * K + 2;
const long long inf = 1000000000;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
struct Solution : Data {
long long dst[N][N][N][N];
struct item {
int to, c, f, pr;
item() {}
item(int To, int C, int F, int Pr) {
to = To;
c = C;
f = F;
pr = Pr;
}
};
queue<pair<int, int> > qd;
void bfs(int stx, int sty) {
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
dst[stx][sty][i][j] = 1ll * inf * inf;
}
}
dst[stx][sty][stx][sty] = 0;
qd.push(make_pair(stx, sty));
while (!qd.empty()) {
pair<int, int> k = qd.front();
qd.pop();
for (int i = int(0); i < int(4); ++i) {
int nx = k.first + dx[i], ny = k.second + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || c[nx][ny] == '#' ||
dst[stx][sty][nx][ny] != 1ll * inf * inf)
continue;
dst[stx][sty][nx][ny] = dst[stx][sty][k.first][k.second] + 1;
qd.push(make_pair(nx, ny));
}
}
}
vector<item> a[C];
int st, fn, sz;
void add(int u, int v, int c) {
item k1(v, c, 0, a[v].size());
item k2(u, 0, 0, a[u].size());
a[u].push_back(k1);
a[v].push_back(k2);
}
bool use[C];
queue<int> q;
int d[C];
int p[C];
bool bfs() {
for (int i = int(0); i < int(sz); ++i) {
d[i] = inf;
}
d[sz] = 0;
memset(use, 0, sizeof(use));
use[st] = 1;
q.push(st);
while (!q.empty()) {
int k = q.front();
q.pop();
for (int i = int(0); i < int(a[k].size()); ++i) {
int to = a[k][i].to;
if (use[to] || a[k][i].c - a[k][i].f <= 0) {
continue;
}
d[to] = d[k] + 1;
use[to] = 1;
q.push(to);
}
}
return d[fn] != inf;
}
int dfs(int v, int minn = inf) {
if (v == fn) {
return minn;
}
use[v] = 1;
for (int i = p[v]; i < int(a[v].size()); ++i) {
int to = a[v][i].to;
if (a[v][i].c - a[v][i].f <= 0 || use[to] || d[to] != d[v] + 1) continue;
int k = dfs(to, min(minn, a[v][i].c - a[v][i].f));
if (k > 0) {
a[v][i].f += k;
a[to][a[v][i].pr].f -= k;
return k;
}
p[v]++;
}
return 0;
}
void build(long long maxx) {
sz = 2 * n * m + 2 * mn + 2;
st = sz - 2, fn = sz - 1;
for (int i = int(0); i < int(sz); ++i) {
a[i].clear();
}
for (int i = int(0); i < int(mn); ++i) {
add(st, i, 1);
}
for (int i = int(0); i < int(n * m); ++i) {
add(mn + i, mn + n * m + i, 1);
}
for (int i = int(0); i < int(wmn); ++i) {
add(mn + 2 * n * m + i, fn, 1);
}
for (int i = int(0); i < int(mn); ++i) {
for (int j = int(0); j < int(n); ++j) {
for (int k = int(0); k < int(m); ++k) {
if (dst[xmn[i]][ymn[i]][j][k] <= maxx &&
1ll * dst[xmn[i]][ymn[i]][j][k] * tmn[i] <= maxx &&
c[j][k] == '.') {
add(i, mn + j * m + k, 1);
}
}
}
}
for (int i = int(0); i < int(wmn); ++i) {
for (int j = int(0); j < int(n); ++j) {
for (int k = int(0); k < int(m); ++k) {
if (dst[xwmn[i]][ywmn[i]][j][k] <= maxx &&
1ll * dst[xwmn[i]][ywmn[i]][j][k] * twmn[i] <= maxx &&
c[j][k] == '.') {
add(mn + n * m + j * m + k, mn + 2 * n * m + i, 1);
}
}
}
}
}
bool check(long long m) {
build(m);
memset(use, 0, sizeof(use));
while (bfs()) {
memset(use, 0, sizeof(use));
memset(p, 0, sizeof(p));
while (dfs(st) > 0) {
memset(use, 0, sizeof(use));
}
}
int f = 0;
for (int i = int(0); i < int(a[st].size()); ++i) {
f += a[st][i].f;
}
return f == mn;
}
void solve() {
if (mn < wmn) {
xmn[mn] = x, ymn[mn] = y, tmn[mn] = t;
mn++;
} else {
xwmn[wmn] = x, ywmn[wmn] = y, twmn[wmn] = t;
wmn++;
}
if (mn != wmn) {
ok = 0;
return;
}
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
if (c[i][j] != '#') {
bfs(i, j);
}
}
}
long long l = 0, r = 1000000000000ll;
while (r > l) {
long long m = (r + l) >> 1;
if (check(m)) {
r = m;
} else {
l = m + 1;
}
}
if (check(r)) {
ok = 1;
ans = r;
} else {
ok = 0;
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int tmp;
scanf("%d", &tmp);
return tmp;
}
int &in(int &x) { return x = in(); }
template <typename T, typename... Args>
void in(T &x, Args &...args) {
in(x);
if (sizeof...(args)) in(args...);
}
template <class T, class L>
T &smax(T &x, L y) {
if (y > x) x = y;
return x;
}
template <class T, class L>
T &smin(T &x, L y) {
if (y < x) x = y;
return x;
}
const int maxn = 4e3 + 17, maxm = maxn * maxn, maxx = 17 + 17;
char c[maxx][maxx];
long long dead;
int so = maxn - 1, sink = maxn - 2, ecnt, n, m, ml, fml, xm[maxn], xf[maxn],
I_LOVE_MCNA[maxn], tf[maxn], yf[maxn], ym[maxn];
int ptr[maxn], head[maxn], prv[maxm], to[maxm], cap[maxm], d[maxn], q[maxn],
xs[] = {0, 0, -1, 1}, ys[] = {1, -1, 0, 0};
long long dis[maxx][maxx][maxx][maxx];
void add(int v, int u, int vu = 1, int uv = 0) {
to[ecnt] = u, prv[ecnt] = head[v], cap[ecnt] = vu, head[v] = ecnt++;
to[ecnt] = v, prv[ecnt] = head[u], cap[ecnt] = uv, head[u] = ecnt++;
}
bool bfs() {
int h = 0, t = 1;
memset(d, 63, sizeof d);
d[so] = 0;
q[0] = so;
while (h != t) {
int v = q[h++];
for (int e = head[v]; ~e; e = prv[e])
if (cap[e] && d[to[e]] > d[v] + 1) d[to[e]] = d[v] + 1, q[t++] = to[e];
}
return d[sink] < 1e9;
}
int dfs(int v, int flow = 1e9) {
if (v == sink || !flow) return flow;
int ans = 0;
for (; ~ptr[v]; ptr[v] = prv[ptr[v]]) {
if (d[v] != d[to[ptr[v]]] - 1) continue;
int x = dfs(to[ptr[v]], min(flow, cap[ptr[v]]));
flow -= x;
ans += x;
cap[ptr[v]] -= x;
cap[ptr[v] ^ 1] += x;
if (!flow) break;
}
return ans;
}
int maxflow() {
int ans = 0;
while (bfs()) {
memcpy(ptr, head, sizeof head);
ans += dfs(so);
}
return ans;
}
bool ok(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m && c[x][y]; }
void ArpaLovesDeemo() {
memset(dis, 63, sizeof dis);
in(n, m, ml, fml);
if (abs(ml - fml) != 1) cout << "-1\n", exit(0);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j], c[i][j] = c[i][j] == '.';
if (ml < fml) {
ml++;
for (int i = 0; i < ml; i++)
in(xm[i], ym[i], I_LOVE_MCNA[i]), xm[i]--, ym[i]--;
for (int i = 0; i < fml; i++) in(xf[i], yf[i], tf[i]), xf[i]--, yf[i]--;
} else {
fml++;
in(xf[0], yf[0], tf[0]), xf[0]--, yf[0]--;
for (int i = 0; i < ml; i++)
in(xm[i], ym[i], I_LOVE_MCNA[i]), xm[i]--, ym[i]--;
for (int i = 1; i < fml; i++) in(xf[i], yf[i], tf[i]), xf[i]--, yf[i]--;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (c[i][j]) {
for (int k = 0; k < 4; k++)
if (ok(i + xs[k], j + ys[k])) dis[i][j][i + xs[k]][j + ys[k]] = 1;
dis[i][j][i][j] = 0;
}
for (int kx = 0; kx < n; kx++)
for (int ky = 0; ky < m; ky++)
for (int ix = 0; ix < n; ix++)
for (int iy = 0; iy < m; iy++)
for (int jx = 0; jx < n; jx++)
for (int jy = 0; jy < m; jy++)
smin(dis[ix][iy][jx][jy],
dis[ix][iy][kx][ky] + dis[kx][ky][jx][jy]);
}
int w(int x, int y = 0, int z = 0) {
if (z) return 2 * (x * m + y) + z - 1;
if (!y) return n * m * 4 + x;
return n * m * 4 + x + ml;
}
void DeemoLovesInit() {
memset(head, -1, sizeof head);
ecnt = 0;
for (int i = 0; i < ml; i++) add(so, w(i));
for (int i = 0; i < ml; i++)
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (dis[xm[i]][ym[i]][x][y] < 1e17 &&
dis[xm[i]][ym[i]][x][y] * I_LOVE_MCNA[i] <= dead)
add(w(i), w(x, y, 1));
for (int i = 0; i < fml; i++)
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (dis[xf[i]][yf[i]][x][y] < 1e17 &&
dis[xf[i]][yf[i]][x][y] * tf[i] <= dead)
add(w(x, y, 2), w(i, 17));
for (int i = 0; i < fml; i++) add(w(i, 17), sink);
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) add(w(x, y, 1), w(x, y, 2));
}
int main() {
ArpaLovesDeemo();
long long l = -1, r = 1e15;
while (r - l > 1) {
dead = (l + r) / 2;
DeemoLovesInit();
if (maxflow() == ml)
r = dead;
else
l = dead;
}
cout << (r == 1e15 ? -1 : r) << '\n';
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 ford_fulkerson {
int n, m;
vector<edge> edge_set;
vector<vector<int>> graph;
ford_fulkerson() {}
ford_fulkerson(int n) {
this->n = n;
this->m = 0;
graph.resize(n);
}
void add_directed_edge(int u, int v, int c) {
edge_set.push_back(edge(u, v, c));
graph[u].push_back(m);
m++;
edge_set.push_back(edge(v, u, 0));
graph[v].push_back(m);
m++;
}
bool augment(vector<int> &path, vector<bool> &vis, int u) {
if (u == n - 1) {
int min_edge = 0;
for (int e : path) {
if (min_edge == 0 || min_edge > edge_set[e].w) {
min_edge = edge_set[e].w;
}
}
for (int e : path) {
edge_set[e].w -= min_edge;
edge_set[e ^ 1].w += min_edge;
}
return 1;
}
vis[u] = 1;
for (int e : graph[u]) {
if (edge_set[e].w > 0 && !vis[edge_set[e].v]) {
path.push_back(e);
if (augment(path, vis, edge_set[e].v)) {
return 1;
}
path.pop_back();
}
}
return 0;
}
int max_flow() {
vector<bool> vis(n);
vector<int> path;
while (augment(path, vis, 0)) {
vis.assign(n, 0);
path.clear();
}
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;
ford_fulkerson 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 maxN = 25;
const int maxn = maxN * maxN * 4 + 20;
const int maxm = maxn * maxN * maxN + 20;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
template <int maxn, int maxm>
struct Flow {
static const long long inf = 1e18;
int from[maxm * 2], to[maxm * 2], head[maxn], prv[maxm * 2], id, d[maxn],
pt[maxn];
long long cap[maxm * 2];
Flow() {
memset(from, 0, sizeof from);
memset(to, 0, sizeof to);
memset(cap, 0, sizeof cap);
memset(d, 0, sizeof d);
memset(head, -1, sizeof head);
id = 0;
}
void add_edge(int v, int u, long long c) {
prv[id] = head[v], head[v] = id, from[id] = v, to[id] = u, cap[id] = c,
id++;
prv[id] = head[u], head[u] = id, from[id] = u, to[id] = v, cap[id] = 0,
id++;
}
bool bfs(int S, int T) {
queue<int> q;
memset(d, 63, sizeof d);
d[S] = 0;
q.push(S);
memcpy(pt, head, sizeof head);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int e = head[v]; e != -1; e = prv[e])
if (cap[e] && d[to[e]] > d[v] + 1) {
d[to[e]] = d[v] + 1;
q.push(to[e]);
}
}
return (d[T] < 1e9);
}
long long dfs(int v, int T, long long flow = inf) {
if (v == T || !flow) return flow;
long long res = 0;
for (; pt[v] != -1; pt[v] = prv[pt[v]]) {
int e = pt[v], u = to[e];
if (cap[e] && d[u] == d[v] + 1) {
long long x = dfs(u, T, min(flow, cap[e]));
flow -= x, cap[e] -= x, cap[e ^ 1] += x;
res += x;
}
if (!flow) break;
}
return res;
}
long long getFlow(int S, int T) {
long long res = 0;
while (bfs(S, T)) res += dfs(S, T);
return res;
}
};
int id[maxN][maxN], sht[maxn], x[maxn], y[maxn], sp[maxn], nw;
long long d[maxn][maxn], n, m, R, B;
string s[maxN];
void bfs(int sx, int sy) {
int k = id[sx][sy];
memset(d[k], 63, sizeof d[k]);
d[k][k] = 0;
queue<pair<int, int> > q;
q.push({sx, sy});
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
int idv = id[x][y];
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && nx < n && 0 <= ny && ny < m && s[nx][ny] == '.') {
int tmp = id[nx][ny];
if (d[k][tmp] > d[k][idv] + 1) {
d[k][tmp] = d[k][idv] + 1;
q.push({nx, ny});
}
}
}
}
}
Flow<maxn, maxm> G;
bool check(long long M, int S, int T) {
G.id = 0;
memset(G.head, -1, sizeof G.head);
for (int ind = 0; ind < R + B; ind++) {
int k = id[x[ind]][y[ind]];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '.' && d[k][id[i][j]] <= M / sp[ind]) {
if (ind < R)
G.add_edge(sht[ind], 2 * id[i][j], 1);
else
G.add_edge(2 * id[i][j] + 1, sht[ind], 1);
}
if (ind < R)
G.add_edge(S, sht[ind], 1);
else
G.add_edge(sht[ind], T, 1);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '.') G.add_edge(2 * id[i][j], 2 * id[i][j] + 1, 1);
return (G.getFlow(S, T) == R);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(id, 63, sizeof id);
cin >> n >> m >> R >> B;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++)
if (s[i][j] == '.') id[i][j] = nw++;
}
nw *= 2;
for (int i = 0; i <= R + B; i++)
cin >> x[i] >> y[i] >> sp[i], sht[i] = nw++, x[i]--, y[i]--;
if (abs(R - B) != 1) return cout << -1 << endl, 0;
if (R > B) {
swap(x[R], x[0]);
swap(y[R], y[0]);
swap(sp[R], sp[0]);
B++;
} else
R++;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '.') bfs(i, j);
int S = nw++, T = nw++;
long long l = -1, r = 1e12;
if (!check(r, S, T)) return cout << -1 << endl, 0;
while (r - l > 1) {
long long M = (l + r) / 2;
if (check(M, S, T))
r = M;
else
l = M;
}
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, cap, rev;
};
int n, m, males, females;
vector<edge> G[3005];
int level[3005];
int iter[3005];
int V, source, sink, k;
struct node {
int r, c, t;
};
vector<node> a, b;
void add_edge(int from, int to, int cap) {
G[from].push_back((edge){to, cap, (int)G[to].size()});
G[to].push_back((edge){from, 0, (int)G[from].size() - 1});
}
void bfs(int s) {
memset(level, -1, sizeof(level));
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t) return f;
for (int &i = iter[v]; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (level[v] < level[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0) return flow;
memset(iter, 0, sizeof(iter));
int f;
while ((f = dfs(s, t, 1000000)) > 0) flow += f;
}
}
char str[25][25];
int dist[505][505];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void bfs() {
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) dist[i][j] = 1000000;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (str[i][j] == '#') continue;
queue<pair<int, int> > que;
int x = (i - 1) * m + j;
dist[x][x] = 0;
que.push(pair<int, int>(i, j));
while (que.size()) {
pair<int, int> p = que.front();
que.pop();
int curid = (p.first - 1) * m + p.second;
for (int k = 0; k < 4; k++) {
int nx = p.first + dx[k], ny = p.second + dy[k];
int id = (nx - 1) * m + ny;
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && str[nx][ny] != '#' &&
dist[x][id] == 1000000) {
dist[x][id] = dist[x][curid] + 1;
que.push(pair<int, int>(nx, ny));
}
}
}
}
}
vector<long long> times;
bool check(long long t) {
for (int i = 1; i <= V; i++) G[i].clear();
for (int i = 1; i <= k; i++) add_edge(source, i, 1);
for (int i = k + 1; i <= 2 * k; i++) add_edge(i, sink, 1);
for (int i = 1; i <= n * m; i++) add_edge(2 * k + i, 2 * k + n * m + i, 1);
for (int i = 1; i <= k; i++) {
int id = (a[i - 1].r - 1) * m + a[i - 1].c;
for (int j = 1; j <= n * m; j++) {
if (dist[id][j] == 1000000 || 1LL * a[i - 1].t * dist[id][j] > t)
continue;
add_edge(i, 2 * k + j, 1);
}
}
for (int i = 1; i <= k; i++) {
int id = (b[i - 1].r - 1) * m + b[i - 1].c;
for (int j = 1; j <= n * m; j++) {
if (dist[id][j] == 1000000 || 1LL * b[i - 1].t * dist[id][j] > t)
continue;
add_edge(2 * k + n * m + j, k + i, 1);
}
}
return max_flow(source, sink) == k;
}
int main() {
scanf("%d%d%d%d", &n, &m, &males, &females);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
int r, c, t;
scanf("%d%d%d", &r, &c, &t);
bool f = true;
if (males == females - 1)
a.push_back((node){r, c, t});
else if (males == females + 1)
b.push_back((node){r, c, t});
else
f = false;
for (int i = 0; i < males; i++) {
scanf("%d%d%d", &r, &c, &t);
a.push_back((node){r, c, t});
}
for (int i = 0; i < females; i++) {
scanf("%d%d%d", &r, &c, &t);
b.push_back((node){r, c, t});
}
if (!f) {
puts("-1");
return 0;
}
bfs();
for (auto p : a) {
int id = (p.r - 1) * m + p.c;
for (int i = 1; i <= n * m; i++) {
if (dist[id][i] == 1000000) continue;
times.push_back(1LL * p.t * dist[id][i]);
}
}
for (auto p : b) {
int id = (p.r - 1) * m + p.c;
for (int i = 1; i <= n * m; i++) {
if (dist[id][i] == 1000000) continue;
times.push_back(1LL * p.t * dist[id][i]);
}
}
k = (int)a.size();
sort(times.begin(), times.end());
times.erase(unique(times.begin(), times.end()), times.end());
V = 2 * k + 2 * n * m + 2;
source = V - 1;
sink = V;
int l = -1;
r = (int)times.size() - 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(times[mid]))
r = mid;
else
l = mid;
}
if (!check(times[r]))
puts("-1");
else
printf("%lld\n", times[r]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
const long long INF = 1e18;
struct Dinic {
int nodes, src, dst;
vector<int> dist, q, work;
struct edge {
int to, rev;
long long f, cap;
};
vector<vector<edge>> g;
Dinic(int x) : nodes(x), g(x), dist(x), q(x), work(x) {}
void add_edge(int s, int t, long long cap) {
g[s].push_back((edge){t, ((int)g[t].size()), 0, cap});
g[t].push_back((edge){s, ((int)g[s].size()) - 1, 0, 0});
}
bool dinic_bfs() {
fill(dist.begin(), dist.end(), -1);
dist[src] = 0;
int qt = 0;
q[qt++] = src;
for (int qh = 0; qh < qt; qh++) {
int u = q[qh];
for (int i = 0; i < ((int)g[u].size()); i++) {
edge &e = g[u][i];
int v = g[u][i].to;
if (dist[v] < 0 && e.f < e.cap) dist[v] = dist[u] + 1, q[qt++] = v;
}
}
return dist[dst] >= 0;
}
long long dinic_dfs(int u, long long f) {
if (u == dst) return f;
for (int &i = work[u]; i < ((int)g[u].size()); i++) {
edge &e = g[u][i];
if (e.cap <= e.f) continue;
int v = e.to;
if (dist[v] == dist[u] + 1) {
long long df = dinic_dfs(v, min(f, e.cap - e.f));
if (df > 0) {
e.f += df;
g[v][e.rev].f -= df;
return df;
}
}
}
return 0;
}
long long max_flow(int _src, int _dst) {
src = _src;
dst = _dst;
long long result = 0;
while (dinic_bfs()) {
fill(work.begin(), work.end(), 0);
while (long long delta = dinic_dfs(src, INF)) result += delta;
}
return result;
}
};
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});
}
}
}
struct connection {
int x, y;
long long cost;
};
Dinic *buildGraph(int N) {
Dinic *mcf = new Dinic(N + 2);
for (int i = 0; i < males; i++) mcf->add_edge(N, i, 1);
for (int i = 0; i < females; i++) mcf->add_edge(males + i, N + 1, 1);
for (int i = 0; i < n * m; i++) {
int p = females + males + i;
mcf->add_edge(p, p + n * m, 1);
}
return mcf;
}
void expandGraph(Dinic *mcf, vector<connection> &connections) {
for (auto &c : connections) {
mcf->add_edge(c.x, c.y, 1);
}
}
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);
vector<connection> edges;
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) edges.push_back({k, p, dist[v][w] * male[k].t});
}
for (int k = 0; k < females; k++) {
int v = get(female[k]);
if (dist[v][w] != -1)
edges.push_back({p + n * m, males + k, dist[v][w] * female[k].t});
}
}
sort(edges.begin(), edges.end(),
[](connection a, connection b) -> bool { return a.cost < b.cost; });
int B = sqrt(((int)edges.size()));
vector<vector<connection>> buckets = {{}};
for (auto c : edges) {
if (((int)buckets.back().size()) < B)
buckets.back().push_back(c);
else
buckets.push_back({c});
}
int N = males + females + 2 * n * m;
Dinic *mcf = buildGraph(N);
int w = -1;
int curflow = 0;
for (int i = 0; i < ((int)buckets.size()); i++) {
expandGraph(mcf, buckets[i]);
curflow += mcf->max_flow(N, N + 1);
if (curflow == males) {
w = i;
break;
}
}
if (w == -1) return w;
mcf = buildGraph(N);
curflow = 0;
for (int i = 0; i < w; i++)
expandGraph(mcf, buckets[i]), curflow += mcf->max_flow(N, N + 1);
for (auto x : buckets[w]) {
vector<connection> y = {x};
expandGraph(mcf, y);
curflow += mcf->max_flow(N, N + 1);
if (curflow == males) return x.cost;
}
assert(false);
}
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;
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 = 1050;
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;
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<vector<int>> &layered_graph) {
queue<pair<int, int>> que;
vector<int> layer(n, -1);
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) {
if (layer[edge_set[e].v] == -1) {
que.push({edge_set[e].v, cur.second + 1});
layer[edge_set[e].v] = cur.second + 1;
layered_graph[cur.first].push_back(e);
} else if (layer[edge_set[e].v] == cur.second + 1) {
layered_graph[cur.first].push_back(e);
}
}
}
}
return 0;
}
bool dfs(vector<int> &path, vector<int> &cur_edge,
vector<vector<int>> &layered_graph, 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;
if (edge_set[e].w == 0) {
layered_graph[edge_set[e].u].resize(
layered_graph[edge_set[e].u].size() - 1);
}
}
return 1;
}
while (cur_edge[u] >= 0) {
swap(layered_graph[u][cur_edge[u]],
layered_graph[u][layered_graph[u].size() - 1]);
cur_edge[u]--;
int e = layered_graph[u][layered_graph[u].size() - 1];
path.push_back(e);
if (dfs(path, cur_edge, layered_graph, edge_set[e].v)) {
return 1;
}
path.pop_back();
}
return 0;
}
int max_flow() {
vector<vector<int>> layered_graph(n);
while (bfs(layered_graph)) {
vector<int> path;
vector<int> cur_edge(n);
for (int i = 0; i < n; i++) {
cur_edge[i] = layered_graph[i].size() - 1;
sort(layered_graph[i].begin(), layered_graph[i].end(),
[&](int i, int j) { return edge_set[i].w < edge_set[j].w; });
}
while (dfs(path, cur_edge, layered_graph, 0)) {
path.clear();
}
layered_graph.clear();
layered_graph.resize(n);
}
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 = 1e12;
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)] < 1000 &&
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)] < 1000 &&
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 == 1e12 ? -1 : lower) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
while (y > 0) {
x %= y;
swap(x, y);
}
return x;
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int c;
a = 0;
while (!isdigit(c = getchar()) && c != '-') {
}
char neg = 0;
if (c == '-') {
neg = 1;
c = getchar();
}
while (isdigit(c)) {
a = 10 * a + c - '0';
c = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
struct S {
int x, y, cost;
};
struct Edge {
int from, to, cap, flow;
long long len;
};
const int N = 22;
char s[N][N + 1];
vector<S> le;
vector<S> ri;
const int NM = N * N;
int dist[NM][NM];
int qu[NM];
char used[NM];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
long long distle[NM][NM];
long long distri[NM][NM];
vector<Edge> edges;
vector<int> g[4 * NM + 5];
int us[4 * NM + 5];
int phase = 1;
int que[4 * NM + 5];
int p[4 * NM + 5];
void addEdge(int from, int to, int cap, long long len) {
g[from].push_back(edges.size());
edges.push_back(Edge{from, to, cap, 0, len});
g[to].push_back(edges.size());
edges.push_back(Edge{to, from, 0, 0, len});
}
int vertSize;
int ptr[5 * NM + 5];
int ddd[5 * NM + 5];
bool bfs(int s, int t, long long len) {
++phase;
int q1 = 0, q2 = 0;
que[q2++] = s;
us[s] = phase;
ddd[s] = 0;
p[s] = -1;
while (q1 < q2) {
int v = que[q1++];
for (int ed : g[v]) {
Edge &e = edges[ed];
if (e.len > len) break;
if (e.cap > e.flow) {
if (us[e.to] != phase) {
us[e.to] = phase;
que[q2++] = e.to;
p[e.to] = ed;
ddd[e.to] = ddd[v] + 1;
}
}
}
}
return us[t] == phase;
}
int dfs(int v, int t, int flow, long long len) {
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 = edges[id].to;
if (edges[id].len > len) {
break;
}
if (ddd[to] != ddd[v] + 1) continue;
int pushed = dfs(to, t, min(flow, edges[id].cap - edges[id].flow), len);
if (pushed) {
edges[id].flow += pushed;
edges[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
int dinic(int s, int t, long long len) {
int flow = 0;
for (;;) {
if (!bfs(s, t, len)) break;
memset(ptr, 0, vertSize * sizeof(int));
while (int pushed = dfs(s, t, 1000, len)) flow += pushed;
}
return flow;
}
void clearFlow(long long len) {
for (int i = 0; i < vertSize; ++i) {
for (int ed : g[i]) {
if (edges[ed].len > len) {
break;
}
edges[ed].flow = 0;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, B, G;
n = nxt();
m = nxt();
B = nxt();
G = nxt();
if (abs(B - G) != 1) {
puts("-1");
return 0;
}
int emptyCell = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) {
emptyCell += s[i][j] == '.';
}
}
if ((B + G + 1) / 2 > emptyCell) {
puts("-1");
return 0;
}
{
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
if (B < G) {
le.push_back(S{r, c, t});
} else {
ri.push_back(S{r, c, t});
}
}
for (int i = 0; i < B; ++i) {
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
le.push_back(S{r, c, t});
}
for (int i = 0; i < G; ++i) {
int r = nxt() - 1;
int c = nxt() - 1;
int t = nxt();
ri.push_back(S{r, c, t});
}
memset(dist, 0x3f, sizeof(dist));
int inf = dist[0][0];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int st = i * m + j;
if (s[i][j] == '#') continue;
dist[st][st] = 0;
int q1 = 0, q2 = 0;
qu[q2++] = st;
memset(used, 0, sizeof(used));
used[st] = 1;
while (q1 < q2) {
int id = qu[q1++];
int vx = id / m;
int vy = id % m;
for (int k = 0; k < 4; ++k) {
int x = vx + dx[k];
int y = vy + dy[k];
if (x < 0 || x >= n || y < 0 || y >= m) continue;
if (s[x][y] == '#') continue;
int nid = x * m + y;
if (!used[nid]) {
used[nid] = 1;
qu[q2++] = nid;
dist[st][nid] = dist[st][id] + 1;
}
}
}
}
}
long long maxdist = 0;
for (int i = 0; i < int(le.size()); ++i) {
int ii = le[i].x * m + le[i].y;
for (int jj = 0; jj < n * m; ++jj) {
if (dist[ii][jj] != inf) {
distle[i][jj] = dist[ii][jj] * 1ll * le[i].cost;
maxdist = max(maxdist, distle[i][jj]);
} else {
distle[i][jj] = LLONG_MAX;
}
}
}
for (int i = 0; i < int(ri.size()); ++i) {
int ii = ri[i].x * m + ri[i].y;
for (int jj = 0; jj < n * m; ++jj) {
if (dist[ii][jj] != inf) {
distri[i][jj] = dist[ii][jj] * 1ll * ri[i].cost;
maxdist = max(maxdist, distri[i][jj]);
} else {
distri[i][jj] = LLONG_MAX;
}
}
}
for (int i = 0; i < n * m; ++i) {
addEdge(2 * i, 2 * i + 1, 1, 0);
}
int curv = 2 * n * m;
int source = curv + le.size() + ri.size();
int sink = curv + le.size() + ri.size() + 1;
for (int i = 0; i < (int)le.size(); ++i) {
for (int j = 0; j < n * m; ++j) {
if (distle[i][j] != LLONG_MAX) addEdge(curv + i, 2 * j, 1, distle[i][j]);
}
addEdge(source, curv + i, 1, 0);
}
curv += le.size();
for (int i = 0; i < int(ri.size()); ++i) {
for (int j = 0; j < n * m; ++j) {
if (distri[i][j] != LLONG_MAX)
addEdge(2 * j + 1, curv + i, 1, distri[i][j]);
}
addEdge(curv + i, sink, 1, 0);
}
for (int i = 0; i <= sink; ++i) {
sort((g[i]).begin(), (g[i]).end(),
[&](int l, int r) { return edges[l].len < edges[r].len; });
}
long long l = 0, r = maxdist;
int needFlow = le.size();
vertSize = sink + 1;
while (l < r) {
long long mid = (l + r) >> 1;
int flow = dinic(source, sink, mid);
clearFlow(mid);
if (flow < needFlow) {
l = mid + 1;
} else {
r = mid;
}
}
int flow = dinic(source, sink, l);
if (flow != needFlow) {
cout << "-1" << endl;
return 0;
}
cout << l << endl;
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
const int N = 23, MXN = N * N * 4;
struct Edge {
int to, flow;
};
struct Dinic {
int s, t, P[MXN], D[MXN], qu[MXN];
vector<int> Adj[MXN];
vector<Edge> E;
inline void Add(int v, int u, int w) {
Adj[v].push_back(E.size());
E.push_back({u, w});
Adj[u].push_back(E.size());
E.push_back({v, 0});
}
inline bool BFS() {
int l = 0, r = 0;
memset(D, -1, sizeof(D));
D[s] = 0;
qu[r++] = s;
while (r - l) {
int v = qu[l++];
for (int &id : Adj[v])
if (E[id].flow && D[E[id].to] == -1)
D[E[id].to] = D[v] + 1, qu[r++] = E[id].to;
}
return (D[t] != -1);
}
int DFS(int v, int flow) {
if (v == t) return flow;
int Flow = 0;
for (int i = P[v]; i < Adj[v].size(); i++) {
int id = Adj[v][i];
if (E[id].flow && D[E[id].to] == D[v] + 1) {
int sub = DFS(E[id].to, min(flow, E[id].flow));
if (!sub) {
swap(Adj[v][i], Adj[v][P[v]]);
P[v]++;
continue;
}
E[id].flow -= sub;
E[id ^ 1].flow += sub;
flow -= sub;
Flow += sub;
if (!flow) return Flow;
} else
swap(Adj[v][i], Adj[v][P[v]]), P[v]++;
}
return Flow;
}
inline int MaxFlow(int _s, int _t) {
int Flow = 0;
s = _s;
t = _t;
while (BFS()) {
memset(P, 0, sizeof(P));
Flow += DFS(s, INT_MAX);
}
return Flow;
}
};
int n, m, D[N][N], gg[] = {-1, 1, 0, 0};
int fl, ml, X[MXN], Y[MXN], T[MXN];
pair<int, int> qu[MXN];
char S[N][N];
vector<vector<long long> > E;
inline bool Solve(int md) {
Dinic G;
int s = ml + fl + n * m * 2, t = s + 1;
for (int i = 0; i < ml; i++) G.Add(s, i, 1);
for (int i = 0; i < fl; i++) G.Add(i + ml, t, 1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
G.Add(ml + fl + i + j * n, ml + fl + i + j * n + n * m, 1);
for (int i = 0; i <= md; i++) {
int id = E[i][1], cell = n * E[i][3] + E[i][2] + ml + fl;
if (id < ml)
G.Add(id, cell, 1);
else
G.Add(cell + n * m, id, 1);
}
return (G.MaxFlow(s, t) == ml);
}
int main() {
scanf("%d%d%d%d", &n, &m, &ml, &fl);
if (abs(ml - fl) != 1) return !printf("-1");
for (int i = 0; i < n; i++) scanf("%s", &S[i]);
if (ml < fl)
scanf("%d%d%d", &X[ml], &Y[ml], &T[ml]);
else
scanf("%d%d%d", &X[ml + fl], &Y[ml + fl], &T[ml + fl]);
for (int i = 0; i < ml; i++) scanf("%d%d%d", &X[i], &Y[i], &T[i]);
if (ml < fl) ml++;
for (int i = ml; i < ml + fl; i++) scanf("%d%d%d", &X[i], &Y[i], &T[i]);
if (fl < ml) fl++;
for (int i = 0; i < ml + fl; i++) {
int l = 0, r = 0;
memset(D, -1, sizeof(D));
X[i]--;
Y[i]--;
D[X[i]][Y[i]] = 0;
qu[r++] = {X[i], Y[i]};
while (r - l) {
int a = qu[l].first, b = qu[l++].second;
E.push_back({1LL * D[a][b] * T[i], i, a, b});
for (int h = 0; h < 4; h++) {
int ta = a + gg[h], tb = b + gg[(h + 2) % 4];
if (ta < 0 || tb < 0 || ta >= n || tb >= m) continue;
if (S[ta][tb] == '#' || D[ta][tb] != -1) continue;
D[ta][tb] = D[a][b] + 1;
qu[r++] = {ta, tb};
}
}
}
sort(E.begin(), E.end());
int le = -1, ri = E.size(), md;
while (ri - le > 1) {
md = (le + ri) >> 1;
if (Solve(md))
ri = md;
else
le = md;
}
if (ri < E.size()) return !printf("%lld", E[ri][0]);
return !printf("-1");
}
|
#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 = 1e4 + 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>
using namespace std;
namespace MF {
const int N = 4 * (22 * 22 + 5) + 2,
M = 2 * (22 * 22 + 5) * (22 * 22 + 5) + 3 * (22 * 22 + 5);
int f[N], e[2 * M], c[2 * M], fl[2 * M], nxt[2 * M], ce;
int n, s, t;
int Q[N], lvl[N];
int le[N];
void init(int _n) {
n = _n + 2;
s = _n;
t = _n + 1;
ce = 0;
for (int i = (0); i < (n); i++) f[i] = -1;
}
void add(int a, int b, int cap) {
nxt[ce] = f[a];
f[a] = ce;
e[ce] = b;
fl[ce] = 0;
c[ce] = cap;
ce++;
nxt[ce] = f[b];
f[b] = ce;
e[ce] = a;
fl[ce] = 0;
c[ce] = 0;
ce++;
}
bool bfs() {
for (int i = (0); i < (n); i++) lvl[i] = -1;
int qi = 1;
Q[0] = s;
lvl[s] = 0;
for (int i = (0); i < (qi); i++) {
int x = Q[i];
le[x] = f[x];
for (int j = f[x]; j >= 0; j = nxt[j])
if (c[j] - fl[j] > 0) {
int y = e[j];
if (lvl[y] == -1) {
lvl[y] = lvl[x] + 1;
Q[qi++] = y;
}
}
}
return lvl[t] != -1;
}
int aug(int cu, int f) {
if (cu == t) return f;
for (int &i = le[cu]; i >= 0; i = nxt[i])
if (c[i] - fl[i] > 0) {
int x = e[i];
if (lvl[x] != lvl[cu] + 1) continue;
int rf = aug(x, min(f, c[i] - fl[i]));
if (rf > 0) {
fl[i] += rf;
fl[i ^ 1] -= rf;
return rf;
}
}
lvl[cu] = -1;
return 0;
}
int mf() {
int tot = 0;
while (bfs())
for (int x = aug(s, 1e9); x; x = aug(s, 1e9)) tot += x;
return tot;
}
}; // namespace MF
char g[25][25];
int d[25][25], D;
int dst[(22 * 22 + 5)][(22 * 22 + 5)];
int h, w;
int my[(22 * 22 + 5)], mx[(22 * 22 + 5)], mt[(22 * 22 + 5)], nm,
fy[(22 * 22 + 5)], fx[(22 * 22 + 5)], ft[(22 * 22 + 5)], nf;
void rf() {
scanf("%d %d %d", fy + nf, fx + nf, ft + nf);
fy[nf]--;
fx[nf]--;
nf++;
}
void rm() {
scanf("%d %d %d", my + nm, mx + nm, mt + nm);
my[nm]--;
mx[nm]--;
nm++;
}
bool mk(int i, int j, int t, long long m) {
if (dst[i][j] > 5e7) return false;
return dst[i][j] * 1ll * t <= m;
}
int main() {
int m, f;
scanf("%d %d %d %d", &h, &w, &m, &f);
if (abs(m - f) != 1) {
printf("-1\n");
return 0;
}
for (int y = (0); y < (h); y++) scanf(" %s ", g[y]);
if (m > f)
rf();
else
rm();
for (int i = (0); i < (m); i++) rm();
for (int i = (0); i < (f); i++) rf();
assert(nm == nf);
for (int y = (0); y < (h); y++)
for (int x = (0); x < (w); x++)
if (g[y][x] == '.') d[y][x] = D++;
for (int i = (0); i < (D); i++)
for (int j = (0); j < (D); j++) dst[i][j] = 1e8;
for (int y = (0); y < (h); y++)
for (int x = (0); x < (w); x++)
if (g[y][x] == '.')
for (int i = (0); i < (4); i++) {
int ny = y + ((int[]){-1, 0, 1, 0})[i];
int nx = x + ((int[]){0, -1, 0, 1})[i];
if (0 <= ny && ny < h && 0 <= nx && nx < w && g[ny][nx] == '.')
dst[d[y][x]][d[ny][nx]] = 1;
}
for (int i = (0); i < (D); i++) dst[i][i] = 0;
for (int i = (0); i < (D); i++)
for (int j = (0); j < (D); j++)
for (int k = (0); k < (D); k++)
dst[j][k] = min(dst[j][k], dst[j][i] + dst[i][k]);
long long s = 0, e = 1e12, b = -1;
while (s <= e) {
long long m = (s + e) / 2;
MF::init(nm + D + D + nf);
for (int i = (0); i < (nm); i++) MF::add(MF::s, i, 1);
for (int i = (0); i < (nm); i++)
for (int j = (0); j < (D); j++)
if (mk(d[my[i]][mx[i]], j, mt[i], m)) MF::add(i, nm + j, 1);
for (int i = (0); i < (D); i++) MF::add(nm + i, nm + D + i, 1);
for (int i = (0); i < (nf); i++)
for (int j = (0); j < (D); j++)
if (mk(d[fy[i]][fx[i]], j, ft[i], m))
MF::add(nm + D + j, nm + D + D + i, 1);
for (int i = (0); i < (nf); i++) MF::add(nm + D + D + i, MF::t, 1);
if (MF::mf() == nm) {
e = m - 1;
b = m;
} else
s = m + 1;
}
printf("%lld\n", b);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSIDE = 22;
const int MAXCELL = MAXSIDE * MAXSIDE;
const int MAXN = 1 + MAXCELL + 2 * MAXCELL + MAXCELL + 1;
const int MAXM =
2 * (MAXCELL + MAXCELL * MAXCELL + MAXCELL + MAXCELL * MAXCELL + MAXCELL);
typedef struct MF {
int n, m, s, t;
int flow;
int fst[MAXN];
int nxt[MAXM];
int to[MAXM];
int cap[MAXM];
int root[MAXN];
int back[MAXN];
int q[MAXN], qhead, qtail;
void init() {
for (int i = (0); i < (n); ++i) fst[i] = -1;
for (int i = (0); i < (n); ++i) root[i] = back[i] = -1;
root[s] = s;
root[t] = t;
}
void addedge(int a, int b) {
nxt[m] = fst[a];
fst[a] = m;
to[m] = b;
cap[m] = 1;
int ab = m++;
nxt[m] = fst[b];
fst[b] = m;
to[m] = a;
cap[m] = 0;
int ba = m++;
if (root[a] == s && root[b] == t) {
foundpath(ab);
return;
}
if (root[a] == s && root[b] != s) {
qhead = qtail = 0;
root[b] = s;
back[b] = ba;
q[qhead++] = b;
while (qtail < qhead) {
int at = q[qtail++];
for (int x = fst[at]; x != -1; x = nxt[x])
if (cap[x] > 0 && root[to[x]] != s) {
if (root[to[x]] == t) {
foundpath(x);
return;
}
root[to[x]] = s;
back[to[x]] = x ^ 1;
q[qhead++] = to[x];
}
}
}
if (root[b] == t && root[a] != t) {
qhead = qtail = 0;
root[a] = t;
back[a] = ab;
q[qhead++] = a;
while (qtail < qhead) {
int at = q[qtail++];
for (int x = fst[at]; x != -1; x = nxt[x])
if (cap[x ^ 1] > 0 && root[to[x ^ 1]] != t) {
if (root[to[x ^ 1]] == s) {
foundpath(x ^ 1);
return;
}
root[to[x ^ 1]] = t;
back[to[x ^ 1]] = x ^ 1;
q[qhead++] = to[x ^ 1];
}
}
}
}
void foundpath(int x) {
--cap[x];
++cap[x ^ 1];
++flow;
for (int at = to[x ^ 1]; at != s; at = to[back[at]]) {
++cap[back[at]];
--cap[back[at] ^ 1];
}
for (int at = to[x]; at != t; at = to[back[at]]) {
--cap[back[at]];
++cap[back[at] ^ 1];
}
for (int i = (0); i < (n); ++i) root[i] = back[i] = -1;
qhead = qtail = 0;
root[s] = s;
q[qhead++] = s;
while (qtail < qhead) {
int at = q[qtail++];
assert(at != t);
for (int x = fst[at]; x != -1; x = nxt[x])
if (cap[x] > 0 && root[to[x]] != s) {
assert(root[to[x]] != t);
root[to[x]] = s;
back[to[x]] = x ^ 1;
q[qhead++] = to[x];
}
}
qhead = qtail = 0;
root[t] = t;
q[qhead++] = t;
while (qtail < qhead) {
int at = q[qtail++];
assert(at != s);
for (int x = fst[at]; x != -1; x = nxt[x])
if (cap[x ^ 1] > 0 && root[to[x ^ 1]] != t) {
assert(root[to[x ^ 1]] != s);
root[to[x ^ 1]] = t;
back[to[x ^ 1]] = x ^ 1;
q[qhead++] = to[x ^ 1];
}
}
}
} G;
G g;
typedef struct Evnt {
int a, b;
long long t;
} Evnt;
bool operator<(const Evnt &p, const Evnt &q) { return p.t < q.t; }
Evnt evnt[2 * MAXCELL * MAXCELL];
int nevnt;
int h, w, na, nb, npair;
char m[MAXSIDE][MAXSIDE];
int ax[MAXCELL], ay[MAXCELL], at[MAXCELL];
int bx[MAXCELL], by[MAXCELL], bt[MAXCELL];
int c[MAXSIDE][MAXSIDE], ncell;
int d[MAXCELL][MAXCELL];
const int DX[] = {-1, 0, +1, 0}, DY[] = {0, +1, 0, -1};
void run() {
scanf("%d%d%d%d", &h, &w, &na, &nb);
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y) scanf(" %c", &m[x][y]);
if (na + 1 == nb)
scanf("%d%d%d", &ax[na], &ay[na], &at[na]);
else if (nb + 1 == na)
scanf("%d%d%d", &bx[nb], &by[nb], &bt[nb]);
else {
printf("-1\n");
return;
}
for (int i = (0); i < (na); ++i) scanf("%d%d%d", &ax[i], &ay[i], &at[i]);
for (int i = (0); i < (nb); ++i) scanf("%d%d%d", &bx[i], &by[i], &bt[i]);
npair = max(na, nb);
for (int i = (0); i < (npair); ++i) --ax[i], --ay[i], --bx[i], --by[i];
ncell = 0;
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y)
if (m[x][y] == '#')
c[x][y] = -1;
else
c[x][y] = ncell++;
for (int i = (0); i < (ncell); ++i)
for (int j = (0); j < (ncell); ++j) d[i][j] = i == j ? 0 : INT_MAX;
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y)
if (c[x][y] != -1)
for (int k = (0); k < (4); ++k) {
int nx = x + DX[k], ny = y + DY[k];
if (nx < 0 || nx >= h || ny < 0 || ny >= w || c[nx][ny] == -1)
continue;
d[c[x][y]][c[nx][ny]] = 1;
}
for (int k = (0); k < (ncell); ++k)
for (int i = (0); i < (ncell); ++i)
for (int j = (0); j < (ncell); ++j)
if (d[i][k] != INT_MAX && d[k][j] != INT_MAX &&
d[i][k] + d[k][j] < d[i][j])
d[i][j] = d[i][k] + d[k][j];
g.n = 2 * npair + 2 * ncell + 2;
g.m = 0;
g.s = g.n - 2;
g.t = g.n - 1;
g.flow = 0;
g.init();
for (int i = (0); i < (npair); ++i) g.addedge(g.s, i);
for (int i = (0); i < (npair); ++i) g.addedge(npair + i, g.t);
for (int i = (0); i < (ncell); ++i)
g.addedge(2 * npair + 2 * i + 0, 2 * npair + 2 * i + 1);
nevnt = 0;
for (int i = (0); i < (npair); ++i) {
int ac = c[ax[i]][ay[i]];
assert(ac != -1);
for (int j = (0); j < (ncell); ++j)
if (d[ac][j] != INT_MAX) {
evnt[nevnt].a = i;
evnt[nevnt].b = 2 * npair + 2 * j + 0;
evnt[nevnt].t = (long long)at[i] * d[ac][j];
++nevnt;
}
}
for (int i = (0); i < (npair); ++i) {
int bc = c[bx[i]][by[i]];
assert(bc != -1);
for (int j = (0); j < (ncell); ++j)
if (d[bc][j] != INT_MAX) {
evnt[nevnt].a = 2 * npair + 2 * j + 1;
evnt[nevnt].b = npair + i;
evnt[nevnt].t = (long long)bt[i] * d[bc][j];
++nevnt;
}
}
sort(evnt, evnt + nevnt);
for (int i = (0); i < (nevnt); ++i) {
g.addedge(evnt[i].a, evnt[i].b);
if (g.flow == npair) {
cout << evnt[i].t << endl;
return;
}
}
printf("-1\n");
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5, M = 1e6;
struct edge {
int to, next, f;
} e[M];
int head[N], tot, S, T;
bool mp[100][100];
int vis[100][100], cnt;
long long dis[100][100];
int q[N], qx[N], qy[N];
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int n, m, d[N], cur[N];
int id(int x, int y) { return (x - 1) * m + y; }
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
e[++tot] = (edge){x, head[y], 0};
head[y] = tot;
}
bool bfs() {
for (int i = S; i <= T; i++) d[i] = -1;
int h = 0, t = 1;
q[1] = S;
d[S] = 0;
while (h != t) {
int x = q[++h];
for (int i = head[x]; i; i = e[i].next)
if (d[e[i].to] == -1 && e[i].f) {
d[e[i].to] = d[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 rest = flow, k;
for (int i = cur[x]; i && rest; cur[x] = i = e[i].next)
if (d[e[i].to] == d[x] + 1 && e[i].f) {
k = dfs(e[i].to, min(rest, e[i].f));
rest -= k;
e[i].f -= k;
e[i ^ 1].f += k;
}
if (rest) d[x] = -1;
return flow - rest;
}
int f1, f2;
int x1[555], wzpakking[555], v1[555];
int x2[555], y2[555], v2[555];
int main() {
scanf("%d%d%d%d", &n, &m, &f1, &f2);
for (int i = 1; i <= n; i++) {
char s[100];
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) mp[i][j] = (s[j] == '.');
}
if (f1 + 1 == f2)
scanf("%d%d%d", &x1[f2], &wzpakking[f2], &v1[f2]);
else if (f2 + 1 == f1)
scanf("%d%d%d", &x2[f1], &y2[f1], &v2[f1]);
else
return puts("-1"), 0;
for (int i = 1; i <= f1; i++) scanf("%d%d%d", &x1[i], &wzpakking[i], &v1[i]);
for (int i = 1; i <= f2; i++) scanf("%d%d%d", &x2[i], &y2[i], &v2[i]);
int Q = max(f1, f2);
S = 0;
T = ((n * m + Q) << 1) + 1;
long long l = 0, r = 1ll << 60;
while (l < r) {
long long mid = (l + r) / 2;
for (int i = S; i <= T; i++) head[i] = 0;
tot = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j]) add(id(i, j), id(i, j) + n * m, 1);
for (int k = 1; k <= Q; k++) {
add(S, n * m * 2 + k, 1);
int x = x1[k], y = wzpakking[k];
vis[x][y] = ++cnt;
dis[x][y] = 0;
int h = 0, t = 1;
qx[1] = x;
qy[1] = y;
while (h != t) {
x = qx[++h], y = qy[h];
add(n * m * 2 + k, id(x, y), 1);
if (dis[x][y] + v1[k] > mid) continue;
for (int di = 0; di < 4; di++) {
int nx = x + dx[di];
int ny = y + dy[di];
if (nx && ny && nx <= n && ny <= m && mp[nx][ny] &&
vis[nx][ny] != cnt) {
vis[nx][ny] = cnt;
dis[nx][ny] = dis[x][y] + v1[k];
qx[++t] = nx, qy[t] = ny;
}
}
}
}
for (int k = 1; k <= Q; k++) {
add(n * m * 2 + Q + k, T, 1);
int x = x2[k], y = y2[k];
vis[x][y] = ++cnt;
dis[x][y] = 0;
int h = 0, t = 1;
qx[1] = x;
qy[1] = y;
while (h != t) {
x = qx[++h], y = qy[h];
add(id(x, y) + n * m, 2 * n * m + Q + k, 1);
if (dis[x][y] + v2[k] > mid) continue;
for (int di = 0; di < 4; di++) {
int nx = x + dx[di];
int ny = y + dy[di];
if (nx && ny && nx <= n && ny <= m && mp[nx][ny] &&
vis[nx][ny] != cnt) {
vis[nx][ny] = cnt;
dis[nx][ny] = dis[x][y] + v2[k];
qx[++t] = nx, qy[t] = ny;
}
}
}
}
int k = Q;
for (; bfs();) {
for (int i = S; i <= T; i++) cur[i] = head[i];
k -= dfs(S, 1e9);
}
if (k)
l = mid + 1;
else
r = mid;
}
if (l >= (1ll << 60))
puts("-1");
else
printf("%lld\n", l);
}
|
#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;
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;
const int MAXN = 2005;
const int MAXM = 2000010;
const int INF = 0x3f3f3f3f;
struct Node {
int from, to, next;
int cap;
} edge[MAXM];
int tol;
int head[MAXN];
int dep[MAXN];
int gap[MAXN];
int n;
void init() {
tol = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w) {
edge[tol].from = u;
edge[tol].to = v;
edge[tol].cap = w;
edge[tol].next = head[u];
head[u] = tol++;
edge[tol].from = v;
edge[tol].to = u;
edge[tol].cap = 0;
edge[tol].next = head[v];
head[v] = tol++;
}
void BFS(int start, int end) {
memset(dep, -1, sizeof(dep));
memset(gap, 0, sizeof(gap));
gap[0] = 1;
int que[MAXN];
int front, rear;
front = rear = 0;
dep[end] = 0;
que[rear++] = end;
while (front != rear) {
int u = que[front++];
if (front == MAXN) front = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (dep[v] != -1) continue;
que[rear++] = v;
if (rear == MAXN) rear = 0;
dep[v] = dep[u] + 1;
++gap[dep[v]];
}
}
}
int SAP(int start, int end) {
int res = 0;
BFS(start, end);
int cur[MAXN];
int S[MAXN];
int top = 0;
memcpy(cur, head, sizeof(head));
int u = start;
int i;
while (dep[start] < n) {
if (u == end) {
int temp = INF;
int inser;
for (i = 0; i < top; i++)
if (temp > edge[S[i]].cap) {
temp = edge[S[i]].cap;
inser = i;
}
for (i = 0; i < top; i++) {
edge[S[i]].cap -= temp;
edge[S[i] ^ 1].cap += temp;
}
res += temp;
top = inser;
u = edge[S[top]].from;
}
if (u != end && gap[dep[u] - 1] == 0) break;
for (i = cur[u]; i != -1; i = edge[i].next)
if (edge[i].cap != 0 && dep[u] == dep[edge[i].to] + 1) break;
if (i != -1) {
cur[u] = i;
S[top++] = i;
u = edge[i].to;
} else {
int min = n;
for (i = head[u]; i != -1; i = edge[i].next) {
if (edge[i].cap == 0) continue;
if (min > dep[edge[i].to]) {
min = dep[edge[i].to];
cur[u] = i;
}
}
--gap[dep[u]];
dep[u] = min + 1;
++gap[dep[u]];
if (u != start) u = edge[S[--top]].from;
}
}
return res;
}
char mp[25][25];
struct Scayger {
int x, y, t;
inline void read() {
scanf("%d%d%d", &x, &y, &t);
--x;
--y;
}
} Boy[490], Girl[490], Boss;
int N, M, male, female;
int dis[23][23][23][23];
inline bool in(int x, int y) { return 0 <= x && x < N && 0 <= y && y < M; }
queue<int> Q;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
void bfs(int sx, int sy, int dis[23][23]) {
if (mp[sx][sy] == '#') return;
dis[sx][sy] = 0;
Q.push(sx * M + sy);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int x = u / M, y = u % M;
for (int d = 0; d < 4; ++d) {
int xx = x + dx[d], yy = y + dy[d];
if (!in(xx, yy) || mp[xx][yy] == '#' || dis[xx][yy] != -1) continue;
dis[xx][yy] = dis[x][y] + 1;
Q.push(xx * M + yy);
}
}
}
inline bool check(long long val) {
init();
int S = 2 * N * M + male + female, T = S + 1;
n = T + 3;
for (int i = 0; i < male; ++i) {
addedge(S, 2 * N * M + i, 1);
int x = Boy[i].x, y = Boy[i].y;
for (int j = 0; j < N; ++j) {
for (int k = 0; k < M; ++k) {
if (dis[x][y][j][k] == -1) continue;
if (1LL * Boy[i].t * dis[x][y][j][k] > val) continue;
addedge(2 * N * M + i, j * M + k, 1);
}
}
}
for (int i = 0; i < female; ++i) {
addedge(2 * N * M + male + i, T, 1);
int x = Girl[i].x, y = Girl[i].y;
for (int j = 0; j < N; ++j) {
for (int k = 0; k < M; ++k) {
if (dis[x][y][j][k] == -1) continue;
if (1LL * Girl[i].t * dis[x][y][j][k] > val) continue;
addedge(N * M + j * M + k, 2 * N * M + male + i, 1);
}
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
if (mp[i][j] == '#') continue;
addedge(i * M + j, N * M + i * M + j, 1);
}
}
return SAP(S, T) == male;
}
int main() {
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", mp[i]);
Boss.read();
for (int i = 0; i < male; ++i) Boy[i].read();
for (int i = 0; i < female; ++i) Girl[i].read();
if (male < female) {
Boy[male++] = Boss;
} else {
Girl[female++] = Boss;
}
memset(dis, -1, sizeof(dis));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
bfs(i, j, dis[i][j]);
}
}
long long low = 0, high = 1e12, mid, res = -1;
while (low <= high) {
mid = (low + high) >> 1;
if (check(mid)) {
res = mid;
high = mid - 1;
} else
low = mid + 1;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
inline long long parse(const string &s) {
stringstream ss(s);
long long x;
ss >> x;
return x;
}
const double EPS = 1e-9;
const int inf = 1000 * 1000 * 1000;
const char cinf = 102;
const long long linf = inf * 1ll * inf;
const double dinf = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
struct graph {
struct edge {
int v, i, c;
};
vector<vector<edge>> gr;
vector<char> W;
int S, T;
graph(int n) : gr(n) {}
void add(int a, int b, int c) {
edge e1 = {b, ((int)(gr[b]).size()), c};
edge e2 = {a, ((int)(gr[a]).size()), 0};
gr[a].push_back(e1);
gr[b].push_back(e2);
}
bool dfs(int v) {
if (v == T) return true;
if (W[v]) return false;
W[v] = true;
for (int i = 0; i < (((int)(gr[v]).size())); ++i) {
edge &e = gr[v][i];
if (e.c && dfs(e.v)) {
edge &e2 = gr[e.v][e.i];
--e.c;
++e2.c;
return true;
}
}
return false;
}
bool flow() {
W.assign(((int)(gr).size()), false);
return dfs(S);
}
};
vector<string> A;
vector<vector<int>> I;
int ii;
void numb() {
I.resize(((int)(A).size()), vector<int>(((int)(A[0]).size()), -1));
int c = 0;
for (int i = 0; i < (((int)(A).size())); ++i) {
for (int j = 0; j < (((int)(A[0]).size())); ++j) {
if (A[i][j] != '#') I[i][j] = c++;
}
}
ii = c;
}
struct guy {
int a, b, t;
vector<pair<long long, long long>> v;
void read() {
cin >> a >> b >> t;
--a;
--b;
}
void prep() {
vector<vector<int>> D(((int)(A).size()),
vector<int>(((int)(A[0]).size()), inf));
queue<pair<int, int>> qu;
D[a][b] = 0;
qu.push(make_pair(a, b));
while (!qu.empty()) {
pair<int, int> p = qu.front();
qu.pop();
v.push_back(
make_pair(I[p.first][p.second], D[p.first][p.second] * 1ll * t));
int da[] = {0, 0, -1, 1};
int db[] = {-1, 1, 0, 0};
for (int q = 0; q < (4); ++q) {
int aa = p.first + da[q];
int bb = p.second + db[q];
if (aa < 0 || aa >= ((int)(A).size()) || bb < 0 ||
bb >= ((int)(A[0]).size()) || D[aa][bb] != inf || A[aa][bb] == '#')
continue;
D[aa][bb] = D[p.first][p.second] + 1;
qu.push(make_pair(aa, bb));
}
}
}
};
vector<guy> M, F;
bool check(long long k) {
int n = ((int)(M).size());
graph g(n * 2 + ii * 2 + 2);
g.S = n * 2 + ii * 2;
g.T = g.S + 1;
for (int i = 0; i < (n); ++i) {
g.add(g.S, i, 1);
g.add(n + i, g.T, 1);
}
for (int i = 0; i < (ii); ++i) {
g.add(n * 2 + i * 2, n * 2 + i * 2 + 1, 1);
}
for (int q = 0; q < (((int)(M).size())); ++q) {
for (int i = 0; i < (((int)(M[q].v).size())); ++i) {
if (M[q].v[i].second > k) break;
g.add(q, n * 2 + 2 * M[q].v[i].first, 1);
}
for (int i = 0; i < (((int)(F[q].v).size())); ++i) {
if (F[q].v[i].second > k) break;
g.add(n * 2 + 2 * F[q].v[i].first + 1, n + q, 1);
}
}
for (int i = 0; i < (n); ++i) {
if (!g.flow()) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, x, y;
cin >> n >> m >> x >> y;
A.resize(n);
for (int i = 0; i < (n); ++i) {
cin >> A[i];
}
numb();
M.resize(x);
F.resize(y);
guy bi;
bi.read();
for (int i = 0; i < (x); ++i) {
M[i].read();
}
for (int i = 0; i < (y); ++i) {
F[i].read();
}
if (x < y)
M.push_back(bi);
else
F.push_back(bi);
if (((int)(M).size()) != ((int)(F).size())) {
cout << -1;
return 0;
}
for (int i = 0; i < (((int)(M).size())); ++i) {
M[i].prep();
}
for (int i = 0; i < (((int)(F).size())); ++i) {
F[i].prep();
}
long long a = -1, b = inf * 1000ll;
while (b > a + 1) {
long long k = (a + b) / 2;
if (check(k))
b = k;
else
a = k;
}
if (b == inf * 1000ll) {
cout << -1;
return 0;
}
cout << b;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SOURCE = 0, SINK = 1;
struct edge {
int to, idx, cap;
};
vector<vector<edge>> adj;
vector<int> lvl, ptr;
int totalflow;
int dfs(int n, int f) {
if (n == SINK) {
totalflow += f;
return f;
}
if (lvl[n] == lvl[SINK]) return 0;
while (ptr[n] < (int)adj[n].size()) {
edge& e = adj[n][ptr[n]];
ptr[n]++;
if (lvl[e.to] == lvl[n] + 1 && e.cap > 0) {
int nf = dfs(e.to, min(f, e.cap));
if (nf) {
e.cap -= nf;
adj[e.to][e.idx].cap += nf;
return nf;
}
}
}
return 0;
}
bool runMaxFlow() {
lvl.assign(adj.size(), -1);
ptr.assign(adj.size(), 0);
lvl[SOURCE] = 0;
queue<int> bfs;
bfs.push(SOURCE);
while (!bfs.empty()) {
int t = bfs.front();
bfs.pop();
for (edge& e : adj[t]) {
if (lvl[e.to] != -1 || e.cap <= 0) continue;
lvl[e.to] = lvl[t] + 1;
bfs.push(e.to);
}
}
if (lvl[SINK] == -1) return false;
while (dfs(SOURCE, 1 << 30)) {
}
return true;
}
void initMaxFlow(int nodes) {
totalflow = 0;
adj.clear();
adj.resize(nodes);
}
void addEdge(int a, int b, int w) {
adj[a].push_back(edge{b, (int)adj[b].size(), w});
adj[b].push_back(edge{a, (int)adj[a].size() - 1, 0});
}
const int dr[] = {0, 0, -1, 1}, dc[] = {-1, 1, 0, 0};
int R, C, M, F, S, fw[22][22][22][22];
char gd[23][23];
struct scayger {
int r, c, t, g;
} sg[22 * 22 * 2 + 1];
bool try1(long long t, bool sgm) {
initMaxFlow(M + F + R * C * 2 + 3);
for (int r = 0; r < int(R); r++)
for (int c = 0; c < int(C); c++)
addEdge(M + F + 3 + (r * C + c) * 2, M + F + 3 + (r * C + c) * 2 + 1, 1);
for (int i = 0; i < int(M); i++) addEdge(0, 3 + i, 1);
for (int i = 0; i < int(F); i++) addEdge(M + 3 + i, 1, 1);
if (sgm)
addEdge(0, 2, 1);
else
addEdge(2, 1, 1);
for (int i = 0; i < int(S); i++) {
scayger& s = sg[i];
int g = s.g;
if (g == 0) g = (sgm) ? 1 : 2;
for (int r = 0; r < int(R); r++)
for (int c = 0; c < int(C); c++) {
long long d = fw[r][c][s.r][s.c];
if (d == -1) continue;
if (t >= d * s.t) {
if (g == 1)
addEdge(2 + i, M + F + 3 + (r * C + c) * 2, 1);
else
addEdge(M + F + 3 + (r * C + c) * 2 + 1, 2 + i, 1);
}
}
}
while (runMaxFlow()) {
}
return totalflow == S / 2;
}
bool tryit(long long t) { return try1(t, true) || try1(t, false); }
int main() {
scanf("%d%d%d%d", &R, &C, &M, &F);
for (int r = 0; r < int(R); r++) scanf("%s", gd[r]);
S = M + F + 1;
for (int i = 0; i < int(S); i++) {
scayger& s = sg[i];
scanf("%d%d%d", &s.r, &s.c, &s.t);
s.r--;
s.c--;
if (i == 0)
s.g = 0;
else if (i <= M)
s.g = 1;
else
s.g = 2;
}
memset(fw, -1, sizeof fw);
for (int r = 0; r < int(R); r++)
for (int c = 0; c < int(C); c++)
if (gd[r][c] == '.') {
for (int i = 0; i < int(4); i++) {
int r2 = r + dr[i], c2 = c + dc[i];
if (r2 < 0 || r2 >= R || c2 < 0 || c2 >= C || gd[r2][c2] == '#')
continue;
fw[r][c][r2][c2] = fw[r2][c2][r][c] = 1;
}
fw[r][c][r][c] = 0;
}
for (int kr = 0; kr < int(R); kr++)
for (int kc = 0; kc < int(C); kc++)
if (gd[kr][kc] == '.')
for (int ir = 0; ir < int(R); ir++)
for (int ic = 0; ic < int(C); ic++)
if (gd[ir][ic] == '.')
for (int jr = 0; jr < int(R); jr++)
for (int jc = 0; jc < int(C); jc++)
if (gd[jr][jc] == '.') {
int &d1 = fw[ir][ic][kr][kc], &d2 = fw[kr][kc][jr][jc],
&d = fw[ir][ic][jr][jc];
if (d1 == -1 || d2 == -1) continue;
if (d == -1 || d1 + d2 < d) d = d1 + d2;
}
if (S % 2 != 0 || !tryit(LLONG_MAX)) {
puts("-1");
return 0;
}
long long t0 = -1, t1 = 1000000000LL * R * C;
while (t1 - t0 > 1) {
long long t = (t0 + t1) / 2;
if (tryit(t))
t1 = t;
else
t0 = t;
}
printf("%lld\n", t1);
}
|
#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];
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[1000000];
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++] = 1000000000000000LL;
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 >= 1000000000000000LL) A = -1;
writerLn(A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[5000];
int capacidad[5000][5000];
int llega[5000];
int anterior[5000];
int aumenta(int uant, int uini) {
anterior[uini] = uant;
llega[uini] = 1;
queue<int> q;
q.push(uini);
while (not q.empty()) {
int u = q.front();
q.pop();
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
if (not llega[v] and capacidad[u][v]) {
llega[v] = 1;
anterior[v] = u;
q.push(v);
if (v == 1) {
while (v != 0) {
int antv = anterior[v];
capacidad[antv][v]--;
capacidad[v][antv]++;
v = antv;
}
for (int i = 0; i < 5000; i++) llega[i] = 0;
aumenta(0, 0);
return 1;
}
}
}
}
return 0;
}
void aumenta() {}
int n, m;
int cuantos[2];
int libre[50][50];
int visto[50][50];
int acum[50][50];
int ii[2][500], jj[2][500], tt[2][500];
int movi[] = {-1, 1, 0, 0};
int movj[] = {0, 0, -1, 1};
int acumula(int i, int j) {
if (not libre[i][j]) return 0;
if (visto[i][j]) return 0;
visto[i][j] = 1;
int c = acum[i][j];
for (int k = 0; k < 4; k++) c += acumula(i + movi[k], j + movj[k]);
return c;
}
struct elem {
int gender, ind;
int i, j;
long long int t;
elem() {}
elem(int ingender, int inind, int ini, int inj, long long int intt) {
gender = ingender;
ind = inind;
i = ini;
j = inj;
t = intt;
}
};
void escribe(elem e) {
cout << "(" << e.gender << "," << e.ind << "," << e.i << "," << e.j << ","
<< e.t << ")" << endl;
}
bool operator<(elem e1, elem e2) { return e1.t < e2.t; }
int main() {
cin >> n >> m >> cuantos[0] >> cuantos[1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '.') libre[i][j] = 1;
}
}
int ib, jb, tb;
cin >> ib >> jb >> tb;
for (int d = 0; d < 2; d++) {
for (int k = 0; k < cuantos[d]; k++) {
cin >> ii[d][k] >> jj[d][k] >> tt[d][k];
acum[ii[d][k]][jj[d][k]] += 1 - 2 * d;
}
}
int acc = acumula(ib, jb);
if (acc == 1) {
ii[1][cuantos[1]] = ib;
jj[1][cuantos[1]] = jb;
tt[1][cuantos[1]] = tb;
cuantos[1]++;
} else if (acc == -1) {
ii[0][cuantos[0]] = ib;
jj[0][cuantos[0]] = jb;
tt[0][cuantos[0]] = tb;
cuantos[0]++;
} else {
cout << -1 << endl;
exit(0);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (not visto[i][j]) {
int c = acumula(i, j);
if (c != 0) {
cout << -1 << endl;
exit(0);
}
}
}
}
vector<elem> ve;
for (int gender = 0; gender < 2; gender++) {
for (int ind = 0; ind < cuantos[gender]; ind++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) visto[i][j] = 0;
vector<pair<int, int> > vinf;
long long int tact = 0;
vinf.push_back(pair<int, int>(ii[gender][ind], jj[gender][ind]));
while (vinf.size()) {
vector<pair<int, int> > nextvinf;
for (int d = 0; d < int(vinf.size()); d++) {
int i = vinf[d].first;
int j = vinf[d].second;
if (not libre[i][j]) continue;
if (visto[i][j]) continue;
visto[i][j] = 1;
ve.push_back(elem(gender, ind, i, j, tact));
for (int k = 0; k < 4; k++) {
int nexti = i + movi[k];
int nextj = j + movj[k];
nextvinf.push_back(pair<int, int>(nexti, nextj));
}
}
vinf = nextvinf;
tact += tt[gender][ind];
}
}
}
for (int d = 0; d < cuantos[0]; d++) {
g[0].push_back(1000 + d);
capacidad[0][1000 + d] = 1;
g[4000 + d].push_back(1);
capacidad[4000 + d][1] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int u = 2000 + i * 22 + j;
int v = 3000 + i * 22 + j;
g[u].push_back(v);
g[v].push_back(u);
capacidad[u][v] = 1;
}
}
sort(ve.begin(), ve.end());
int flujo = 0;
aumenta(0, 0);
for (int d = 0; d < int(ve.size()); d++) {
elem &e = ve[d];
int u, v;
if (e.gender == 0) {
u = 1000 + e.ind;
v = 2000 + e.i * 22 + e.j;
} else {
u = 3000 + e.i * 22 + e.j;
v = 4000 + e.ind;
}
g[u].push_back(v);
g[v].push_back(u);
capacidad[u][v] = 1;
if (llega[u] and not llega[v]) flujo += aumenta(u, v);
if (flujo == cuantos[0]) {
cout << e.t << endl;
exit(0);
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1000 + 10, maxe = 500 * 1000 + 10,
INF = 1 * 1000 * 1000 * 1000 + 10;
const long long OO = 10000000000000;
int TOTAL, ptr[maxn], dis[maxn], q[maxn], r, c, x, y, M[maxn], F[maxn], cnt, n,
m, mls, fms, ecnt, cap[2 * maxe], frm[2 * maxe], to[2 * maxe],
prv[2 * maxe], head[maxn], numm, numf, ted;
char ch;
pair<int, int> d[maxn][maxn];
long long s, f, mid;
bool mark[maxn], park[maxn], flg;
vector<int> vec[maxn], good;
struct hmn {
int id;
long long sp;
hmn() { id = sp = -1; }
};
vector<hmn> ml, fm;
hmn tmp, boss;
inline void adde(int xx, int yy, int xy, int yx = 0) {
frm[ecnt] = xx, to[ecnt] = yy, cap[ecnt] = xy, prv[ecnt] = head[xx];
head[xx] = ecnt++;
frm[ecnt] = yy, to[ecnt] = xx, cap[ecnt] = yx, prv[ecnt] = head[yy];
head[yy] = ecnt++;
}
inline int ABS(int xx) {
if (xx < 0) return -xx;
return xx;
}
inline void floyd() {
for (int k = 0; k < n * m; k++) {
for (int i = 0; i < n * m; i++) {
d[k][i].second = i;
for (int j = 0; j < n * m; j++)
d[i][j].first = min(d[i][j].first, d[i][k].first + d[k][j].first);
}
}
for (int i = 0; i < n * m; i++) sort(d[i], d[i] + n * m);
}
inline void dfsr(int v) {
ted++;
mark[v] = 1;
numm += M[v];
numf += F[v];
if (v == r * m + c) flg = 1;
for (int i = 0; i < ((int(vec[v].size()))); i++) {
if (!mark[vec[v][i]]) dfsr(vec[v][i]);
}
}
inline bool bfs(int src, int snk) {
memset(dis, 63, sizeof dis);
int a = 0, b = 0, p;
dis[src] = 0;
q[b++] = src;
while (a < b) {
p = q[a++];
for (int i = head[p]; i != -1; i = prv[i]) {
if (cap[i] && dis[to[i]] > dis[p] + 1) {
dis[to[i]] = dis[p] + 1;
q[b++] = to[i];
}
}
}
return dis[snk] < INF;
}
int dfs(int xx, int snk, int ff = INF) {
if (xx == snk) return ff;
int ans = 0, a;
for (; ptr[xx] != -1; ptr[xx] = prv[ptr[xx]]) {
if (dis[xx] + 1 == dis[to[ptr[xx]]]) {
a = dfs(to[ptr[xx]], snk, min(ff, cap[ptr[xx]]));
cap[ptr[xx]] -= a;
cap[ptr[xx] ^ 1] += a;
ff -= a;
ans += a;
if (ff == 0) break;
}
}
return ans;
}
inline int flow(int src, int snk) {
int ff = 0;
while (bfs(src, snk)) {
memcpy(ptr, head, sizeof head);
ff += dfs(src, snk);
}
return ff;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> mls >> fms;
memset(d, 63, sizeof d);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++, cnt++) {
cin >> ch;
if (ch == '#') park[cnt] = 1;
d[cnt][cnt].first = 0;
if (!park[cnt]) good.push_back(cnt);
if (i > 0 && !park[cnt] && !park[cnt - m]) {
vec[cnt].push_back(cnt - m);
vec[cnt - m].push_back(cnt);
d[cnt][cnt - m].first = d[cnt - m][cnt].first = 1;
}
if (j > 0 && !park[cnt] && !park[cnt - 1]) {
vec[cnt].push_back(cnt - 1);
vec[cnt - 1].push_back(cnt);
d[cnt][cnt - 1].first = d[cnt - 1][cnt].first = 1;
}
}
}
floyd();
cin >> r >> c >> boss.sp;
r--;
c--;
boss.id = r * m + c;
for (int i = 0; i < mls; i++) {
cin >> x >> y >> tmp.sp;
x--;
y--;
tmp.id = x * m + y;
ml.push_back(tmp);
M[tmp.id]++;
}
for (int i = 0; i < fms; i++) {
cin >> x >> y >> tmp.sp;
x--;
y--;
tmp.id = x * m + y;
fm.push_back(tmp);
F[tmp.id]++;
}
for (int i = 0; i < n * m; i++) {
if (!park[i] && !mark[i]) {
numm = numf = ted = 0;
flg = 0;
dfsr(i);
if (!flg) {
if (numm != numf || numm > ted) {
cout << -1;
return 0;
}
} else {
if (ABS(numm - numf) != 1 || max(numm, numf) > ted) {
cout << -1;
return 0;
}
if (numm > numf)
fm.push_back(boss);
else
ml.push_back(boss);
}
}
}
s = -1;
f = OO;
TOTAL = (mls + fms + 1) / 2;
while (f - s > 1) {
memset(head, -1, sizeof head);
ecnt = 0;
mid = (s + f) / 2;
for (int i = 0; i < ((int(good.size()))); i++)
adde(2 * good[i], 2 * good[i] + 1, 1);
for (int i = 0; i < ((int(ml.size()))); i++) {
adde(2 * n * m + ((int(ml.size()))) + ((int(fm.size()))), 2 * n * m + i,
1);
for (int j = 0; j < n * m && ml[i].sp * d[ml[i].id][j].first <= mid; j++)
adde(2 * n * m + i, 2 * d[ml[i].id][j].second, 1);
}
for (int i = 0; i < ((int(fm.size()))); i++) {
adde(2 * n * m + ((int(ml.size()))) + i,
2 * n * m + ((int(ml.size()))) + ((int(fm.size()))) + 1, 1);
for (int j = 0; j < n * m && fm[i].sp * d[fm[i].id][j].first <= mid; j++)
adde(2 * d[fm[i].id][j].second + 1, 2 * n * m + ((int(ml.size()))) + i,
1);
}
if (flow(2 * n * m + ((int(ml.size()))) + ((int(fm.size()))),
2 * n * m + ((int(ml.size()))) + ((int(fm.size()))) + 1) == TOTAL)
f = mid;
else
s = mid;
}
cout << f;
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 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 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 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 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;
}
int main(void) {
int male, fem;
int x, y, z;
int male_id;
int fem_id;
long long int next;
int k;
int s, t;
int idx, idx2;
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);
s = fem_id;
t = fem_id + 1;
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);
}
}
}
flow = 0;
k = 0;
next = 0;
while (flow < fem) {
if (k >= (int)v.size()) {
printf("-1\n");
return 0;
}
next = v[k].w;
while (k < (int)v.size() && v[k].w == next) {
idx = 22 * v[k].x + v[k].y;
if (v[k].id < male_id) {
add_edge(v[k].id, idx, 1);
} else {
idx = idx + 22 * 22;
add_edge(idx, v[k].id, 1);
}
k++;
}
max_flow(s, t);
}
printf("%lld\n", next);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int N, typename T>
struct MaxFlow {
int l[N], tot, d[N], Q[N], s, t, u, v, src, sink, cur[N];
struct Edge {
int v, x;
T cap;
} E[1111111];
void add(int u, int v, T cap) {
E[tot] = (Edge){v, l[u], cap};
l[u] = tot++;
E[tot] = (Edge){u, l[v], 0};
l[v] = tot++;
}
void init() {
memset(l, -1, sizeof l);
tot = 0;
}
bool bfs() {
memset(d, -1, sizeof d);
memcpy(cur, l, sizeof cur);
d[src] = 0;
s = t = 0;
Q[t++] = src;
while (s < t) {
u = Q[s++];
for (int i = l[u]; ~i; i = E[i].x) {
v = E[i].v;
if (d[v] == -1 && E[i].cap > 0) {
Q[t++] = v;
d[v] = d[u] + 1;
}
}
}
return d[sink] != -1;
}
T dfs(int u, T in) {
if (u == sink) return in;
T flow = 0, f;
for (int i = l[u]; ~i; i = E[i].x) {
v = E[i].v;
if (d[v] == d[u] + 1 && E[i].cap) {
if (f = dfs(v, min(in - flow, E[i].cap))) {
flow += f;
E[i].cap -= f;
E[i ^ 1].cap += f;
if (flow == in) break;
}
}
}
if (flow < in) d[u] = -1;
return flow;
}
T dinic(int _src, int _sink) {
src = _src;
sink = _sink;
T flow = 0;
while (bfs()) flow += dfs(src, 123456789);
return flow;
}
};
const int N = 23;
MaxFlow<4 * N * N, int> F;
char field[N][N];
struct QQ {
int x, y, t, Dist[N][N];
void Scan() {
scanf("%d%d%d", &x, &y, &t);
x--;
y--;
}
} males[N * N], females[N * N], king;
const int inf = 1e9;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int n, m;
int male, female;
void BFS(int x, int y, int Dist[][N]) {
fill(Dist[0], Dist[N], inf);
Dist[x][y] = 0;
queue<int> Q;
Q.push(x);
Q.push(y);
while (!Q.empty()) {
x = Q.front();
Q.pop();
y = Q.front();
Q.pop();
for (int _ = 0; _ < 4; _++) {
int xx = x + dx[_];
int yy = y + dy[_];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && field[xx][yy] == '.') {
if (Dist[xx][yy] > Dist[x][y] + 1) {
Dist[xx][yy] = Dist[x][y] + 1;
Q.push(xx);
Q.push(yy);
}
}
}
}
}
bool check(long long need) {
int src = 4 * n * m + 2, sink = src + 1;
F.init();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (field[i][j] == '.') {
F.add(i * m + j, i * m + j + n * m, 1);
for (int _ = 0; _ < male; _++) {
QQ &ie = males[_];
if (ie.Dist[i][j] == inf) continue;
if (ie.Dist[i][j] * 1LL * ie.t <= need) {
F.add(_ + n * m * 2, i * m + j, 1);
}
}
for (int _ = 0; _ < female; _++) {
QQ &ie = females[_];
if (ie.Dist[i][j] == inf) continue;
if (ie.Dist[i][j] * 1LL * ie.t <= need) {
F.add(i * m + j + n * m, _ + n * m * 3, 1);
}
}
if (king.Dist[i][j] == inf) continue;
if (female > male) {
if (king.Dist[i][j] * 1LL * king.t <= need) {
F.add(4 * n * m, i * m + j, 1);
}
} else {
if (king.Dist[i][j] * 1LL * king.t <= need) {
F.add(i * m + j + n * m, 4 * n * m, 1);
}
}
}
}
}
for (int _ = 0; _ < male; _++) {
F.add(src, _ + n * m * 2, 1);
}
for (int _ = 0; _ < female; _++) {
F.add(_ + n * m * 3, sink, 1);
}
if (female > male) {
F.add(src, 4 * n * m, 1);
} else {
F.add(4 * n * m, sink, 1);
}
return F.dinic(src, sink) == max(male, female);
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &female);
F.init();
for (int i = 0; i < n; i++) {
scanf("%s", field[i]);
}
king.Scan();
for (int i = 0; i < male; i++) {
males[i].Scan();
}
for (int i = 0; i < female; i++) {
females[i].Scan();
}
if (abs(male - female) != 1) {
puts("-1");
} else {
BFS(king.x, king.y, king.Dist);
for (int i = 0; i < male; i++) {
BFS(males[i].x, males[i].y, males[i].Dist);
}
for (int i = 0; i < female; i++) {
BFS(females[i].x, females[i].y, females[i].Dist);
}
long long left = 0, right = (n * m) * 1LL * inf;
while (left < right) {
long long middle = left + right >> 1;
if (check(middle)) {
right = middle;
} else {
left = middle + 1;
}
}
if (check(left)) {
printf("%I64d\n", left);
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
struct node {
int v;
int c;
int f;
int next, r;
} edge[1111111];
int dist[22222], nm[22222], src, des, n;
int head[22222], e;
void add(int x, int y, int c) {
edge[e].v = y;
edge[e].c = c;
edge[e].f = 0;
edge[e].r = e + 1;
edge[e].next = head[x];
head[x] = e++;
edge[e].v = x;
edge[e].c = 0;
edge[e].f = 0;
edge[e].r = e - 1;
edge[e].next = head[y];
head[y] = e++;
}
void rev_BFS() {
int Q[22222], h = 0, t = 0;
for (int i = 1; i <= n; ++i) {
dist[i] = 22222;
nm[i] = 0;
}
Q[t++] = des;
dist[des] = 0;
nm[0] = 1;
while (h != t) {
int v = Q[h++];
for (int i = head[v]; i != -1; i = edge[i].next) {
if (edge[edge[i].r].c == 0 || dist[edge[i].v] < 22222) continue;
dist[edge[i].v] = dist[v] + 1;
++nm[dist[edge[i].v]];
Q[t++] = edge[i].v;
}
}
}
void init() {
e = 0;
memset(head, -1, sizeof(head));
}
int maxflow() {
rev_BFS();
int u;
int total = 0;
int cur[22222], rpath[22222];
for (int i = 1; i <= n; ++i) cur[i] = head[i];
u = src;
while (dist[src] < n) {
if (u == des) {
int tf = 100000007;
for (int i = src; i != des; i = edge[cur[i]].v)
tf = min(tf, edge[cur[i]].c);
for (int i = src; i != des; i = edge[cur[i]].v) {
edge[cur[i]].c -= tf;
edge[edge[cur[i]].r].c += tf;
edge[cur[i]].f += tf;
edge[edge[cur[i]].r].f -= tf;
}
total += tf;
u = src;
}
int i;
for (i = cur[u]; i != -1; i = edge[i].next)
if (edge[i].c > 0 && dist[u] == dist[edge[i].v] + 1) break;
if (i != -1) {
cur[u] = i;
rpath[edge[i].v] = edge[i].r;
u = edge[i].v;
} else {
if (0 == (--nm[dist[u]])) break;
cur[u] = head[u];
int mindist = n;
for (int j = head[u]; j != -1; j = edge[j].next)
if (edge[j].c > 0) mindist = min(mindist, dist[edge[j].v]);
dist[u] = mindist + 1;
++nm[dist[u]];
if (u != src) u = edge[rpath[u]].v;
}
}
return total;
}
struct nods {
int x;
int y;
int s;
};
vector<nods> FE;
vector<nods> ME;
vector<nods> DOT;
int nt, m, L, N, M;
unordered_map<long long, long long> Q;
long long DP[30][30][30][30];
int MA[30][30];
int CP[30][30];
void make() {
int i, j, k, n1, n2;
stack<nods> S, S_new;
nods p1, p2;
for (i = 0; i < 30; i++) {
for (j = 0; j < 30; j++) {
for (n1 = 0; n1 < 30; n1++) {
for (n2 = 0; n2 < 30; n2++) DP[i][j][n1][n2] = -1;
}
}
}
for (i = 1; i <= N; i++) {
for (j = 1; j <= M; j++) {
memset(CP, 0, sizeof(CP));
if (MA[i][j] == 0) continue;
p1.x = i;
p1.y = j;
S.push(p1);
CP[i][j] = 1;
while (S.size() > 0) {
while (S.size() > 0) {
p1 = S.top();
S.pop();
n1 = p1.x;
n2 = p1.y;
if (MA[n1 + 1][n2] == 1 && CP[n1 + 1][n2] == 0) {
CP[n1 + 1][n2] = CP[n1][n2] + 1;
p2.x = n1 + 1;
p2.y = n2;
S_new.push(p2);
}
if (MA[n1 - 1][n2] == 1 && CP[n1 - 1][n2] == 0) {
CP[n1 - 1][n2] = CP[n1][n2] + 1;
p2.x = n1 - 1;
p2.y = n2;
S_new.push(p2);
}
if (MA[n1][n2 + 1] == 1 && CP[n1][n2 + 1] == 0) {
CP[n1][n2 + 1] = CP[n1][n2] + 1;
p2.x = n1;
p2.y = n2 + 1;
S_new.push(p2);
}
if (MA[n1][n2 - 1] == 1 && CP[n1][n2 - 1] == 0) {
CP[n1][n2 - 1] = CP[n1][n2] + 1;
p2.x = n1;
p2.y = n2 - 1;
S_new.push(p2);
}
}
S.swap(S_new);
}
for (n1 = 1; n1 <= N; n1++) {
for (n2 = 1; n2 <= M; n2++) {
if (CP[n1][n2] != 0) DP[i][j][n1][n2] = CP[n1][n2] - 1;
}
}
}
}
return;
}
long long calculate(nods a, nods b) {
long long dis = DP[a.x][a.y][b.x][b.y];
if (dis == -1) return -1;
dis *= a.s;
return dis;
}
bool solve(long long v) {
nt = FE.size() + ME.size() + 2 * DOT.size();
int u, w, i, j, A, B, C = FE.size(), D = DOT.size();
src = nt + 1;
des = nt + 2;
n = des;
init();
for (i = 1; i <= C; i++) {
add(src, i, 1);
}
for (i = C + 1; i <= 2 * C; i++) {
add(i, des, 1);
}
for (i = 2 * C + 1; i <= 2 * C + D; i++) {
add(i, i + D, 1);
}
for (i = 0; i < C; i++) {
for (j = 0; j < D; j++) {
u = (i + 1) * 1000 + j;
if (Q.find(u) == Q.end()) {
Q[u] = calculate(FE[i], DOT[j]);
}
if (Q[u] <= v && Q[u] != -1) add(i + 1, 2 * C + j + 1, 1);
}
}
for (i = 0; i < C; i++) {
for (j = 0; j < D; j++) {
u = (i + 1 + C) * 1000 + j;
if (Q.find(u) == Q.end()) {
Q[u] = calculate(ME[i], DOT[j]);
}
if (Q[u] <= v && Q[u] != -1) add(2 * C + j + 1 + D, C + i + 1, 1);
}
}
long long res = maxflow();
if (res == C) return 1;
return 0;
}
int main() {
int male, female, i, j, n1, n2, n3;
char c;
cin >> N >> M >> male >> female;
if (male + 1 != female && female + 1 != male) {
cout << -1 << endl;
return 0;
}
nods p;
memset(MA, 0, sizeof(MA));
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
cin >> c;
if (c == '.') {
p.x = i + 1;
p.y = j + 1;
p.s = 0;
DOT.push_back(p);
MA[i + 1][j + 1] = 1;
}
}
}
make();
cin >> n1 >> n2 >> n3;
p.x = n1;
p.y = n2;
p.s = n3;
if (male + 1 == female)
ME.push_back(p);
else
FE.push_back(p);
for (i = 0; i < male; i++) {
cin >> n1 >> n2 >> n3;
p.x = n1;
p.y = n2;
p.s = n3;
ME.push_back(p);
}
for (i = 0; i < female; i++) {
cin >> n1 >> n2 >> n3;
p.x = n1;
p.y = n2;
p.s = n3;
FE.push_back(p);
}
long long sm = 0, bg = N * M, md;
bg *= 1E9;
if (solve(bg) == 0) {
cout << -1 << endl;
return 0;
}
while (sm + 1 < bg) {
md = (sm + bg) / 2;
if (solve(md) == 1)
bg = md;
else
sm = md;
}
while (solve(sm) == 0) sm++;
cout << sm << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1LL << 60;
const double EPS = 1e-9;
const long long MAXN = (long long)1e5 + 10;
bool dbg = false;
struct Edge {
long long from, to, cap, flow, index;
Edge(long long from, long long to, long long cap, long long flow,
long long index)
: from(from), to(to), cap(cap), flow(flow), index(index) {}
};
struct Dinic {
long long N;
vector<vector<Edge> > G;
vector<Edge *> dad;
vector<long long> Q;
Dinic(long long N) : N(N), G(N), dad(N), Q(N) {}
void AddEdge(long long from, long long to, long long cap) {
if (dbg) cout << from << " " << to << " " << cap << endl;
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(long long s, long long t) {
fill(dad.begin(), dad.end(), (Edge *)NULL);
dad[s] = &G[0][0] - 1;
long long head = 0, tail = 0;
Q[tail++] = s;
while (head < tail) {
long long x = Q[head++];
for (long long i = 0; i < (long long)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 (long long i = 0; i < (long long)G[t].size(); ++i) {
Edge *start = &G[G[t][i].to][G[t][i].index];
long long amt = oo;
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(long long s, long long t) {
long long totflow = 0;
while (long long flow = BlockingFlow(s, t)) totflow += flow;
return totflow;
}
};
struct scayger {
long long x, y, v;
};
long long n, m, males, females;
char Map[30][30];
long long ID[2][30][30];
long long Dist[30][30][30][30];
long long dx[4] = {0, 0, -1, 1};
long long dy[4] = {1, -1, 0, 0};
bool valid(long long x, long long y) {
return 0 <= x && x < n && 0 <= y && y < m && Map[x][y] != '#';
}
void bfs(long long x, long long y) {
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) Dist[x][y][i][j] = oo;
Dist[x][y][x][y] = 0;
queue<pair<long long, long long> > Q;
Q.push(make_pair(x, y));
while (!Q.empty()) {
pair<long long, long long> cur = Q.front();
Q.pop();
long long dst = Dist[x][y][cur.first][cur.second];
for (int i = 0; i < 4; ++i) {
long long nx = cur.first + dx[i], ny = cur.second + dy[i];
if (valid(nx, ny) && Dist[x][y][nx][ny] > dst + 1) {
Dist[x][y][nx][ny] = dst + 1;
Q.push(make_pair(nx, ny));
}
}
}
}
bool myvalid(long long v) { return v != oo; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> males >> females;
for (long long i = 0; i < n; ++i) {
cin >> Map[i];
}
if (abs(males - females) != 1) {
cout << -1 << endl;
return 0;
}
long long vmax = 0;
vector<scayger> vm, vf;
scayger SB;
cin >> SB.x >> SB.y >> SB.v;
SB.x--;
SB.y--;
vmax = SB.v;
if (males < females)
vm.push_back(SB);
else
vf.push_back(SB);
for (long long i = 0; i < males; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vm.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < females; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vf.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (Map[i][j] != '#') bfs(i, j);
}
}
long long lo = 0, hi = m * n * vmax + 1;
long long top = hi;
for (long long i = 0, cnt = 2 + 2 * (long long)((vm).size()); i < n; ++i)
for (long long j = 0; j < m; ++j)
for (long long k = 0; k < 2; ++k) ID[k][i][j] = cnt++;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
dbg = false;
Dinic flow(2 + 2 * (long long)((vm).size()) + 2 * n * m);
for (long long i = 0; i < (long long)((vm).size()); ++i) {
flow.AddEdge(0, i + 2, 1);
flow.AddEdge(i + 2 + (long long)((vm).size()), 1, 1);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
flow.AddEdge(ID[0][i][j], ID[1][i][j], 1);
}
}
for (long long i = 0; i < (long long)((vm).size()); ++i) {
scayger cur1 = vm[i];
scayger cur2 = vf[i];
for (long long j = 0; j < n; ++j) {
for (long long k = 0; k < m; ++k) {
if (Map[j][k] == '#') continue;
if (dbg && !i)
cout << "ID " << j << " " << k << " "
<< 2 + 2 * (long long)((vm).size()) + j * m + k << endl;
if (myvalid(Dist[cur1.x][cur1.y][j][k]) &&
Dist[cur1.x][cur1.y][j][k] * cur1.v <= mid)
flow.AddEdge(i + 2, ID[0][j][k], 1);
if (myvalid(Dist[cur2.x][cur2.y][j][k]) &&
Dist[cur2.x][cur2.y][j][k] * cur2.v <= mid)
flow.AddEdge(ID[1][j][k], 2 + (long long)((vm).size()) + i, 1);
}
}
}
long long value = flow.GetMaxFlow(0, 1);
if (value == (long long)((vm).size()))
hi = mid;
else
lo = mid + 1;
}
if (hi == top)
cout << -1 << endl;
else
cout << hi << endl;
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[10005], que[10005], dis[10005], 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[5555];
Time F[5555];
struct Node {
int ed, before, flow;
} s[1000001];
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;
const int max_n = 15;
const int max_v = 4 * max_n * max_n;
const long long inf = 1111111111111111111;
struct edge {
int v, c, f, numr;
edge() {}
edge(int v, int c, int f, int numr) : v(v), c(c), f(f), numr(numr) {}
};
int n, m, k, k1, k2, x[2][max_v], y[2][max_v], t[2][max_v], used[max_v];
long long dist[max_v][max_n][max_n];
string s[max_n];
vector<edge> g[max_v];
void add_edge(int u, int v, int c) {
int rg1 = g[v].size();
int rg2 = g[u].size();
g[u].push_back(edge(v, c, 0, rg1));
g[v].push_back(edge(u, 0, 0, rg2));
}
bool dfs(int v, int t, int fl) {
if (v == t) {
return true;
}
if (used[v] == 1) {
return false;
}
used[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i].c >= g[v][i].f + fl && dfs(g[v][i].v, t, fl)) {
g[v][i].f += fl;
g[g[v][i].v][g[v][i].numr].f -= fl;
return true;
}
}
return false;
}
bool check(long long x) {
for (int i = 0; i < max_v; ++i) {
g[i].clear();
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = 2 * (i * m + j);
add_edge(num, num + 1, 1);
}
}
int s = 2 * n * m + 2 * k;
int t = s + 1;
for (int i = 0; i < k; ++i) {
add_edge(s, 2 * n * m + i, 1);
add_edge(2 * n * m + k + i, t, 1);
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w);
if (dist[i][j][w] > -1 && x >= dist[i][j][w]) {
add_edge(2 * n * m + i, num, 1);
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w) + 1;
if (dist[i + k][j][w] > -1 && x >= dist[i + k][j][w]) {
add_edge(num, 2 * n * m + k + i, 1);
}
}
}
}
memset(used, 0, sizeof(used));
int res = 0;
while (dfs(s, t, 1)) {
memset(used, 0, sizeof(used));
++res;
}
return res == k;
}
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
bool is_in(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void bfs(int num, int poz) {
int stx = x[num][poz - num * k];
int sty = y[num][poz - num * k];
int tt = t[num][poz - num * k];
dist[poz][stx][sty] = 0;
queue<pair<int, int> > q;
q.push(make_pair(stx, sty));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first, y = p.second;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (is_in(nx, ny) && s[nx][ny] == '.' && dist[poz][nx][ny] == -1) {
dist[poz][nx][ny] = dist[poz][x][y] + tt;
q.push(make_pair(nx, ny));
}
}
}
}
int main() {
cin >> n >> m >> k1 >> k2;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int st1 = 0, st2 = 0;
if (k1 + 1 == k2) {
k = k2;
cin >> x[0][0] >> y[0][0] >> t[0][0];
st1 = 1;
} else if (k2 + 1 == k1) {
k = k1;
cin >> x[1][0] >> y[1][0] >> t[1][0];
st2 = 1;
} else {
cout << -1 << endl;
return 0;
}
for (int i = st1; i < k; ++i) {
cin >> x[0][i] >> y[0][i] >> t[0][i];
}
for (int i = st2; i < k; ++i) {
cin >> x[1][i] >> y[1][i] >> t[1][i];
}
memset(dist, -1, sizeof(dist));
for (int i = 0; i < k; ++i) {
--x[0][i];
--x[1][i];
--y[0][i];
--y[1][i];
bfs(0, i);
bfs(1, k + i);
}
long long l = -1, r = inf;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (r == inf) {
r = -1;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e18 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const int maxn = 25;
namespace MaxFlow {
struct Edge {
int to, cap, rev;
Edge(int to, int cap, int rev) : to(to), cap(cap), rev(rev) {}
};
static const int maxv = maxn * maxn * 4;
int iter[maxv], level[maxv];
vector<Edge> g[maxv];
inline void clear() {
for (int i = (0); i < (maxv); ++i) g[i].clear();
}
inline void addEdge(int from, int to, int cap) {
g[from].push_back(Edge(to, cap, g[to].size()));
g[to].push_back(Edge(from, 0, g[from].size() - 1));
return;
}
inline int dfs(int u, int t, int f) {
if (u == t) return f;
for (int &i = iter[u]; i < g[u].size(); ++i) {
Edge &e = g[u][i];
if (level[e.to] > level[u] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
inline void bfs(int s, int t) {
memset(level, -1, sizeof(level));
queue<int> q;
q.push(s);
level[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = (0); i < (g[u].size()); ++i) {
Edge &e = g[u][i];
if (!(~level[e.to]) && e.cap > 0) {
level[e.to] = level[u] + 1;
if (e.to == t) return;
q.push(e.to);
}
}
}
return;
}
inline int maxFlow(int s, int t) {
int ret = 0;
for (;;) {
bfs(s, t);
if (!(~level[t])) break;
memset(iter, 0, sizeof(iter));
for (int f; f = dfs(s, t, INF); ret += f)
;
}
return ret;
}
inline void print(int totv) {
for (int i = (0); i <= (totv); ++i) {
for (int j = (0); j < (g[i].size()); ++j) {
printf("u=%d v=%d cap=%d\n", i, g[i][j].to, g[i][j].cap);
}
}
return;
}
} // namespace MaxFlow
struct Scayger {
int x, y, spd;
} boss;
int n, m, male, female, cel, s, t;
int dis[maxn][maxn][maxn][maxn];
char str[maxn][maxn];
Scayger b[maxn * maxn], g[maxn * maxn];
inline int id(int x, int y) { return x * m + y; }
inline bool canGo(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && str[x][y] == '.');
}
inline void bfs(int sx, int sy) {
if (str[sx][sy] == '#') {
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) dis[sx][sy][i][j] = INF;
return;
}
queue<pair<int, int> > q;
dis[sx][sy][sx][sy] = 0;
q.push(make_pair(sx, sy));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = (0); i < (4); ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (canGo(nx, ny) && !(~dis[sx][sy][nx][ny])) {
q.push(make_pair(nx, ny));
dis[sx][sy][nx][ny] = dis[sx][sy][x][y] + 1;
}
}
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j)
if (!(~dis[sx][sy][i][j])) dis[sx][sy][i][j] = INF;
return;
}
inline bool check(long long md) {
MaxFlow::clear();
for (int u = (0); u < (male); ++u) {
MaxFlow::addEdge(s, u, 1);
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
if (dis[b[u].x][b[u].y][i][j] == INF) continue;
if (1ll * dis[b[u].x][b[u].y][i][j] * b[u].spd > 1ll * md) continue;
MaxFlow::addEdge(u, male + (id(i, j) << 1), 1);
}
}
}
for (int u = (0); u < (female); ++u) {
MaxFlow::addEdge(u + male + cel * 2, t, 1);
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
if (dis[g[u].x][g[u].y][i][j] == INF) continue;
if (1ll * dis[g[u].x][g[u].y][i][j] * g[u].spd > 1ll * md) continue;
MaxFlow::addEdge(male + (id(i, j) << 1 | 1), u + male + cel * 2, 1);
}
}
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
if (str[i][j] == '.') {
MaxFlow::addEdge(male + (id(i, j) << 1), male + (id(i, j) << 1 | 1), 1);
}
}
int res = MaxFlow::maxFlow(s, t);
return (res == male);
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &female);
cel = n * m;
s = male + female + 1 + cel * 2;
t = s + 1;
if (abs(male - female) != 1) {
puts("-1");
return 0;
}
for (int i = (0); i < (n); ++i) scanf("%s", str + i);
memset(dis, -1, sizeof(dis));
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) bfs(i, j);
scanf("%d%d%d", &boss.x, &boss.y, &boss.spd);
--boss.x, --boss.y;
for (int i = (0); i < (male); ++i)
scanf("%d%d%d", &b[i].x, &b[i].y, &b[i].spd), --b[i].x, --b[i].y;
for (int i = (0); i < (female); ++i)
scanf("%d%d%d", &g[i].x, &g[i].y, &g[i].spd), --g[i].x, --g[i].y;
if (male < female)
b[male++] = boss;
else
g[female++] = boss;
long long l = -1, r = 1e15, md;
while (l + 1 < r) {
md = (l + r) >> 1;
if (check(md))
r = md;
else
l = md;
}
printf("%I64d\n", (r == 1e15) ? (-1) : (r));
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;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
class MaxFlow {
public:
int cap[1000000], flow[1000000];
int to[1000000], prev[1000000], last[2000], used[2000], level[2000];
int V, E;
MaxFlow(int n) {
V = n;
E = 0;
for (int(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 (int(i) = 0; (i) < (int)(V); (i)++) level[i] = -1;
queue<int> q;
q.push(s);
level[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (i = last[x]; i >= 0; i = prev[i])
if (level[to[i]] == -1 && cap[i] > flow[i]) {
q.push(to[i]);
level[to[i]] = level[x] + 1;
}
}
return (level[t] != -1);
}
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) {
while (bfs(s, t)) {
for (int(i) = 0; (i) < (int)(V); (i)++) used[i] = last[i];
while (dfs(s, t, (1 << 29)) != 0)
;
}
int ans = 0;
for (int i = last[s]; i >= 0; i = prev[i]) ans += flow[i];
return ans;
}
};
char mp[25][25];
int male, female, r, c, t;
int fr[600], fc[600], ft[600], mr[600], mc[600], mt[600];
int dis[25][25][25][25];
void init() {
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++)
if (mp[i][j] == '.') {
priority_queue<pair<int, pair<int, int>>,
std::vector<pair<int, pair<int, int>>>,
std::greater<pair<int, pair<int, int>>>>
q;
q.push({1, {i, j}});
while (!q.empty()) {
auto p = q.top();
q.pop();
int d = p.first, u = p.second.first, v = p.second.second;
if (dis[i][j][u][v] != 0) continue;
dis[i][j][u][v] = d;
for (int(k) = 0; (k) < (int)(4); (k)++) {
int x = dx[k] + u, y = dy[k] + v;
if (mp[x][y] == '.' && !dis[i][j][x][y]) {
q.push({d + 1, {x, y}});
}
}
}
}
}
bool ck(long long ti) {
int S = 0, E = 2 + m * n * 2 + female + male;
MaxFlow mf = MaxFlow(E);
E--;
int b = male + 1, c = male + n * m + 1, d = male + n * m * 2 + 1;
for (int(i) = 1; (i) <= (int)(male); (i)++) {
mf.add_edge(S, i, 1);
mf.add_edge(d + i - 1, E, 1);
}
int cnt = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (mp[i][j] == '.') mf.add_edge(b + cnt, c + cnt, 1);
cnt++;
}
for (int(id) = 1; (id) <= (int)(male); (id)++) {
cnt = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (dis[mr[id]][mc[id]][i][j] != 0) {
if ((long long)(dis[mr[id]][mc[id]][i][j] - 1) * mt[id] <= ti) {
mf.add_edge(id, b + cnt, 1);
}
}
if (dis[fr[id]][fc[id]][i][j] != 0) {
if ((long long)(dis[fr[id]][fc[id]][i][j] - 1) * ft[id] <= ti) {
mf.add_edge(c + cnt, d + id - 1, 1);
}
}
cnt++;
}
}
int flw = mf.maxflow(S, E);
return flw == male;
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &female);
if (abs(male - female) != 1) {
puts("-1");
return 0;
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%s", mp[i] + 1);
}
scanf("%d%d%d", &r, &c, &t);
for (int(i) = 1; (i) <= (int)(male); (i)++) {
scanf("%d%d%d", mr + i, mc + i, mt + i);
}
for (int(i) = 1; (i) <= (int)(female); (i)++)
scanf("%d%d%d", fr + i, fc + i, ft + i);
if (male + 1 == female) {
male++;
mr[male] = r;
mc[male] = c;
mt[male] = t;
} else {
female++;
fr[female] = r;
fc[female] = c;
ft[female] = t;
}
init();
long long l = 0, r = 5e11;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (ck(mid))
r = mid;
else
l = mid + 1;
}
long long ans = -1;
if (ck(l))
ans = l;
else if (ck(r))
ans = r;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 22 + 2;
const long long MAXE = 2e6 + 200;
const long long MAX = 4000;
const long long INF = 1e18 + 1000;
long long n, m, x, y, ec;
char c[MAXN][MAXN];
long long lvl[MAX];
long long 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];
long long ptr[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(long long v, long long des) {
memset(lvl, -1, sizeof(lvl));
lvl[v] = 0;
long long h = 0, t = 0;
q[t++] = v;
while (h < t) {
v = q[h++];
for (long long e = head[v]; e != -1; e = prv[e]) {
long long u = to[e];
if (cap[e] && (lvl[u] == -1 || lvl[u] > lvl[v] + 1)) {
lvl[u] = lvl[v] + 1;
q[t++] = u;
}
}
}
return lvl[des] != -1;
}
long long dfs(long long v, long long sink, long long flow = INF) {
if (flow == 0 || v == sink) return flow;
long long ret = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]])
if (lvl[to[ptr[v]]] == lvl[v] + 1) {
long long xx = dfs(to[ptr[v]], sink, min(flow, cap[ptr[v]]));
cap[ptr[v]] -= xx;
cap[ptr[v] ^ 1] += xx;
flow -= xx;
ret += xx;
if (flow == 0) break;
}
return ret;
}
long long max_flow(long long source, long long sink) {
long long ret = 0;
while (bfs(source, sink)) {
memcpy(ptr, head, sizeof(head));
ret += dfs(source, sink);
}
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;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int maxm = 500005;
const int maxn = 2005;
char ma[maxn][maxn];
struct node {
int r, c, t;
node() {}
node(int _r, int _c, int _t) : r(_r), c(_c), t(_t) {}
};
vector<node> males, females;
struct Ed {
int u, v, nx, c;
Ed() {}
Ed(int _u, int _v, int _nx, int _c) : u(_u), v(_v), nx(_nx), c(_c) {}
} E[maxm << 1];
int edtot;
int G[maxn], cur[maxn];
void addedge(int u, int v, int c) {
E[edtot] = Ed(u, v, G[u], c);
G[u] = edtot++;
E[edtot] = Ed(v, u, G[v], 0);
G[v] = edtot++;
}
int go[25][25][25][25];
int vis[25][25];
void BFS(int X, int Y) {
static queue<pair<int, int> > Q;
Q.push(make_pair(X, Y));
go[X][Y][X][Y] = 0;
memset(vis, 0, sizeof(vis));
vis[X][Y] = 1;
static int tx[] = {-1, 1, 0, 0}, ty[] = {0, 0, -1, 1};
while (!Q.empty()) {
int x = Q.front().first, y = Q.front().second;
Q.pop();
for (int i = 0; i < 4; i++) {
int first = x + tx[i], second = y + ty[i];
if (ma[first][second] == '.' && !vis[first][second]) {
vis[first][second] = 1;
Q.push(make_pair(first, second));
go[X][Y][first][second] = go[X][Y][x][y] + 1;
}
}
}
}
int level[maxn], s, t;
bool bfs() {
static int que[maxn];
int qh(0), qt(0);
memset(level, 0, sizeof(level));
level[que[++qt] = s] = 1;
while (qh != qt) {
int x = que[++qh];
for (int i = G[x]; i != -1; i = E[i].nx)
if (!level[E[i].v] && E[i].c) {
level[que[++qt] = E[i].v] = level[x] + 1;
}
}
return !!level[t];
}
int dfs(int u, int rm) {
if (u == t) return rm;
int rm1 = rm;
for (int &i = cur[u]; i != -1; i = E[i].nx) {
if (level[E[i].v] == level[u] + 1 && E[i].c) {
int flow = dfs(E[i].v, min(rm, E[i].c));
E[i].c -= flow, E[i ^ 1].c += flow;
if ((rm -= flow) == 0) break;
}
}
if (rm1 == rm) level[u] = 0;
return rm1 - rm;
}
int main() {
int n, m, male, female;
scanf("%d%d%d%d", &n, &m, &male, &female);
for (int i = 1; i <= n; i++) scanf("%s", ma[i] + 1);
memset(go, 0x3f, sizeof(go));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ma[i][j] == '.') {
BFS(i, j);
}
int r, c, T;
scanf("%d%d%d", &r, &c, &T);
males.resize(1);
females.resize(1);
if (male < female) {
males.emplace_back(r, c, T);
} else {
females.emplace_back(r, c, T);
}
for (int i = 1; i <= male; i++) {
scanf("%d%d%d", &r, &c, &T);
males.emplace_back(r, c, T);
}
for (int i = 1; i <= female; i++) {
scanf("%d%d%d", &r, &c, &T);
females.emplace_back(r, c, T);
}
male = males.size() - 1;
female = females.size() - 1;
if (male != female) {
puts("-1");
return 0;
}
s = female + male + 2 * n * m + 1;
t = s + 1;
long long low = -1, high = INF;
bool flag = false;
while (low < high - 1) {
long long mid = (low + high) >> 1;
edtot = 0;
memset(G, -1, sizeof(G));
for (int i = 1; i <= female; i++) {
addedge(s, i, 1);
}
for (int i = 1; i <= female; i++) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
int tmp = go[females[i].r][females[i].c][j][k];
if (tmp != inf && 1ll * tmp * females[i].t <= mid) {
addedge(i, female + (j - 1) * m + k, 1);
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
addedge(female + (i - 1) * m + j, female + n * m + (i - 1) * m + j, 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= male; k++) {
int tmp = go[males[k].r][males[k].c][i][j];
if (tmp != inf && 1ll * tmp * males[k].t <= mid) {
addedge(female + n * m + (i - 1) * m + j, female + 2 * n * m + k,
1);
}
}
}
for (int i = 1; i <= male; i++) {
addedge(female + 2 * n * m + i, t, 1);
}
int ans = 0;
while (bfs()) memcpy(cur, G, sizeof(G)), ans += dfs(s, inf);
if (ans != male) {
low = mid;
} else {
high = mid;
flag = true;
}
}
if (!flag)
puts("-1");
else
printf("%I64d\n", high);
return 0;
}
|
#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 = 8e10;
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 == 8e10)
out(-1);
else
out(rr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
template <class T>
int size(T &x) {
return x.size();
}
int q[3000], d[3000];
struct flow_network {
struct edge {
int v, cap, nxt;
edge() {}
edge(int _v, int _cap, int _nxt) : v(_v), cap(_cap), nxt(_nxt) {}
};
int n, ecnt, *head, *curh;
vector<edge> e, e_store;
flow_network(int _n, int m = -1) : n(_n), ecnt(0) {
e.reserve(2 * (m == -1 ? n : m));
head = new int[n], curh = new int[n];
memset(head, -1, n * sizeof(int));
}
void destroy() {
delete[] head;
delete[] curh;
}
void reset() { e = e_store; }
void add_edge(int u, int v, int uv, int vu = 0) {
e.push_back(edge(v, uv, head[u]));
head[u] = ecnt++;
e.push_back(edge(u, vu, head[v]));
head[v] = ecnt++;
}
int augment(int v, int t, int f) {
if (v == t) return f;
for (int &i = curh[v], ret; i != -1; i = e[i].nxt)
if (e[i].cap > 0 && d[e[i].v] + 1 == d[v])
if ((ret = augment(e[i].v, t, min(f, e[i].cap))) > 0)
return (e[i].cap -= ret, e[i ^ 1].cap += ret, ret);
return 0;
}
int max_flow(int s, int t, bool res = true) {
if (s == t) return 0;
e_store = e;
int f = 0, x, l, r;
while (true) {
memset(d, -1, n * sizeof(int));
l = r = 0, d[q[r++] = t] = 0;
while (l < r)
for (int v = q[l++], i = head[v]; i != -1; i = e[i].nxt)
if (e[i ^ 1].cap > 0 && d[e[i].v] == -1)
d[q[r++] = e[i].v] = d[v] + 1;
if (d[s] == -1) break;
memcpy(curh, head, n * sizeof(int));
while ((x = augment(s, t, INF)) != 0) f += x;
}
if (res) reset();
return f;
}
};
char arr[30][30];
int dist[30][30][30][30];
vector<pair<pair<int, int>, int> > ppl[3];
pair<pair<int, int>, int> get_person() {
int x, y, sp;
scanf("%d %d %d\n", &x, &y, &sp);
x--, y--;
return make_pair(pair<int, int>(x, y), sp);
}
int main() {
int n, m, males, females;
scanf("%d %d %d %d\n", &n, &m, &males, &females);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%c", &arr[i][j]);
}
scanf("\n");
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) dist[i][j][k][l] = INF;
if (arr[i][j] == '#') continue;
dist[i][j][i][j] = 0;
queue<pair<int, int> > Q;
Q.push(pair<int, int>(i, j));
while (!Q.empty()) {
pair<int, int> cur = Q.front();
Q.pop();
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if ((di == 0) == (dj == 0)) {
continue;
}
pair<int, int> nxt(cur.first + di, cur.second + dj);
if (nxt.first >= 0 && nxt.first < n && nxt.second >= 0 &&
nxt.second < m && arr[nxt.first][nxt.second] == '.') {
if (dist[i][j][nxt.first][nxt.second] == INF) {
dist[i][j][nxt.first][nxt.second] =
1 + dist[i][j][cur.first][cur.second];
Q.push(nxt);
}
}
}
}
}
}
}
pair<pair<int, int>, int> weird = get_person();
for (int i = 0; i < males; i++) ppl[0].push_back(get_person());
for (int i = 0; i < females; i++) ppl[1].push_back(get_person());
if (size(ppl[0]) < size(ppl[1]))
ppl[0].push_back(weird);
else
ppl[1].push_back(weird);
if (size(ppl[0]) != size(ppl[1])) {
cout << -1 << endl;
return 0;
}
long long lo = 0, hi = 10000000000000000LL;
long long res = -1;
while (lo <= hi) {
long long mid = lo + (hi - lo) / 2;
int SOURCE = 0, SINK = 1, MEN = SINK + 1, CELLL = MEN + size(ppl[0]),
CELLR = CELLL + n * m, WOMEN = CELLR + n * m,
CNT = WOMEN + size(ppl[1]);
flow_network g(CNT);
for (int i = 0; i < size(ppl[0]); i++) {
g.add_edge(SOURCE, MEN + i, 1);
}
for (int i = 0; i < size(ppl[1]); i++) {
g.add_edge(WOMEN + i, SINK, 1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '.') {
g.add_edge(CELLL + i * m + j, CELLR + i * m + j, 1);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < size(ppl[0]); k++) {
pair<int, int> at = ppl[0][k].first;
long long spd = ppl[0][k].second;
if (dist[at.first][at.second][i][j] == INF) continue;
if (spd * dist[at.first][at.second][i][j] <= mid) {
g.add_edge(MEN + k, CELLL + i * m + j, 1);
}
}
for (int k = 0; k < size(ppl[1]); k++) {
pair<int, int> at = ppl[1][k].first;
long long spd = ppl[1][k].second;
if (dist[at.first][at.second][i][j] == INF) continue;
if (spd * dist[at.first][at.second][i][j] <= mid) {
g.add_edge(CELLR + i * m + j, WOMEN + k, 1);
}
}
}
}
if (g.max_flow(SOURCE, SINK) == size(ppl[0])) {
res = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DELTA[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
struct Person {
int sx;
int sy;
int speed;
vector<pair<int, long long> > edges;
void read() {
cin >> sx >> sy >> speed;
--sx;
--sy;
}
void buildEdge(char field[][30], int m, int n) {
edges.push_back(make_pair(sx * n + sy, 0));
vector<vector<bool> > visited(m, vector<bool>(n));
visited[sx][sy] = true;
for (int ptr = 0; ptr < (int)edges.size(); ++ptr) {
int x = edges[ptr].first / n;
int y = edges[ptr].first % n;
long long dist = edges[ptr].second;
for (int dir = 0; dir < 4; ++dir) {
int nx = x + DELTA[dir][0];
int ny = y + DELTA[dir][1];
if (nx >= 0 && nx < m && ny >= 0 && ny < n && field[nx][ny] != '#' &&
!visited[nx][ny]) {
visited[nx][ny] = true;
edges.push_back(make_pair(nx * n + ny, dist + speed));
}
}
}
}
};
const int N = (int)2e6;
int firstEdge[N];
int nextEdge[N];
int pointTo[N];
int layer[N];
int cap[N];
int work[N];
char field[30][30];
Person males[500];
Person females[500];
int numFlowVertices;
int numPeople;
int m;
int n;
int ptr;
void addFlowEdge(int u, int v, int c1, int c2 = 0) {
pointTo[ptr] = v;
cap[ptr] = c1;
nextEdge[ptr] = firstEdge[u];
firstEdge[u] = ptr++;
pointTo[ptr] = u;
cap[ptr] = c2;
nextEdge[ptr] = firstEdge[v];
firstEdge[v] = ptr++;
}
bool bfs(int source, int sink) {
memset(layer, -1, sizeof(int) * numFlowVertices);
layer[0] = source;
queue<int> q;
q.push(source);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int e = firstEdge[u]; e != -1; e = nextEdge[e])
if (cap[e] > 0) {
int v = pointTo[e];
if (layer[v] == -1) {
layer[v] = layer[u] + 1;
q.push(v);
}
}
}
return layer[sink] != -1;
}
int dfs(int u, int sink, int flow) {
if (u == sink) return flow;
for (int &e = work[u]; e != -1; e = nextEdge[e])
if (cap[e] > 0) {
int v = pointTo[e];
if (layer[u] + 1 != layer[v]) continue;
int result = dfs(v, sink, min(flow, cap[e]));
if (result != 0) {
cap[e] -= result;
cap[e ^ 1] += result;
return result;
}
}
return 0;
}
int getMaxFlow(int source, int sink) {
int result = 0;
while (bfs(source, sink)) {
memcpy(work, firstEdge, sizeof(int) * numFlowVertices);
for (int delta = 0; (delta = dfs(source, sink, (int)1e9)) != 0;
result += delta)
;
}
return result;
}
bool possible(long long maxTime) {
memset(firstEdge, -1, sizeof firstEdge);
ptr = 0;
int source = 0;
int sink = 1;
for (int i = 0; i < m * n; ++i) {
addFlowEdge(i + 2, i + 2 + m * n, 1);
}
for (int i = 0; i < numPeople; ++i) {
addFlowEdge(source, 2 * m * n + 2 + i, 1);
addFlowEdge(2 * m * n + 2 + numPeople + i, sink, 1);
for (auto e : males[i].edges) {
if (e.second > maxTime) break;
addFlowEdge(2 * m * n + 2 + i, e.first + 2, 1);
}
for (auto e : females[i].edges) {
if (e.second > maxTime) break;
addFlowEdge(e.first + 2 + m * n, 2 * m * n + 2 + numPeople + i, 1);
}
}
numFlowVertices = 2 * m * n + 2 * numPeople + 2;
if (getMaxFlow(source, sink) == numPeople) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> m >> n;
int numMales;
cin >> numMales;
int numFemales;
cin >> numFemales;
for (int i = 0; i < m; ++i) cin >> field[i];
if (abs(numMales - numFemales) != 1) {
puts("-1");
return 0;
}
numPeople = max(numMales, numFemales);
if (numMales < numFemales)
males[numPeople - 1].read();
else
females[numPeople - 1].read();
for (int i = 0; i < numMales; ++i) males[i].read();
for (int i = 0; i < numFemales; ++i) females[i].read();
for (int i = 0; i < numPeople; ++i) {
males[i].buildEdge(field, m, n);
females[i].buildEdge(field, m, n);
}
long long low = 0;
long long high = (long long)1e15;
while (low < high) {
long long mid = (low + high) / 2;
if (possible(mid))
high = mid;
else
low = mid + 1;
}
cout << (low == (long long)1e15 ? -1 : low) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
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;
}
};
const int maxN = 25;
int n, m, male, female;
string s[maxN];
int r[2 * maxN * maxN], c[2 * maxN * maxN], t[2 * maxN * maxN];
int d[maxN][maxN][maxN][maxN];
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
bool isValid(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m && s[x][y] == '.';
}
void calc(int d[maxN][maxN], int u, int v) {
memset(d, -1, sizeof(d));
d[u][v] = 0;
queue<pair<int, int> > q;
q.push(make_pair(u, v));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first;
int y = p.second;
for (int i = 0; i < 4; ++i) {
if (isValid(x + dx[i], y + dy[i]) && d[x + dx[i]][y + dy[i]] == -1) {
d[x + dx[i]][y + dy[i]] = d[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
}
}
bool check(long long value) {
{
MaximumFlow F(male + female + 1 + 2 * n * m + 2);
int start = male + female + 1 + 2 * n * m;
int finish = start + 1;
for (int i = (male < female ? 0 : 1); i <= male; ++i) {
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(i, male + female + 1 + x * m + y, 1);
}
}
}
F.addEdge(start, i, 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
F.addEdge(male + female + 1 + i * m + j,
male + female + 1 + n * m + i * m + j, 1);
}
}
}
for (int i = 0; i <= male + female; ++i) {
if (i < male + 1) {
if (female < male && i == 0) {
} else {
continue;
}
}
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(male + female + 1 + n * m + x * m + y, i, 1);
}
}
}
F.addEdge(i, finish, 1);
}
return F.dinicFlow(start, finish) == (male + female + 1) / 2;
}
}
int main() {
cin >> n >> m >> male >> female;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
cin >> r[0] >> c[0] >> t[0];
--r[0];
--c[0];
for (int i = 1; i <= male; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
for (int i = male + 1; i <= male + female; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
memset(d, -1, sizeof(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
calc(d[i][j], i, j);
}
}
}
if (male + 1 != female && male != female + 1) {
cout << -1 << endl;
return 0;
}
long long left_bound = 0, right_bound = 1000000000000000000LL;
if (!check(right_bound)) {
cout << -1 << endl;
return 0;
}
while (right_bound - left_bound > 1) {
long long middle = (left_bound + right_bound) / 2;
if (check(middle)) {
right_bound = middle;
} else {
left_bound = middle;
}
}
if (check(left_bound)) {
cout << left_bound << endl;
} else {
cout << right_bound << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int oo = 2147483647;
const long long ool = 1ll << 60;
struct Edge {
int from, to, flow;
Edge() {}
Edge(int _1, int _2, int _3) : from(_1), to(_2), flow(_3) {}
};
namespace Dinic {
int n, m, s, t, head[2000], nxt[1000000];
Edge es[1000000];
int Q[2000], hd, tl, vis[2000];
int cur[2000];
void init() {
m = 0;
memset(head, -1, sizeof(head));
return;
}
void setn(int _) {
n = _;
return;
}
void AddEdge(int a, int b, int c) {
es[m] = Edge(a, b, c);
nxt[m] = head[a];
head[a] = m++;
es[m] = Edge(b, a, 0);
nxt[m] = head[b];
head[b] = m++;
return;
}
bool BFS() {
memset(vis, 0, sizeof(vis));
vis[t] = 1;
hd = tl = 0;
Q[++tl] = t;
while (hd != tl) {
int u = Q[++hd];
for (int i = head[u]; i != -1; i = nxt[i]) {
Edge& e = es[i ^ 1];
if (!vis[e.from] && e.flow) vis[e.from] = vis[u] + 1, Q[++tl] = e.from;
}
}
return vis[s] > 1;
}
int DFS(int u, int a) {
if (u == t || !a) return a;
int flow = 0, f;
for (int& i = cur[u]; i != -1; i = nxt[i]) {
Edge& e = es[i];
if (vis[e.to] == vis[u] - 1 && (f = DFS(e.to, min(a, e.flow)))) {
flow += f;
a -= f;
e.flow -= f;
es[i ^ 1].flow += f;
if (!a) return flow;
}
}
return flow;
}
int MaxFlow(int _s, int _t) {
s = _s;
t = _t;
int flow = 0;
while (BFS()) {
for (int i = (1), mi = (n); i <= mi; i++) cur[i] = head[i];
flow += DFS(s, oo);
}
return flow;
}
} // namespace Dinic
char Map[25][25];
int CntP;
struct Point {
int id;
Point() : id(0) {}
int p() { return id ? id : id = ++CntP; }
} boy[2000], girl[2000], In[25][25], Out[25][25], S, T;
int hd, tl, step[25][25], dx[4] = {0, 0, -1, 1}, dy[4] = {-1, 1, 0, 0};
pair<int, int> Q[25 * 25];
void bfs(int sx, int sy, int n, int m) {
memset(step, -1, sizeof(step));
step[sx][sy] = 0;
hd = tl = 0;
Q[++tl] = make_pair(sx, sy);
while (hd < tl) {
pair<int, int> u = Q[++hd], v;
for (int i = (0), mi = (3); i <= mi; i++) {
v = make_pair(u.first + dx[i], u.second + dy[i]);
if (1 <= v.first && v.first <= n && 1 <= v.second && v.second <= m &&
step[v.first][v.second] < 0 && Map[v.first][v.second] == '.')
step[v.first][v.second] = step[u.first][u.second] + 1, Q[++tl] = v;
}
}
return;
}
struct Info {
int first, second, t;
Info() {}
Info(int _1, int _2, int _3) : first(_1), second(_2), t(_3) {}
} Boy[2000], Girl[2000];
int main() {
int n = read(), m = read(), male = read(), female = read();
for (int i = (1), mi = (n); i <= mi; i++) scanf("%s", Map[i] + 1);
int ax = read(), ay = read(), at = read(), mxt = at;
for (int i = (1), mi = (male); i <= mi; i++) {
int first = read(), second = read(), t = read();
Boy[i] = Info(first, second, t);
mxt = max(mxt, t);
if (Map[first][second] == '#') return puts("-1"), 0;
}
for (int i = (1), mi = (female); i <= mi; i++) {
int first = read(), second = read(), t = read();
Girl[i] = Info(first, second, t);
mxt = max(mxt, t);
if (Map[first][second] == '#') return puts("-1"), 0;
}
if (male == female || abs(male - female) > 1) return puts("-1"), 0;
if (male < female)
Boy[++male] = Info(ax, ay, at);
else
Girl[++female] = Info(ax, ay, at);
int K = male;
long long l = 0, r = ((long long)mxt * n * m << 1) + 1;
while (l < r) {
long long mid = l + r >> 1;
Dinic::init();
for (int i = (1), mi = (K); i <= mi; i++) {
Dinic::AddEdge(S.p(), boy[i].p(), 1);
int first = Boy[i].first, second = Boy[i].second, t = Boy[i].t;
bfs(first, second, n, m);
for (int a = (1), mi = (n); a <= mi; a++)
for (int b = (1), mi = (m); b <= mi; b++)
if (step[a][b] >= 0 && (long long)step[a][b] * t <= mid)
Dinic::AddEdge(boy[i].p(), In[a][b].p(), 1);
}
for (int i = (1), mi = (K); i <= mi; i++) {
Dinic::AddEdge(girl[i].p(), T.p(), 1);
int first = Girl[i].first, second = Girl[i].second, t = Girl[i].t;
bfs(first, second, n, m);
for (int a = (1), mi = (n); a <= mi; a++)
for (int b = (1), mi = (m); b <= mi; b++)
if (step[a][b] >= 0 && (long long)step[a][b] * t <= mid)
Dinic::AddEdge(Out[a][b].p(), girl[i].p(), 1);
}
for (int a = (1), mi = (n); a <= mi; a++)
for (int b = (1), mi = (m); b <= mi; b++)
Dinic::AddEdge(In[a][b].p(), Out[a][b].p(), 1);
Dinic::setn(CntP);
int flow = Dinic::MaxFlow(S.p(), T.p());
if (flow < K)
l = mid + 1;
else
r = mid;
}
printf("%I64d\n", l == ((long long)mxt * n * m << 1) + 1 ? -1 : l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DELTA[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
struct Person {
int sx;
int sy;
int speed;
vector<pair<int, long long> > edges;
void read() {
cin >> sx >> sy >> speed;
--sx;
--sy;
}
void buildEdge(char field[][30], int m, int n) {
edges.push_back(make_pair(sx * n + sy, 0));
vector<vector<bool> > visited(m, vector<bool>(n));
visited[sx][sy] = true;
for (int ptr = 0; ptr < (int)edges.size(); ++ptr) {
int x = edges[ptr].first / n;
int y = edges[ptr].first % n;
long long dist = edges[ptr].second;
for (int dir = 0; dir < 4; ++dir) {
int nx = x + DELTA[dir][0];
int ny = y + DELTA[dir][1];
if (nx >= 0 && nx < m && ny >= 0 && ny < n && field[nx][ny] != '#' &&
!visited[nx][ny]) {
visited[nx][ny] = true;
edges.push_back(make_pair(nx * n + ny, dist + speed));
}
}
}
}
};
const int N = (int)2e6;
int firstEdge[N];
int nextEdge[N];
int pointTo[N];
int layer[N];
int cap[N];
int work[N];
char field[30][30];
Person males[500];
Person females[500];
int numPeople;
int m;
int n;
int ptr;
void addFlowEdge(int u, int v, int c1, int c2 = 0) {
pointTo[ptr] = v;
cap[ptr] = c1;
nextEdge[ptr] = firstEdge[u];
firstEdge[u] = ptr++;
pointTo[ptr] = u;
cap[ptr] = c2;
nextEdge[ptr] = firstEdge[v];
firstEdge[v] = ptr++;
}
bool bfs(int source, int sink) {
memset(layer, -1, sizeof layer);
layer[0] = source;
queue<int> q;
q.push(source);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int e = firstEdge[u]; e != -1; e = nextEdge[e])
if (cap[e] > 0) {
int v = pointTo[e];
if (layer[v] == -1) {
layer[v] = layer[u] + 1;
q.push(v);
}
}
}
return layer[sink] != -1;
}
int dfs(int u, int sink, int flow) {
if (u == sink) return flow;
for (int &e = work[u]; e != -1; e = nextEdge[e])
if (cap[e] > 0) {
int v = pointTo[e];
if (layer[u] + 1 != layer[v]) continue;
int result = dfs(v, sink, min(flow, cap[e]));
if (result != 0) {
cap[e] -= result;
cap[e ^ 1] += result;
return result;
}
}
return 0;
}
int getMaxFlow(int source, int sink) {
int result = 0;
while (bfs(source, sink)) {
memcpy(work, firstEdge, sizeof work);
for (int delta = 0; (delta = dfs(source, sink, (int)1e9)) != 0;
result += delta)
;
}
return result;
}
bool possible(long long maxTime) {
memset(firstEdge, -1, sizeof firstEdge);
ptr = 0;
int source = 0;
int sink = 1;
for (int i = 0; i < m * n; ++i) {
addFlowEdge(i + 2, i + 2 + m * n, 1);
}
for (int i = 0; i < numPeople; ++i) {
addFlowEdge(source, 2 * m * n + 2 + i, 1);
addFlowEdge(2 * m * n + 2 + numPeople + i, sink, 1);
for (auto e : males[i].edges) {
if (e.second > maxTime) break;
addFlowEdge(2 * m * n + 2 + i, e.first + 2, 1);
}
for (auto e : females[i].edges) {
if (e.second > maxTime) break;
addFlowEdge(e.first + 2 + m * n, 2 * m * n + 2 + numPeople + i, 1);
}
}
if (getMaxFlow(source, sink) == numPeople) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> m >> n;
int numMales;
cin >> numMales;
int numFemales;
cin >> numFemales;
for (int i = 0; i < m; ++i) cin >> field[i];
if (abs(numMales - numFemales) != 1) {
puts("-1");
return 0;
}
numPeople = max(numMales, numFemales);
if (numMales < numFemales)
males[numPeople - 1].read();
else
females[numPeople - 1].read();
for (int i = 0; i < numMales; ++i) males[i].read();
for (int i = 0; i < numFemales; ++i) females[i].read();
for (int i = 0; i < numPeople; ++i) {
males[i].buildEdge(field, m, n);
females[i].buildEdge(field, m, n);
}
long long low = 0;
long long high = (long long)1e15;
while (low < high) {
long long mid = (low + high) / 2;
if (possible(mid))
high = mid;
else
low = mid + 1;
}
cout << (low == (long long)1e15 ? -1 : low) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:128777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 1000007;
const int MAX2 = 200000;
const int BASE = 1000000007;
const int MOD = 1000000007;
const int CNT = 1000;
string s[23];
long long d[500][500];
int dirx[4] = {1, 0, -1, 0};
int diry[4] = {0, 1, 0, -1};
int n, m, k, l;
bool ok(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < m && s[x][y] == '.';
}
int N, S, T;
int c[2000][2000];
int f[2000][2000];
int D[2000], ptr[2000], q[2000];
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = S;
memset(D, -1, sizeof(D));
D[S] = 0;
while (qh < qt) {
int v = q[qh++];
for (int to = 0; to < N; ++to)
if (D[to] == -1 && f[v][to] < c[v][to]) {
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 (int& to = ptr[v]; to < N; ++to) {
if (D[to] != D[v] + 1) continue;
int pushed = dfs(to, min(flow, c[v][to] - f[v][to]));
if (pushed) {
f[v][to] += pushed;
f[to][v] -= pushed;
return pushed;
}
}
return 0;
}
int dinic() {
int flow = 0;
for (;;) {
if (!bfs()) break;
memset(ptr, 0, sizeof(ptr));
while (int pushed = dfs(S, INF)) flow += pushed;
}
return flow;
}
vector<pair<pair<int, int>, int> > a;
vector<pair<pair<int, int>, int> > b;
int F(long long MID) {
memset(c, 0, sizeof(c));
memset(f, 0, sizeof(f));
for (int i = (0); i < (a.size()); ++i) {
c[0][i + 1] = 1;
}
for (int i = (0); i < (a.size()); ++i) {
for (int x = (0); x < (n); ++x) {
for (int y = (0); y < (m); ++y) {
int X = a[i].first.first;
int Y = a[i].first.second;
long long dist = d[X * m + Y][x * m + y];
if (s[x][y] == '.' && dist < INF && 1LL * dist * a[i].second <= MID) {
c[i + 1][1 + a.size() + x * m + y] = 1;
}
}
}
}
for (int x = (0); x < (n); ++x) {
for (int y = (0); y < (m); ++y) {
c[1 + a.size() + x * m + y][1 + a.size() + x * m + y + n * m] = 1;
}
}
for (int i = (0); i < (b.size()); ++i) {
for (int x = (0); x < (n); ++x) {
for (int y = (0); y < (m); ++y) {
int X = b[i].first.first;
int Y = b[i].first.second;
long long dist = d[X * m + Y][x * m + y];
if (dist < INF && 1LL * dist * b[i].second <= MID) {
c[1 + a.size() + x * m + y + n * m][1 + a.size() + 2 * n * m + i] = 1;
}
}
}
c[1 + a.size() + 2 * n * m + i][T] = 1;
}
int flow = dinic();
return flow == a.size();
}
int main() {
cin >> n >> m >> k >> l;
for (int i = (0); i < (n); ++i) {
cin >> s[i];
}
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
--x;
--y;
for (int i = (0); i < (k); ++i) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
--x;
--y;
a.push_back(make_pair(make_pair(x, y), v));
}
for (int i = (0); i < (l); ++i) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
--x;
--y;
b.push_back(make_pair(make_pair(x, y), v));
}
if (a.size() < b.size()) {
a.push_back(make_pair(make_pair(x, y), v));
} else {
b.push_back(make_pair(make_pair(x, y), v));
}
if (a.size() != b.size()) {
cout << -1 << endl;
return 0;
}
for (int i = (0); i < (500); ++i) {
for (int j = (0); j < (500); ++j) {
d[i][j] = 1LL * INF * INF;
}
d[i][i] = 0;
}
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
if (ok(i, j)) {
for (int dd = (0); dd < (4); ++dd) {
int x = i + dirx[dd];
int y = j + diry[dd];
if (ok(x, y)) {
d[i * m + j][x * m + y] = 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) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
N = 2 + a.size() + b.size() + 2 * n * m;
S = 0;
T = N - 1;
long long L = 0;
long long R = 1LL * INF * INF;
while (R - L > 1) {
long long MID = (L + R) / 2;
if (F(MID)) {
R = MID;
} else {
L = MID;
}
}
if (!F(R)) {
cout << -1 << endl;
return 0;
}
if (F(L)) {
R = L;
}
cout << R << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 23;
const int INF = 1 << 30;
const int stepx[4] = {0, 0, 1, -1};
const int stepy[4] = {1, -1, 0, 0};
struct person {
int x, y;
long long speed;
};
struct edge {
int from, to, cap, flow;
};
int n, m, male, female;
vector<person> males;
vector<person> females;
vector<edge> edges;
vector<int> net[10 * MAXN * MAXN];
queue<person> Q;
queue<int> netQ;
int nets, netm, netr1[10 * MAXN * MAXN], netr2[10 * MAXN * MAXN], netf, nett;
int maps[MAXN][MAXN];
int visit[MAXN][MAXN];
int netvisit[10 * MAXN * MAXN];
int dis[10 * MAXN * MAXN];
int cur[10 * MAXN * MAXN];
int netbfs() {
memset(netvisit, 0, sizeof(netvisit));
netQ.push(nets);
dis[nets] = 0;
netvisit[nets] = 1;
while (!netQ.empty()) {
int x = netQ.front();
netQ.pop();
for (int i = 0; i < net[x].size(); i++) {
edge e = edges[net[x][i]];
if (!netvisit[e.to] && e.cap > e.flow) {
netvisit[e.to] = true;
dis[e.to] = dis[x] + 1;
netQ.push(e.to);
}
}
}
return netvisit[nett];
}
int netdfs(int x, int a) {
if (x == nett || a == 0) return a;
int flow = 0, f;
for (int &i = cur[x]; i < net[x].size(); i++) {
edge &e = edges[net[x][i]];
if (dis[x] + 1 == dis[e.to] &&
(f = netdfs(e.to, min(a, e.cap - e.flow))) > 0) {
e.flow += f;
edges[net[x][i] ^ 1].flow -= f;
flow += f;
a -= f;
if (a == 0) break;
}
}
return flow;
}
int addedge(int a, int b, int c) {
edges.push_back((edge){a, b, c, 0});
edges.push_back((edge){b, a, 0, 0});
int temp = edges.size();
net[a].push_back(temp - 2);
net[b].push_back(temp - 1);
return 0;
}
int bfsinit(int a, int b, long long c) {
memset(visit, 0, sizeof(visit));
Q.push((person){a, b, c});
visit[a][b] = 1;
return 0;
}
int pd(person in) {
if (in.x < 1 || in.x > n || in.y < 1 || in.y > m || visit[in.x][in.y] ||
maps[in.x][in.y] == 1)
return 0;
visit[in.x][in.y] = 1;
return 1;
}
int bfs(int a, int b, int c, int d, long long e, long long f) {
bfsinit(a, b, e);
while (!Q.empty()) {
person tempa = Q.front();
Q.pop();
if (d == 0)
addedge(netm + c - 1, netr1[tempa.x] + tempa.y - 1, 1);
else
addedge(netr2[tempa.x] + tempa.y - 1, netf + c - 1, 1);
if (tempa.speed >= f)
for (int i = 0; i < 4; i++) {
person tempb =
(person){tempa.x + stepx[i], tempa.y + stepy[i], tempa.speed - f};
if (!pd(tempb)) continue;
Q.push(tempb);
}
}
return 0;
}
int judgeinit(long long in) {
edges.clear();
for (int i = 0; i <= nett; i++) net[i].clear();
for (int i = 1; i <= males.size(); i++) {
addedge(nets, netm + i - 1, 1);
bfs(males[i - 1].x, males[i - 1].y, i, 0, in, males[i - 1].speed);
}
for (int i = 1; i <= females.size(); i++) {
addedge(netf + i - 1, nett, 1);
bfs(females[i - 1].x, females[i - 1].y, i, 1, in, females[i - 1].speed);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) addedge(netr1[i] + j - 1, netr2[i] + j - 1, 1);
return 0;
}
int judge(long long in) {
judgeinit(in);
int flow = 0;
while (netbfs()) {
memset(cur, 0, sizeof(cur));
flow += netdfs(nets, INF);
}
if (flow == females.size())
return 1;
else
return 0;
}
int read() {
while (true) {
int tempc = getchar();
if (tempc == '.')
return 0;
else if (tempc == '#')
return 1;
}
}
int init() {
scanf("%d%d%d%d", &n, &m, &male, &female);
if (abs(male - female) != 1) {
printf("-1\n");
return 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) maps[i][j] = read();
{
int tempa, tempb, tempc;
scanf("%d%d%d", &tempa, &tempb, &tempc);
if (male > female)
females.push_back((person){tempa, tempb, tempc});
else
males.push_back((person){tempa, tempb, tempc});
}
for (int i = 1; i <= male; i++) {
int tempa, tempb, tempc;
scanf("%d%d%d", &tempa, &tempb, &tempc);
males.push_back((person){tempa, tempb, tempc});
}
for (int i = 1; i <= female; i++) {
int tempa, tempb, tempc;
scanf("%d%d%d", &tempa, &tempb, &tempc);
females.push_back((person){tempa, tempb, tempc});
}
nets = 0;
netm = 1;
for (int i = 1; i <= n; i++) netr1[i] = males.size() + m * (i - 1) + 1;
for (int i = 1; i <= n; i++)
netr2[i] = males.size() + n * m + m * (i - 1) + 1;
netf = males.size() + 2 * n * m + 1;
nett = males.size() + 2 * n * m + females.size() + 1;
return 0;
}
int solve() {
long long head = 0, tail = 500e9;
int flag = 0;
while (head < tail) {
long long mid = (head + tail) >> 1;
if (judge(mid)) {
tail = mid;
flag = 1;
} else
head = mid + 1;
}
if (flag)
cout << head << endl;
else
printf("-1\n");
return 0;
}
int main(void) {
if (init()) return 0;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
long long const INF = 4e11;
const pair<int, int> dir[4] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
class Isap {
public:
static const int MXN = 10000;
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;
struct pt {
int x, y;
int v;
};
int N, M, ML, FM;
char mp[MX][MX];
long long dis[MX][MX][MX][MX];
bool us[MX][MX];
vector<pt> males, females;
bool test(long long t) {
int N1 = ML + FM;
int N2 = N1 + N * M;
int N3 = N2 + N * M;
int second = N3, T = N3 + 1, V = N3 + 2;
flow.init(V, second, T);
for (int(i) = 0; (i) < ((int)males.size()); (i)++) {
flow.add_edge(second, i, 1);
int x = males[i].x, y = males[i].y, v = males[i].v;
long long w = t / v;
for (int(xx) = 0; (xx) < (N); (xx)++)
for (int(yy) = 0; (yy) < (M); (yy)++) {
if (dis[x][y][xx][yy] <= w) {
flow.add_edge(i, N1 + xx * M + yy, 1);
}
}
}
for (int(i) = 0; (i) < ((int)females.size()); (i)++) {
flow.add_edge(ML + i, T, 1);
int x = females[i].x, y = females[i].y, v = females[i].v;
long long w = t / v;
for (int(xx) = 0; (xx) < (N); (xx)++)
for (int(yy) = 0; (yy) < (M); (yy)++) {
if ((long long)dis[x][y][xx][yy] <= w)
flow.add_edge(N2 + xx * M + yy, ML + i, 1);
}
}
for (int i = 0; i < N * M; i++) {
flow.add_edge(N1 + i, N2 + i, 1);
}
int tt = flow.flow();
return tt == max(ML, FM);
}
int main() {
scanf("%d%d%d%d", &N, &M, &ML, &FM);
for (int(i) = 0; (i) < (N); (i)++) {
scanf("%s", mp[i]);
}
{
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
x--;
y--;
if (ML < FM)
males.push_back({x, y, v});
else
females.push_back({x, y, v});
}
for (int _t153 = 0; _t153 < (ML); (_t153)++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
x--;
y--;
males.push_back({x, y, v});
}
for (int _t160 = 0; _t160 < (FM); (_t160)++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
x--;
y--;
females.push_back({x, y, v});
}
ML = males.size();
FM = females.size();
auto inr = [=](pair<int, int> p) {
if (p.first < 0 or p.first >= N or p.second < 0 or p.second >= M)
return false;
return true;
};
for (int(x) = 0; (x) < (N); (x)++)
for (int(y) = 0; (y) < (M); (y)++)
for (int(xx) = 0; (xx) < (N); (xx)++)
for (int(yy) = 0; (yy) < (M); (yy)++) dis[x][y][xx][yy] = INF;
for (int(x) = 0; (x) < (N); (x)++) {
for (int(y) = 0; (y) < (M); (y)++) {
if (mp[x][y] == '#') continue;
dis[x][y][x][y] = 0;
memset((us), 0, sizeof(us));
queue<pair<int, int> > qe;
us[x][y] = true;
qe.push(make_pair(x, y));
while (qe.size()) {
pair<int, int> p = qe.front();
qe.pop();
long long ds = dis[x][y][p.first][p.second];
for (auto d : dir) {
pair<int, int> q = make_pair(p.first + d.first, p.second + d.second);
if (not inr(q) or us[q.first][q.second] or
mp[q.first][q.second] == '#')
continue;
us[q.first][q.second] = true;
dis[x][y][q.first][q.second] = ds + 1;
qe.push(make_pair(q.first, q.second));
}
}
}
}
long long l = 0, r = INF;
while (l < r) {
long long md = (l + r) / 2;
if (test(md)) {
r = md;
} else {
l = md + 1;
}
}
if (l == INF) {
puts("-1");
} else {
printf("%lld\n", l);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int h[2000050], nxt[2000050], v[2000050], w[2000050], s, tt, dep[200005], ec, m,
n, a, b;
int x[1000], y[1000], ct, tx[4] = {1, 0, -1, 0}, ty[4] = {0, -1, 0, 1};
long long t[1000], d[1010][1010];
char st[30][30];
void add(int a, int b, int c) {
v[++ec] = b;
w[ec] = c;
nxt[ec] = h[a];
h[a] = ec;
}
void adj(int a, int b, int c) {
add(a, b, c);
add(b, a, 0);
}
bool bfs() {
queue<int> q;
q.push(s);
memset(dep, 0, sizeof(dep));
dep[s] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = h[x]; i; i = nxt[i])
if (w[i] > 0 && !dep[v[i]]) dep[v[i]] = dep[x] + 1, q.push(v[i]);
}
return dep[tt];
}
int dfs(int x, int dis) {
if (x == tt || !dis) return dis;
int tp = 0;
for (int i = h[x]; i && tp < dis; i = nxt[i])
if (dep[v[i]] == dep[x] + 1 && w[i] > 0) {
int f = dfs(v[i], min(dis - tp, w[i]));
w[i] -= f;
w[i ^ 1] += f;
tp += f;
}
if (!tp) dep[x] = 0;
return tp;
}
int din() {
int aans = 0;
while (bfs()) aans += dfs(s, 1e9);
return aans;
}
struct no {
int x, y;
};
void gd() {
memset(d, 32, sizeof(d));
queue<no> q;
for (int i = 1; i <= a + b; i++) {
q.push((no){x[i], y[i]});
d[i][(x[i] - 1) * m + y[i]] = 0;
while (!q.empty()) {
no x = q.front();
q.pop();
for (int j = 0; j < 4; j++) {
int nx = x.x + tx[j], ny = x.y + ty[j];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
int p1 = (nx - 1) * m + ny, p2 = (x.x - 1) * m + x.y;
if (st[nx][ny] != '#' && d[i][p1] > 1e15) {
d[i][p1] = d[i][p2] + t[i];
q.push((no){nx, ny});
}
}
}
}
}
int pd(long long x) {
memset(h, 0, sizeof(h));
ec = 1;
for (int i = 1; i <= a; i++) adj(s, i, 1);
for (int i = 1; i <= b; i++) adj(i + a + 2 * n * m, tt, 1);
for (int i = 1; i <= a; i++)
for (int j = 1; j <= n * m; j++)
if (d[i][j] <= x) adj(i, j + a, 1);
for (int i = 1; i <= b; i++)
for (int j = 1; j <= n * m; j++)
if (d[i + a][j] <= x) adj(j + a + n * m, i + a + 2 * n * m, 1);
for (int i = 1; i <= n * m; i++) adj(i + a, i + a + n * m, 1);
return din() == a;
}
int main() {
scanf("%d%d%d%d", &n, &m, &a, &b);
tt = a + b + 2 * n * m + 2;
if (abs(a - b) != 1) {
printf("-1");
return 0;
}
for (int i = 1; i <= n; i++) scanf("%s", st[i] + 1);
int xa, ya, ta;
scanf("%d%d%d", &xa, &ya, &ta);
for (int i = 1; i <= a; i++) scanf("%d%d%lld", &x[i], &y[i], &t[i]);
if (a < b) {
x[++a] = xa;
y[a] = ya;
t[a] = ta;
}
for (int i = a + 1; i <= a + b; i++) scanf("%d%d%lld", &x[i], &y[i], &t[i]);
if (a > b) {
b++;
x[a + b] = xa;
y[a + b] = ya;
t[a + b] = ta;
}
gd();
long long l = 0, r = 1e15, ans = 1e15 + 1;
while (l <= r) {
long long md = (l + r) / 2;
if (pd(md))
r = md - 1, ans = md;
else
l = md + 1;
}
if (ans == 1e15 + 1) {
printf("-1");
return 0;
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1LL << 60;
const double EPS = 1e-9;
const long long MAXN = (long long)1e5 + 10;
bool dbg = false;
template <typename flow_type>
struct dinic {
struct edge {
size_t src, dst, rev;
flow_type flow, cap;
};
int n;
vector<vector<edge>> adj;
dinic(int n) : n(n), adj(n), level(n), q(n), it(n) {}
void add_edge(size_t src, size_t dst, flow_type cap, flow_type rcap = 0) {
adj[src].push_back({src, dst, adj[dst].size(), 0, cap});
if (src == dst) adj[src].back().rev++;
adj[dst].push_back({dst, src, adj[src].size() - 1, 0, rcap});
}
vector<int> level, q, it;
bool bfs(int source, int sink) {
fill(level.begin(), level.end(), -1);
for (int qf = level[q[0] = sink] = 0, qb = 1; qf < qb; ++qf) {
sink = q[qf];
for (edge &e : adj[sink]) {
edge &r = adj[e.dst][e.rev];
if (r.flow < r.cap && level[e.dst] == -1)
level[q[qb++] = e.dst] = 1 + level[sink];
}
}
return level[source] != -1;
}
flow_type augment(int source, int sink, flow_type flow) {
if (source == sink) return flow;
for (; it[source] != adj[source].size(); ++it[source]) {
edge &e = adj[source][it[source]];
if (e.flow < e.cap && level[e.dst] + 1 == level[source]) {
flow_type delta = augment(e.dst, sink, min(flow, e.cap - e.flow));
if (delta > 0) {
e.flow += delta;
adj[e.dst][e.rev].flow -= delta;
return delta;
}
}
}
return 0;
}
flow_type max_flow(int source, int sink) {
for (int u = 0; u < n; ++u)
for (edge &e : adj[u]) e.flow = 0;
flow_type flow = 0;
while (bfs(source, sink)) {
fill(it.begin(), it.end(), 0);
for (flow_type f;
(f = augment(source, sink, numeric_limits<flow_type>::max())) > 0;)
flow += f;
}
return flow;
}
};
struct scayger {
long long x, y, v;
};
long long n, m, males, females;
char Map[30][30];
long long ID[2][30][30];
long long Dist[30][30][30][30];
long long dx[4] = {0, 0, -1, 1};
long long dy[4] = {1, -1, 0, 0};
bool valid(long long x, long long y) {
return 0 <= x && x < n && 0 <= y && y < m && Map[x][y] != '#';
}
void bfs(long long x, long long y) {
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) Dist[x][y][i][j] = oo;
Dist[x][y][x][y] = 0;
queue<pair<long long, long long>> Q;
Q.push(make_pair(x, y));
while (!Q.empty()) {
pair<long long, long long> cur = Q.front();
Q.pop();
long long dst = Dist[x][y][cur.first][cur.second];
for (int i = 0; i < 4; ++i) {
long long nx = cur.first + dx[i], ny = cur.second + dy[i];
if (valid(nx, ny) && Dist[x][y][nx][ny] > dst + 1) {
Dist[x][y][nx][ny] = dst + 1;
Q.push(make_pair(nx, ny));
}
}
}
}
bool myvalid(long long v) { return v != oo; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> males >> females;
for (long long i = 0; i < n; ++i) {
cin >> Map[i];
}
if (abs(males - females) != 1) {
cout << -1 << endl;
return 0;
}
long long vmax = 0;
vector<scayger> vm, vf;
scayger SB;
cin >> SB.x >> SB.y >> SB.v;
SB.x--;
SB.y--;
vmax = SB.v;
if (males < females)
vm.push_back(SB);
else
vf.push_back(SB);
for (long long i = 0; i < males; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vm.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < females; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vf.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (Map[i][j] != '#') bfs(i, j);
}
}
long long lo = 0, hi = m * n * vmax + 1;
long long top = hi;
for (long long i = 0, cnt = 2 + 2 * (long long)((vm).size()); i < n; ++i)
for (long long j = 0; j < m; ++j)
for (long long k = 0; k < 2; ++k) ID[k][i][j] = cnt++;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
dbg = false;
dinic<long long> flow(2 + 2 * (long long)((vm).size()) + 2 * n * m);
for (long long i = 0; i < (long long)((vm).size()); ++i) {
flow.add_edge(0, i + 2, 1);
flow.add_edge(i + 2 + (long long)((vm).size()), 1, 1);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
flow.add_edge(ID[0][i][j], ID[1][i][j], 1);
}
}
for (long long i = 0; i < (long long)((vm).size()); ++i) {
scayger cur1 = vm[i];
scayger cur2 = vf[i];
for (long long j = 0; j < n; ++j) {
for (long long k = 0; k < m; ++k) {
if (Map[j][k] == '#') continue;
if (dbg && !i)
cout << "ID " << j << " " << k << " "
<< 2 + 2 * (long long)((vm).size()) + j * m + k << endl;
if (myvalid(Dist[cur1.x][cur1.y][j][k]) &&
Dist[cur1.x][cur1.y][j][k] * cur1.v <= mid)
flow.add_edge(i + 2, ID[0][j][k], 1);
if (myvalid(Dist[cur2.x][cur2.y][j][k]) &&
Dist[cur2.x][cur2.y][j][k] * cur2.v <= mid)
flow.add_edge(ID[1][j][k], 2 + (long long)((vm).size()) + i, 1);
}
}
}
long long value = flow.max_flow(0, 1);
if (value == (long long)((vm).size()))
hi = mid;
else
lo = mid + 1;
}
if (hi == top)
cout << -1 << endl;
else
cout << hi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int MAXV = 1000;
int n, m, n1, n2;
char mat[MAXN][MAXN];
int r0, c0, t0, rs[MAXV], cs[MAXV], ts[MAXV];
bool v[MAXV][MAXN][MAXN], cap[2 * MAXV][2 * MAXV], vis[2 * MAXV];
int from[2 * MAXV];
int vs = 2 * MAXV - 2, vt = 2 * MAXV - 1;
int id(int r, int c) { return (r - 1) * m + (c - 1); }
bool dfs(int i) {
if (vis[i]) return 0;
vis[i] = 1;
if (i == vt) return 1;
for (int j = 0; j < 2 * MAXV; j++)
if (cap[i][j] && dfs(j)) {
from[j] = i;
return 1;
}
return 0;
}
bool check(long long mid) {
memset(v, 0, sizeof(v));
memset(cap, 0, sizeof(cap));
for (int i = 0; i < n1 + n2; i++) {
long long t = mid / ts[i];
queue<pair<int, int> > que;
que.push(pair<int, int>(rs[i], cs[i]));
for (int j = 0; j <= t && !que.empty(); j++) {
int sze = que.size();
for (int k = 0; k < sze; k++) {
int r = que.front().first, c = que.front().second;
que.pop();
if (v[i][r][c]) continue;
v[i][r][c] = 1;
if (i < n1)
cap[i][id(r, c) + 2 * n1] = 1;
else
cap[id(r, c) + 2 * n1 + 500][i] = 1;
for (int dr = -1; dr <= 1; dr++)
for (int dc = -1; dc <= 1; dc++)
if ((dr == 0) != (dc == 0)) {
int nr = r + dr, nc = c + dc;
if (mat[nr][nc] == '.' && !v[i][nr][nc])
que.push(pair<int, int>(nr, nc));
}
}
}
}
for (int i = 0; i < n1; i++) cap[vs][i] = 1;
for (int i = n1; i < n1 + n2; i++) cap[i][vt] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cap[id(i, j) + 2 * n1][id(i, j) + 2 * n1 + 500] = 1;
for (int i = 0; i < n1; i++) {
memset(vis, 0, sizeof(vis));
if (!dfs(vs)) return 0;
int cur = vt;
while (cur != vs) {
int nxt = from[cur];
cap[nxt][cur] = 0;
cap[cur][nxt] = 1;
cur = nxt;
}
}
return 1;
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n >> m >> n1 >> n2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mat[i][j];
cin >> r0 >> c0 >> t0;
if (abs(n1 - n2) != 1) {
cout << -1;
return 0;
}
memset(rs, -1, sizeof(rs));
if (n1 < n2)
rs[n1] = r0, cs[n1] = c0, ts[n1] = t0, n1++;
else
rs[n1 + n2] = r0, cs[n1 + n2] = c0, ts[n1 + n2] = t0, n2++;
for (int i = 0; i < n1 + n2; i++)
if (rs[i] == -1) cin >> rs[i] >> cs[i] >> ts[i];
long long lo = 0, hi = 1e12;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
if (check(lo))
cout << lo;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace MF {
int n, m, s, t, to[(1000 * 1000)];
long long fl[(1000 * 1000)], cp[(1000 * 1000)];
int dst[1000];
vector<int> al[1000];
queue<int> q;
void init(int _n) {
n = _n + 2;
m = 0;
s = _n;
t = _n + 1;
for (int i = (0); i < (n); i++) al[i].clear();
}
void add(int a, int b, long long c) {
al[a].push_back(m);
to[m] = b;
fl[m] = 0;
cp[m] = c;
m++;
al[b].push_back(m);
to[m] = a;
fl[m] = 0;
cp[m] = 0;
m++;
}
bool bfs() {
for (int i = (0); i < (n); i++) dst[i] = i == s ? 0 : -1;
q.push(s);
while (!q.empty()) {
int at = q.front();
q.pop();
for (int i = (0); i < (al[at].size()); i++) {
int e = al[at][i];
if (dst[to[e]] != -1 || fl[e] == cp[e]) continue;
dst[to[e]] = dst[at] + 1;
q.push(to[e]);
}
}
return dst[t] != -1;
}
long long aug(int at, long long cf) {
if (at == t) return cf;
for (int i = (0); i < (al[at].size()); i++) {
int e = al[at][i];
if (dst[to[e]] != dst[at] + 1 || fl[e] == cp[e]) continue;
long long tf = aug(to[e], min(cf, cp[e] - fl[e]));
if (tf) {
fl[e] += tf;
fl[e ^ 1] -= tf;
return tf;
}
}
dst[at] = -1;
return 0;
}
long long mf() {
long long ans = 0;
while (bfs())
for (int add = aug(s, 1e18); add; add = aug(s, 1e18)) ans += add;
return ans;
}
} // namespace MF
int n, m, ml, fml, id[12][12], y[200], x[200], iut, my[200], mx[200], fy[200],
fx[200], by, bx;
long long mt[200], ft[200], dst[200][200], bt;
int dy[] = {1, 0, 0, -1};
int dx[] = {0, 1, -1, 0};
long long mi = 0, ma = 1000000000000LL, mid;
char gr[12][12];
int main() {
scanf("%d %d %d %d", &n, &m, &ml, &fml);
if (abs(ml - fml) != 1) {
puts("-1");
return 0;
}
for (int i = (0); i < (n); i++) {
scanf("%s", gr[i]);
for (int j = (0); j < (m); j++)
if (gr[i][j] == '.') {
id[i][j] = iut;
y[iut] = i;
x[iut] = j;
iut++;
}
}
scanf("%d %d %lld", &by, &bx, &bt);
by--;
bx--;
for (int i = (0); i < (ml); i++)
scanf("%d %d %lld", my + i, mx + i, mt + i), my[i]--, mx[i]--;
for (int i = (0); i < (fml); i++)
scanf("%d %d %lld", fy + i, fx + i, ft + i), fy[i]--, fx[i]--;
if (ml > fml) {
fy[fml] = by;
fx[fml] = bx;
ft[fml] = bt;
fml++;
} else {
my[ml] = by;
mx[ml] = bx;
mt[ml] = bt;
ml++;
}
for (int i = (0); i < (iut); i++)
for (int j = (i + 1); j < (iut); j++)
dst[i][j] = dst[j][i] = 1000000000000LL;
for (int i = (0); i < (iut); i++)
for (int d = (0); d < (4); d++) {
int ny = y[i] + dy[d], nx = x[i] + dx[d];
if (ny < 0 || ny >= n || nx < 0 || nx >= m || gr[ny][nx] == '#') continue;
dst[i][id[ny][nx]] = 1;
}
for (int i = (0); i < (iut); i++)
for (int j = (0); j < (iut); j++)
for (int k = (0); k < (iut); k++)
dst[j][k] = min(dst[j][k], dst[j][i] + dst[i][k]);
while (mi != ma) {
mid = (mi + ma) / 2;
MF::init(ml + 2 * (iut + fml));
for (int i = (0); i < (ml); i++) MF::add(MF::s, i, 1);
for (int i = (0); i < (iut); i++) MF::add(ml + 2 * i, ml + 2 * i + 1, 1);
for (int i = (0); i < (fml); i++)
MF::add(ml + 2 * iut + 2 * i, ml + 2 * iut + 2 * i + 1, 1),
MF::add(ml + 2 * iut + 2 * i + 1, MF::t, 1);
for (int i = (0); i < (ml); i++)
for (int j = (0); j < (iut); j++)
if (dst[j][id[my[i]][mx[i]]] < 1000000000000LL &&
mt[i] * dst[j][id[my[i]][mx[i]]] <= mid)
MF::add(i, ml + 2 * j, 1);
for (int i = (0); i < (fml); i++)
for (int j = (0); j < (iut); j++)
if (dst[j][id[fy[i]][fx[i]]] < 1000000000000LL &&
ft[i] * dst[j][id[fy[i]][fx[i]]] <= mid)
MF::add(ml + 2 * j + 1, ml + 2 * iut + 2 * i, 1);
if (MF::mf() == ml)
ma = mid;
else
mi = mid + 1;
}
printf("%lld\n", mi == 1000000000000LL ? -1 : mi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50 + 2;
const int MAX = MAXN * MAXN;
const int MAXE = 5e6 + 3;
const long long INF = 1e15 + 1000;
const int FF = 1e9;
long long n, m, x, y, ec;
char c[MAXN][MAXN];
int lvl[MAX];
int q[MAX];
int dis[MAX][MAX];
int from[2 * MAXE], to[2 * MAXE], prv[2 * MAXE];
long long cap[2 * MAXE];
int head[MAX];
int ptr[MAX];
bool mark[MAX];
int hs[MAXN][MAXN];
vector<pair<long long, long long>> vec, sec;
bool fit(int a, int b) { return a >= 0 && a < n && b >= 0 && b < m; }
int hhash(int a, int b) { return a * m + b; }
void init() {
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (i != j) dis[i][j] = FF;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (c[i][j] == '#') continue;
long long h = hs[i][j];
if (fit(i + 1, j) && c[i + 1][j] != '#') dis[h][hs[i + 1][j]] = 1;
if (fit(i - 1, j) && c[i - 1][j] != '#') dis[h][hs[i - 1][j]] = 1;
if (fit(i, j + 1) && c[i][j + 1] != '#') dis[h][hs[i][j + 1]] = 1;
if (fit(i, j - 1) && c[i][j - 1] != '#') dis[h][hs[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++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void put_edge(int u, int 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;
int source = x + y + 2 * n * m;
int sink = source + 1;
for (int i = 0; i < x; i++) put_edge(source, i, 1);
for (int i = 0; i < x; i++) {
long long h = vec[i].first, v = vec[i].second;
for (int j = 0; j < n; j++)
for (int w = 0; w < m; w++) {
long long hh = hs[j][w];
if (dis[h][hh] == FF) continue;
long long time = v * dis[h][hh];
if (time > maxi) continue;
put_edge(i, x + hh, 1);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
long long hh = hs[i][j];
hh += x;
put_edge(hh, hh + n * m, 1);
}
for (int i = 0; i < y; i++) {
int id = x + 2 * n * m + i;
long long h = sec[i].first, v = sec[i].second;
for (int j = 0; j < n; j++)
for (int w = 0; w < m; w++) {
long long hh = hs[j][w];
if (dis[h][hh] == FF) continue;
long long temp = v * dis[h][hh];
if (temp > maxi) continue;
put_edge(x + hh + n * m, id, 1);
}
}
for (int i = 0; i < y; i++) {
int id = x + 2 * n * m + i;
put_edge(id, sink, 1);
}
}
bool bfs(int v, int des) {
fill(lvl, lvl + MAX, FF);
lvl[v] = 0;
long long 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] > lvl[v] + 1) {
lvl[u] = lvl[v] + 1;
q[t++] = u;
}
}
}
return lvl[des] != FF;
}
long long dfs(int v, int sink, long long flow = INF) {
if (flow == 0 || v == sink) return flow;
long long ret = 0;
for (; ptr[v] != -1; ptr[v] = prv[ptr[v]])
if (lvl[to[ptr[v]]] == lvl[v] + 1) {
long long xx = dfs(to[ptr[v]], sink, min(flow, cap[ptr[v]]));
cap[ptr[v]] -= xx;
cap[ptr[v] ^ 1] += xx;
flow -= xx;
ret += xx;
if (flow == 0) break;
}
return ret;
}
long long max_flow(int source, int sink) {
long long ret = 0;
while (bfs(source, sink)) {
memcpy(ptr, head, sizeof(head));
ret += dfs(source, sink);
}
return ret;
}
int main() {
cin >> n >> m >> x >> y;
if ((x + y + 1) % 2) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) hs[i][j] = hhash(i, j);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
init();
{
int a, b;
long long v;
cin >> a >> b >> v;
a--, b--;
if (x < y) {
x++;
vec.push_back({hs[a][b], v});
} else
sec.push_back({hs[a][b], v}), y++;
int i = 0;
if (vec.size()) i++;
for (; i < x; i++) {
cin >> a >> b >> v;
a--, b--;
vec.push_back({hs[a][b], v});
}
i = 0;
if (sec.size()) i++;
for (; i < y; i++) {
cin >> a >> b >> v;
a--, b--;
sec.push_back({hs[a][b], v});
}
}
long long b = 0, e = 1e12, 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) == max(x, y)) {
e = mid - 1;
ret = mid;
} else
b = mid + 1;
}
cout << ret << endl;
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 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<vector<int>> &layered_graph) {
queue<pair<int, int>> que;
vector<int> layer(n, -1);
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) {
if (layer[edge_set[e].v] == -1) {
que.push({edge_set[e].v, cur.second + 1});
layer[edge_set[e].v] = cur.second + 1;
layered_graph[cur.first].push_back(e);
} else if (layer[edge_set[e].v] == cur.second + 1) {
layered_graph[cur.first].push_back(e);
}
}
}
}
return 0;
}
bool dfs(vector<int> &path, vector<int> &cur_edge,
vector<vector<int>> &layered_graph, 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;
if (edge_set[e].w == 0) {
layered_graph[edge_set[e].u].resize(
layered_graph[edge_set[e].u].size() - 1);
}
}
return 1;
}
while (cur_edge[u] >= 0) {
swap(layered_graph[u][cur_edge[u]],
layered_graph[u][layered_graph[u].size() - 1]);
cur_edge[u]--;
int e = layered_graph[u][layered_graph[u].size() - 1];
path.push_back(e);
if (dfs(path, cur_edge, layered_graph, edge_set[e].v)) {
return 1;
}
path.pop_back();
}
return 0;
}
int max_flow() {
vector<vector<int>> layered_graph(n);
while (bfs(layered_graph)) {
vector<int> path;
vector<int> cur_edge(n);
for (int i = 0; i < n; i++) {
cur_edge[i] = layered_graph[i].size() - 1;
}
while (dfs(path, cur_edge, layered_graph, 0)) {
path.clear();
}
layered_graph.clear();
layered_graph.resize(n);
}
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 = 1e12;
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)] < 1000 &&
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)] < 1000 &&
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 == 1e12 ? -1 : lower) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, p1, p2, ay[25 * 25], ax[25 * 25], ac[25 * 25], by[25 * 25],
bx[25 * 25], bc[25 * 25], dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
int f[2000], v[1000000], o[1000000], w[1000000], p, d[2000], q[2000], fl, S, T;
long long dis[25 * 25][25 * 25];
char s[25][25];
void bd(int a, int b) {
v[++p] = b;
o[p] = f[a];
f[a] = p;
w[p] = 1;
v[++p] = a;
o[p] = f[b];
f[b] = p;
w[p] = 0;
}
int dfs(int y, int ff) {
if (y == T) {
fl += ff;
return ff;
}
int cap = ff;
for (int i = (f[y]); i; i = o[i])
if (w[i] && d[v[i]] == d[y] + 1) {
int x = dfs(v[i], min(cap, w[i]));
cap -= x;
w[i] -= x;
w[i ^ 1] += x;
if (!cap) break;
}
if (cap == ff) d[y] = -1;
return ff - cap;
}
bool bfs() {
for (int i = (0); i <= (T); i++) d[i] = -1;
d[S] = 0;
int l = 0, h = 0;
q[h++] = S;
while (l < h) {
int y = q[l++];
for (int i = (f[y]); i; i = o[i])
if (w[i] && d[v[i]] < 0) {
d[v[i]] = d[y] + 1;
q[h++] = v[i];
if (v[i] == T) return 1;
}
}
return 0;
}
bool ok(long long val) {
p = 1;
for (int i = (0); i <= (T); i++) f[i] = 0;
for (int i = (0); i < (a); i++) bd(S, i);
for (int i = (0); i < (b); i++) bd(a + i, T);
for (int i = (0); i < (n * m); i++) {
bd(a + b + i, a + b + i + n * m);
for (int j = (0); j < (a); j++)
if (dis[(ay[j] - 1) * m + ax[j] - 1][i] <= val / ac[j]) bd(j, a + b + i);
for (int j = (0); j < (b); j++)
if (dis[(by[j] - 1) * m + bx[j] - 1][i] <= val / bc[j])
bd(a + b + i + n * m, a + j);
}
fl = 0;
while (bfs())
while (dfs(S, a))
;
return fl == a;
}
int main() {
scanf("%d %d %d %d", &n, &m, &a, &b);
if (abs(a - b) != 1) {
puts("-1");
return 0;
}
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) dis[i][j] = 1000000000000LL;
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;
int e = i * m + j;
dis[e][e] = 0;
for (int k = (0); k < (4); k++) {
int ni = i + dy[k], nj = j + dx[k], ne = ni * m + nj;
if (ni < 0 || ni >= n || nj < 0 || nj >= m || s[ni][nj] == '#')
continue;
dis[e][ne] = 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) {
scanf("%d %d %d", &by[0], &bx[0], &bc[0]);
p2++;
} else {
scanf("%d %d %d", &ay[0], &ax[0], &ac[0]);
p1++;
}
for (int i = (0); i < (a); i++) {
scanf("%d %d %d", &ay[p1], &ax[p1], &ac[p1]);
p1++;
}
for (int i = (0); i < (b); i++) {
scanf("%d %d %d", &by[p2], &bx[p2], &bc[p2]);
p2++;
}
a = b = max(a, b);
S = a + b + n * m + n * m;
T = S + 1;
long long l = 0, h = 1000000000000LL;
while (l < h) {
long long m = l + h >> 1;
if (ok(m))
h = m;
else
l = m + 1;
}
if (h == 1000000000000LL)
puts("-1");
else
printf("%I64d\n", h);
}
|
#include <bits/stdc++.h>
using namespace std;
void testGen() {
freopen("biginput2.txt", "w", stdout);
int n = 14;
cout << n << " " << n << " " << n * n << " " << n * n - 1 << endl;
for (auto repeat_var = 0; repeat_var < n; ++repeat_var) {
for (auto repeat_var = 0; repeat_var < n; ++repeat_var) {
cout << ".";
}
cout << endl;
}
for (auto repeat_var = 0; repeat_var < 2 * n * n; ++repeat_var) {
cout << 1 << " " << 1 << " " << 1 << endl;
}
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 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>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const int inf = 1e9;
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 22 + 5;
const int K = 3000 + 5;
const int M = 1e6 + 7;
struct Node {
int x, y, t;
} A[K], B[K], C;
struct EDGE {
int to, nxt, cap;
} edge[M << 1];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int r, c, n, m, s, t, E, dep[K], head[K], backup[K];
long long L, R, ans, dis[N][N][N][N];
char ch[N][N];
inline void addedge(int u, int v, int cap) {
edge[++E].to = v;
edge[E].nxt = head[u];
edge[E].cap = cap;
head[u] = E;
backup[u] = head[u];
}
inline void Add(int u, int v, int w) {
addedge(u, v, w);
addedge(v, u, 0);
}
inline int HASHA(int a) { return a - 1; }
inline int HASHB(int a, int b) { return n + (a - 1) * c + b - 1; }
inline int HASHC(int a, int b) { return n + r * c + (a - 1) * c + b - 1; }
inline int HASHD(int a) { return n + 2 * r * c + a - 1; }
inline int dfs(int u, int t, int limit) {
if (!limit || u == t) return limit;
int flow = 0;
for (int &i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to, f = edge[i].cap;
if (dep[v] == dep[u] + 1 && (f = dfs(v, t, min(limit, f))) > 0) {
limit -= f;
flow += f;
edge[i ^ 1].cap += f;
edge[i].cap -= f;
if (!limit) break;
}
}
return flow;
}
inline bool BFS(int s, int t, int n) {
for (int i = 0; i <= n; i++) dep[i] = inf, head[i] = backup[i];
queue<int> q;
q.push(s);
dep[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to, w = edge[i].cap;
if (dep[v] != inf || !w) continue;
dep[v] = dep[u] + 1;
q.push(v);
}
}
return dep[t] != inf;
}
inline int Dinic(int s, int t, int n) {
int maxflow = 0;
while (BFS(s, t, n)) maxflow += dfs(s, t, inf);
return maxflow;
}
inline void build(long long NOW) {
E = 1;
memset(head, 0, sizeof(head));
s = HASHD(m) + 1, t = s + 1;
for (int i = 1; i <= n; i++) {
Add(s, HASHA(i), 1);
for (int x = 1; x <= r; x++) {
for (int y = 1; y <= c; y++) {
if (dis[A[i].x][A[i].y][x][y] < inf &&
1ll * dis[A[i].x][A[i].y][x][y] * A[i].t <= NOW) {
Add(HASHA(i), HASHB(x, y), 1);
}
}
}
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
if (ch[i][j] == '.') Add(HASHB(i, j), HASHC(i, j), 1);
}
}
for (int i = 1; i <= m; i++) {
Add(HASHD(i), t, 1);
for (int x = 1; x <= r; x++) {
for (int y = 1; y <= c; y++) {
if (dis[B[i].x][B[i].y][x][y] < inf &&
1ll * dis[B[i].x][B[i].y][x][y] * B[i].t <= NOW) {
Add(HASHC(x, y), HASHD(i), 1);
}
}
}
}
}
inline bool check(long long x) {
build(x);
return Dinic(s, t, t) == m;
}
inline void pre() {
for (int A = 1; A <= r; A++)
for (int B = 1; B <= c; B++)
for (int C = 1; C <= r; C++)
for (int D = 1; D <= c; D++) dis[A][B][C][D] = inf;
for (int x = 1; x <= r; x++) {
for (int y = 1; y <= c; y++) {
if (ch[x][y] == '#') continue;
dis[x][y][x][y] = 0;
for (int a = 0; a < 4; a++) {
int sx = x + dx[a], sy = y + dy[a];
if (sx < 1 || sx > r || sy < 1 || sy > c || ch[sx][sy] == '#') continue;
dis[x][y][sx][sy] = 1;
}
}
}
for (int kx = 1; kx <= r; kx++) {
for (int ky = 1; ky <= c; ky++) {
if (ch[kx][ky] == '#') continue;
for (int ix = 1; ix <= r; ix++) {
for (int iy = 1; iy <= c; iy++) {
if (ch[ix][iy] == '#' || dis[ix][iy][kx][ky] == inf) continue;
for (int jx = 1; jx <= r; jx++) {
for (int jy = 1; jy <= c; jy++) {
if (ch[jx][jy] == '#' || dis[kx][ky][jx][jy] == inf) continue;
dis[ix][iy][jx][jy] =
min(dis[ix][iy][jx][jy],
dis[ix][iy][kx][ky] + dis[kx][ky][jx][jy]);
}
}
}
}
}
}
}
inline void solve() {
if (n != m) return (void)puts("-1");
L = 0;
R = 1e12;
ans = 1e12;
while (L <= R) {
long long mid = (L + R) >> 1;
if (check(mid))
R = mid - 1, ans = mid;
else
L = mid + 1;
}
printf("%lld\n", ans == 1e12 ? -1 : ans);
}
signed main() {
read(r);
read(c);
read(n);
read(m);
for (int i = 1; i <= r; i++) scanf("%s", ch[i] + 1);
read(C.x);
read(C.y);
read(C.t);
for (int i = 1; i <= n; i++) read(A[i].x), read(A[i].y), read(A[i].t);
for (int i = 1; i <= m; i++) read(B[i].x), read(B[i].y), read(B[i].t);
if (n > m)
B[++m] = C;
else
A[++n] = C;
pre();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 5000;
const double INF = 1e18;
const double ep = 1e-8;
struct Edge {
int from, to;
double cap, flow;
Edge(int u, int v, double c, double f) : from(u), to(v), cap(c), flow(f) {}
};
struct Dinic {
int n, m, s, t;
vector<Edge> edges;
vector<int> G[maxn];
int d[maxn], cur[maxn];
bool vis[maxn];
void init(int n) {
for (int i = 0; i < maxn; i++) G[i].clear();
edges.clear();
}
void add(int from, int to, double cap) {
edges.push_back(Edge(from, to, cap, 0));
edges.push_back(Edge(to, from, 0, 0));
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
bool BFS() {
memset(vis, 0, sizeof(vis));
queue<int> Q;
Q.push(s);
d[s] = 0;
vis[s] = 1;
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 (!vis[e.to] && e.cap - e.flow > ep) {
vis[e.to] = 1;
d[e.to] = d[x] + 1;
Q.push(e.to);
}
}
}
return vis[t];
}
double DFS(int x, double a) {
if (x == t || a == 0) return a;
double flow = 0, f;
for (int& i = cur[x]; i < G[x].size(); i++) {
Edge& e = edges[G[x][i]];
if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
e.flow += f;
edges[G[x][i] ^ 1].flow -= f;
flow += f;
a -= f;
if (a == 0) break;
}
}
return flow;
}
double maxFlow(int s, int t) {
this->s = s;
this->t = t;
double flow = 0;
while (BFS()) {
memset(cur, 0, sizeof(cur));
flow += DFS(s, INF);
}
return flow;
}
void show() {
for (auto& e : edges) {
printf("(%d -> %d) => cap = %f , flow = %f\n", e.from, e.to, e.cap,
e.flow);
}
}
void DFS2(int v) {
vis[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge e = edges[G[v][i]];
if (!vis[e.to] && e.cap - e.flow > ep) {
DFS2(e.to);
}
}
}
void showMinCut(int v) {
DFS2(v);
for (auto& e : edges) {
if (vis[e.from] && !vis[e.to] && e.cap != 0 && e.flow != 0)
printf("(%d -> %d) => cap = %f , flow = %f\n", e.from, e.to, e.cap,
e.flow);
}
}
};
char g[25][25];
int N, M;
int male[500][3], female[500][3];
int nmale, nfemale;
int rboss, cboss, tboss;
long long dis[500][500];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool solve(long long lim) {
Dinic G;
int tot = nmale + nfemale + N * M * 2 + 3;
int s = tot - 2;
int t = tot - 1;
G.init(tot);
auto id = [&](int i, int j) { return j + (i - 1) * M; };
auto in = [&](int i, int j) { return id(i, j); };
auto out = [&](int i, int j) { return N * M + id(i, j); };
int base = N * M * 2;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
if (g[i][j] == '#') continue;
G.add(in(i, j), out(i, j), 1);
}
}
for (int x = 1; x <= nmale; ++x) {
G.add(s, x + base, 1);
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
int id1 = id(male[x][0], male[x][1]);
int id2 = id(i, j);
if (g[i][j] == '#') continue;
if (dis[id1][id2] >= INF) continue;
if (dis[id1][id2] * male[x][2] > lim) continue;
G.add(x + base, in(i, j), 1);
}
}
}
for (int x = 1; x <= nfemale; ++x) {
G.add(base + nmale + x, t, 1);
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
int id1 = id(female[x][0], female[x][1]);
int id2 = id(i, j);
if (g[i][j] == '#') continue;
if (dis[id1][id2] >= INF) continue;
if (dis[id1][id2] * female[x][2] > lim) continue;
G.add(out(i, j), base + nmale + x, 1);
}
}
}
long long ret = G.maxFlow(s, t);
return ret >= nmale;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> nmale >> nfemale;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
cin >> g[i][j];
}
}
cin >> rboss >> cboss >> tboss;
for (int i = 1; i <= nmale; ++i) {
cin >> male[i][0] >> male[i][1] >> male[i][2];
}
for (int i = 1; i <= nfemale; ++i) {
cin >> female[i][0] >> female[i][1] >> female[i][2];
}
if (abs(nmale - nfemale) != 1) {
cout << -1 << endl;
return 0;
}
if (nmale > nfemale) {
++nfemale;
female[nfemale][0] = rboss;
female[nfemale][1] = cboss;
female[nfemale][2] = tboss;
} else {
++nmale;
male[nmale][0] = rboss;
male[nmale][1] = cboss;
male[nmale][2] = tboss;
}
auto id = [&](int i, int j) { return j + (i - 1) * M; };
for (int i = 1; i <= N * M; ++i) {
for (int j = 1; j <= N * M; ++j) {
dis[i][j] = INF;
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
if (g[i][j] == '#') continue;
dis[id(i, j)][id(i, j)] = 0;
for (int x = 0; x < 4; ++x) {
int di = i + dir[x][0];
int dj = j + dir[x][1];
if (di < 1 || di > N || dj < 1 || dj > M) continue;
if (g[di][dj] == '#') continue;
dis[id(i, j)][id(di, dj)] = 1;
}
}
}
for (int k = 1; k <= N * M; ++k) {
for (int i = 1; i <= N * M; ++i) {
for (int j = 1; j <= N * M; ++j) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
long long ret = -1, l = 0, r = 1e14;
while (l <= r) {
long long mid = (l + r) >> 1;
if (solve(mid)) {
ret = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ret << endl;
}
|
#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 push_relabel {
int n, m;
vector<edge> edge_set;
vector<vector<int>> graph;
vector<int> excess, height;
push_relabel() {}
push_relabel(int n) {
this->n = n;
this->m = 0;
graph.resize(n);
excess.resize(n);
height.resize(n);
}
void add_directed_edge(int u, int v, int w) {
edge_set.push_back(edge(u, v, w));
graph[u].push_back(m);
m++;
edge_set.push_back(edge(v, u, 0));
graph[v].push_back(m);
m++;
}
int exist_excess() {
for (int i = 1; i < n - 1; i++) {
if (excess[i] > 0) {
return i;
}
}
return 0;
}
int max_flow() {
height[0] = n;
for (int e : graph[0]) {
excess[edge_set[e].v] = edge_set[e ^ 1].w = edge_set[e].w;
edge_set[e].w = 0;
}
int v;
while (v = exist_excess()) {
bool find_out = 0;
for (int e : graph[v]) {
if (edge_set[e].w > 0 && height[edge_set[e].v] < height[v]) {
int bottleneck = min(excess[v], edge_set[e].w);
edge_set[e].w -= bottleneck;
edge_set[e ^ 1].w += bottleneck;
excess[v] -= bottleneck;
excess[edge_set[e].v] += bottleneck;
find_out = 1;
break;
}
}
if (!find_out) {
height[v]++;
}
}
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;
push_relabel 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 long long INF = LLONG_MAX / 2;
const int N = 30;
const int M = 30;
const int A = N * M;
const int B = N * M;
const int S = N * M;
const int V = A + B + S * 2;
const int E = (A + B + A * S + B * S + S) << 1;
int n, m, a, b, xb, yb, vb, mx, size;
int pos[A + B][2], v[A + B];
long long dis[N][M][N][M];
char pic[N][M];
long long ans;
struct network {
int tov[E], next[E], f[E], v[E], r[E];
int lab[V], last[V];
queue<int> q;
int s, t, tot;
void insert(int x, int y, int full, int rev) {
tov[++tot] = y, f[tot] = full, r[tot] = tot + rev, next[tot] = last[x],
last[x] = tot;
}
void addedge(int x, int y, int full) {
insert(x, y, full, 1), insert(y, x, 0, -1);
}
bool relabel() {
for (int i = s; i <= t; i++) lab[i] = 0;
for (lab[s] = 1, q.push(s); !q.empty();) {
int x = q.front();
q.pop();
for (int i = last[x], y; i; i = next[i])
if (!lab[y = tov[i]] && f[i] - v[i]) lab[y] = lab[x] + 1, q.push(y);
}
return lab[t];
}
int aug(int x, int flow) {
if (x == t) return flow;
int ret = 0;
for (int i = last[x], y; i; i = next[i])
if (lab[y = tov[i]] == lab[x] + 1 && f[i] - v[i]) {
int tmp = aug(y, min(flow, f[i] - v[i]));
if (tmp) {
ret += tmp, flow -= tmp;
v[i] += tmp, v[r[i]] -= tmp;
if (!flow) break;
} else
lab[y] = 0;
}
return ret;
}
int maxflow() {
int ret = 0, tmp;
while (relabel()) {
do {
ret += tmp = aug(s, INT_MAX);
} while (tmp);
}
return ret;
}
void rebuild(long long lim, bool sex) {
memset(last, 0, sizeof last), memset(next, 0, sizeof next),
memset(f, 0, sizeof f), memset(v, 0, sizeof v), tot = 0;
s = 0, t = a + b + size * 2 + 2;
for (int i = 1; i <= a; i++) addedge(s, i, 1);
if (sex) addedge(s, a + 1, 1);
for (int i = 1; i <= b; i++) addedge(i + a + sex + size * 2, t, 1);
if (!sex) addedge(a + sex + b + size * 2 + 1, t, 1);
for (int i = 1; i <= size; i++) {
int x = (i - 1) / m + 1, y = (i - 1) % m + 1;
for (int j = 1; j <= a; j++)
if (dis[pos[j][0]][pos[j][1]][x][y] != INF &&
dis[pos[j][0]][pos[j][1]][x][y] * ::v[j] <= lim)
addedge(j, a + sex + i * 2 - 1, 1);
if (sex && dis[xb][yb][x][y] != INF && dis[xb][yb][x][y] * vb <= lim)
addedge(a + 1, a + sex + i * 2 - 1, 1);
addedge(a + sex + i * 2 - 1, a + sex + i * 2, 1);
for (int j = 1; j <= b; j++)
if (dis[pos[j + a][0]][pos[j + a][1]][x][y] != INF &&
dis[pos[j + a][0]][pos[j + a][1]][x][y] * ::v[j + a] <= lim)
addedge(a + sex + i * 2, a + sex + size * 2 + j, 1);
if (!sex && dis[xb][yb][x][y] != INF && dis[xb][yb][x][y] * vb <= lim)
addedge(a + sex + i * 2, a + sex + b + 1 + size * 2, 1);
}
}
bool check(int aim) { return maxflow() == aim; }
} net;
queue<pair<int, int> > que;
int di[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
void pre() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) dis[i + 1][j + 1][x + 1][y + 1] = INF;
mx = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (pic[i][j] == '.') {
for (dis[i + 1][j + 1][i + 1][j + 1] = 0, que.push(make_pair(i, j));
!que.empty();) {
pair<int, int> now = que.front();
que.pop(),
mx = max(mx,
(int)dis[i + 1][j + 1][now.first + 1][now.second + 1]);
for (int d = 0, x, y; d < 4; d++) {
x = now.first + di[d][0], y = now.second + di[d][1];
if (0 <= x && x < n && 0 <= y && y < m && pic[x][y] == '.' &&
dis[i + 1][j + 1][x + 1][y + 1] == INF)
dis[i + 1][j + 1][x + 1][y + 1] =
dis[i + 1][j + 1][now.first + 1][now.second + 1] + 1,
que.push(make_pair(x, y));
}
}
}
}
bool check(long long lim) {
if (a > b)
return net.rebuild(lim, 0), net.check(a);
else
return net.rebuild(lim, 1), net.check(b);
}
void binary_search() {
pre(), ans = -1;
if (min(a, b) + 1 != max(a, b)) return;
long long l = 0, r = 1ll * mx * 1000000000, mid;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &a, &b);
for (int i = 0; i < n; i++) scanf("%s", pic[i]);
size = n * m;
scanf("%d%d%d", &xb, &yb, &vb);
for (int i = 1; i <= a; i++) scanf("%d%d%d", &pos[i][0], &pos[i][1], &v[i]);
for (int i = 1; i <= b; i++)
scanf("%d%d%d", &pos[i + a][0], &pos[i + a][1], &v[i + a]);
binary_search();
printf("%I64d\n", ans);
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[1000000], liu[1000000], ne[1000000], 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>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
long long rll() {
long long x;
scanf("%lld", &x);
return x;
}
char s[25][25];
pair<int, int> FE[500], MA[500];
long long TFE[500], TMA[500];
long long MAS_FE[500][25][25];
long long MAS_MA[500][25][25];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int f[1050][1050];
int c[1050][1050];
int TA, TB, TC, TD, TE;
bool mark[1050];
int go(int v) {
if (v == TE + 1) return 1;
if (mark[v]) return 0;
mark[v] = true;
for (int i = 0; i <= TE + 1; i++)
if (c[v][i] - f[v][i] > 0) {
if (go(i)) {
f[v][i]++;
f[i][v]--;
return 1;
}
}
return 0;
}
int check() {
memset(mark, 0, sizeof(mark));
int res = 0;
while (go(0)) {
res++;
memset(mark, 0, sizeof(mark));
}
return res;
}
void solve() {
int n = ri(), m = ri(), ma = ri(), fe = ri();
if (abs(ma - fe) > 1 || ma == fe) {
cout << -1 << endl;
return;
}
for (int i = (int)(1); i <= (int)(n); i++) scanf("%s", s[i] + 1);
cin >> FE[0].first >> FE[0].second >> TFE[0];
MA[0] = FE[0], TMA[0] = TFE[0];
for (int i = (int)(1); i <= (int)(ma); i++)
cin >> MA[i].first >> MA[i].second >> TMA[i];
for (int i = (int)(1); i <= (int)(fe); i++)
cin >> FE[i].first >> FE[i].second >> TFE[i];
if (ma + 1 == fe)
MA[++ma] = MA[0], TMA[ma] = TMA[0];
else
FE[++fe] = FE[0], TFE[fe] = TFE[0];
for (int t = (int)(1); t <= (int)(ma); t++) {
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++) MAS_MA[t][i][j] = -1;
MAS_MA[t][MA[t].first][MA[t].second] = 0;
queue<pair<int, int> > st;
st.push(MA[t]);
while (!st.empty()) {
for (int j = 0, maxsz = st.size(); j < maxsz; j++) {
int x = st.front().first;
int y = st.front().second;
st.pop();
for (int k = (int)(0); k <= (int)(3); k++) {
int xx = x + dx[k], yy = y + dy[k];
if (xx > 0 && xx <= n && yy > 0 && yy <= m &&
MAS_MA[t][xx][yy] == -1 && s[xx][yy] != '#') {
MAS_MA[t][xx][yy] = MAS_MA[t][x][y] + TMA[t];
st.push(make_pair(xx, yy));
}
}
}
}
}
for (int t = (int)(1); t <= (int)(fe); t++) {
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++) MAS_FE[t][i][j] = -1;
MAS_FE[t][FE[t].first][FE[t].second] = 0;
queue<pair<int, int> > st;
st.push(FE[t]);
while (!st.empty()) {
for (int j = 0, maxsz = st.size(); j < maxsz; j++) {
int x = st.front().first;
int y = st.front().second;
st.pop();
for (int k = (int)(0); k <= (int)(3); k++) {
int xx = x + dx[k], yy = y + dy[k];
if (xx > 0 && xx <= n && yy > 0 && yy <= m &&
MAS_FE[t][xx][yy] == -1 && s[xx][yy] != '#') {
MAS_FE[t][xx][yy] = MAS_FE[t][x][y] + TFE[t];
st.push(make_pair(xx, yy));
}
}
}
}
}
long long l = -1, r = 1e18;
TA = ma;
TB = TA + n * m;
TC = TB + n * m;
TD = TC + fe;
TE = TD + fe;
while (l + 1 < r) {
long long mid = (l + r) >> 1;
memset(c, 0, sizeof(c));
memset(f, 0, sizeof(f));
for (int i = (int)(1); i <= (int)(ma); i++) c[0][i] = 1;
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++)
c[TA + (i - 1) * m + j][TB + (i - 1) * m + j] = 1;
for (int i = (int)(TC + 1); i <= (int)(TD); i++) c[i][i + fe] = 1;
for (int i = (int)(TD + 1); i <= (int)(TE); i++) c[i][TE + 1] = 1;
for (int i = (int)(1); i <= (int)(ma); i++)
for (int k = (int)(1); k <= (int)(n); k++)
for (int t = (int)(1); t <= (int)(m); t++) {
if (MAS_MA[i][k][t] != -1 && MAS_MA[i][k][t] <= mid) {
c[i][TA + (k - 1) * m + t] = 1;
}
}
for (int i = (int)(1); i <= (int)(fe); i++)
for (int k = (int)(1); k <= (int)(n); k++)
for (int t = (int)(1); t <= (int)(m); t++) {
if (MAS_FE[i][k][t] != -1 && MAS_FE[i][k][t] <= mid) {
c[TB + (k - 1) * m + t][TC + i] = 1;
}
}
int yes = check();
if (yes == ma)
r = mid;
else
l = mid;
}
if (r == 1000000000000000000LL) r = -1;
cout << r << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int maxn = 25;
const int INF = int(1e9) + 7;
int n, m, male, female;
char Map[maxn][maxn];
struct Node {
int x, y;
int speed;
long long dis[maxn][maxn];
bool used[maxn][maxn];
queue<int> quex, quey;
void read() {
scanf("%d%d%d", &x, &y, &speed);
return;
}
void pre_bfs() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dis[i][j] = INF, used[i][j] = false;
while (quex.size()) quex.pop();
while (quey.size()) quey.pop();
dis[x][y] = 0;
used[x][y] = true;
quex.push(x), quey.push(y);
while (quex.size()) {
int a = quex.front(), b = quey.front();
quex.pop(), quey.pop();
used[a][b] = false;
for (int k = 0; k < 4; k++) {
int nx = a + dir[k][0], ny = b + dir[k][1];
if (Map[nx][ny] == '#') continue;
if (nx < 1 || ny < 1 || nx > n || ny > m ||
dis[nx][ny] <= dis[a][b] + 1)
continue;
dis[nx][ny] = dis[a][b] + 1;
if (!used[nx][ny]) {
used[nx][ny] = true;
quex.push(nx), quey.push(ny);
}
}
}
return;
}
} node1[maxn * maxn], node2[maxn * maxn];
void read() {
scanf("%d%d%d%d", &n, &m, &male, &female);
for (int i = 1; i <= n; i++) scanf("%s", Map[i] + 1);
Node boss;
boss.read();
for (int i = 1; i <= male; i++) node1[i].read();
for (int i = 1; i <= female; i++) node2[i].read();
if (male - female == 1)
node2[++female] = boss;
else if (female - male == 1)
node1[++male] = boss;
else {
printf("-1\n");
exit(0);
}
return;
}
void init() {
for (int i = 1; i <= male; i++) node1[i].pre_bfs();
for (int i = 1; i <= female; i++) node2[i].pre_bfs();
return;
}
const int maxd = int(1e4) + 7;
const int maxe = int(1e6) + 7;
int tot = 0;
int head[maxd];
int S, T;
struct Edge {
int from, to, cap, next;
Edge() {}
Edge(int x, int y, int c, int nx) : from(x), to(y), cap(c), next(nx) {}
} eage[maxe * 2];
void add(int x, int y, int c) {
eage[tot] = Edge(x, y, c, head[x]), head[x] = tot++;
eage[tot] = Edge(y, x, 0, head[y]), head[y] = tot++;
return;
}
int dis[maxd];
bool used[maxd];
queue<int> que;
bool bfs() {
for (int i = S; i <= T; i++) dis[i] = INF, used[i] = false;
while (que.size()) que.pop();
que.push(S);
used[S] = true;
dis[S] = 0;
while (que.size()) {
int u = que.front();
que.pop();
used[u] = false;
for (int i = head[u]; ~i; i = eage[i].next)
if (dis[eage[i].to] > dis[u] + 1 && eage[i].cap) {
int v = eage[i].to;
dis[v] = dis[u] + 1;
if (!used[v]) {
used[v] = true;
que.push(v);
}
}
}
return (dis[T] < INF);
}
int dfs(int u, int flow) {
if (u == T || !flow) return flow;
int ret = 0;
for (int i = head[u]; ~i; i = eage[i].next)
if (eage[i].cap && dis[eage[i].to] == dis[u] + 1) {
int v = eage[i].to;
int newf = dfs(v, min(flow, eage[i].cap));
eage[i].cap -= newf;
eage[i ^ 1].cap += newf;
ret += newf;
flow -= newf;
if (!flow) break;
}
if (!ret) dis[u] = -1;
return ret;
}
int dinic() {
int res = 0;
while (bfs()) res += dfs(S, INF);
return res;
}
void build(long long val) {
S = 1, T = ((((S + male) + female) + (n - 1) * m + m) + (n - 1) * m + m) + 1;
for (int i = S; i <= T; i++) head[i] = -1;
tot = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
add((((S + male) + female) + (i - 1) * m + j),
((((S + male) + female) + (n - 1) * m + m) + (i - 1) * m + j), 1);
for (int i = 1; i <= male; i++) {
add(S, (S + i), 1);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (node1[i].dis[x][y] != INF &&
node1[i].dis[x][y] * node1[i].speed <= val)
add((S + i), (((S + male) + female) + (x - 1) * m + y), 1);
}
for (int i = 1; i <= female; i++) {
add(((S + male) + i), T, 1);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (node2[i].dis[x][y] != INF &&
node2[i].dis[x][y] * node2[i].speed <= val)
add(((((S + male) + female) + (n - 1) * m + m) + (x - 1) * m + y),
((S + male) + i), 1);
}
return;
}
bool check(long long val) {
build(val);
return (dinic() == male);
}
int main() {
read();
init();
long long l = 0, r = (1ll << 40), res = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, res = mid;
else
l = mid + 1;
}
printf("%I64d\n", res == INF ? -1 : res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long INFTIME = 90000ll * 1000 * 1000 * 10;
const int MAXN = 25;
const int MAXV = MAXN * MAXN * 5;
const int MAXE = MAXV * MAXV * 2;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
struct per {
int x, y;
long long t;
int v;
per(int _x, int _y, int _t, int _v) { x = _x, y = _y, t = _t, v = _v; }
};
int n, m;
pair<int, int> q[MAXN * MAXN];
int q2[MAXV];
int dist[MAXN][MAXN][MAXN][MAXN];
int dis[MAXV], ptr[MAXV];
vector<per> v[2];
int to[MAXE], nex[MAXE], cap[MAXE], head[MAXV];
char t[MAXN][MAXN];
int ecnt = 0, vers = 0;
inline void addEdge(int x, int y, int c) {
to[ecnt] = y;
nex[ecnt] = head[x];
head[x] = ecnt;
cap[ecnt] = c;
ecnt++;
to[ecnt] = x;
nex[ecnt] = head[y];
head[y] = ecnt;
cap[ecnt] = 0;
ecnt++;
}
inline bool valid(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && t[x][y] != '#';
}
inline void bfs(int x, int y) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dist[x][y][i][j] = INF;
dist[x][y][x][y] = 0;
int l = 0, r = 0;
q[r++] = pair<int, int>(x, y);
while (l < r) {
int curx = q[l].first;
int cury = q[l].second;
l++;
for (int dir = 0; dir < 4; dir++) {
int nx = curx + dx[dir];
int ny = cury + dy[dir];
if (valid(nx, ny) && dist[x][y][nx][ny] > dist[x][y][curx][cury] + 1) {
dist[x][y][nx][ny] = dist[x][y][curx][cury] + 1;
q[r++] = pair<int, int>(nx, ny);
}
}
}
}
inline bool bfs2(int s, int t) {
for (int i = 0; i < vers; i++) dis[i] = INF;
dis[s] = 0;
int l = 0, r = 0;
q2[r++] = s;
while (l < r) {
int v = q2[l];
l++;
for (int i = head[v]; i != -1; i = nex[i])
if (cap[i ^ 1] > 0) {
int u = to[i];
if (dis[u] > dis[v] + 1) {
dis[u] = dis[v] + 1;
q2[r++] = u;
}
}
}
return dis[t] != INF;
}
inline int dinic(int v, int t, int c) {
if (v == t) return c;
int ans = 0;
for (; ptr[v] != -1; ptr[v] = nex[ptr[v]]) {
if (cap[ptr[v]] > 0) {
int u = to[ptr[v]];
if (dis[u] + 1 == dis[v]) {
int x = dinic(u, t, min(c, cap[ptr[v]]));
cap[ptr[v]] -= x;
cap[ptr[v] ^ 1] += x;
ans += x;
c -= x;
if (c == 0) break;
}
}
}
return ans;
}
inline int maxFlow(int source, int sink) {
int x;
int ans = 0;
while (bfs2(sink, source)) {
for (int i = 0; i < vers; i++) ptr[i] = head[i];
ans += dinic(source, sink, INF);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int a, b;
cin >> n >> m >> a >> b;
if (a - b != 1 && a - b != -1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> t[i][j];
int x0, y0, t0;
cin >> x0 >> y0 >> t0;
x0--, y0--;
int source = vers++, sink = vers++;
if (a < b) {
v[0].push_back(per(x0, y0, t0, vers));
vers++;
} else {
v[1].push_back(per(x0, y0, t0, vers));
vers++;
}
for (int i = 0; i < a; i++) {
cin >> x0 >> y0 >> t0;
x0--, y0--;
v[0].push_back(per(x0, y0, t0, vers));
vers++;
}
for (int i = 0; i < b; i++) {
cin >> x0 >> y0 >> t0;
x0--, y0--;
v[1].push_back(per(x0, y0, t0, vers));
vers++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) bfs(i, j);
long long lo = -1, hi = INFTIME;
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
int rvers = vers;
memset(head, -1, sizeof head);
ecnt = 0;
for (int i = 0; i < v[0].size(); i++) addEdge(source, v[0][i].v, 1);
for (int i = 0; i < v[1].size(); i++) addEdge(v[1][i].v, sink, 1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (t[i][j] != '#') {
for (int p = 0; p < v[0].size(); p++)
if (dist[i][j][v[0][p].x][v[0][p].y] != INF &&
dist[i][j][v[0][p].x][v[0][p].y] * v[0][p].t <= mid)
addEdge(v[0][p].v, vers, 1);
addEdge(vers, vers + 1, 1);
vers++;
for (int p = 0; p < v[1].size(); p++)
if (dist[i][j][v[1][p].x][v[1][p].y] != INF &&
dist[i][j][v[1][p].x][v[1][p].y] * v[1][p].t <= mid)
addEdge(vers, v[1][p].v, 1);
vers++;
}
if (maxFlow(source, sink) == v[0].size())
hi = mid;
else
lo = mid;
vers = rvers;
}
if (hi != INFTIME)
cout << hi << endl;
else
cout << -1 << endl;
}
|
#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<vector<int>> &layered_graph) {
queue<pair<int, int>> que;
vector<int> layer(n, -1);
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) {
if (layer[edge_set[e].v] == -1) {
que.push({edge_set[e].v, cur.second + 1});
layer[edge_set[e].v] = cur.second + 1;
layered_graph[cur.first].push_back(e);
} else if (layer[edge_set[e].v] == cur.second + 1) {
layered_graph[cur.first].push_back(e);
}
}
}
}
return 0;
}
bool dfs(vector<int> &path, vector<int> &cur_edge,
vector<vector<int>> &layered_graph, 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;
if (edge_set[e].w == 0) {
layered_graph[edge_set[e].u].resize(
layered_graph[edge_set[e].u].size() - 1);
}
}
return 1;
}
while (cur_edge[u] >= 0) {
swap(layered_graph[u][cur_edge[u]],
layered_graph[u][layered_graph[u].size() - 1]);
cur_edge[u]--;
int e = layered_graph[u][layered_graph[u].size() - 1];
if (edge_set[e].w > 0) {
path.push_back(e);
if (dfs(path, cur_edge, layered_graph, edge_set[e].v)) {
return 1;
}
path.pop_back();
}
}
return 0;
}
int max_flow() {
vector<vector<int>> layered_graph(n);
while (bfs(layered_graph)) {
vector<int> path;
vector<int> cur_edge(n);
for (int i = 0; i < n; i++) {
cur_edge[i] = layered_graph[i].size() - 1;
}
while (dfs(path, cur_edge, layered_graph, 0)) {
path.clear();
}
layered_graph.clear();
layered_graph.resize(n);
}
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 N = 405;
const int K = 55;
const int mod = 1000000007;
const int inf = 1000000000;
const long long INF = 1000000000000LL;
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>
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 = 1000000000000L;
const int N = 605;
const int M = N * N * 10;
struct Edge {
long long to, cap, cost, nex;
Edge() {}
Edge(long long to, long long cap, long long cost, long long next)
: to(to), cap(cap), cost(cost), nex(next) {}
} edge[M << 1];
long long head[N], edgenum;
long long D[N], A[N], P[N];
bool inq[N];
void add(long long from, long long to, long long cap, long long cost) {
edge[edgenum] = Edge(to, cap, cost, head[from]);
head[from] = edgenum++;
edge[edgenum] = Edge(from, 0, -cost, head[to]);
head[to] = edgenum++;
}
bool spfa(long long s, long long t, long long &flow, long long &cost) {
for (long long i = 0; i <= t; i++) D[i] = inf;
memset(inq, 0, sizeof inq);
queue<long long> q;
q.push(s);
D[s] = 0;
A[s] = inf;
while (!q.empty()) {
long long u = q.front();
q.pop();
inq[u] = 0;
for (long long i = head[u]; ~i; i = edge[i].nex) {
Edge &e = edge[i];
if (e.cap && D[e.to] > D[u] + e.cost) {
D[e.to] = D[u] + e.cost;
P[e.to] = i;
A[e.to] = min(A[u], e.cap);
if (!inq[e.to]) {
inq[e.to] = 1;
q.push(e.to);
}
}
}
}
if (D[t] == inf) return false;
cost += D[t] * A[t];
flow += A[t];
long long u = t;
while (u != s) {
edge[P[u]].cap -= A[t];
edge[P[u] ^ 1].cap += A[t];
u = edge[P[u] ^ 1].to;
}
return true;
}
long long Mincost(long long s, long long t) {
long long flow = 0, cost = 0;
while (spfa(s, t, flow, cost))
;
return flow;
}
void init() {
memset(head, -1, sizeof head);
edgenum = 0;
}
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[13][13];
long long Dis[13][13][13][13];
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;
init();
for (int i = 1; i <= a; i++) {
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)
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] == '.') add(has2(i, j), has3(i, j), 1, 0);
for (int i = 1; i <= b; i++) {
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)
add(has3(x, y), has4(i), 1, 0);
}
return Mincost(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 long long oo = 1LL << 60;
const double EPS = 1e-9;
const long long MAXN = (long long)1e5 + 10;
bool dbg = false;
template <typename F>
struct dinic {
struct edge {
int src, dst, rev;
F flow, cap;
};
int n;
vector<vector<edge>> adj;
dinic(int n) : n(n), adj(n), it(n), level(n) {}
void add_edge(int u, int v, F cuv, F cvu = 0) {
adj[u].push_back({u, v, (int)adj[v].size(), 0, cuv});
if (u == v) adj[u].back().rev++;
adj[v].push_back({v, u, (int)adj[u].size() - 1, 0, cvu});
}
vector<decltype(adj.front().begin())> it;
vector<int> level;
bool bfs(int s, int t) {
fill(level.begin(), level.end(), -1);
queue<int> q;
for (q.push(t), level[t] = 0; !q.empty(); q.pop()) {
t = q.front();
for (edge &e : adj[t]) {
edge &ee = adj[e.dst][e.rev];
if (ee.flow < ee.cap && level[e.dst] == -1)
level[e.dst] = 1 + level[t], q.push(e.dst);
}
}
return level[s] >= 0;
}
F dfs(int s, int t, F f) {
if (s == t) return f;
for (; it[s] != adj[s].end(); ++it[s]) {
edge &e = *it[s];
if (level[s] == 1 + level[e.dst] && e.flow < e.cap) {
F delta = dfs(e.dst, t, min(f, e.cap - e.flow));
if (delta > 0) {
e.flow += delta;
adj[e.dst][e.rev].flow -= delta;
return delta;
}
}
}
return 0;
}
const F oo = numeric_limits<F>::max();
F max_flow(int s, int t) {
for (int u = 0; u < n; ++u)
for (edge &e : adj[u]) e.flow = 0;
F flow = 0;
while (bfs(s, t)) {
for (int u = 0; u < n; ++u) it[u] = adj[u].begin();
for (F f; (f = dfs(s, t, oo));) flow += f;
}
return flow;
}
};
struct scayger {
long long x, y, v;
};
long long n, m, males, females;
char Map[30][30];
long long ID[2][30][30];
long long Dist[30][30][30][30];
long long dx[4] = {0, 0, -1, 1};
long long dy[4] = {1, -1, 0, 0};
bool valid(long long x, long long y) {
return 0 <= x && x < n && 0 <= y && y < m && Map[x][y] != '#';
}
void bfs(long long x, long long y) {
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) Dist[x][y][i][j] = oo;
Dist[x][y][x][y] = 0;
queue<pair<long long, long long>> Q;
Q.push(make_pair(x, y));
while (!Q.empty()) {
pair<long long, long long> cur = Q.front();
Q.pop();
long long dst = Dist[x][y][cur.first][cur.second];
for (int i = 0; i < 4; ++i) {
long long nx = cur.first + dx[i], ny = cur.second + dy[i];
if (valid(nx, ny) && Dist[x][y][nx][ny] > dst + 1) {
Dist[x][y][nx][ny] = dst + 1;
Q.push(make_pair(nx, ny));
}
}
}
}
bool myvalid(long long v) { return v != oo; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> males >> females;
for (long long i = 0; i < n; ++i) {
cin >> Map[i];
}
if (abs(males - females) != 1) {
cout << -1 << endl;
return 0;
}
long long vmax = 0;
vector<scayger> vm, vf;
scayger SB;
cin >> SB.x >> SB.y >> SB.v;
SB.x--;
SB.y--;
vmax = SB.v;
if (males < females)
vm.push_back(SB);
else
vf.push_back(SB);
for (long long i = 0; i < males; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vm.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < females; ++i) {
scayger cur;
cin >> cur.x >> cur.y >> cur.v;
cur.x--;
cur.y--;
vf.push_back(cur);
vmax = max(vmax, cur.v);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (Map[i][j] != '#') bfs(i, j);
}
}
long long lo = 0, hi = m * n * vmax + 1;
long long top = hi;
for (long long i = 0, cnt = 2 + 2 * (long long)((vm).size()); i < n; ++i)
for (long long j = 0; j < m; ++j)
for (long long k = 0; k < 2; ++k) ID[k][i][j] = cnt++;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
dbg = false;
dinic<long long> flow(2 + 2 * (long long)((vm).size()) + 2 * n * m);
for (long long i = 0; i < (long long)((vm).size()); ++i) {
flow.add_edge(0, i + 2, 1);
flow.add_edge(i + 2 + (long long)((vm).size()), 1, 1);
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
flow.add_edge(ID[0][i][j], ID[1][i][j], 1);
}
}
for (long long i = 0; i < (long long)((vm).size()); ++i) {
scayger cur1 = vm[i];
scayger cur2 = vf[i];
for (long long j = 0; j < n; ++j) {
for (long long k = 0; k < m; ++k) {
if (Map[j][k] == '#') continue;
if (dbg && !i)
cout << "ID " << j << " " << k << " "
<< 2 + 2 * (long long)((vm).size()) + j * m + k << endl;
if (myvalid(Dist[cur1.x][cur1.y][j][k]) &&
Dist[cur1.x][cur1.y][j][k] * cur1.v <= mid)
flow.add_edge(i + 2, ID[0][j][k], 1);
if (myvalid(Dist[cur2.x][cur2.y][j][k]) &&
Dist[cur2.x][cur2.y][j][k] * cur2.v <= mid)
flow.add_edge(ID[1][j][k], 2 + (long long)((vm).size()) + i, 1);
}
}
}
long long value = flow.max_flow(0, 1);
if (value == (long long)((vm).size()))
hi = mid;
else
lo = mid + 1;
}
if (hi == top)
cout << -1 << endl;
else
cout << hi << endl;
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;
long long lf = -1, rg = INF;
while (rg - lf > 1) {
long long mid = (lf + rg) / 2;
if (can(mid))
rg = mid;
else
lf = mid;
}
if (rg > INF / 2) rg = -1;
cout << rg << endl;
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const long long INF = 1000000000000000ll;
const long long maxN = 2000;
long long N, SRC, DST;
vector<long long> adj[maxN];
long long residual[maxN][maxN];
long long dx[] = {-1, 0, 0, 1};
long long dy[] = {0, -1, 1, 0};
struct scayger {
long long x, y, t;
vector<vector<long long>> distTo;
void bfs(vector<string> &area) {
distTo = vector<vector<long long>>(
int((area).size()), vector<long long>(int((area[0]).size()), INF));
queue<long long> q;
distTo[x][y] = 0;
q.push(x);
q.push(y);
while (int((q).size())) {
long long cx = q.front();
q.pop();
long long cy = q.front();
q.pop();
for (int k = (0); k < (4); k++) {
long long nx = cx + dx[k], ny = cy + dy[k];
if (area[nx][ny] == '#' || distTo[nx][ny] < INF) continue;
distTo[nx][ny] = distTo[cx][cy] + t;
q.push(nx);
q.push(ny);
}
}
}
};
void reset(long long n, long long s, long long t) {
N = n, SRC = s, DST = t;
for (int i = (0); i < (N); i++) adj[i].clear();
for (int i = (0); i < (N); i++)
for (int j = (0); j < (N); j++) residual[i][j] = 0;
}
void add_edge(long long a, long long b, long long c) {
adj[a].push_back(b);
adj[b].push_back(a);
residual[a][b] += c;
}
bool mark[maxN];
long long dfs(long long n, long long cap, long long delta) {
if (n == DST) return cap;
mark[n] = true;
for (const long long &to : adj[n]) {
if (mark[to] || residual[n][to] < delta) continue;
if (long long c = dfs(to, min(cap, residual[n][to]), delta)) {
residual[n][to] -= c;
residual[to][n] += c;
return c;
}
}
return 0;
}
long long maxflow() {
long long flow = 0, delta = 1;
while (delta) {
fill_n(mark, N, 0);
long long c = dfs(SRC, INF, delta);
if (c)
flow += c;
else
delta /= 2;
}
return flow;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m, males, females;
cin >> n >> m >> males >> females;
if (abs(males - females) != 1) {
cout << -1 << endl;
return 0;
}
vector<string> area(n + 2, string(m + 2, '#'));
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) cin >> area[i][j];
vector<scayger> scay[2];
long long boss = males > females;
{
scayger s;
cin >> s.x >> s.y >> s.t;
scay[boss].push_back(s);
}
for (int k = (0); k < (males); k++) {
scayger s;
cin >> s.x >> s.y >> s.t;
scay[0].push_back(s);
}
for (int k = (0); k < (females); k++) {
scayger s;
cin >> s.x >> s.y >> s.t;
scay[1].push_back(s);
}
long long k = max(males, females);
assert(k == int((scay[0]).size()));
assert(k == int((scay[1]).size()));
for (int h = (0); h < (2); h++)
for (int i = (0); i < (k); i++) {
scay[h][i].bfs(area);
}
long long tmin = -1, tmax = 100000000000000ll;
while (tmax - tmin > 1) {
long long t = (tmin + tmax + 1) / 2;
long long h = 2 * (k + n * m);
reset(h + 2, h, h + 1);
for (int i = (0); i < (k); i++) {
add_edge(h, i, 1);
add_edge(k + i, h + 1, 1);
}
for (int i = (0); i < (k); i++) {
auto &s = scay[0][i];
for (int x = (1); x < (n + 1); x++)
for (int y = (1); y < (m + 1); y++) {
if (s.distTo[x][y] <= t) add_edge(i, 2 * k + (x - 1) * m + y - 1, 1);
}
}
for (int i = (0); i < (n * m); i++)
add_edge(2 * k + i, 2 * k + n * m + i, 1);
for (int i = (0); i < (k); i++) {
auto &s = scay[1][i];
for (int x = (1); x < (n + 1); x++)
for (int y = (1); y < (m + 1); y++) {
if (s.distTo[x][y] <= t)
add_edge(2 * k + n * m + (x - 1) * m + y - 1, k + i, 1);
}
}
if (maxflow() == k)
tmax = t;
else
tmin = t;
}
if (tmax >= 100000000000000ll)
cout << -1 << endl;
else
cout << tmax << endl;
}
|
#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_male[MAXN][MAXN];
long long times_female[MAXN][MAXN];
int nodes_to_visit[MAX_GRAPH_N];
struct scayger {
int r, c, t;
};
struct edge {
long long time;
int from, to, capacity, flow;
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 other(int v) {
if (v == from) return to;
if (v == to) return from;
}
int cap_left_to(int v) {
if (v == from) return flow;
if (v == to) return capacity - flow;
}
int add_flow_to(int v, int delta) {
if (v == from) flow -= delta;
if (v == to) flow += delta;
}
};
void bfs(int xm, int ym, int tm, int xf, int yf, int tf, long long time, int n,
int m) {
times_male[xm][ym] = time;
times_female[xf][yf] = time;
bool changed = true;
while (changed) {
changed = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (field[i][j]) {
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 && field[nx][ny]) {
if (times_male[i][j] + tm < times_male[nx][ny]) {
times_male[nx][ny] = times_male[i][j] + tm;
changed = true;
}
if (times_female[i][j] + tf < times_female[nx][ny]) {
times_female[nx][ny] = times_female[i][j] + tf;
changed = true;
}
}
}
}
}
}
}
}
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); }
};
long long time_arr[MAX_GRAPH_N][MAX_GRAPH_N];
int c[MAX_GRAPH_N][MAX_GRAPH_N];
int f[MAX_GRAPH_N][MAX_GRAPH_N];
int q[MAX_GRAPH_N];
int d[MAX_GRAPH_N];
int ptr[MAX_GRAPH_N];
class MaxFlow {
int value, s, t, n;
long long res_time;
long long add_edges_to_graph(long long time, int size,
vector<edge>& new_edges) {
int index = new_edges.size() - 1;
while (index >= 0) {
auto e = new_edges[index];
if (e.time > time) break;
c[e.from][e.to] = 1;
f[e.from][e.to] = 0;
time_arr[e.from][e.to] = e.time;
index--;
}
return time;
}
bool bfs() {
int qh = 0, qt = 0;
q[qt++] = s;
memset(d, -1, n * sizeof d[0]);
d[s] = 0;
while (qh < qt) {
int v = q[qh++];
for (int to = 0; to < n; to++) {
if (d[to] == -1 && f[v][to] < c[v][to]) {
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 (int& to = ptr[v]; to < n; ++to) {
if (d[to] != d[v] + 1) continue;
int pushed = dfs(to, min(flow, c[v][to] - f[v][to]));
if (pushed) {
f[v][to] += pushed;
f[to][v] -= pushed;
return pushed;
}
}
return 0;
}
int dinic(int size, vector<edge>& new_edges, int k, int cells) {
int value = 0;
s = 0, t = size - 1, n = size;
while (true) {
if (!bfs()) break;
memset(ptr, 0, size * sizeof ptr[0]);
while (int pushed = dfs(s, INF)) {
value += pushed;
if (value >= k) break;
}
if (value >= k) break;
}
return value;
}
public:
long long get_time() { return res_time; }
bool check(long long time, int size, vector<edge>& new_edges, int k,
int cell_counter) {
int cell_start = k + 1, females_start = size - 1 - k;
for (int i = 0; i < MAX_GRAPH_N; i++) {
for (int j = 0; j < MAX_GRAPH_N; j++) {
c[i][j] = 0;
f[i][j] = 0;
time_arr[i][j] = LLONG_INF;
}
}
for (int i = 0; i < k; i++) {
c[0][i + 1] = 1;
f[0][i + 1] = 0;
time_arr[0][i + 1] = 0;
c[females_start + i][size - 1] = 1;
f[females_start + i][size - 1] = 0;
time_arr[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;
c[from][to] = 1;
f[from][to] = 0;
time_arr[from][to] = 0;
}
if (time == 3) {
int gg = 1;
}
add_edges_to_graph(time, size, new_edges);
int ff_val = dinic(size, new_edges, k, cell_counter);
return ff_val >= k;
}
MaxFlow(int size, vector<edge>& new_edges, int k, int cells) {
long long MAX_HI = MAXN * MAXN * 2 * 1ll * INF;
long long lo = 0, hi = MAX_HI;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (check(mid, size, new_edges, k, cells))
hi = mid;
else
lo = mid + 1;
}
res_time = lo;
if (!check(lo, size, new_edges, k, cells)) res_time = lo + 1;
if (res_time >= MAX_HI) res_time = -1;
}
};
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++) {
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++) {
times_male[j][k] = LLONG_INF;
times_female[j][k] = LLONG_INF;
}
bfs(males[i].r, males[i].c, males[i].t, 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]) {
new_edges.push_back(
edge{times_male[j][k], i + 1, cell_start + cell_index});
new_edges.push_back(edge{times_female[j][k],
cell_start + cell_counter + cell_index,
females_start + i});
cell_index++;
}
}
new QuickSort(new_edges);
cout << MaxFlow(size, new_edges, males.size(), cell_counter).get_time()
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
char s[13][13];
bool nn[13][13];
int x, y, mc, fc;
long long INF;
set<pair<long long, pair<int, int> > > ss;
set<pair<long long, pair<int, int> > >::iterator pt;
struct sk {
int Y, X, T;
long long a[13][13];
void read() { scanf("%i%i%i", &Y, &X, &T); }
void debug() {
for (int i = 1; i <= y; ++i) {
for (int j = 1; j <= x; ++j)
if (a[i][j] < INF)
printf("%2i ", a[i][j]);
else
printf("** ");
printf("\n");
}
printf("\n");
}
long long dey() {
ss.clear();
for (int i = 1; i <= y; ++i)
for (int j = 1; j <= x; ++j) {
a[i][j] = INF;
ss.insert(make_pair(INF, make_pair(i, j)));
}
pt = ss.find(make_pair(INF, make_pair(Y, X)));
ss.erase(pt);
a[Y][X] = 0;
ss.insert(make_pair(0, make_pair(Y, X)));
while (ss.size() != 0) {
long long best = INF;
int ii, jj;
ii = jj = 0;
pt = ss.begin();
best = pt->first;
if (best == INF) break;
ii = pt->second.first;
jj = pt->second.second;
ss.erase(pt);
for (int i = 0; i < 4; ++i) {
int i1 = ii + dy[i];
int j1 = jj + dx[i];
if (s[i1][j1] != '#' && a[i1][j1] > best + T) {
pt = ss.find(make_pair(a[i1][j1], make_pair(i1, j1)));
ss.erase(pt);
a[i1][j1] = best + T;
ss.insert(make_pair(a[i1][j1], make_pair(i1, j1)));
}
}
}
long long r = 0;
for (int i = 1; i <= y; ++i)
for (int j = 1; j <= x; ++j)
if (a[i][j] < INF) r = max(r, a[i][j]);
return r;
}
} mm[13 * 13], ff[13 * 13];
int c[(13 * 13 * 4)][(13 * 13 * 4)];
int f[(13 * 13 * 4)][(13 * 13 * 4)];
int n, t, st;
vector<int> g[(13 * 13 * 4)];
bool was[(13 * 13 * 4)];
int d[(13 * 13 * 4)];
int o[(13 * 13 * 4)];
int from[(13 * 13 * 4)];
void add(int x, int y, int cup) {
c[x][y] = cup;
g[x].push_back(y);
g[y].push_back(x);
}
vector<int> e((13 * 13 * 4));
vector<int> h((13 * 13 * 4));
vector<int> maxh((13 * 13 * 4));
int max_flow(int n, int s, int t) {
for (int i = 0; i < n; ++i) {
e[i] = h[i] = maxh[i] = 0;
}
h[s] = n - 1;
for (int i = 0; i < n; ++i) {
f[s][i] = c[s][i];
f[i][s] = -f[s][i];
e[i] = c[s][i];
}
int sz = 0;
for (;;) {
if (!sz)
for (int i = 0; i < n; ++i)
if (i != s && i != t && e[i] > 0) {
if (sz && h[i] > h[maxh[0]]) sz = 0;
if (!sz || h[i] == h[maxh[0]]) maxh[sz++] = i;
}
if (!sz) break;
while (sz) {
int i = maxh[sz - 1];
bool pushed = false;
for (int j = 0; j < n && e[i]; ++j)
if (c[i][j] - f[i][j] > 0 && h[i] == h[j] + 1) {
pushed = true;
int addf = min(c[i][j] - f[i][j], e[i]);
f[i][j] += addf, f[j][i] -= addf;
e[i] -= addf, e[j] += addf;
if (e[i] == 0) --sz;
}
if (!pushed) {
h[i] = INF;
for (int j = 0; j < n; ++j)
if (c[i][j] - f[i][j] > 0 && h[j] + 1 < h[i]) h[i] = h[j] + 1;
if (h[i] > h[maxh[0]]) {
sz = 0;
break;
}
}
}
}
int sum = 0;
for (int i = 0; i < n; ++i) sum += f[0][i];
return sum;
}
int max_flow2(int n, int s, int t) {
int tail, head;
int v, w, cap;
int z, q;
while (true) {
tail = head = 0;
for (int i = 0; i < n; ++i) {
was[i] = false;
d[i] = 0;
}
d[s] = n;
o[s] = 0;
was[s] = true;
while (tail <= head) {
v = o[tail];
for (int i = 0; i < g[v].size(); ++i) {
w = g[v][i];
cap = c[v][w] - f[v][w] + f[w][v];
if (!was[w] && cap > 0) {
from[w] = v;
d[w] = min(d[v], cap);
was[w] = true;
o[++head] = w;
}
}
tail++;
}
if (!was[t]) break;
q = d[t];
v = t;
while (v != s) {
q = d[t];
w = from[v];
z = min(f[v][w], q);
f[v][w] -= z;
q -= z;
f[w][v] += q;
v = w;
}
}
int sum = 0;
for (int i = 0; i < n; ++i) sum += f[s][i] - f[i][s];
return sum;
}
bool solve(long long C) {
memset(f, 0, sizeof(f));
memset(c, 0, sizeof(c));
int xy1 = mc + 1;
int xy2 = xy1 + x * y;
int fs = xy2 + x * y;
t = fs + fc;
for (int i = 0; i <= t; ++i) g[i].clear();
for (int i = 1; i <= mc; ++i) add(0, i, 1);
for (int i = 0; i < fc; ++i) add(i + fs, t, 1);
int q = 0;
for (int i = 1; i <= y; ++i)
for (int j = 1; j <= x; ++j) {
if (s[i][j] != '#') add(xy1 + q, xy2 + q, 1);
for (int z = 0; z < mc; ++z)
if (mm[z].a[i][j] <= C) add(1 + z, xy1 + q, 1);
for (int z = 0; z < fc; ++z)
if (ff[z].a[i][j] <= C) add(xy2 + q, fs + z, 1);
++q;
}
int flow = max_flow2(t + 1, 0, t);
return flow == fc;
}
int main() {
INF = 1;
for (int i = 0; i < 17; ++i) INF = INF * 10;
scanf("%i%i%i%i", &y, &x, &mc, &fc);
for (int i = 1; i <= y; ++i) {
scanf("%s", &s[i][1]);
s[i][0] = '#';
s[i][x + 1] = '#';
}
for (int i = 0; i <= x + 1; ++i) {
s[0][i] = '#';
s[y + 1][i] = '#';
}
if (mc + 1 == fc) {
mm[0].read();
for (int i = 1; i <= mc; ++i) mm[i].read();
mc++;
for (int i = 0; i < fc; ++i) ff[i].read();
} else if (mc == fc + 1) {
ff[0].read();
for (int i = 0; i < mc; ++i) mm[i].read();
for (int i = 1; i <= fc; ++i) ff[i].read();
fc++;
} else {
printf("-1\n");
return 0;
}
long long A = 0;
long long B = 0;
long long C = 0;
for (int i = 0; i < mc; ++i) {
B = max(B, mm[i].dey());
}
for (int i = 0; i < fc; ++i) {
B = max(B, ff[i].dey());
}
if (!solve(B)) {
cout << -1 << endl;
return 0;
}
while (B - A > 1) {
C = (A + B) / 2;
if (solve(C))
B = C;
else
A = C;
}
if (!solve(A)) {
A++;
}
cout << A << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int maxn = 25;
const int INF = int(1e9) + 7;
int n, m, male, female;
char Map[maxn][maxn];
struct Node {
int x, y;
int speed;
long long dis[maxn][maxn];
bool used[maxn][maxn];
queue<int> quex, quey;
void read() {
scanf("%d%d%d", &x, &y, &speed);
return;
}
void pre_bfs() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dis[i][j] = INF, used[i][j] = false;
while (quex.size()) quex.pop();
while (quey.size()) quey.pop();
dis[x][y] = 0;
used[x][y] = true;
quex.push(x), quey.push(y);
while (quex.size()) {
int a = quex.front(), b = quey.front();
quex.pop();
quey.pop();
used[a][b] = false;
for (int k = 0; k < 4; k++) {
int nx = a + dir[k][0], ny = b + dir[k][1];
if (Map[nx][ny] == '#') continue;
if (nx < 1 || ny < 1 || nx > n || ny > m ||
dis[nx][ny] <= dis[a][b] + 1)
continue;
dis[nx][ny] = dis[a][b] + 1;
if (!used[nx][ny]) {
used[nx][ny] = true;
quex.push(nx);
quey.push(ny);
}
}
}
return;
}
} node1[maxn * maxn], node2[maxn * maxn];
const int maxd = int(1e4) + 7;
const int maxe = int(1e6) + 7;
int tot = 0;
int head[maxd];
int S, T;
struct Edge {
int from, to, cap, next;
Edge() {}
Edge(int x, int y, int c, int nx) : from(x), to(y), cap(c), next(nx) {}
} eage[maxe * 2];
void add(int x, int y, int c) {
eage[tot] = Edge(x, y, c, head[x]);
head[x] = tot++;
eage[tot] = Edge(y, x, 0, head[y]);
head[y] = tot++;
}
int dis[maxd];
bool used[maxd];
queue<int> que;
bool bfs() {
for (int i = S; i <= T; i++) dis[i] = INF, used[i] = false;
while (que.size()) que.pop();
que.push(S);
used[S] = true;
dis[S] = 0;
while (que.size()) {
int u = que.front();
que.pop();
used[u] = false;
for (int i = head[u]; ~i; i = eage[i].next)
if (dis[eage[i].to] > dis[u] + 1 && eage[i].cap) {
int v = eage[i].to;
dis[v] = dis[u] + 1;
if (!used[v]) {
used[v] = true;
que.push(v);
}
}
}
return (dis[T] < INF);
}
int dfs(int u, int flow) {
if (u == T || !flow) return flow;
int ret = 0;
for (int i = head[u]; ~i; i = eage[i].next)
if (eage[i].cap && dis[eage[i].to] == dis[u] + 1) {
int v = eage[i].to;
int newf = dfs(v, min(flow, eage[i].cap));
eage[i].cap -= newf;
eage[i ^ 1].cap += newf;
ret += newf;
flow -= newf;
if (!flow) break;
}
if (!ret) dis[u] = -1;
return ret;
}
int dinic() {
int res = 0;
while (bfs()) res += dfs(S, INF);
return res;
}
void build(long long val) {
S = 1, T = ((((S + male) + female) + (n - 1) * m + m) + (n - 1) * m + m) + 1;
for (int i = S; i <= T; i++) head[i] = -1;
tot = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
add((((S + male) + female) + (i - 1) * m + j),
((((S + male) + female) + (n - 1) * m + m) + (i - 1) * m + j), 1);
for (int i = 1; i <= male; i++) {
add(S, (S + i), 1);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (node1[i].dis[x][y] != INF &&
node1[i].dis[x][y] * node1[i].speed <= val) {
add((S + i), (((S + male) + female) + (x - 1) * m + y), 1);
}
}
}
}
for (int i = 1; i <= female; i++) {
add(((S + male) + i), T, 1);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (node2[i].dis[x][y] != INF &&
node2[i].dis[x][y] * node2[i].speed <= val) {
add(((((S + male) + female) + (n - 1) * m + m) + (x - 1) * m + y),
((S + male) + i), 1);
}
}
}
}
}
bool check(long long val) {
build(val);
return (dinic() == male);
}
int main() {
scanf("%d%d%d%d", &n, &m, &male, &female);
for (int i = 1; i <= n; i++) scanf("%s", Map[i] + 1);
Node boss;
boss.read();
for (int i = 1; i <= male; i++) node1[i].read();
for (int i = 1; i <= female; i++) node2[i].read();
if (male - female == 1)
node2[++female] = boss;
else if (female - male == 1)
node1[++male] = boss;
else {
printf("-1\n");
exit(0);
}
for (int i = 1; i <= male; i++) node1[i].pre_bfs();
for (int i = 1; i <= female; i++) node2[i].pre_bfs();
long long l = 0, r = (1ll << 40), res = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
res = mid;
} else
l = mid + 1;
}
printf("%I64d\n", res == INF ? -1 : res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
const int dirU[] = {0, 1, 0, -1};
const int dirV[] = {-1, 0, 1, 0};
int n, m, male, female;
int x[2][N * N], y[2][N * N], t[2][N * N], cnt[2];
char a[N][N];
long long h[2][N * N][N][N];
int used[N][N], cntUsed;
pair<int, int> q[N * N];
int top;
void bfs(int uu, int vv, int id, int r) {
top = 1;
cntUsed++;
used[uu][vv] = cntUsed;
q[0] = make_pair(uu, vv);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
h[id][r][i][j] = (1ll << 60);
}
}
h[id][r][uu][vv] = 0;
for (int i = 0; i < top; i++) {
int u = q[i].first;
int v = q[i].second;
for (int j = 0; j < 4; j++) {
int nu = u + dirU[j];
int nv = v + dirV[j];
if (nu < 1 || nu > n || nv < 1 || nv > m) {
continue;
}
if (a[nu][nv] == '#' || used[nu][nv] >= cntUsed) {
continue;
}
used[nu][nv] = cntUsed;
h[id][r][nu][nv] = h[id][r][u][v] + t[id][r];
q[top++] = make_pair(nu, nv);
}
}
}
int getId(int u, int v) { return m * (u - 1) + v + cnt[0] + cnt[1]; }
int getId1(int u, int v) { return getId(u, v) + n * m; }
const int V = 1e6;
struct Flow {
int n, s, t, cnt, top;
int head[V], to[V], nxt[V], c[V], f[V], q[V], h[V], cur[V];
Flow(int n, int s, int t) {
this->n = n;
this->s = s;
this->t = t;
cnt = 0;
for (int i = 0; i < n; i++) {
head[i] = -1;
}
}
void addEdge(int u, int v, int _c) {
to[cnt] = v, c[cnt] = _c, f[cnt] = 0, nxt[cnt] = head[u], head[u] = cnt++;
to[cnt] = u, c[cnt] = 0, f[cnt] = 0, nxt[cnt] = head[v], head[v] = cnt++;
}
bool bfs() {
top = 1;
q[0] = s;
for (int i = 0; i < n; i++) {
h[i] = -1;
}
h[s] = 0;
for (int i = 0; i < top; i++) {
int u = q[i];
for (int id = head[u]; id != -1; id = nxt[id]) {
int v = to[id];
if (h[v] < 0 && c[id] > f[id]) {
h[v] = h[u] + 1;
q[top++] = v;
}
}
}
return h[t] > 0;
}
int dfs(int u, int now) {
if (u == t) {
return now;
}
for (int &id = cur[u]; id != -1; id = nxt[id]) {
int v = to[id];
if (h[v] == h[u] + 1 && c[id] > f[id]) {
int foo = dfs(v, min(now, c[id] - f[id]));
if (foo) {
f[id] += foo;
f[id ^ 1] -= foo;
return foo;
}
}
}
return 0;
}
int maxFlow() {
int res = 0;
while (bfs()) {
for (int i = 0; i < n; i++) {
cur[i] = head[i];
}
while (1) {
int f = dfs(s, 2e9);
if (!f) {
break;
}
res += f;
}
}
return res;
}
};
bool check(long long lim) {
Flow f(getId1(n, m) + 2, 0, getId1(n, m) + 1);
for (int i = 1; i <= cnt[0]; i++) {
f.addEdge(f.s, i, 1);
f.addEdge(i + cnt[0], f.t, 1);
}
for (int id = 1; id <= cnt[0]; id++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (h[0][id][i][j] <= lim) {
f.addEdge(id, getId(i, j), 1);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f.addEdge(getId(i, j), getId1(i, j), 1);
}
}
for (int id = 1; id <= cnt[1]; id++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (h[1][id][i][j] <= lim) {
f.addEdge(getId1(i, j), id + cnt[0], 1);
}
}
}
}
return f.maxFlow() >= cnt[0];
}
int main() {
scanf("%d %d %d %d", &n, &m, &male, &female);
if (abs(male - female) != 1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
}
if (male > female) {
cnt[1]++;
scanf("%d %d %d", x[1] + cnt[1], y[1] + cnt[1], t[1] + cnt[1]);
} else {
cnt[0]++;
scanf("%d %d %d", x[0] + cnt[0], y[0] + cnt[0], t[0] + cnt[0]);
}
for (int i = 1; i <= male; i++) {
cnt[0]++;
scanf("%d %d %d", x[0] + cnt[0], y[0] + cnt[0], t[0] + cnt[0]);
}
for (int i = 1; i <= female; i++) {
cnt[1]++;
scanf("%d %d %d", x[1] + cnt[1], y[1] + cnt[1], t[1] + cnt[1]);
}
for (int i = 1; i <= cnt[0]; i++) {
bfs(x[0][i], y[0][i], 0, i);
}
for (int i = 1; i <= cnt[1]; i++) {
bfs(x[1][i], y[1][i], 1, i);
}
long long low = -1, high = 1e13;
while (high - low > 1) {
long long mid = (high + low) >> 1ll;
if (check(mid)) {
high = mid;
} else {
low = mid;
}
}
printf("%I64d", high >= 1e13 ? -1ll : high);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 28;
const long long LINF = 1ll << 61;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c != ' ' && c != '\n') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
struct graph {
int curflow, head[2000], to[1000000], nxt[1000000], cap[1000000], tot;
void init() {
memset(head, 0, sizeof(head));
tot = 1;
curflow = 0;
}
void operator=(const graph &tmp) {
curflow = tmp.curflow;
for (int i = 0; i < 2000; i++) head[i] = tmp.head[i];
tot = tmp.tot;
for (int i = 0; i <= tot; i++)
to[i] = tmp.to[i], nxt[i] = tmp.nxt[i], cap[i] = tmp.cap[i];
}
int dis[2000], que[2000], qb, qe;
void bfs(int S) {
memset(dis, -1, sizeof(dis));
dis[S] = 0;
qb = qe = 0;
que[qe++] = S;
while (qb < qe) {
int x = que[qb++];
for (int i = head[x]; i; i = nxt[i]) {
if (cap[i] && dis[to[i]] == -1) {
dis[to[i]] = dis[x] + 1;
que[qe++] = to[i];
}
}
}
}
int it[2000];
int dfs(int x, int T, int f) {
if (x == T) return f;
for (int &i = it[x]; i; i = nxt[i]) {
if (cap[i] && dis[x] + 1 == dis[to[i]]) {
int d = dfs(to[i], T, min(f, cap[i]));
if (d > 0) {
cap[i] -= d;
cap[i ^ 1] += d;
return d;
}
}
}
return 0;
}
int max_flow(int S, int T) {
int flow = 0;
while (true) {
bfs(S);
if (dis[T] == -1) {
curflow += flow;
return curflow;
}
for (int i = 0; i < 2000; i++) it[i] = head[i];
int f;
while ((f = dfs(S, T, INF)) > 0) flow += f;
}
}
void add_edge(int x, int y, int c) {
nxt[++tot] = head[x];
head[x] = tot;
to[tot] = y;
cap[tot] = c;
nxt[++tot] = head[y];
head[y] = tot;
to[tot] = x;
cap[tot] = 0;
}
} last, cur;
int n, m, n1, n2;
int dis[500][500];
int id[23][23];
vector<int> con[500];
char g[23][23];
vector<pair<int, int> > v1, v2;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
pair<int, int> readperson() {
int r, c, t;
r = getnum(), c = getnum(), t = getnum();
return make_pair(id[r][c], t);
}
void bfs(int x) {
dis[x][x] = 0;
queue<int> q;
q.push(x);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < con[u].size(); i++) {
if (dis[x][con[u][i]] == -1) {
dis[x][con[u][i]] = dis[x][u] + 1;
q.push(con[u][i]);
}
}
}
}
int main() {
n = getnum(), m = getnum();
n1 = getnum(), n2 = getnum();
if (n1 + 1 != n2 && n2 + 1 != n1) {
puts("-1");
return 0;
}
int ttot = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
g[i][j] = mygetchar();
if (g[i][j] == '.') {
id[i][j] = ++ttot;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (g[i][j] == '.') {
for (int _ = 0; _ < 4; _++) {
int ni = i + dx[_], nj = j + dy[_];
if (ni > 0 && ni <= n && nj > 0 && nj <= m && g[ni][nj] == '.') {
con[id[i][j]].push_back(id[ni][nj]);
}
}
}
}
v1.push_back(make_pair(0, 0));
v2.push_back(make_pair(0, 0));
if (n1 < n2)
v1.push_back(readperson());
else
v2.push_back(readperson());
for (int i = 1; i <= n1; i++) v1.push_back(readperson());
for (int i = 1; i <= n2; i++) v2.push_back(readperson());
if (n1 < n2) n1++;
if (n1 > n2) n2++;
memset(dis, -1, sizeof(dis));
for (int i = 1; i <= ttot; i++) bfs(i);
last.init();
int S = ttot * 2 + n1 + n2 + 1, T = S + 1;
for (int i = 1; i <= ttot; i++) last.add_edge(i, ttot + i, 1);
for (int i = 1; i <= n1; i++) last.add_edge(S, ttot * 2 + i, 1);
for (int i = 1; i <= n2; i++) last.add_edge(ttot * 2 + n1 + i, T, 1);
long long lastt = -1;
for (long long delta = 1ll << 40; delta > 0; delta >>= 1) {
long long curt = lastt + delta;
cur = last;
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= ttot; j++) {
if (dis[v1[i].first][j] == -1) continue;
long long tneed = 1ll * v1[i].second * dis[v1[i].first][j];
if (lastt < tneed && curt >= tneed) {
cur.add_edge(ttot * 2 + i, j, 1);
}
}
}
for (int i = 1; i <= n2; i++) {
for (int j = 1; j <= ttot; j++) {
if (dis[v2[i].first][j] == -1) continue;
long long tneed = 1ll * v2[i].second * dis[v2[i].first][j];
if (lastt < tneed && curt >= tneed) {
cur.add_edge(ttot + j, ttot * 2 + n1 + i, 1);
}
}
}
if (cur.max_flow(S, T) < n1) {
last = cur;
lastt += delta;
}
}
if (lastt > (1ll << 40))
puts("-1");
else
cout << lastt + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int n, l, e[2 * 500010], a[2 * 500010], u[100010], p[100010];
vector<int> m[100010];
queue<int> q;
int dfs(int i, int l, int f) {
int j, k, r;
if (!f || i == l) return f;
for (r = 0; p[i] < m[i].size(); p[i]++)
if (u[e[j = m[i][p[i]]]] == u[i] + 1) {
k = dfs(e[j], l, min(f, a[j]));
a[j] -= k;
a[j ^ 1] += k;
f -= k;
r += k;
if (!f) break;
}
return r;
}
bool bfs(int b, int l) {
int i, j;
for (i = 0; i < n; u[i] = 0, p[i] = 0, i++)
;
for (q.push(b), u[b] = 1; !q.empty();)
for (i = q.front(), q.pop(), j = 0; j < m[i].size(); j++)
if (a[m[i][j]] && !u[e[m[i][j]]]) {
u[e[m[i][j]]] = u[i] + 1;
q.push(e[m[i][j]]);
}
return u[l] > 0;
}
int mxfl(int b, int e) {
int f;
for (f = 0; bfs(b, e); f += dfs(b, e, 11000))
;
return f;
}
void add(int i, int j, int c) {
e[l] = j;
a[l] = c;
m[i].push_back(l++);
e[l] = i;
a[l] = 0;
m[j].push_back(l++);
}
void clr() {
int i;
l = 0;
for (i = 0; i < n; m[i].clear(), i++)
;
}
int r, c, w[500][25][25], uu[25][25],
di[] = {-1, 1, 0, 0}, dj[] = {0, 0, -1, 1}, ff, mm, t[500], pi[500],
pj[500];
char g[25][25];
void push(int i, int j, int v) {
if (i >= 0 && i < r && j >= 0 && j < c && g[i][j] == '.' && uu[i][j] == 500) {
uu[i][j] = v;
q.push(i);
q.push(j);
}
}
void bfss(int bi, int bj) {
int i, j, k;
for (i = 0; i < r; i++)
for (j = 0; j < c; uu[i][j] = 500, j++)
;
push(bi, bj, 0);
for (; !q.empty();) {
i = q.front();
q.pop();
j = q.front();
q.pop();
for (k = 0; k < 4; push(i + di[k], j + dj[k], uu[i][j] + 1), k++)
;
}
}
int main() {
int i, j, k, p;
long long ll, rr, cc;
scanf("%d%d%d%d", &r, &c, &ff, &mm);
for (i = 0; i < r; scanf("%s", g[i]), i++)
;
if (ff + 1 != mm && ff - 1 != mm) {
printf("-1\n");
return 0;
}
if (ff + 1 == mm) {
scanf("%d%d%d", &pi[ff], &pj[ff], &t[ff]);
pi[ff]--;
pj[ff]--;
} else {
scanf("%d%d%d", &pi[ff + mm], &pj[ff + mm], &t[ff + mm]);
pi[ff + mm]--;
pj[ff + mm]--;
}
k = (ff + mm + 1) / 2;
for (i = 0; i < ff;
scanf("%d%d%d", &pi[i], &pj[i], &t[i]), pi[i]--, pj[i]--, i++)
;
for (i = 0; i < mm; scanf("%d%d%d", &pi[k + i], &pj[k + i], &t[k + i]),
pi[k + i]--, pj[k + i]--, i++)
;
for (p = 0; p < 2 * k; p++) {
bfss(pi[p], pj[p]);
for (i = 0; i < r; i++)
for (j = 0; j < c; w[p][i][j] = uu[i][j], j++)
;
}
for (ll = 0, rr = 10000000000000ll; ll < rr;) {
cc = (ll + rr) / 2;
n = 2 * k + r * c * 2 + 2;
for (i = 0; i < r; i++)
for (j = 0; j < c;
add(2 * k + i * c + j, 2 * k + r * c + i * c + j, 1), j++)
;
for (p = 0; p < k; p++) {
add(n - 2, p, 1);
add(k + p, n - 1, 1);
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)
if (g[i][j] == '.') {
if (w[p][i][j] < 500 && (long long)w[p][i][j] * t[p] <= cc)
add(p, 2 * k + i * c + j, 1);
if (w[k + p][i][j] < 500 &&
(long long)w[k + p][i][j] * t[k + p] <= cc)
add(2 * k + r * c + i * c + j, k + p, 1);
}
}
if (mxfl(n - 2, n - 1) == k)
rr = cc;
else
ll = cc + 1;
clr();
}
if (rr >= 10000000000000ll)
printf("-1\n");
else
printf("%lld\n", rr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int MAXNODE, int MAXEDGE, typename T = int, T INF = 1012345678>
struct Dinic {
struct Edge {
int pnt, nxt;
T cap;
Edge() {}
Edge(int pnt, int nxt, T cap) : pnt(pnt), nxt(nxt), cap(cap) {}
};
int N, M, source, sink, start[MAXNODE];
T value[MAXNODE], res;
bool mark[MAXNODE];
Edge edge[MAXEDGE << 1];
void init(int n) {
N = n;
M = 0;
res = 0;
memset(start, 0xFF, sizeof(int) * N);
}
void addEdge(int x, int y, T z) {
edge[M] = Edge(y, start[x], z);
start[x] = M++;
edge[M] = Edge(x, start[y], 0);
start[y] = M++;
}
void reset() {
res = 0;
for (int i = 0; i < M; i += 2) {
edge[i].cap += edge[i ^ 1].cap;
edge[i ^ 1].cap = 0;
}
}
int level[MAXNODE];
void BFS() {
int open, closed, L[MAXNODE];
memset(level, 0xFF, sizeof(int) * N);
level[source] = 0;
L[0] = source;
open = -1;
closed = 0;
int now;
while (open < closed && level[sink] == -1) {
now = L[++open];
int i = start[now];
while (i != -1) {
if (edge[i].cap && level[edge[i].pnt] == -1) {
level[edge[i].pnt] = level[now] + 1;
L[++closed] = edge[i].pnt;
}
i = edge[i].nxt;
}
}
}
int startnow[MAXNODE], last[MAXNODE];
T maxflow(int source, int sink) {
this->source = source;
this->sink = sink;
T delta;
while (true) {
BFS();
if (level[sink] == -1) break;
memset(value, 0, sizeof(T) * N);
value[source] = INF;
for (int i = 0; i < N; i++) mark[i] = true;
memcpy(startnow, start, sizeof(int) * N);
int now = source;
while (true) {
int i = startnow[now];
while (i != -1) {
if (edge[i].cap && level[now] + 1 == level[edge[i].pnt] &&
mark[edge[i].pnt]) {
last[edge[i].pnt] = i;
value[edge[i].pnt] = min(edge[i].cap, value[now]);
startnow[now] = i;
now = edge[i].pnt;
break;
}
i = edge[i].nxt;
}
if (i == -1) {
mark[now] = false;
if (now == source) break;
now = edge[last[now] ^ 1].pnt;
} else if (now == sink) {
delta = value[sink];
res += delta;
int i = sink, tmp;
while (i != source) {
value[i] -= delta;
edge[last[i]].cap -= delta;
tmp = last[i] ^ 1;
if (value[i] == 0) now = edge[tmp].pnt;
edge[tmp].cap += delta;
i = edge[tmp].pnt;
}
}
}
}
return res;
}
};
const int MAXN = 32;
const int MAXM = 512;
const int INF = 1012345678;
const int DX[4] = {0, 0, 1, -1};
const int DY[4] = {1, -1, 0, 0};
int n, m, males, females, cells;
char mat[MAXN][MAXN];
int idx[MAXN][MAXN], dist[MAXM][MAXM];
vector<pair<int, long long> > male, female;
bool isValid(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
void init() {
for (int i = (0); i < (cells); i++) {
for (int j = (0); j < (cells); j++) dist[i][j] = INF;
dist[i][i] = 0;
}
for (int x0 = (0); x0 < (n); x0++)
for (int y0 = (0); y0 < (m); y0++)
if (idx[x0][y0] != -1) {
for (int dir = (0); dir < (4); dir++) {
int x1 = x0 + DX[dir], y1 = y0 + DY[dir];
if (isValid(x1, y1) && idx[x1][y1] != -1) {
dist[idx[x0][y0]][idx[x1][y1]] = 1;
}
}
}
for (int k = (0); k < (cells); k++)
for (int i = (0); i < (cells); i++)
for (int j = (0); j < (cells); j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
void readIn(vector<pair<int, long long> > &v) {
int r, c, t;
scanf("%d%d%d", &r, &c, &t);
r--;
c--;
v.push_back(make_pair(idx[r][c], t));
}
Dinic<1 + MAXM * 4 + 1, MAXM + MAXM * MAXM + MAXM + MAXM * MAXM + MAXM> dinic;
int MALE(int x) { return x; }
int INCELL(int x) { return males + x; }
int OUTCELL(int x) { return males + cells + x; }
int FEMALE(int x) { return males + (cells << 1) + x; }
bool isValid(long long t) {
int SOURCE = males + (cells << 1) + females, SINK = SOURCE + 1;
dinic.init(SINK + 1);
for (int i = (0); i < (males); i++) dinic.addEdge(SOURCE, MALE(i), 1);
for (int i = (0); i < (males); i++)
for (int j = (0); j < (cells); j++)
if (dist[male[i].first][j] != INF &&
dist[male[i].first][j] * male[i].second <= t) {
dinic.addEdge(MALE(i), INCELL(j), 1);
}
for (int i = (0); i < (cells); i++) dinic.addEdge(INCELL(i), OUTCELL(i), 1);
for (int i = (0); i < (cells); i++)
for (int j = (0); j < (females); j++)
if (dist[i][female[j].first] != INF &&
dist[i][female[j].first] * female[j].second <= t) {
dinic.addEdge(OUTCELL(i), FEMALE(j), 1);
}
for (int i = (0); i < (females); i++) dinic.addEdge(FEMALE(i), SINK, 1);
return dinic.maxflow(SOURCE, SINK) == males;
}
vector<long long> candidates;
long long calc() {
if (abs(males - females) != 1) return -1;
if (males < females)
readIn(male);
else
readIn(female);
for (int i = (0); i < (males); i++) readIn(male);
for (int i = (0); i < (females); i++) readIn(female);
males = females = ((int)(male).size());
for (int i = (0); i < (males); i++)
for (int j = (0); j < (cells); j++) {
int idx = male[i].first;
if (dist[idx][j] != INF) {
candidates.push_back(dist[idx][j] * male[i].second);
}
}
for (int i = (0); i < (females); i++)
for (int j = (0); j < (cells); j++) {
int idx = female[i].first;
if (dist[idx][j] != INF) {
candidates.push_back(dist[idx][j] * female[i].second);
}
}
sort(((candidates).begin()), ((candidates).end()));
(candidates)
.erase(unique(((candidates).begin()), ((candidates).end())),
((candidates).end()));
int lower = 0, upper = ((int)(candidates).size()) - 1;
long long res = -1;
while (lower <= upper) {
int medium = (lower + upper) >> 1;
if (isValid(candidates[medium])) {
res = candidates[medium];
upper = medium - 1;
} else {
lower = medium + 1;
}
}
return res;
}
int main() {
scanf("%d%d%d%d", &n, &m, &males, &females);
for (int i = (0); i < (n); i++) scanf("%s", mat[i]);
memset(idx, 0xFF, sizeof(idx));
cells = 0;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++)
if (mat[i][j] != '#') {
idx[i][j] = cells++;
}
init();
cout << calc() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000ll * 1000ll * 1000ll * 1000ll * 1000ll * 100ll;
const int MAXN = 3000;
int fl;
int dd[23][23];
int arr[23][23];
int n, m, fm, ml;
vector<tuple<int, int, long long> > bb;
vector<tuple<int, int, long long> > gg;
deque<int> dq;
int t, s;
struct edge {
long long c, w, f;
int a, b;
};
long long nd;
int was[MAXN];
vector<edge> ed;
vector<int> eds[MAXN];
void add_edge(int a, int b, int c, long long w) {
edge x;
x.a = a;
x.b = b;
x.c = c;
x.w = w;
x.f = 0;
eds[a].push_back(ed.size());
ed.push_back(x);
swap(x.a, x.b);
x.c = 0;
x.w = -x.w;
eds[b].push_back(ed.size());
ed.push_back(x);
}
int tm = 0;
int dfs(int v, long long x) {
if (v == t) return 1;
was[v] = tm;
for (int i = 0; i < (int)eds[v].size(); ++i) {
int q = eds[v][i];
int u = ed[q].b;
if (was[u] < tm && ed[q].w <= x && ed[q].c > ed[q].f) {
if (dfs(u, x)) {
++ed[q].f;
--ed[q ^ 1].f;
return 1;
}
}
}
return 0;
}
bool flow(long long x) {
for (int i = 0; i < (int)ed.size(); ++i) ed[i].f = 0;
int ans = 0;
while (true) {
++tm;
int xx = dfs(s, x);
if (!xx) break;
ans += xx;
}
if (ans < nd)
return 0;
else
return 1;
}
int main() {
cin >> n >> m >> ml >> fm;
if (ml + 1 == fm) fl = 1;
if (fm + 1 == ml) fl = 2;
if (!fl) {
cout << -1;
return 0;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
scanf(" %c", &c);
if (c == '.')
arr[i][j] = 1;
else
arr[i][j] = 0;
}
int a, b;
long long c;
scanf("%d%d%I64d", &a, &b, &c);
--a;
--b;
if (fl == 1)
bb.push_back(make_tuple(a, b, c));
else
gg.push_back(make_tuple(a, b, c));
for (int i = 0; i < ml; ++i) {
scanf("%d%d%I64d", &a, &b, &c);
--a;
--b;
bb.push_back(make_tuple(a, b, c));
}
for (int i = 0; i < fm; ++i) {
scanf("%d%d%I64d", &a, &b, &c);
--a;
--b;
gg.push_back(make_tuple(a, b, c));
}
s = ml + fm + 2 * n * m + 1;
t = s + 1;
for (int i = 0; i < (int)bb.size(); ++i) add_edge(s, i, 1, 0);
for (int i = 0; i < (int)gg.size(); ++i)
add_edge(i + (int)bb.size(), t, 1, 0);
for (int i = 0; i < (int)bb.size(); ++i) {
for (int i1 = 0; i1 < n; ++i1)
for (int j1 = 0; j1 < m; ++j1) dd[i1][j1] = 2280;
int x = get<0>(bb[i]);
int y = get<1>(bb[i]);
dd[x][y] = 0;
queue<pair<int, int> > qu;
qu.push({x, y});
while (!qu.empty()) {
pair<int, int> tmp = qu.front();
qu.pop();
int xx = tmp.first;
int yy = tmp.second;
for (int dx = -1; dx < 2; ++dx)
for (int dy = -1; dy < 2; ++dy) {
if (abs(dx) + abs(dy) != 1 || xx + dx < 0 || xx + dx >= n ||
yy + dy < 0 || yy + dy >= m || !arr[xx + dx][yy + dy])
continue;
if (dd[xx + dx][yy + dy] > dd[xx][yy] + 1) {
dd[xx + dx][yy + dy] = dd[xx][yy] + 1;
qu.push({xx + dx, yy + dy});
}
}
}
for (int i1 = 0; i1 < n; ++i1)
for (int j1 = 0; j1 < m; ++j1)
if (dd[i1][j1] < 2280)
add_edge(i, ml + fm + 1 + i1 * m + j1, 1, dd[i1][j1] * get<2>(bb[i]));
}
for (int i = 0; i < (int)gg.size(); ++i) {
for (int i1 = 0; i1 < n; ++i1)
for (int j1 = 0; j1 < m; ++j1) dd[i1][j1] = 2280;
int x = get<0>(gg[i]);
int y = get<1>(gg[i]);
dd[x][y] = 0;
queue<pair<int, int> > qu;
qu.push({x, y});
while (!qu.empty()) {
pair<int, int> tmp = qu.front();
qu.pop();
int xx = tmp.first;
int yy = tmp.second;
for (int dx = -1; dx < 2; ++dx)
for (int dy = -1; dy < 2; ++dy) {
if (abs(dx) + abs(dy) != 1 || xx + dx < 0 || xx + dx >= n ||
yy + dy < 0 || yy + dy >= m || !arr[xx + dx][yy + dy])
continue;
if (dd[xx + dx][yy + dy] > dd[xx][yy] + 1) {
dd[xx + dx][yy + dy] = dd[xx][yy] + 1;
qu.push({xx + dx, yy + dy});
}
}
}
for (int i1 = 0; i1 < n; ++i1)
for (int j1 = 0; j1 < m; ++j1)
if (dd[i1][j1] < 2280)
add_edge(ml + fm + 1 + n * m + i1 * m + j1, i + (int)bb.size(), 1,
dd[i1][j1] * get<2>(gg[i]));
}
for (int i = 0; i < n * m; ++i)
add_edge(ml + fm + 1 + i, ml + fm + 1 + n * m + i, 1, 0);
nd = max(fm, ml);
long long l = -1;
long long r = 500ll * 1000000000;
while (r - l > 1) {
long long x = (l + r) / 2;
if (flow(x))
r = x;
else
l = x;
}
if (r == 500ll * 1000000000)
cout << -1;
else
cout << r;
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;
}
};
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int X, Y;
string board[30];
int dist[30][30][30][30];
int A, B;
int cx, cy, ct;
int ax[500], ay[500], at[500];
int bx[500], by[500], bt[500];
queue<int> q;
void bfs(int s, int t) {
int i, j;
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++) dist[s][t][i][j] = (1 << 29);
if (board[s][t] == '#') return;
dist[s][t][s][t] = 0;
q.push(s);
q.push(t);
while (!q.empty()) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
for ((i) = 0; (i) < (int)(4); (i)++) {
int x2 = x + dx[i], y2 = y + dy[i];
if (x2 >= 0 && x2 < X && y2 >= 0 && y2 < Y && board[x2][y2] != '#' &&
dist[s][t][x2][y2] == (1 << 29)) {
dist[s][t][x2][y2] = dist[s][t][x][y] + 1;
q.push(x2);
q.push(y2);
}
}
}
}
bool check(long long T) {
int i, j, k;
MaxFlow mf(A + A + 2 * (X * Y) + 2);
int V = A + A + 2 * (X * Y) + 2;
for ((i) = 0; (i) < (int)(A); (i)++) mf.add_edge(V - 2, i, 1);
for ((i) = 0; (i) < (int)(A); (i)++) mf.add_edge(A + i, V - 1, 1);
for ((i) = 0; (i) < (int)(X * Y); (i)++)
mf.add_edge(A + A + i, A + A + X * Y + i, 1);
for ((i) = 0; (i) < (int)(A); (i)++)
for ((j) = 0; (j) < (int)(X); (j)++)
for ((k) = 0; (k) < (int)(Y); (k)++) {
int d = dist[ax[i]][ay[i]][j][k];
if (d != (1 << 29) && (long long)d * at[i] <= T)
mf.add_edge(i, A + A + j * Y + k, 1);
}
for ((i) = 0; (i) < (int)(A); (i)++)
for ((j) = 0; (j) < (int)(X); (j)++)
for ((k) = 0; (k) < (int)(Y); (k)++) {
int d = dist[bx[i]][by[i]][j][k];
if (d != (1 << 29) && (long long)d * bt[i] <= T)
mf.add_edge(A + A + X * Y + j * Y + k, A + i, 1);
}
int f = mf.maxflow(V - 2, V - 1);
return (f == A);
}
int main(void) {
int i, j;
cin >> X >> Y >> A >> B;
for ((i) = 0; (i) < (int)(X); (i)++) cin >> board[i];
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++) bfs(i, j);
cin >> cx >> cy >> ct;
for ((i) = 0; (i) < (int)(A); (i)++) cin >> ax[i] >> ay[i] >> at[i];
for ((i) = 0; (i) < (int)(B); (i)++) cin >> bx[i] >> by[i] >> bt[i];
cx--;
cy--;
for ((i) = 0; (i) < (int)(A); (i)++) {
ax[i]--;
ay[i]--;
}
for ((i) = 0; (i) < (int)(B); (i)++) {
bx[i]--;
by[i]--;
}
if (A < B) {
ax[A] = cx;
ay[A] = cy;
at[A] = ct;
A++;
} else {
bx[B] = cx;
by[B] = cy;
bt[B] = ct;
B++;
}
if (A != B) {
cout << -1 << endl;
return 0;
}
long long low = -1, high = (1ll << 40);
while (high - low > 1) {
long long mid = (low + high) / 2;
if (check(mid))
high = mid;
else
low = mid;
}
if (high == (1ll << 40)) high = -1;
cout << high << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
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;
}
};
const int maxN = 25;
int n, m, male, female;
string s[maxN];
int r[2 * maxN * maxN], c[2 * maxN * maxN], t[2 * maxN * maxN];
int d[maxN][maxN][maxN][maxN];
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
bool isValid(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m && s[x][y] == '.';
}
void calc(int d[maxN][maxN], int u, int v) {
memset(d, -1, sizeof(d));
d[u][v] = 0;
queue<pair<int, int> > q;
q.push(make_pair(u, v));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first;
int y = p.second;
for (int i = 0; i < 4; ++i) {
if (isValid(x + dx[i], y + dy[i]) && d[x + dx[i]][y + dy[i]] == -1) {
d[x + dx[i]][y + dy[i]] = d[x][y] + 1;
q.push(make_pair(x + dx[i], y + dy[i]));
}
}
}
}
bool check(long long value) {
{
MaximumFlow F(male + female + 1 + 2 * n * m + 2);
int start = male + female + 1 + 2 * n * m;
int finish = start + 1;
for (int i = (male < female ? 0 : 1); i <= male; ++i) {
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(i, male + female + 1 + x * m + y, 1);
}
}
}
F.addEdge(start, i, 1);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
F.addEdge(male + female + 1 + i * m + j,
male + female + 1 + n * m + i * m + j, 1);
}
}
}
for (int i = 0; i <= male + female; ++i) {
if (i < male + 1) {
if (female < male && i == 0) {
} else {
continue;
}
}
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (d[r[i]][c[i]][x][y] == -1) {
continue;
}
if ((long long)(d[r[i]][c[i]][x][y]) * (long long)(t[i]) <= value) {
F.addEdge(male + female + 1 + n * m + x * m + y, i, 1);
}
}
}
F.addEdge(i, finish, 1);
}
return F.dinicFlow(start, finish) == (male + female + 1) / 2;
}
}
int main() {
cin >> n >> m >> male >> female;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
cin >> r[0] >> c[0] >> t[0];
--r[0];
--c[0];
for (int i = 1; i <= male; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
for (int i = male + 1; i <= male + female; ++i) {
cin >> r[i] >> c[i] >> t[i];
--r[i];
--c[i];
}
memset(d, -1, sizeof(d));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (isValid(i, j)) {
calc(d[i][j], i, j);
}
}
}
if (male + 1 != female && male != female + 1) {
cout << -1 << endl;
return 0;
}
long long left_bound = 0, right_bound = 1000000000000LL;
if (!check(right_bound)) {
cout << -1 << endl;
return 0;
}
while (right_bound - left_bound > 1) {
long long middle = (left_bound + right_bound) / 2;
if (check(middle)) {
right_bound = middle;
} else {
left_bound = middle;
}
}
if (check(left_bound)) {
cout << left_bound << endl;
} else {
cout << right_bound << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[50][50];
string s;
long long int X[1000], Y[1000], T[1000];
vector<long long int> female, male;
long long int n, m, ma, fe;
long long int d[1005][50][50];
queue<pair<long long int, long long int> > q;
void bfs(long long int si) {
d[si][X[si]][Y[si]] = 0;
q.push(make_pair(X[si], Y[si]));
while (q.size()) {
long long int i = q.front().first;
long long int j = q.front().second;
q.pop();
if (!vis[i + 1][j] && d[si][i + 1][j] > d[si][i][j] + T[si]) {
d[si][i + 1][j] = d[si][i][j] + T[si];
q.push(make_pair(i + 1, j));
}
if (!vis[i - 1][j] && d[si][i - 1][j] > d[si][i][j] + T[si]) {
d[si][i - 1][j] = d[si][i][j] + T[si];
q.push(make_pair(i - 1, j));
}
if (!vis[i][j + 1] && d[si][i][j + 1] > d[si][i][j] + T[si]) {
d[si][i][j + 1] = d[si][i][j] + T[si];
q.push(make_pair(i, j + 1));
}
if (!vis[i][j - 1] && d[si][i][j - 1] > d[si][i][j] + T[si]) {
d[si][i][j - 1] = d[si][i][j] + T[si];
q.push(make_pair(i, j - 1));
}
}
}
const long long int INFLL = 1e18;
vector<int> adj[2013];
int res[2013][2013];
int source = 2011, sink = 2012;
void AddEdge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
res[a][b] = 1;
}
int h[2013];
queue<int> frontier;
int visited[2013];
bool level() {
for (int i = 0; i < 2013; i++) h[i] = 1e9;
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] == 1e9) {
h[i] = h[x] + 1;
frontier.push(i);
}
}
return (h[sink] != 1e9);
}
int dfs(int x) {
if (x == sink) return 1;
visited[x] = 1;
int num = 0;
for (int i : adj[x])
if (!visited[i] && h[i] == h[x] + 1 && res[x][i] && dfs(i)) {
res[x][i] -= 1;
res[i][x] += 1;
num += 1;
if (x != source) return num;
}
return num;
}
int maxflow() {
int flow = 0;
while (true) {
if (!level()) break;
for (int i = 0; i < 2013; i++) visited[i] = 0;
flow += dfs(source);
}
return flow;
}
bool check(long long int x) {
for (int i = 0; i < 2013; i++) {
adj[i].clear();
for (int j = 0; j < 2013; j++) res[i][j] = 0;
}
source = 0;
sink = 2 * n * m + ma + fe + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
AddEdge((i - 1) * m + j, (i - 1) * m + j + n * m);
for (int k = 0; k < female.size(); k++) {
AddEdge(0, 2 * n * m + k + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (d[female[k]][i][j] <= x)
AddEdge(2 * n * m + k + 1, (i - 1) * m + j);
}
for (int k = 0; k < male.size(); k++) {
AddEdge(2 * n * m + k + 1 + fe, 2 * n * m + ma + fe + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (d[male[k]][i][j] <= x)
AddEdge((i - 1) * m + j + n * m, 2 * n * m + k + 1 + fe);
}
return (maxflow() == male.size());
}
long long int binsearch() {
long long int l = 0, r = 1e15;
if (!check(r)) return -1;
long long int mid = (l + r) >> 1;
while (r - l > 1) {
if (check(mid))
r = mid;
else
l = mid;
mid = (l + r) >> 1;
}
while (!check(mid)) mid++;
return mid;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 50; i++)
for (int j = 0; j < 50; j++) vis[i][j] = 1;
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 50; j++)
for (int h = 0; h < 50; h++) d[i][j][h] = 1e18;
cin >> n >> m >> ma >> fe;
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 1; j <= m; j++) {
if (s[j - 1] == '.') vis[i][j] = 0;
}
}
if (abs(ma - fe) > 1) return cout << -1 << '\n', 0;
long long int x, y, t;
cin >> X[1] >> Y[1] >> T[1];
if (ma > fe)
female.push_back(1);
else
male.push_back(1);
for (int i = 2; i <= ma + 1; i++)
cin >> X[i] >> Y[i] >> T[i], male.push_back(i);
for (int i = ma + 2; i <= fe + ma + 1; i++)
cin >> X[i] >> Y[i] >> T[i], female.push_back(i);
for (int i = 1; i <= ma + fe + 1; i++) bfs(i);
ma = male.size();
fe = female.size();
long long int ans = binsearch();
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), x = 0; c >= '0' && c <= '9';
c = getchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
}
template <class T, class T1>
inline void gn(T &x, T1 &y) {
gn(x);
gn(y);
}
template <class T, class T1, class T2>
inline void gn(T &x, T1 &y, T2 &z) {
gn(x);
gn(y);
gn(z);
}
template <class T>
inline void print(T x) {
if (x < 0) {
putchar('-');
return print(-x);
}
if (x < 10) {
putchar('0' + x);
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void printsp(T x) {
print(x);
putchar(' ');
}
template <class T>
inline void println(T x) {
print(x);
putchar('\n');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int dist[11111], head[11111], work[11111];
int cap[2222222], nxt[2222222], to[2222222], q[2222222];
int src, tar, V, E, qf, qb;
char grid[11111][11111];
int dis[22][22][22][22];
int fx[11111], fy[11111], mx[11111], my[11111], tf[11111], tmm[11111];
int init(int n) {
memset(head, -1, sizeof(head));
E = 0, V = n;
}
int add(int u, int v, int c) {
to[E] = v, nxt[E] = head[u], head[u] = E, cap[E++] = c;
to[E] = u, nxt[E] = head[v], head[v] = E, cap[E++] = 0;
}
bool bfs() {
memset(dist, -1, sizeof(dist));
qf = qb = 0, dist[src] = 0;
q[qb++] = src;
while (qf < qb && dist[tar] == -1) {
int u = q[qf++];
for (int e = head[u]; e >= 0; e = nxt[e]) {
int v = to[e];
if (dist[v] == -1 && cap[e] > 0) dist[v] = dist[u] + 1, q[qb++] = v;
}
}
return dist[tar] >= 0;
}
int dfs(int u, int &bot) {
int bot1, delta;
if (u == tar) return bot;
for (int &e = work[u]; e >= 0; e = nxt[e]) {
int v = to[e];
if (dist[v] == dist[u] + 1 && cap[e] > 0) {
bot1 = min(bot, cap[e]);
if (delta = dfs(v, bot1)) {
cap[e] -= delta;
cap[e ^ 1] += delta;
bot = bot1;
return delta;
}
}
}
return 0;
}
int dinic() {
int ans = 0, delta, bot;
while (bfs()) {
memcpy(work, head, sizeof(int) * (V + 10));
while (delta = dfs(src, bot = 1000000000)) ans += delta;
}
return ans;
}
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int main() {
int N, M, r, c, t, n1, n2;
cin >> N >> M >> n1 >> n2;
for (int i = 0; i < N; i++) scanf("%s", grid[i]);
memset(dis, -1, sizeof(dis));
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
if (grid[i][j] == '#') continue;
dis[i][j][i][j] = 0;
qf = qb = 0;
q[qb++] = i, q[qb++] = j;
while (qf < qb) {
int ux = q[qf++];
int uy = q[qf++];
for (int k = 0; k < 4; k++) {
int vx = ux + dx[k];
int vy = uy + dy[k];
if ((vx < 0 || vy < 0 || vx >= N || vy >= M)) continue;
if (grid[vx][vy] == '#') continue;
if (dis[i][j][vx][vy] >= 0) continue;
dis[i][j][vx][vy] = dis[i][j][ux][uy] + 1;
q[qb++] = vx, q[qb++] = vy;
}
}
}
cin >> r >> c >> t;
if (n1 != n2 + 1 && n2 != n1 + 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n1; i++) scanf("%d%d%d", mx + i, my + i, tmm + i);
for (int i = 1; i <= n2; i++) scanf("%d%d%d", fx + i, fy + i, tf + i);
if (n1 > n2)
fx[++n2] = r, fy[n2] = c, tf[n2] = t;
else
mx[++n1] = r, my[n1] = c, tmm[n1] = t;
long long st = -1, ed = 100000000000000LL;
bool ok = 0;
while (ed - st > 1) {
long long md = st + ed >> 1;
src = 0;
tar = n1 + n2 + 1;
init(tar + 2 * N * M);
for (int i = 1; i <= n1; i++) {
add(src, i, 1);
int ux = mx[i] - 1;
int uy = my[i] - 1;
for (int j = 0; j < N; j++)
for (int k = 0; k < M; k++) {
int id = j * M + k + 1 + tar;
if (dis[ux][uy][j][k] < 0) continue;
if (1LL * tmm[i] * dis[ux][uy][j][k] > md) continue;
add(i, id, 1);
}
}
for (int i = 1; i <= n2; i++) {
add(n1 + i, tar, 1);
int ux = fx[i] - 1;
int uy = fy[i] - 1;
for (int j = 0; j < N; j++)
for (int k = 0; k < M; k++) {
int id = j * M + k + 1 + tar;
if (grid[j][k] == '#') continue;
if (dis[ux][uy][j][k] < 0) continue;
if (1LL * tf[i] * dis[ux][uy][j][k] > md) continue;
add(id + N * M, n1 + i, 1);
}
}
for (int i = 1; i <= N * M; i++) add(tar + i, tar + i + N * M, 1);
if (dinic() >= n1)
ed = md, ok = 1;
else
st = md;
}
if (!ok) ed = -1;
printf("%I64d\n", ed);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 27081993;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const long long LIM = 1LL << 50;
struct edge {
int x, y, cap, flow;
};
struct DinicFlow {
int n, S, T;
vector<vector<int> > a;
vector<int> cur, d;
vector<edge> e;
DinicFlow() {}
DinicFlow(int n, int S, int T) {
this->n = n;
this->S = S;
this->T = T;
a = vector<vector<int> >(n + 1);
cur = vector<int>(n + 1);
d = vector<int>(n + 1);
}
void addEdge(int x, int y, int cap) {
edge e1 = {x, y, cap, 0};
edge e2 = {y, x, 0, 0};
a[x].push_back(e.size());
e.push_back(e1);
a[y].push_back(e.size());
e.push_back(e2);
}
int bfs() {
queue<int> q;
for (int i = 1; i <= n; i++) d[i] = -1;
q.push(S);
d[S] = 0;
while (!q.empty() && d[T] < 0) {
int x = q.front();
q.pop();
for (int i = 0; i < int(a[x].size()); i++) {
int id = a[x][i], y = e[id].y;
if (d[y] < 0 && e[id].flow < e[id].cap) q.push(y), d[y] = d[x] + 1;
}
}
return d[T] >= 0;
}
int dfs(int x, int val) {
if (!val) return 0;
if (x == T) return val;
for (; cur[x] < int(a[x].size()); cur[x]++) {
int id = a[x][cur[x]], y = e[id].y;
if (d[y] != d[x] + 1) continue;
int pushed = dfs(y, min(val, e[id].cap - e[id].flow));
if (pushed) {
e[id].flow += pushed;
e[id ^ 1].flow -= pushed;
return pushed;
}
}
return 0;
}
int maxFlow() {
int res = 0;
while (bfs()) {
for (int i = 1; i <= n; i++) cur[i] = 0;
while (1) {
int val = dfs(S, oo);
if (!val) break;
res += val;
}
}
return res;
}
};
struct Scayger {
int x, y, t;
Scayger(int x = 0, int y = 0, int t = 0) {
this->x = x;
this->y = y;
this->t = t;
}
};
int m, n, M, F, dist[25][25][25][25];
Scayger males[555], females[555], boss;
string a[25];
void bfs(int sx, int sy) {
queue<pair<int, int> > q;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) dist[sx][sy][i][j] = -1;
dist[sx][sy][sx][sy] = 0;
q.push(make_pair(sx, sy));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx < 0 || xx >= m || yy < 0 || yy >= n) continue;
if (dist[sx][sy][xx][yy] >= 0) continue;
if (a[xx][yy] != '.') continue;
dist[sx][sy][xx][yy] = dist[sx][sy][x][y] + 1;
q.push(make_pair(xx, yy));
}
}
}
int ok(long long maxTime) {
int S = M + F + m * n * 2 + 1, T = S + 1;
DinicFlow f(T, S, T);
for (int i = 0; i < M; i++) f.addEdge(S, i + 1, 1);
for (int i = 0; i < F; i++) f.addEdge(M + i + 1, T, 1);
for (int x = 0; x < m; x++)
for (int y = 0; y < n; y++)
if (a[x][y] == '.')
f.addEdge(M + F + x * n + y + 1, M + F + m * n + x * n + y + 1, 1);
for (int i = 0; i < M; i++)
for (int x = 0; x < m; x++)
for (int y = 0; y < n; y++) {
if (a[x][y] == '#') continue;
int curDist = dist[x][y][males[i].x][males[i].y];
if (curDist < 0) continue;
if (1LL * curDist * males[i].t > maxTime) continue;
f.addEdge(i + 1, M + F + x * n + y + 1, 1);
}
for (int i = 0; i < F; i++)
for (int x = 0; x < m; x++)
for (int y = 0; y < n; y++) {
if (a[x][y] == '#') continue;
int curDist = dist[x][y][females[i].x][females[i].y];
if (curDist < 0) continue;
if (1LL * curDist * females[i].t > maxTime) continue;
f.addEdge(M + F + m * n + x * n + y + 1, M + i + 1, 1);
}
return f.maxFlow() == M;
}
int main() {
ios::sync_with_stdio(0);
int x, y, t;
cin >> m >> n >> M >> F;
for (int i = 0; i < m; i++) cin >> a[i];
cin >> x >> y >> t;
boss = Scayger(x - 1, y - 1, t);
for (int i = 0; i < M; i++) {
cin >> x >> y >> t;
males[i] = Scayger(x - 1, y - 1, t);
}
for (int i = 0; i < F; i++) {
cin >> x >> y >> t;
females[i] = Scayger(x - 1, y - 1, t);
}
if (abs(M - F) != 1) {
cout << -1 << endl;
return 0;
}
if (M > F)
females[F++] = boss;
else
males[M++] = boss;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) bfs(i, j);
long long low = 0, high = LIM, ans = LIM + 1;
while (low <= high) {
long long mid = (low + high) / 2;
if (ok(mid)) {
ans = mid;
high = mid - 1;
} else
low = mid + 1;
}
if (ans > LIM) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
const int M = 25;
const int V = 2e6;
const int E = 2e6;
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;
const int nmax = 2000, inf = 1e9, MX = 25;
struct edge {
int from, to, flow;
};
vector<int> adj[nmax];
vector<edge> all;
void add_edge(int from, int to, int flow) {
edge current;
current.from = from;
current.to = to;
current.flow = flow;
adj[from].push_back(all.size());
all.push_back(current);
swap(current.from, current.to);
current.flow = 0;
adj[to].push_back(all.size());
all.push_back(current);
}
int source, sink;
int parent[nmax];
bool been[nmax];
int dfs(int node) {
if (node == sink) return 1;
if (been[node]) return 0;
been[node] = 1;
for (auto k : adj[node]) {
assert(all[k].from == node);
if (all[k].flow && dfs(all[k].to)) {
all[k].flow--;
all[k ^ 1].flow++;
return 1;
}
}
return 0;
}
int max_flow() {
int total_flow = 0;
while (1) {
memset(been, 0, sizeof(been));
int current = dfs(source);
if (current == 0) break;
total_flow += current;
}
return total_flow;
}
int n, m, mal, femal;
struct person {
int x, y, t;
};
void no() {
printf("-1\n");
exit(0);
}
person males[MX * MX], females[MX * MX];
person other;
long long dist[MX][MX][MX][MX];
int hsh(int x, int y) { return (x - 1) * m + y; }
int test(long long current) {
all = {};
for (int i = source; i <= sink; i++) adj[i] = {};
for (int i = 1; i <= mal; i++) add_edge(source, i, 1);
for (int i = 1; i <= mal; i++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (dist[males[i].x][males[i].y][x][y] <= current / males[i].t)
add_edge(i, mal + hsh(x, y), 1);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
add_edge(mal + hsh(x, y), mal + n * m + hsh(x, y), 1);
for (int j = 1; j <= femal; j++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (dist[females[j].x][females[j].y][x][y] <= current / females[j].t)
add_edge(mal + n * m + hsh(x, y), mal + n * m + n * m + j, 1);
for (int j = 1; j <= femal; j++) add_edge(mal + n * m + n * m + j, sink, 1);
return max_flow();
}
char inp[MX][MX];
int main() {
scanf("%i%i%i%i", &n, &m, &mal, &femal);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> inp[i][j];
for (int x1 = 1; x1 <= n; x1++)
for (int y1 = 1; y1 <= m; y1++)
for (int x2 = 1; x2 <= n; x2++)
for (int y2 = 1; y2 <= m; y2++) {
dist[x1][y1][x2][y2] = 1e18;
if (inp[x1][y1] == '.' && inp[x2][y2] == '.') {
if (abs(x1 - x2) + abs(y1 - y2) == 0)
dist[x1][y1][x2][y2] = 0;
else if (abs(x1 - x2) + abs(y1 - y2) == 1)
dist[x1][y1][x2][y2] = 1;
}
}
for (int x1 = 1; x1 <= n; x1++)
for (int y1 = 1; y1 <= m; y1++)
for (int x2 = 1; x2 <= n; x2++)
for (int y2 = 1; y2 <= m; y2++)
for (int x3 = 1; x3 <= n; x3++)
for (int y3 = 1; y3 <= m; y3++)
dist[x2][y2][x3][y3] =
min(dist[x2][y2][x3][y3],
dist[x2][y2][x1][y1] + dist[x1][y1][x3][y3]);
scanf("%i%i%i", &other.x, &other.y, &other.t);
person current;
for (int i = 1; i <= mal; i++) {
scanf("%i%i%i", ¤t.x, ¤t.y, ¤t.t);
males[i] = current;
}
for (int j = 1; j <= femal; j++) {
scanf("%i%i%i", ¤t.x, ¤t.y, ¤t.t);
females[j] = current;
}
if (mal < femal) {
mal++;
males[mal] = other;
} else {
femal++;
females[femal] = other;
}
if (mal != femal) no();
source = 0;
sink = mal + n * m + n * m + femal + 1;
if (test(1e12) < mal) no();
long long not_ok = -1, ok = 1e12;
while (ok - not_ok > 1) {
long long av = (ok + not_ok) / 2;
if (test(av) == mal)
ok = av;
else
not_ok = av;
}
printf("%lld\n", ok);
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 = 1e10;
const int N = 10019;
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[24][24];
long long Dis[24][24][24][24];
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 = 1e18;
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 max_n = 25;
const int max_v = 4 * max_n * max_n;
const long long inf = 1111111111111LL;
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 add_edge(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, 1);
if (pushed == 0) {
break;
}
result += pushed;
}
ptr.assign(n, 0);
}
return result;
}
};
struct edge {
int v, c, f, numr;
edge() {}
edge(int v, int c, int f, int numr) : v(v), c(c), f(f), numr(numr) {}
};
int last_res, n, m, k, k1, k2, x[2][max_v], y[2][max_v], t[2][max_v],
used[max_v];
long long last, dist[max_v][max_n][max_n];
string s[max_n];
vector<long long> v;
MaximumFlow F;
bool check(long long x) {
int s = 2 * n * m + 2 * k;
int t = s + 1;
if (x <= last) {
F = MaximumFlow(2 * n * m + 2 * k + 5);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = 2 * (i * m + j);
F.add_edge(num, num + 1, 1);
}
}
for (int i = 0; i < k; ++i) {
F.add_edge(s, 2 * n * m + i, 1);
F.add_edge(2 * n * m + k + i, t, 1);
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w);
if (dist[i][j][w] > -1 && x >= dist[i][j][w]) {
F.add_edge(2 * n * m + i, num, 1);
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w) + 1;
if (dist[i + k][j][w] > -1 && x >= dist[i + k][j][w]) {
F.add_edge(num, 2 * n * m + k + i, 1);
}
}
}
}
} else {
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w);
if (dist[i][j][w] > -1 && x >= dist[i][j][w] &&
last < dist[i][j][w]) {
F.add_edge(2 * n * m + i, num, 1);
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
for (int w = 0; w < m; ++w) {
int num = 2 * (j * m + w) + 1;
if (dist[i + k][j][w] > -1 && x >= dist[i + k][j][w] &&
last < dist[i + k][j][w]) {
F.add_edge(num, 2 * n * m + k + i, 1);
}
}
}
}
}
memset(used, 0, sizeof(used));
int res = 0;
if (x > last) {
res = last_res;
}
res += F.dinicFlow(s, t);
last = x;
last_res = res;
return res == k;
}
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
bool is_in(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void bfs(int num, int poz) {
int stx = x[num][poz - num * k];
int sty = y[num][poz - num * k];
int tt = t[num][poz - num * k];
dist[poz][stx][sty] = 0;
queue<pair<int, int> > q;
q.push(make_pair(stx, sty));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first, y = p.second;
v.push_back(dist[poz][x][y]);
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (is_in(nx, ny) && s[nx][ny] == '.' && dist[poz][nx][ny] == -1) {
dist[poz][nx][ny] = dist[poz][x][y] + tt;
q.push(make_pair(nx, ny));
}
}
}
}
int main() {
cin >> n >> m >> k1 >> k2;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int st1 = 0, st2 = 0;
if (k1 + 1 == k2) {
k = k2;
cin >> x[0][0] >> y[0][0] >> t[0][0];
st1 = 1;
} else if (k2 + 1 == k1) {
k = k1;
cin >> x[1][0] >> y[1][0] >> t[1][0];
st2 = 1;
} else {
cout << -1 << endl;
return 0;
}
for (int i = st1; i < k; ++i) {
cin >> x[0][i] >> y[0][i] >> t[0][i];
}
for (int i = st2; i < k; ++i) {
cin >> x[1][i] >> y[1][i] >> t[1][i];
}
memset(dist, -1, sizeof(dist));
for (int i = 0; i < k; ++i) {
--x[0][i];
--x[1][i];
--y[0][i];
--y[1][i];
bfs(0, i);
bfs(1, k + i);
}
sort(v.begin(), v.end());
last = inf + 1;
if (!check(inf)) {
cout << -1 << endl;
return 0;
}
long long l = -1, r = v.size() - 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(v[mid])) {
r = mid;
} else {
l = mid;
}
}
cout << v[r] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, p1, p2, ay[25 * 25], ax[25 * 25], ac[25 * 25], by[25 * 25],
bx[25 * 25], bc[25 * 25], dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
int f[2000], v[1000000], o[1000000], w[1000000], p, d[2000], q[2000], fl, S, T;
long long dis[25 * 25][25 * 25];
char s[25][25];
void bd(int a, int b) {
v[++p] = b;
o[p] = f[a];
f[a] = p;
w[p] = 1;
v[++p] = a;
o[p] = f[b];
f[b] = p;
w[p] = 0;
}
int dfs(int y, int ff) {
if (y == T) {
fl += ff;
return ff;
}
int cap = ff;
for (int i = (f[y]); i; i = o[i])
if (w[i] && d[v[i]] == d[y] + 1) {
int x = dfs(v[i], min(cap, w[i]));
cap -= x;
w[i] -= x;
w[i ^ 1] += x;
if (!cap) break;
}
if (cap == ff) d[y] = -1;
return ff - cap;
}
bool bfs() {
for (int i = (0); i <= (T); i++) d[i] = -1;
d[S] = 0;
int l = 0, h = 0;
q[h++] = S;
while (l < h) {
int y = q[l++];
for (int i = (f[y]); i; i = o[i])
if (w[i] && d[v[i]] < 0) {
d[v[i]] = d[y] + 1;
q[h++] = v[i];
if (v[i] == T) return 1;
}
}
return 0;
}
bool ok(long long val) {
p = 1;
for (int i = (0); i <= (T); i++) f[i] = 0;
for (int i = (0); i < (a); i++) bd(S, i);
for (int i = (0); i < (b); i++) bd(a + i, T);
for (int i = (0); i < (n * m); i++) {
bd(a + b + i, a + b + i + n * m);
for (int j = (0); j < (a); j++)
if (dis[(ay[j] - 1) * m + ax[j] - 1][i] <= val / ac[j]) bd(j, a + b + i);
for (int j = (0); j < (b); j++)
if (dis[(by[j] - 1) * m + bx[j] - 1][i] <= val / bc[j])
bd(a + b + i + n * m, a + j);
}
fl = 0;
while (bfs())
while (dfs(S, a))
;
return fl == a;
}
int main() {
scanf("%d%d%d%d", &n, &m, &a, &b);
if (abs(a - b) != 1) {
puts("-1");
return 0;
}
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) dis[i][j] = 1000000000000LL;
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;
int e = i * m + j;
dis[e][e] = 0;
for (int k = (0); k < (4); k++) {
int ni = i + dy[k], nj = j + dx[k], ne = ni * m + nj;
if (ni < 0 || ni >= n || nj < 0 || nj >= m || s[ni][nj] == '#')
continue;
dis[e][ne] = 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) {
scanf("%d%d%d", &by[0], &bx[0], &bc[0]);
p2++;
} else {
scanf("%d%d%d", &ay[0], &ax[0], &ac[0]);
p1++;
}
for (int i = (0); i < (a); i++) {
scanf("%d%d%d", &ay[p1], &ax[p1], &ac[p1]);
p1++;
}
for (int i = (0); i < (b); i++) {
scanf("%d%d%d", &by[p2], &bx[p2], &bc[p2]);
p2++;
}
a = b = max(a, b);
S = a + b + n * m + n * m;
T = S + 1;
long long l = 0, h = 1000000000000LL;
while (l < h) {
long long m = l + h >> 1;
if (ok(m))
h = m;
else
l = m + 1;
}
if (h == 1000000000000LL)
puts("-1");
else
printf("%I64d\n", h);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001;
const long long INF = (long long)1000 * 1000 * 1000 * 1000;
const int INF_SMAL = 1000 * 1000 * 1000;
const int K = 13;
struct edge {
int u, v, cap, flow;
edge(){};
edge(int u, int v, int cap) : u(u), v(v), cap(cap), flow(0){};
};
int x[2 * K * K], y[2 * K * K], ti[2 * K * K];
char p[K][K];
int n, m, female, male;
bool was[K][K];
int s, t;
vector<edge> ed;
vector<int> g[MAXN];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
void add_edge(int u, int v, int cap) {
g[u].push_back(((int)(ed.size())));
ed.push_back(edge(u, v, cap));
g[v].push_back(((int)(ed.size())));
ed.push_back(edge(v, u, 0));
}
int getc(edge &a) { return a.cap - a.flow; }
bool in_range(int l, int s, int r) { return (l <= s && s < r); }
pair<int, int> deq[MAXN];
void get_g(int ind, int x, int y, long long ti, int fl) {
int di[K][K];
int l = 0, r = 0;
memset(was, 0, sizeof was);
di[x][y] = 0;
was[x][y] = 1;
deq[r++] = {x, y};
while (l < r) {
int x = deq[l].first, y = deq[l].second;
l++;
if (p[x][y] == '#') continue;
if (di[x][y] <= ti) {
if (fl == 0) {
add_edge(ind, x * m + y + male + female, 1);
} else {
add_edge(x * m + y + male + female + n * m, ind, 1);
}
}
for (int i = 0; i < 4; i++) {
if (in_range(0, x + dx[i], n) && in_range(0, y + dy[i], m)) {
if (!was[x + dx[i]][y + dy[i]]) {
was[x + dx[i]][y + dy[i]] = 1;
deq[r++] = {x + dx[i], y + dy[i]};
di[x + dx[i]][y + dy[i]] = di[x][y] + 1;
}
}
}
}
}
int di[MAXN];
int bfs(int s, int t) {
int deq[MAXN];
int l = 0, r = 0;
bool was[MAXN];
memset(was, 0, sizeof was);
memset(di, 0, sizeof di);
di[s] = 0;
was[s] = 1;
deq[r++] = s;
while (l < r) {
int u = deq[l++];
for (int i = 0; i < ((int)(g[u].size())); i++) {
if (getc(ed[g[u][i]]) > 0) {
edge buf = ed[g[u][i]];
if (!was[buf.v]) {
was[buf.v] = 1;
di[buf.v] = di[buf.u] + 1;
deq[r++] = buf.v;
}
}
}
}
if (was[t]) return 1;
return 0;
}
int pnt[MAXN];
int dfs(int u, int t, int flow) {
if (u == t || flow == 0) return flow;
for (int &i = pnt[u]; i < ((int)(g[u].size())); i++) {
edge buf = ed[g[u][i]];
if (di[u] + 1 == di[buf.v] && getc(buf) > 0) {
int lans = dfs(buf.v, t, min(flow, getc(buf)));
if (lans > 0) {
ed[g[u][i]].flow += lans;
ed[g[u][i] ^ 1].flow -= lans;
return lans;
}
}
}
return 0;
}
int find_max_flow(int s, int t) {
int ans = 0;
while (bfs(s, t) > 0) {
int lans = -1;
memset(pnt, 0, sizeof pnt);
while ((lans = dfs(s, t, INF_SMAL)) > 0) {
ans += lans;
}
}
return ans;
}
bool check(long long s) {
int t = male + female + 2 * n * m;
int st = t + 1;
for (int i = 0; i < MAXN; i++) {
g[i].clear();
}
ed.clear();
for (int i = 0; i < male; i++) {
get_g(i, x[i], y[i], s / ti[i], 0);
add_edge(st, i, 1);
}
for (int i = 0; i < female; i++) {
get_g(male + i, x[male + i], y[male + i], s / ti[male + i], 1);
add_edge(male + i, t, 1);
}
for (int i = 0; i < n * m; i++) {
add_edge(male + female + i, male + female + i + n * m, 1);
}
int ans = find_max_flow(st, t);
if (ans == male) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> male >> female;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> p[i][j];
if (abs(male - female) != 1) {
cout << -1;
return 0;
}
for (int i = 0; i < 1 + female + male; i++) {
cin >> x[i] >> y[i] >> ti[i];
x[i]--;
y[i]--;
}
if (male > female) {
swap(x[0], x[male]);
swap(y[0], y[male]);
swap(ti[0], ti[male]);
}
male = female = max(male, female);
long long l = -1, r = INF;
while (l + 1 < r) {
long long s = (l + r) / 2;
if (check(s))
r = s;
else
l = s;
}
if (r == INF) {
cout << -1;
return 0;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf_int = 1e8;
long long inf_ll = 1e17;
const double pi = 3.1415926535898;
const long long mod = 1e9 + 9;
const int MAXN = 3000;
bool debug = 0;
struct edge {
int a, b, cap, flow;
};
struct max_flow {
vector<int> g[MAXN];
vector<edge> e;
int s, t;
int n;
int ptr[MAXN], dis[MAXN], q[MAXN];
void init(int s, int t, int n) {
this->s = s;
this->t = t;
this->n = n;
}
bool bfs() {
fill(dis, dis + n, inf_int);
q[0] = s;
dis[s] = 0;
int qh = 0, qt = 1;
while (qh < qt) {
int v = q[qh++];
for (int id : g[v]) {
edge &rib = e[id];
int to = rib.b;
if (rib.cap > rib.flow && dis[to] > dis[v] + 1) {
dis[to] = dis[v] + 1;
q[qt++] = to;
}
}
}
return dis[t] != inf_int;
}
int dfs(int v, int flow) {
if (v == t) return flow;
for (; ptr[v] < g[v].size(); ++ptr[v]) {
int id = g[v][ptr[v]];
edge &rib = e[id];
int to = rib.b;
if (rib.cap > rib.flow && dis[to] == dis[v] + 1) {
int pushed = dfs(to, min(flow, rib.cap - rib.flow));
if (pushed) {
e[id].flow += pushed;
e[id ^ 1].flow -= pushed;
return pushed;
}
}
}
return 0;
}
inline void add_edge(int a, int b, int cap) {
edge e1 = {a, b, cap, 0};
edge e2 = {b, a, 0, 0};
g[a].push_back(e.size());
e.push_back(e1);
g[b].push_back(e.size());
e.push_back(e2);
}
int flow() {
int res = 0;
if (debug) cout << "here" << endl;
while (bfs()) {
if (debug) cout << "here" << endl;
fill(ptr, ptr + n, 0);
while (int pushed = dfs(s, inf_int)) res += pushed;
}
return res;
}
};
struct person {
int r, c, s;
};
person p1[MAXN], p2[MAXN];
char a[30][30];
int n, m;
inline int get(int x, int y) { return (x - 1) * m + y; }
bool is_ok(int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= m && a[x][y] != '#';
}
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int dis[25][25][25][25];
void bfs(int X, int Y) {
for (int i = 1; i <= n; ++i) {
for (int e = 1; e <= m; ++e) {
dis[X][Y][i][e] = inf_int;
}
}
queue<pair<int, int> > q;
q.push({X, Y});
dis[X][Y][X][Y] = 0;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; ++i) {
int x1 = x + dx[i], y1 = y + dy[i];
if (is_ok(x1, y1) && dis[X][Y][x1][y1] > dis[X][Y][x][y] + 1) {
dis[X][Y][x1][y1] = dis[X][Y][x][y] + 1;
q.push({x1, y1});
}
}
}
}
int n1, n2;
bool ok(long long val) {
max_flow flow;
int st = 2 * n1 + 1;
int st1 = st + n * m + 5;
int s = 0, t = st1 + n * m + 5;
flow.init(s, t, t + 1);
for (int i = 1; i <= n1; ++i) {
flow.add_edge(s, i, 1);
flow.add_edge(n1 + i, t, 1);
}
for (int i = 1; i <= n1; ++i) {
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
int d = dis[p1[i].r][p1[i].c][x][y];
if (d == inf_int) continue;
if (1ll * d * p1[i].s <= val) {
if (debug) cout << i << " " << x << " " << y << endl;
flow.add_edge(i, st + get(x, y), 1);
}
}
}
}
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
flow.add_edge(st + get(x, y), st1 + get(x, y), 1);
}
}
for (int i = 1; i <= n1; ++i) {
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
int d = dis[p2[i].r][p2[i].c][x][y];
if (d == inf_int) continue;
if (1ll * d * p2[i].s <= val) {
if (debug) cout << i << " " << x << " " << y << endl;
flow.add_edge(st1 + get(x, y), n1 + i, 1);
}
}
}
}
return flow.flow() == n1;
}
void solve() {
cin >> n >> m;
cin >> n1 >> n2;
if (abs(n1 - n2) != 1) {
cout << "-1";
return;
}
for (int i = 1; i <= n; ++i) {
for (int e = 1; e <= m; ++e) {
cin >> a[i][e];
}
}
if (n1 < n2) {
n1++;
for (int i = 1; i <= n1; ++i) {
cin >> p1[i].r >> p1[i].c >> p1[i].s;
}
for (int i = 1; i <= n2; ++i) {
cin >> p2[i].r >> p2[i].c >> p2[i].s;
}
} else {
cin >> p2[1].r >> p2[1].c >> p2[1].s;
n2++;
for (int i = 1; i <= n1; ++i) {
cin >> p1[i].r >> p1[i].c >> p1[i].s;
}
for (int i = 2; i <= n2; ++i) {
cin >> p2[i].r >> p2[i].c >> p2[i].s;
}
}
for (int i = 1; i <= n1; ++i) {
bfs(p1[i].r, p1[i].c);
bfs(p2[i].r, p2[i].c);
}
long long l = 0, r = 1e15;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (ok(mid)) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int V, E, src, tar;
int head[60000], work[60000], dis[60000];
int to[2010000], cap[2010000], nxt[2010000];
int q[60000], qf, qb;
int n, m, males, females;
void init(int n, int s, int t) {
V = n;
E = 0;
src = s;
tar = t;
memset(head, -1, sizeof(int) * V);
}
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(int) * V);
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]) {
int 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;
}
void NoSolution() {
puts("-1");
exit(0);
}
char grid[33][33];
int dst[33][33][33][33];
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
int mx[33 * 33], my[33 * 33], mt[33 * 33];
int fx[33 * 33], fy[33 * 33], ft[33 * 33];
int can(long long mid) {
init(males + females + n * m * 2 + 10, 0, males + females + n * m * 2 + 1);
for (int i = 0; i < males; i++) {
add_edge(src, i + 1, 1);
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
if (dst[mx[i]][my[i]][j][k] == 0x3f3f3f3f) continue;
if ((long long)dst[mx[i]][my[i]][j][k] * mt[i] > mid) continue;
add_edge(i + 1, males + (j - 1) * m + k, 1);
}
}
for (int i = 0; i < females; i++) {
add_edge(males + n * m * 2 + i + 1, tar, 1);
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
if (dst[fx[i]][fy[i]][j][k] == 0x3f3f3f3f) continue;
if ((long long)dst[fx[i]][fy[i]][j][k] * ft[i] > mid) continue;
add_edge(males + (j - 1) * m + k + n * m, males + n * m * 2 + i + 1, 1);
}
}
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
add_edge(males + (j - 1) * m + k, males + (j - 1) * m + k + n * m, 1);
return dinic() == males;
}
int main() {
gn(n, m);
gn(males, females);
if (abs(males - females) != 1) NoSolution();
for (int i = 1; i <= n; i++) scanf("%s", grid[i] + 1);
int r, c, t;
gn(r, c, t);
memset(dst, 0x3f, sizeof dst);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (grid[i][j] == '.') {
dst[i][j][i][j] = 0;
qf = qb = 0;
q[qb++] = i;
q[qb++] = j;
while (qf < qb) {
int u = q[qf++], v = q[qf++];
for (int k = 0; k < 4; k++) {
int uu = u + dx[k], vv = v + dy[k];
if ((uu < 1 || vv < 1 || uu > n || vv > m) || 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;
}
}
}
}
}
for (int i = 0; i < males; i++) gn(mx[i], my[i], mt[i]);
for (int i = 0; i < females; i++) gn(fx[i], fy[i], ft[i]);
if (males == females + 1) {
fx[females] = r;
fy[females] = c;
ft[females] = t;
females++;
} else if (males + 1 == females) {
mx[males] = r;
my[males] = c;
mt[males] = t;
males++;
}
assert(males == females);
long long st = -1, ed = (long long)1e16;
while (ed - st > 1) {
long long mid = st + ed >> 1;
if (can(mid))
ed = mid;
else
st = mid;
}
if (ed == (long long)1e16) NoSolution();
println(ed);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[2011];
int dist[2011], visited[2011];
int cur[2011];
void init() {
edg.clear();
int i;
for (i = 0; i < 2011; 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[2011][2011];
char g[2011][2011];
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 = 2011 - 2, mf.t = 2011 - 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 < 2011; ++i) {
for (j = 0; j < 2011; ++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;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
struct Maxflow {
static const int INF = 1e8;
struct E {
int to, cap, rev;
E() {}
E(int _to, int _cap, int _rev) : to(_to), cap(_cap), rev(_rev) {}
};
int n;
vector<vector<E> > e;
vector<vector<E>::iterator> cur;
vector<int> dis;
void init(int _n) {
n = _n;
e.resize(n);
cur.resize(n);
dis.resize(n);
for (int i = 0; i < int(n); i++) e[i].clear();
}
void add(int a, int b, int c) {
if (a == b) return;
e[a].push_back(E(b, c, e[b].size()));
e[b].push_back(E(a, 0, e[a].size() - 1));
}
bool bfs() {
fill(dis.begin(), dis.end(), -1);
queue<int> q;
dis[0] = 0;
q.push(0);
while (!q.empty() && dis[n - 1] == -1) {
int p = q.front();
q.pop();
for (auto it = (e[p]).begin(); it != (e[p]).end(); it++) {
if (it->cap == 0 || dis[it->to] != -1) continue;
dis[it->to] = dis[p] + 1;
q.push(it->to);
}
}
return dis[n - 1] != -1;
}
int go(int p, int c) {
if (p == n - 1) return c;
int ret = 0;
for (auto& it = cur[p]; it != e[p].end(); it++) {
if (it->cap == 0 || dis[it->to] != dis[p] + 1) continue;
int now = go(it->to, min(it->cap, c - ret));
ret += now;
it->cap -= now;
e[it->to][it->rev].cap += now;
if (ret == c) break;
}
if (ret == 0) dis[p] = -1;
return ret;
}
int maxflow() {
int ret = 0;
while (bfs()) {
for (int i = 0; i < int(n); i++) cur[i] = e[i].begin();
ret += go(0, INF);
}
return ret;
}
} mf;
int n, m, k1, k2, r[514], c[514], t[514];
char s[25][25];
void input() {
RI(n, m, k1, k2);
for (int i = (1); i <= int(n); i++) scanf("%s", s[i] + 1);
for (int i = 0; i < int(k1 + k2 + 1); i++) RI(r[i], c[i], t[i]);
}
void BFS(int x, int y, int d[25][25]) {
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
static bool vis[25][25];
memset(vis, 0, sizeof(vis));
queue<int> q;
auto push = [&](int xx, int yy, int dd) {
if (s[xx][yy] != '.') return;
if (vis[xx][yy]) return;
vis[xx][yy] = 1;
q.push(xx);
q.push(yy);
d[xx][yy] = dd;
};
push(x, y, 0);
while (!q.empty()) {
x = q.front();
q.pop();
y = q.front();
q.pop();
for (int i = 0; i < int(4); i++) {
int nx = x + dx[i];
int ny = y + dy[i];
push(nx, ny, d[x][y] + 1);
}
}
}
int dis[25][25][25][25];
void build() {
memset(dis, -1, sizeof(dis));
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(m); j++)
if (s[i][j] == '.') BFS(i, j, dis[i][j]);
}
void solve() {
const long long INF = 1e16;
vector<int> a, b;
if (k1 + 1 == k2)
a.push_back(0);
else if (k1 == k2 + 1)
b.push_back(0);
else
return puts("-1"), void();
for (int i = (1); i <= int(k1); i++) a.push_back(i);
for (int i = (k1 + 1); i <= int(k1 + k2); i++) b.push_back(i);
assert(((int)(a).size()) == ((int)(b).size()));
int z = ((int)(a).size()), sink = k1 + k2 + 1 + 2 * n * m + 1;
long long ll = 0, rr = INF;
while (ll != rr) {
long long mm = (ll + rr) / 2;
mf.init(sink + 1);
for (int i = 0; i < int(z); i++) mf.add(0, a[i] + 1, 1);
for (int i = 0; i < int(z); i++) mf.add(b[i] + 1, sink, 1);
for (int x = (1); x <= int(n); x++)
for (int y = (1); y <= int(m); y++)
if (s[x][y] == '.') {
int id = k1 + k2 + 1 + (x - 1) * m + y;
mf.add(id, id + n * m, 1);
}
for (int i = 0; i < int(z); i++)
for (int x = (1); x <= int(n); x++)
for (int y = (1); y <= int(m); y++)
if (s[x][y] == '.') {
int id = k1 + k2 + 1 + (x - 1) * m + y;
long long da = dis[r[a[i]]][c[a[i]]][x][y];
long long db = dis[r[b[i]]][c[b[i]]][x][y];
if (da != -1 && 1LL * t[a[i]] * da <= mm) mf.add(a[i] + 1, id, 1);
if (db != -1 && 1LL * t[b[i]] * db <= mm)
mf.add(id + n * m, b[i] + 1, 1);
}
int flow = mf.maxflow();
if (flow == z)
rr = mm;
else
ll = mm + 1;
}
if (ll == INF)
puts("-1");
else
cout << ll << endl;
}
int main() {
input();
build();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Inf = 0x3f3f3f3f3f3f3f3f;
namespace Flows {
struct Edge {
long long to, cap, rev;
Edge(long long to, long long cap, long long rev)
: to(to), cap(cap), rev(rev) {}
};
vector<Edge> egs[5005];
bool lgl[5005];
void NewEdge(long long u, long long v, long long cap) {
egs[u].push_back(Edge(v, cap, egs[v].size()));
egs[v].push_back(Edge(u, 0, egs[u].size() - 1));
}
int dist[5005];
long long calc(long long frm, long long to, long long cap) {
if (frm == to) {
return cap;
}
lgl[frm] = 1;
long long ycap = cap;
for (long long i = 0; i < ((long long)egs[frm].size()); i++) {
if (egs[frm][i].cap && dist[egs[frm][i].to] == dist[frm] + 1) {
long long ff = calc(egs[frm][i].to, to, min(cap, egs[frm][i].cap));
cap -= ff;
egs[frm][i].cap -= ff;
egs[egs[frm][i].to][egs[frm][i].rev].cap += ff;
if (!cap) {
break;
}
}
}
if (cap == ycap) {
dist[frm] = -1;
}
return ycap - cap;
}
bool bfs(int frm, int to) {
memset(dist, 0x3f, sizeof(dist));
queue<int> q;
q.push(frm);
dist[frm] = 0;
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 0; i < egs[x].size(); i++) {
if (egs[x][i].cap && dist[egs[x][i].to] == 0x3f3f3f3f) {
q.push(egs[x][i].to);
dist[egs[x][i].to] = dist[x] + 1;
}
}
}
return dist[to] != 0x3f3f3f3f;
}
void init() {
for (long long i = 0; i < 5005; i++) {
egs[i].clear();
}
}
} // namespace Flows
struct prs {
int r, c, t;
};
int dist[25][25][25][25];
long long dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
char s[25][25];
int n, m, boy, girl;
vector<prs> boys, girls;
bool valid(long long x, long long y) {
return x >= 1 && x <= n && y >= 1 && y <= m && s[x][y] != '#';
}
void prebfs(long long x, long long y) {
queue<pair<long long, long long> > q;
queue<int> b;
q.push(make_pair(x, y));
b.push(0);
dist[x][y][x][y] = 0;
while (q.size()) {
pair<long long, long long> Q = q.front();
int bs = b.front();
q.pop();
b.pop();
for (long long i = 0; i < 4; i++) {
long long nx = Q.first + dx[i], ny = Q.second + dy[i];
if (valid(nx, ny) && dist[x][y][nx][ny] == 0x3f3f3f3f) {
q.push(make_pair(nx, ny));
b.push(bs + 1);
dist[x][y][nx][ny] = bs + 1;
}
}
}
}
bool check(long long M) {
Flows::init();
for (long long i = 0; i < ((long long)boys.size()); i++) {
Flows::NewEdge(0, i + 1, 1);
for (long long j = 1; j <= n; j++) {
for (long long k = 1; k <= m; k++) {
if (dist[boys[i].r][boys[i].c][j][k] != 0x3f3f3f3f &&
1LL * dist[boys[i].r][boys[i].c][j][k] * boys[i].t <= M) {
Flows::NewEdge(i + 1, 1000 + j * m + k, 1);
}
}
}
}
for (long long j = 1; j <= n; j++) {
for (long long k = 1; k <= m; k++) {
Flows::NewEdge(1000 + j * m + k, 2000 + j * m + k, 1);
}
}
for (long long i = 0; i < ((long long)girls.size()); i++) {
Flows::NewEdge(3000 + i, 4000, 1);
for (long long j = 1; j <= n; j++) {
for (long long k = 1; k <= m; k++) {
if (dist[girls[i].r][girls[i].c][j][k] != 0x3f3f3f3f &&
1LL * dist[girls[i].r][girls[i].c][j][k] * girls[i].t <= M) {
Flows::NewEdge(2000 + j * m + k, 3000 + i, 1);
}
}
}
}
long long ans = 0;
while (Flows::bfs(0, 4000)) {
memset(Flows::lgl, 0, sizeof(Flows::lgl));
long long ff = Flows::calc(0, 4000, Inf);
if (!ff) {
break;
}
ans += ff;
}
return ans == (long long)boys.size();
}
int main() {
scanf("%d%d%d%d", &n, &m, &boy, &girl);
for (long long i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
if (abs(boy - girl) != 1) {
puts("-1\n");
return 0;
}
prs boss;
scanf("%d%d%d", &boss.r, &boss.c, &boss.t);
if (boy < girl) {
boys.push_back(boss);
} else {
girls.push_back(boss);
}
for (long long i = 0; i < boy; i++) {
scanf("%d%d%d", &boss.r, &boss.c, &boss.t);
boys.push_back(boss);
}
for (long long i = 0; i < girl; i++) {
scanf("%d%d%d", &boss.r, &boss.c, &boss.t);
girls.push_back(boss);
}
memset((int*)dist, 0x3f, sizeof(dist));
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
prebfs(i, j);
}
}
long long l = -1, r = 1e12;
while (r - l > 1) {
long long m = (l + r) >> 1;
if (check(m)) {
r = m;
} else {
l = m;
}
}
if (r == 1e12) {
puts("-1");
return 0;
}
printf("%I64d\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25, M = 3e4;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
const long long INF = 3e18;
int n, m, ma, fe, in[N][N], out[N][N];
int stok, istok, sz, x, y, z;
long long dist[M][N][N];
vector<long long> vals;
char a[N][N];
struct st {
int x, y, z, sz;
};
vector<st> female, male;
struct edge {
int a, b, cap, flow;
};
vector<edge> e;
vector<int> g[M];
int ptr[M], d[M];
inline void add_edge(int a, int b) {
edge e1 = {a, b, 1, 0}, e2 = {b, a, 0, 0};
g[a].push_back(e.size());
e.push_back(e1);
g[b].push_back(e.size());
e.push_back(e2);
}
int dfs(int v, int flow) {
if (!flow) {
return 0;
}
if (v == stok) {
return flow;
}
for (; ptr[v] < g[v].size(); ptr[v]++) {
int id = g[v][ptr[v]], to = e[id].b;
if (d[to] != d[v] + 1) {
continue;
}
int x = dfs(to, min(flow, e[id].cap - e[id].flow));
if (x) {
e[id].flow += x;
e[id ^ 1].flow -= x;
return x;
}
}
return 0;
}
inline bool bfs() {
memset(d, -1, sizeof(d));
d[istok] = 0;
queue<int> q;
q.push(istok);
while (!q.empty() && d[stok] == -1) {
int v = q.front();
q.pop();
for (int id : g[v]) {
int to = e[id].b;
if (e[id].flow < e[id].cap && d[to] == -1) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
return d[stok] != -1;
}
inline int dinic() {
int ans = 0;
while (bfs()) {
memset(ptr, 0, sizeof(ptr));
while (int x = dfs(istok, 1e9)) {
ans += x;
}
}
return ans;
}
bool used[M];
void DFS(int v) {
used[v] = true;
cout << v << " ";
for (int id : g[v]) {
int to = e[id].b;
if (e[id].flow < e[id].cap && !used[to]) {
DFS(to);
}
}
}
inline int f(long long val) {
e.clear();
for (int i = 1; i <= sz; i++) {
g[i].clear();
}
for (auto it : male) {
x = it.x, y = it.y;
add_edge(it.sz, stok);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dist[it.sz][i][j] <= val) {
add_edge(out[i][j], it.sz);
}
}
}
}
for (auto it : female) {
x = it.x, y = it.y;
add_edge(istok, it.sz);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dist[it.sz][i][j] <= val) {
add_edge(it.sz, in[i][j]);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
add_edge(in[i][j], out[i][j]);
}
}
return dinic();
}
inline bool check(int x, int y) {
return 1 <= x && x <= n && 1 <= y && y <= m && a[x][y] == '.';
}
inline void upd(int num, int x, int y, int z) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[num][i][j] = INF;
}
}
queue<pair<int, int> > q;
q.push(make_pair(x, y));
dist[num][x][y] = 0;
while (!q.empty()) {
x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (check(xx, yy) && dist[num][xx][yy] > dist[num][x][y] + z) {
dist[num][xx][yy] = dist[num][x][y] + z;
q.push(make_pair(xx, yy));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> ma >> fe;
if (abs(ma - fe) > 1 || ma == fe) {
return cout << "-1", 0;
}
istok = ++sz;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
in[i][j] = ++sz;
out[i][j] = ++sz;
}
}
}
stok = ++sz;
cin >> x >> y >> z;
if (ma + 1 == fe) {
male.push_back({x, y, z, ++sz});
} else {
female.push_back({x, y, z, ++sz});
}
for (int i = 1; i <= ma; i++) {
cin >> x >> y >> z;
male.push_back({x, y, z, ++sz});
}
for (int i = 1; i <= fe; i++) {
cin >> x >> y >> z;
female.push_back({x, y, z, ++sz});
}
for (auto it : male) {
upd(it.sz, it.x, it.y, it.z);
}
for (auto it : female) {
upd(it.sz, it.x, it.y, it.z);
}
long long l = 0, r = 1e14;
if (f(r) < male.size()) {
return cout << "-1", 0;
}
while (r - l > 1) {
long long mid = (r + l) >> 1;
if (f(mid) >= male.size()) {
r = mid;
} else {
l = mid;
}
}
if (f(l) >= male.size()) {
cout << l;
} else {
cout << r;
}
}
|
#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 = 1e10;
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[24][24];
long long Dis[24][24][24][24];
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 = 1e18;
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;
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 <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
struct Edge {
long long v, c, inv;
Edge(long long v_, long long c_, long long inv_) {
v = v_;
c = c_;
inv = inv_;
}
};
struct Dinic {
public:
Dinic() { n = -1; }
void AddEdge(long long a, long long b, long long cap, long long bi_dir = 0) {
if (n < max(a, b)) {
n = max(n, max(a, b));
ResizeVectors();
}
e_orig[a].push_back(Edge(b, cap, ((long long)(e_orig[b]).size())));
e_orig[b].push_back(
Edge(a, bi_dir * cap, ((long long)(e_orig[a]).size()) - 1));
}
long long MaxFlow(long long s, long long t) {
e = e_orig;
long long result = 0;
while (Bfs(s, t)) {
for (long long i = 0; i <= n; i++) {
beg[i] = 0;
}
result += Dfs(s, t, kInf);
}
return result;
}
private:
long long n;
vector<vector<Edge> > e_orig;
vector<vector<Edge> > e;
vector<long long> beg;
vector<long long> dis;
bool Bfs(long long s, long long t) {
for (long long i = 0; i <= n; i++) {
dis[i] = n + 1;
}
dis[s] = 0;
vector<long long> que;
que.push_back(s);
for (long long i = 0; i < ((long long)(que).size()); i++) {
long long v = que[i];
for (long long j = 0; j < ((long long)(e[v]).size()); j++) {
long long nei = e[v][j].v;
if (e[v][j].c && dis[nei] > dis[v] + 1) {
dis[nei] = dis[v] + 1;
que.push_back(nei);
if (nei == t) {
return true;
}
}
}
}
return false;
}
long long Dfs(long long v, long long t, long long min_cap) {
long long result = 0;
if (v == t || min_cap == 0) {
return min_cap;
}
for (long long& i = beg[v]; i < ((long long)(e[v]).size()); i++) {
long long nei = e[v][i].v;
long long c = e[v][i].c;
if (dis[nei] == dis[v] + 1 && c > 0) {
long long flow_here = Dfs(nei, t, min(min_cap, c));
result += flow_here;
min_cap -= flow_here;
e[v][i].c -= flow_here;
e[nei][e[v][i].inv].c += flow_here;
}
if (min_cap == 0) {
break;
}
}
return result;
}
void ResizeVectors() {
e_orig.resize(n + 2);
beg.resize(n + 2);
dis.resize(n + 2);
}
static const long long kInf = 1e18;
};
const long long kInf = 1e15;
struct Guy {
long long r, c, speed;
};
Guy ReadGuy() {
long long r, c, sp;
cin >> r >> c >> sp;
;
return {r, c, sp};
}
vector<Guy> fem, mal;
void ReadFem() { fem.push_back(ReadGuy()); }
void ReadMal() { mal.push_back(ReadGuy()); }
const long long N = 25;
long long can[N][N];
long long dis[N][N][N][N];
long long di[] = {-1, 1, 0, 0};
long long dj[] = {0, 0, 1, -1};
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
double beg_clock = 1.0 * clock() / CLOCKS_PER_SEC;
long long n, m, mal_num, fem_num;
cin >> n >> m >> mal_num >> fem_num;
;
if (abs(mal_num - fem_num) != 1) {
cout << "-1\n";
return 0;
}
for (long long r = (1); r <= (n); ++r) {
for (long long c = (1); c <= (m); ++c) {
char ch;
cin >> ch;
;
if (ch == '.') {
can[r][c] = 1;
}
}
}
if (mal_num < fem_num) {
ReadMal();
} else {
ReadFem();
}
for (long long i = (1); i <= (mal_num); ++i) {
ReadMal();
}
for (long long i = (1); i <= (fem_num); ++i) {
ReadFem();
}
for (long long r = (1); r <= (n); ++r) {
for (long long c = (1); c <= (m); ++c) {
for (long long i = (1); i <= (n); ++i) {
for (long long j = (1); j <= (m); ++j) {
dis[r][c][i][j] = kInf;
}
}
if (!can[r][c]) {
continue;
}
vector<pair<long long, long long> > que;
que.push_back(make_pair(r, c));
dis[r][c][r][c] = 0;
for (long long ii = 0; ii < ((long long)(que).size()); ii++) {
auto p = que[ii];
long long cur_i = p.first;
long long cur_j = p.second;
for (long long dir = 0; dir < (4); ++dir) {
long long new_i = cur_i + di[dir];
long long new_j = cur_j + dj[dir];
if (!can[new_i][new_j]) {
continue;
}
if (dis[r][c][new_i][new_j] == kInf) {
dis[r][c][new_i][new_j] = dis[r][c][cur_i][cur_j] + 1;
que.push_back(make_pair(new_i, new_j));
}
}
}
}
}
long long kl = 0, kp = 1e12, faj = -1;
while (kl <= kp) {
long long aktc = (kl + kp) / 2;
Dinic gr;
long long s = 0;
long long t = 4 * n * m + 1;
for (long long ii = 0; ii < ((long long)(fem).size()); ii++) {
auto g = fem[ii];
gr.AddEdge(s, 1 + ii, 1);
for (long long r = (1); r <= (n); ++r) {
for (long long c = (1); c <= (m); ++c) {
if (dis[r][c][g.r][g.c] < kInf &&
dis[r][c][g.r][g.c] * g.speed <= aktc) {
gr.AddEdge(1 + ii, n * m + (r - 1) * m + c, 1);
}
}
}
}
for (long long ii = 0; ii < ((long long)(mal).size()); ii++) {
auto g = mal[ii];
gr.AddEdge(3 * n * m + 1 + ii, t, 1);
for (long long r = (1); r <= (n); ++r) {
for (long long c = (1); c <= (m); ++c) {
if (dis[r][c][g.r][g.c] < kInf &&
dis[r][c][g.r][g.c] * g.speed <= aktc) {
gr.AddEdge(2 * n * m + (r - 1) * m + c, 3 * n * m + 1 + ii, 1);
}
}
}
}
for (long long r = (1); r <= (n); ++r) {
for (long long c = (1); c <= (m); ++c) {
gr.AddEdge(n * m + (r - 1) * m + c, 2 * n * m + (r - 1) * m + c, 1);
}
}
if (gr.MaxFlow(s, t) == ((long long)(mal).size())) {
faj = aktc;
kp = aktc - 1;
} else {
kl = aktc + 1;
}
}
cout << faj << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.