text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6;
const int MAXV = 2E6 + 1;
int a[N];
int maxpos[MAXV][2];
void update_maxpos(int mask, int val) {
if (val > maxpos[mask][0]) {
maxpos[mask][1] = maxpos[mask][0];
maxpos[mask][0] = val;
} else if (val > maxpos[mask][1] && val != maxpos[mask][0])
maxpos[mask][1] = val;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < MAXV; i++) maxpos[i][0] = maxpos[i][1] = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
update_maxpos(a[i], i);
}
for (int mask = MAXV - 1; mask >= 0; mask--) {
for (int b = 1; b < MAXV; b <<= 1)
if (mask & b) {
update_maxpos(mask - b, maxpos[mask][0]);
update_maxpos(mask - b, maxpos[mask][1]);
}
}
int m = -1;
int HIGHB = 1;
while (HIGHB < MAXV) HIGHB <<= 1;
HIGHB >>= 1;
for (int i = 0; i < n - 2; i++) {
int mask = 0;
for (int b = HIGHB; b > 0; b >>= 1) {
if (!(b & a[i])) {
int newmask = mask | b;
if (maxpos[newmask][1] > i) {
mask = newmask;
}
}
}
m = max(m, mask | a[i]);
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dp[3000004];
void cal(int v, int d, int pos) {
if (dp[v | d].size() == 2) return;
if (v == 0) {
dp[d].push_back(pos);
return;
}
cal(v & (v - 1), d | (v & -v), pos);
cal(v & (v - 1), d, pos);
}
int main() {
int n;
scanf("%d", &n);
int arr[n];
for (long long i = 0; i < n; i++) scanf("%d", &arr[i]);
;
dp[0].resize(2);
dp[0][0] = dp[0][1] = n;
for (int i = n - 1; i >= 0; i--) {
cal(arr[i], 0, i);
}
long long int maxi = 0;
for (int i = n - 3; i >= 0; i--) {
long long int w = 0;
for (int j = 21; j >= 0; j--) {
if (!((arr[i]) & (1 << j))) {
long long int temp = w | (1 << j);
if (dp[temp].size() == 2 && dp[temp].back() > i) w = temp;
}
}
maxi = max(maxi, w | arr[i]);
}
printf("%d\n", maxi);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[(1 << 21)];
int n;
int a[1000005];
int ans;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
int i, j;
for (i = 1; i <= n; i++) {
cin >> a[i];
dp[a[i]].second = dp[a[i]].first;
dp[a[i]].first = i;
}
for (j = 0; j < 21; j++) {
for (i = 0; i < (1 << 21); i++) {
if (i & (1 << j)) continue;
int ii = i + (1 << j);
if (dp[ii].second > dp[i].first) {
dp[i].first = dp[ii].first;
dp[i].second = dp[ii].second;
} else if (dp[ii].first > dp[i].first) {
dp[i].second = dp[i].first;
dp[i].first = dp[ii].first;
} else if (dp[ii].first > dp[i].second) {
dp[i].second = dp[ii].first;
}
}
}
for (i = 1; i <= n - 2; i++) {
int w = 0;
for (j = 20; j >= 0; j--) {
if (a[i] & (1 << j)) continue;
if (dp[w | (1 << j)].second > i) w |= (1 << j);
}
ans = max(ans, w | a[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int u = 1 << 21;
int a[u], f[u], g[u];
int main() {
int n, ret = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
f[a[i]] = g[a[i]], g[a[i]] = i;
}
for (int i = 1; i < u; i <<= 1) {
for (int j = u - 1 - i; j >= 0; j -= i << 1) {
for (int k = 0; k < i; ++k) {
if (g[j - k] > g[j - k + i])
f[j - k] = max({f[j - k], g[j - k + i], f[j - k + i]});
else if (g[j - k] == g[j - k + i])
f[j - k] = max(f[j - k], f[j - k + i]);
else
f[j - k] = max(g[j - k], f[j - k + i]), g[j - k] = g[j - k + i];
}
}
}
for (int i = 1, v, w; i <= n - 2; i++) {
for (v = u >> 1, w = 0; v; v >>= 1)
if (!(a[i] & v) && f[w ^ v] > i) w ^= v;
ret = max(ret, w ^ a[i]);
}
printf("%d\n", ret);
}
|
#include <bits/stdc++.h>
inline int read() {
char c;
int x;
for (c = getchar(); !isdigit(c); c = getchar())
;
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
const int N = 3e6 + 5;
int n, ans, a[N], f[N];
void dfs(int i, int x) {
if (f[x] >= 2) {
return;
}
if (i > 20) {
f[x]++;
return;
}
dfs(i + 1, x);
if (1 << i & x) {
dfs(i + 1, 1 << i ^ x);
}
}
int main() {
n = read();
for (int i = 0; i < n; i++) {
a[i] = read();
}
for (int i = n - 1; i >= 0; i--) {
int x = 0;
for (int j = 20; j >= 0; j--) {
if ((1 << j & a[i]) == 0 && f[1 << j | x] >= 2) {
x |= 1 << j;
}
}
if (i <= n - 3) {
ans = std::max(ans, a[i] | x);
}
dfs(0, a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
struct item {
int a, b;
item() : a(-1), b(-1) {}
item(int b) : a(-1), b(b) {}
item(item x, item y) {
if (x.b < y.b) std::swap(x, y);
b = x.b;
a = std::max(x.a, y.b);
}
};
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n;
std::cin >> n;
std::vector<int> val(n);
int orall = 0;
for (int& x : val) {
std::cin >> x;
orall |= x;
}
if (orall == 0) {
std::cout << "0\n";
return 0;
}
auto npattern = 2 << (31 ^ __builtin_clz(orall));
std::vector<item> t(npattern);
for (int i = 0; i < n; ++i) t[val[i]] = item(t[val[i]], item(i));
for (int bit = 1; bit < npattern; bit <<= 1)
for (int v = 0; v < npattern; ++v)
if (v & bit) t[v ^ bit] = item(t[v ^ bit], t[v]);
int ans = 0;
for (int i = 0; i < n - 2; ++i) {
int mask = (npattern - 1) ^ val[i];
int v = 0;
for (int bit = npattern; bit >>= 1;)
if (mask & bit)
if (t[v | bit].a >= 0) v |= bit;
ans = std::max(ans, val[i] | v);
}
std::cout << ans << '\n';
}
|
#include <bits/stdc++.h>
int f[2100000], a[2100000];
void add(int x, int i) {
if (f[x] == 2) return;
if (i == 21) {
f[x]++;
return;
}
add(x, i + 1);
if ((x >> i) & 1) add(x ^ (1 << i), i + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 1; i--) {
int now = 0;
for (int j = 20; j >= 0; j--)
if (!((a[i] >> j) & 1))
if (f[now + (1 << j)] == 2) now += (1 << j);
if (i <= n - 2) ans = std::max(ans, now ^ a[i]);
add(a[i], 0);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int LG = 21, N = 1e6 + 7;
pair<int, int> r[1 << LG];
int n, a[N];
void add(pair<int, int> &p, int i) {
if (i == p.first || i == p.second) return;
if (i > p.first)
p = {i, p.first};
else if (i > p.second)
p = {p.first, i};
}
void add(pair<int, int> &l, pair<int, int> r) {
add(l, r.first);
add(l, r.second);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) add(r[a[i]], i);
for (int m = (1 << LG) - 1; m >= 0; --m) {
for (int i = 0; i < LG; ++i) {
if (!((m >> i) & 1)) add(r[m], r[m + (1 << i)]);
}
}
int ans = 0;
for (int i = 0; i + 2 < n; ++i) {
int p = 0;
for (int b = LG - 1; b >= 0; --b) {
if ((a[i] >> b) & 1) continue;
if (r[p + (1 << b)].second > i) p += 1 << b;
}
ans = max(ans, a[i] | p);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (!(ch >= '0' && ch <= '9')) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
int n, k, next, max, ans, g[10], a[1000000 + 1], f[2][2000000 + 1], bin[21 + 1],
INF;
void updata(int x, int y) {
g[1] = f[0][x], g[2] = f[1][x], g[3] = f[0][y], g[4] = f[1][y];
std::sort(g + 1, g + 5);
f[0][y] = g[4], k = 3;
while (k > 0 && g[k] == f[0][y]) k--;
if (k == 0)
f[1][y] = INF;
else
f[1][y] = g[k];
}
int main() {
bin[0] = 1;
for (int i = 1; i <= 21; i++) bin[i] = bin[i - 1] * 2;
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
if (n == 3) {
printf("%d\n", (a[1] | (a[2] & a[3])));
return 0;
}
memset(f, -63, sizeof(f));
INF = f[0][0];
for (int i = n; i >= 1; i--) {
if (f[0][a[i]] == INF)
f[0][a[i]] = i;
else if (f[1][a[i]] == INF)
f[1][a[i]] = i;
}
for (int i = 21; i >= 0; i--) {
for (int j = 0; j <= 2000000; j++) {
if ((j & bin[i]) > 0 && f[0][j] != INF) {
updata(j, j - bin[i]);
}
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
max = 0, next = 0;
for (int j = 21; j >= 0; j--) {
if ((a[i] & bin[j]) > 0)
max += bin[j];
else if (next + bin[j] <= 2000000 && f[1][next + bin[j]] > i)
next += bin[j], max += bin[j];
}
ans = std::max(ans, max);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int m = 21;
vector<int> a((size_t)n);
vector<pair<int, int>> b((size_t)1 << m, {-1, -1});
auto f = [&](pair<int, int> x, pair<int, int> y) {
pair<int, int> z{-1, -1};
for (int i : {x.first, x.second, y.first, y.second}) {
if (i > z.first) {
z.first = i;
}
}
for (int i : {x.first, x.second, y.first, y.second}) {
if (i != z.first && i > z.second) {
z.second = i;
}
}
return z;
};
for (int i = 0; i < n; i++) {
cin >> a[i];
b[a[i]] = f(b[a[i]], {-1, i});
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < 1 << m; j++) {
if ((j & 1 << i) == 0) {
b[j] = f(b[j], b[j | 1 << i]);
}
}
}
int g = 0;
for (int i = 0; i < n - 2; i++) {
int h = 0;
for (int j = m - 1; j >= 0; j--) {
if ((a[i] & 1 << j) == 0 && b[h | 1 << j].first > i &&
b[h | 1 << j].second > i) {
h |= 1 << j;
}
}
g = max(g, a[i] | h);
}
cout << g << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000005], ans;
int cnt[1 << 21];
void Upd(int x, int k) {
if (cnt[x] > 1) return;
if (k == 21) return void(cnt[x]++);
if (1 << k & x) Upd(1 << k ^ x, k + 1);
Upd(x, k + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
int now = 0, res = 0;
for (int j = 20; j >= 0; j--)
if (1 << j & a[i])
res |= 1 << j;
else if (cnt[1 << j | now] > 1)
res |= 1 << j, now |= 1 << j;
if (i < n - 1) ans = max(ans, res);
Upd(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
const int c = (1 << 21) + 5;
int n, jad[1000005], a[c], vas;
void leia(int x) {
int y = 0, m = 21;
while (m--)
if (!((x >> m) & 1) and a[(1 << m) + y] == 2) y += 1 << m;
vas = max(vas, x | y);
}
void pane(int x, int k) {
if (a[x] == 2) return;
a[x]++;
while (k < 21) {
if (x >> k & 1) pane(x ^ 1 << k, k + 1);
k++;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int(i) = (0); ((i)) < ((n)); ((i))++) cin >> jad[i];
for (int i = n - 1; i >= 0; i--) {
if (i < n - 2) leia(jad[i]);
pane(jad[i], 0);
}
cout << vas;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100, inf = 2e6;
bool cur1;
int n;
int A[maxn];
struct node {
int num[2];
node operator+(const node &_) const {
node res;
int i = 0, j = 0;
if (num[i] > _.num[j])
res.num[0] = num[i++];
else
res.num[0] = _.num[j++];
if (num[i] > _.num[j])
res.num[1] = num[i++];
else
res.num[1] = _.num[j++];
return res;
}
} sum[maxn << 1];
bool cur2;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= n; i++) {
node tmp;
tmp.num[0] = i;
sum[A[i]] = sum[A[i]] + tmp;
}
for (int i = 0; i <= 20; i++)
for (int j = 0; j <= inf; j++) {
if (1 << i & j) sum[j ^ 1 << i] = sum[j ^ 1 << i] + sum[j];
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int now = 0;
int x = A[i];
for (int j = 20; j >= 0; j--) {
if (1 << j & x) continue;
int nxt = now ^ 1 << j;
if (sum[nxt].num[1] > i) now ^= 1 << j;
}
ans = max(ans, now | A[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2000005];
int flag[2100005];
int mx[2100005];
int q[2100005];
int t[2100005];
int tot = 0, ttt = 0;
int ff[2100005];
int vis[2100005];
int best;
int b[2000005];
int ans = 0;
int out(int now) {
for (int i = 20; i >= 0; i--)
if ((1 << i) & now)
cout << 1;
else
cout << 0;
return 0;
}
void mak(int now) {
int head, tail;
head = tail = 1;
t[head] = now;
mx[now] = now;
while (head <= tail) {
int s = t[head++];
for (int j = 0; j < 21; j++)
if (((1 << j) & s) == 0 && mx[(s ^ (1 << j))] < now) {
mx[(s ^ (1 << j))] = now;
t[++tail] = (s ^ (1 << j));
}
}
return;
}
void ins(int s) {
int now = 1;
for (int i = 20; i >= 0; i--) {
if ((1 << i) & s)
now = ((now << 1) | 1);
else
now = now << 1;
vis[now] = 1;
}
return;
}
void query(int s, int now, int pos) {
ttt++;
if (ttt >= 100) return;
int temp = (now ^ (1 << (20 - pos)));
temp = temp << (pos + 1);
ans = max(ans, s | temp);
if (pos == -1) return;
if (ans >= (s | (temp | ((1 << (pos + 1)) - 1)))) return;
if (((1 << pos) & s) == 0) {
if (vis[(now << 1) | 1])
query(s, (now << 1) | 1, pos - 1);
else
query(s, (now << 1), pos - 1);
} else {
query(s, (now << 1), pos - 1);
query(s, (now << 1) | 1, pos - 1);
}
return;
}
void bfs(int now) {
tot++;
if (flag[now] >= 2) return;
int head, tail;
head = tail = 1;
q[head] = now;
flag[now]++;
ff[now] = tot;
while (head <= tail) {
int s = q[head++];
if (flag[s] == 2) ins(s);
for (int j = 0; j < 21; j++)
if (((1 << j) & s) != 0 && flag[s ^ (1 << j)] < 2 &&
ff[s ^ (1 << j)] != tot) {
ff[s ^ (1 << j)] = tot;
flag[s ^ (1 << j)]++;
q[++tail] = (s ^ (1 << j));
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
int tot = n;
n = 0;
for (int i = 1; i <= tot; i++) {
if (i >= 3 && b[i] == b[i - 1] && b[i - 1] == b[i - 2] &&
b[i - 2] == b[i - 3])
continue;
a[++n] = b[i];
}
for (int i = n; i >= 1; i--) {
if (i <= n - 2) {
ttt = 0;
int t = (1 << 21) - 1;
best = 0;
query(a[i], 1, 20);
}
bfs(a[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 50;
const int maxa = 2e6 + 50;
int n, a[maxn];
pair<int, int> dp[maxa];
void updata(int x, int pos) {
if (dp[x].first < pos) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (dp[x].second < pos && pos != dp[x].first)
dp[x].second = pos;
}
void get_dp() {
for (int x = maxa - 1; x >= 0; x--) {
for (int i = 20; i >= 0; i--) {
if (((x >> i) & 1) == 1) {
updata(x ^ (1 << i), dp[x].first);
updata(x ^ (1 << i), dp[x].second);
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
updata(a[i], i);
}
get_dp();
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int w = 0;
for (int j = 20; j >= 0; j--) {
if (((a[i] >> j) & 1) == 0 && dp[w | (1 << j)].first > i &&
dp[w | (1 << j)].second > i)
w = w | (1 << j);
}
ans = max(ans, a[i] | w);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
int a[N];
int dp[1 << 21][21];
void update(int num, int k) {
if (k > 20) return;
if (dp[num][k] > 1) return;
dp[num][k]++;
update(num, k + 1);
if ((num >> k) & 1) {
update(num ^ (1 << k), k);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = n; i >= 1; i--) {
int tp = 0, cnt = 0;
for (int j = 20; j >= 0; j--) {
if ((a[i] >> j) & 1) {
tp |= 1 << j;
} else if (dp[cnt | (1 << j)][20] > 1) {
tp |= 1 << j, cnt |= 1 << j;
}
}
update(a[i], 0);
if (i < n - 1) {
ans = max(ans, tp);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c = getchar();
int x = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return x;
}
const int N = 3e6 + 5;
int n, m, a[N], f[N], g[N], ans;
int main() {
n = gi();
for (int i = 1; i <= n; ++i) {
a[i] = gi();
g[a[i]] = f[a[i]], f[a[i]] = i;
m = max(m, a[i]);
}
int l;
for (l = 0; (1 << l) <= m; ++l)
;
--l;
for (int j = 0; j <= l; ++j)
for (int i = 0; i <= m; ++i)
if (!(i & (1 << j))) {
if (f[i ^ (1 << j)] > f[i])
g[i] = f[i], f[i] = f[i ^ (1 << j)];
else if (f[i ^ (1 << j)] > g[i])
g[i] = f[i ^ (1 << j)];
if (g[i ^ (1 << j)] > f[i])
g[i] = f[i], f[i] = g[i ^ (1 << j)];
else if (g[i ^ (1 << j)] > g[i])
g[i] = g[i ^ (1 << j)];
}
for (int i = 1; i <= n - 2; ++i) {
int now = 0;
for (int j = l; ~j; --j)
if (!(a[i] & (1 << j)) && g[now | (1 << j)] > i) now |= (1 << j);
ans = max(ans, now | a[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 21;
const int N = 1 << L;
int n, ans, a[N], best[N][3];
void add(int mask, int value) {
auto &b = best[mask];
b[2] = value;
if (b[2] > b[1]) swap(b[2], b[1]);
if (b[1] > b[0]) swap(b[1], b[0]);
}
bool possible() {
for (int i = 0; i < (int)(n); i++) {
auto target = ans & ~a[i];
auto &b = best[target];
if (b[0] > i && b[1] > i) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(best, -1, sizeof best);
cin >> n;
for (int i = 0; i < (int)(n); i++) {
cin >> a[i];
add(a[i], i);
}
for (int bit = 0; bit < (int)(L); bit++)
for (int mask = 0; mask < (int)(N); mask++)
if ((mask >> bit) & 1) {
add(mask - (1 << bit), best[mask][0]);
add(mask - (1 << bit), best[mask][1]);
}
for (int bit = (int)(L)-1; bit >= ((int)0); bit--) {
ans |= 1 << bit;
if (!possible()) ans -= 1 << bit;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LG = 21;
array<int, 2> dp[1 << LG];
array<int, 2> merge(array<int, 2> p, array<int, 2> q) {
array<int, 4> v = {p[0], q[0], p[1], q[1]};
sort(v.rbegin(), v.rend());
return {v[0], v[1]};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < (1 << LG); i++) dp[i] = {-1, -1};
int n;
cin >> n;
vector<int> v(n);
for (auto &x : v) cin >> x;
for (int i = 0; i < n; i++) dp[v[i]] = merge(dp[v[i]], array<int, 2>{i, -1});
for (int b = LG - 1; b >= 0; b--)
for (int msk = (1 << LG) - 1; msk >= 0; msk--)
if ((msk & (1 << b)) == 0) dp[msk] = merge(dp[msk], dp[msk ^ (1 << b)]);
int ans = 0;
for (int i = 0; i < n - 2; i++) {
int x = v[i], m = 0;
for (int b = LG - 1; b >= 0; b--) {
if (x & (1 << b)) continue;
int nm = m ^ (1 << b);
if (min(dp[nm][0], dp[nm][1]) > i) m = nm;
}
ans = max(ans, x + m);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxl = 3e6 + 10;
int n, ans;
int a[maxl];
int mx[maxl], sec[maxl];
inline void upd(int i, int x) {
if (x > mx[i])
sec[i] = mx[i], mx[i] = x;
else if (x > sec[i])
sec[i] = x;
}
inline void prework() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
upd(a[i], i);
}
int up = 1 << 21;
for (int j = 0; j < 20; j++)
for (int i = 0; i < up; i++)
if (!((i >> j) & 1)) {
upd(i, mx[i ^ (1 << j)]);
upd(i, sec[i ^ (1 << j)]);
}
}
inline void mainwork() {
int now;
ans = 0;
for (int i = 1; i <= n - 2; i++) {
now = 0;
for (int j = 20; j >= 0; j--) {
if ((a[i] >> j) & 1) continue;
if (sec[now ^ (1 << j)] > i) now ^= (1 << j);
}
ans = max(ans, now | a[i]);
}
}
inline void print() { printf("%d", ans); }
int main() {
prework();
mainwork();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10, MOD = 1e9 + 7;
array<int, 2> merge(array<int, 2> a, array<int, 2> b) {
array<int, 2> c{-1, -1};
for (auto v : a) c[0] = max(c[0], v);
for (auto v : b) c[0] = max(c[0], v);
for (auto v : a)
if (v != c[0]) c[1] = max(c[1], v);
for (auto v : b)
if (v != c[0]) c[1] = max(c[1], v);
return c;
}
void merge_self(array<int, 2>& a, array<int, 2> b) { a = merge(a, b); }
const int MAXV = 2e6 + 10, MAXB = 21;
int n, a[MAXN];
array<int, 2> super[1 << MAXB];
void solve() {
cin >> n;
fill(super, super + (1 << MAXB), array<int, 2>{-1, -1});
for (int i = 0; i < n; i++) {
cin >> a[i];
merge_self(super[a[i]], {i, -1});
}
for (int i = 0; i < MAXB; i++)
for (int mask = (1 << MAXB) - 1; mask >= 0; mask--) {
if ((mask >> i) & 1) merge_self(super[mask ^ (1 << i)], super[mask]);
}
auto on = [&](int i, int mask) {
return super[mask][0] > i && super[mask][1] > i;
};
int ans = 0;
for (int i = 0; i < n - 2; i++) {
int me = 0, mask = 0;
for (int j = MAXB - 1; j >= 0; j--) {
if ((a[i] >> j) & 1) {
me |= 1 << j;
continue;
}
if (on(i, mask | (1 << j))) {
me |= 1 << j;
mask |= 1 << j;
}
}
if (me == 15) {
cerr << i << endl;
}
ans = max(ans, me);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
int f[1 << 21][N], a[1000001];
int n, m;
void update(int num, int k) {
if (k > 20) return;
if (f[num][k] > 1) return;
++f[num][k];
update(num, k + 1);
if ((num >> k) & 1) update(num ^ (1 << k), k);
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= (int)n; ++i) {
scanf("%d", a + i);
}
int ans = 0;
for (register int i = n; i >= (int)1; --i) {
int res = 0, t = 0;
for (register int j = 20; j >= (int)0; --j) {
if ((a[i] >> j) & 1) {
res |= (1 << j);
} else if (f[t | (1 << j)][20] > 1) {
res |= (1 << j), t |= (1 << j);
}
}
update(a[i], 0);
if (i < n - 1) ans = max(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int mbit = 21;
const int mval = (1 << mbit);
pair<int, int> dp[(1 << mbit)];
int a[1000010], rez;
void mrg(pair<int, int> &x, pair<int, int> y) {
pair<int, int> ret = {0, 0};
if (x.first > y.first) {
ret.first = x.first;
ret.second = max(x.second, y.first);
} else {
ret.first = y.first;
ret.second = max(y.second, x.first);
}
x = ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mrg(dp[a[i]], {i, 0});
}
for (int i = 0; i < mbit; i++)
for (int j = 0; j < mval; j++)
if (!(j & (1 << i))) mrg(dp[j], dp[j ^ (1 << i)]);
for (int i = 1; i <= n; i++) {
int mask = a[i];
int w = 0;
for (int j = mbit - 1; j >= 0; j--) {
if (mask & (1 << j)) continue;
if (dp[w | (1 << j)].first > i && dp[w | (1 << j)].second > i)
w |= (1 << j);
}
if (w == 0) {
if (dp[0].first > i && dp[0].second > i)
rez = max(rez, (mask | w));
else
continue;
} else
rez = max(rez, (mask | w));
}
printf("%d\n", rez);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e6 + 5;
int a[N], cnt[N];
void add(int now, int b) {
if (b > 20) {
cnt[now]++;
}
if (b > 20 || cnt[now] >= 2) return;
add(now, b + 1);
if ((now >> b) & 1) add(now ^ (1 << b), b + 1);
}
int gao(int now) {
int res = 0;
for (int i = 20; i >= 0; --i) {
if (!((now >> i) & 1) && cnt[(res | (1 << i))] >= 2) res |= 1 << i;
}
return res | now;
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); i++) scanf("%d", &a[i]);
int ans = 0;
add(a[n], 0);
for (int i = n - 1; i > 1; --i) {
add(a[i], 0);
ans = max(ans, gao(a[i - 1]));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[1222333];
int n;
int dd[(1 << 21)][2];
int p;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i];
dd[x[i]][1] = dd[x[i]][0];
dd[x[i]][0] = i;
}
for (int k = 0; k < 21; k++) {
for (int i = (1 << 21) - 1; i >= 0; i--) {
if (~i & (1 << k)) {
int u = dd[i ^ (1 << k)][0];
if (u > dd[i][0]) {
dd[i][1] = dd[i][0];
dd[i][0] = u;
} else if (u > dd[i][1]) {
dd[i][1] = u;
}
u = dd[i ^ (1 << k)][1];
if (u > dd[i][1]) {
dd[i][1] = u;
}
}
}
}
for (int i = 1; i + 2 <= n; i++) {
int u = x[i];
int g = 0;
for (int j = 21 - 1; j >= 0; j--) {
if (u & (1 << j)) continue;
if (dd[g | (1 << j)][1] > i) g |= (1 << j);
}
p = max(p, u | g);
}
cout << p << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int res = 0;
char ch = ' ';
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') res *= 10, res += ch - '0', ch = getchar();
return res;
}
int cnt[2097156];
void insert(int x, int y) {
if (cnt[x | y] >= 2) return;
if (x == 0) {
++cnt[y];
return;
}
insert(x & x - 1, y | (x & -x)), insert(x & x - 1, y);
}
int n, ans = 0;
int A[2097156];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) A[i] = read();
for (int i = n, cur; i >= 1; --i) {
if (i <= n - 2) {
cur = 0;
for (int j = 21; j >= 0; --j)
if ((~A[i] >> j & 1) && cnt[cur | (1 << j)] == 2) cur |= (1 << j);
ans = max(ans, A[i] | cur);
}
insert(A[i], 0);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 3000000;
const int LG = 21;
int a[MX];
vector<int> dp[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc, n;
cin >> n;
for (int i = 1; i <= n; dp[a[i]].emplace_back(i), i++) cin >> a[i];
for (int i = 0; i < (1 << LG); i++) {
sort(dp[i].rbegin(), dp[i].rend());
dp[i].resize(2);
}
for (int i = 0; i < LG; i++) {
for (int mask = (1 << LG) - 1; mask >= 0; mask--) {
if (!(mask & (1 << i))) {
for (auto u : dp[mask ^ (1 << i)]) dp[mask].emplace_back(u);
sort(dp[mask].rbegin(), dp[mask].rend());
dp[mask].resize(2);
}
}
}
int mx = 0;
for (int i = 1; i <= n - 2; i++) {
int x = ((1 << LG) - 1) ^ a[i];
int sub = 0;
for (int j = LG - 1; j >= 0; j--) {
if (x & (1 << j)) {
int tsb = sub ^ (1 << j);
if (dp[tsb][0] > i && dp[tsb][1] > i) sub = tsb;
}
}
mx = max(mx, a[i] | sub);
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using db = double;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
template <class T>
void cmax(T& x, const T& y) {
if (x < y) x = y;
}
template <class T>
void cmin(T& x, const T& y) {
if (x > y) x = y;
}
template <class T>
void sort(vector<T>& v) {
sort(v.begin(), v.end());
}
template <class T>
void reverse(vector<T>& v) {
reverse(v.begin(), v.end());
}
template <class T>
void unique(vector<T>& v) {
sort(v.begin(), v.end()), v.erase(unique(v.begin(), v.end()), v.end());
}
const int SZ = 1 << 23 | 233;
struct FILEIN {
char qwq[SZ], *S = qwq, *T = qwq, ch;
char GETC() {
return (S == T) && (T = (S = qwq) + fread(qwq, 1, SZ, stdin), S == T)
? EOF
: *S++;
}
FILEIN& operator>>(char& c) {
while (isspace(c = GETC()))
;
return *this;
}
FILEIN& operator>>(string& s) {
while (isspace(ch = GETC()))
;
s = ch;
while (!isspace(ch = GETC())) s += ch;
return *this;
}
template <class T>
void read(T& x) {
bool sign = 0;
while ((ch = GETC()) < 48) sign ^= (ch == 45);
x = (ch ^ 48);
while ((ch = GETC()) > 47) x = (x << 1) + (x << 3) + (ch ^ 48);
x = sign ? -x : x;
}
FILEIN& operator>>(int& x) { return read(x), *this; }
FILEIN& operator>>(ll& x) { return read(x), *this; }
} in;
struct FILEOUT {
const static int LIMIT = 1 << 22;
char quq[SZ], ST[233];
int sz, O;
~FILEOUT() { flush(); }
void flush() {
fwrite(quq, 1, O, stdout);
fflush(stdout);
O = 0;
}
FILEOUT& operator<<(char c) { return quq[O++] = c, *this; }
FILEOUT& operator<<(string str) {
if (O > LIMIT) flush();
for (char c : str) quq[O++] = c;
return *this;
}
template <class T>
void write(T x) {
if (O > LIMIT) flush();
if (x < 0) {
quq[O++] = 45;
x = -x;
}
do {
ST[++sz] = x % 10 ^ 48;
x /= 10;
} while (x);
while (sz) quq[O++] = ST[sz--];
}
FILEOUT& operator<<(int x) { return write(x), *this; }
FILEOUT& operator<<(ll x) { return write(x), *this; }
} out;
struct Pair {
long long x, y;
Pair() { x = y = 0; }
};
void cmax(Pair& x, long long y) {
if (x.x < y) {
x.x ^= x.y ^= x.x ^= x.y;
x.x = y;
} else {
if (x.y < y) {
x.y = y;
}
}
}
void cmax(Pair& x, Pair y) { cmax(x, y.x), cmax(x, y.y); }
long long n;
const long long maxn = 1 << 22;
long long a[maxn];
Pair dp[maxn];
signed main() {
in >> n;
for (register long long i = (1); i <= (n); ++i) in >> a[i];
for (register long long i = (1); i <= (n); ++i) cmax(dp[a[i]], i);
for (register long long j = (0); j <= (21); ++j)
for (register long long i = (0); i <= (maxn - 1); ++i)
if (i & (1 << j)) cmax(dp[i ^ (1 << j)], dp[i]);
auto getpos = [&](long long x) { return dp[x].y; };
long long ans = 0;
for (register long long i = (1); i <= (n - 2); ++i) {
long long qwq = 0;
for (register long long j = (21); j >= (0); --j) {
if (a[i] & (1 << j)) continue;
if (getpos(qwq ^ (1 << j)) > i) qwq ^= (1 << j);
}
cmax(ans, qwq | a[i]);
}
out << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 998244353;
const int INF = 2147483647;
int A[maxn];
int cnt[1 << 22];
int id[1 << 22];
void add(int x, int y) {
if (cnt[x] == 2) return;
if (id[x] == y) return;
id[x] = y;
cnt[x]++;
for (int i = 0; i < 21; i++)
if (x & (1 << i)) add(x ^ (1 << i), y);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
int ma = 0;
for (int i = n; i >= 1; i--) {
if (i <= n - 2) {
int opt = 0;
for (int j = 20; j >= 0; j--) {
if (A[i] & (1 << j)) continue;
if (cnt[opt | (1 << j)] == 2) opt |= (1 << j);
}
ma = max(ma, A[i] | opt);
}
add(A[i], i);
}
cout << ma << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1 << 22];
int read() {
int p = 0, q = 1;
char ch = getchar();
while (ch < '0' || ch > '9') ch == '-' ? q = -1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9') p = p * 10 + ch - '0', ch = getchar();
return p * q;
}
long long readll() {
long long p = 0, q = 1;
char ch = getchar();
while (ch < '0' || ch > '9') ch == '-' ? q = -1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9') p = p * 10 + ch - '0', ch = getchar();
return p * q;
}
pair<int, int> f[1 << 22];
void add(int mask, int x) {
if (!f[mask].first)
f[mask].first = x;
else if (!f[mask].second) {
if (x != f[mask].first) {
f[mask].second = x;
if (f[mask].first > f[mask].second) swap(f[mask].first, f[mask].second);
}
} else if (f[mask].second < x) {
f[mask].first = f[mask].second;
f[mask].second = x;
} else if (f[mask].first < x && f[mask].second != x)
f[mask].first = x;
}
void merge(int m0, int m1) {
if (f[m1].first) add(m0, f[m1].first);
if (f[m1].second) add(m0, f[m1].second);
}
int main() {
n = read();
int bits = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
add(a[i], i);
if (a[i]) bits = max((int)log2(a[i]), bits);
}
bits = 1 << (bits + 1);
for (int j = 1; j < bits; j <<= 1)
for (int mask = bits - 1; mask; mask--)
if (mask & j) merge(mask ^ j, mask);
int ans = 0;
for (int i = 1; i <= n; i++) {
int cur = (bits - 1) ^ a[i];
int w = 0;
for (int j = bits >> 1; j; j >>= 1)
if ((cur & j) && f[w ^ j].second && f[w ^ j].first > i) w ^= j;
if (f[w].second && f[w].first > i) ans = max(ans, a[i] | w);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int K = 21;
int a[N];
pair<int, int> f[1 << K];
pair<int, int> find(pair<int, int> x, pair<int, int> y) {
int b[4] = {x.first, x.second, y.first, y.second};
sort(b, b + 4);
pair<int, int> res = {0, b[3]};
for (int i = 2; i >= 0; i--) {
if (b[i] != b[3]) {
res.first = b[i];
break;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < (1 << K); i++) f[i] = {0, 0};
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[a[i]] = find({i, 0}, f[a[i]]);
}
for (int i = (1 << K) - 1; i; i--)
for (int j = 0; j < K; j++) {
if (i & (1 << j)) {
int msk = i ^ (1 << j);
f[msk] = find(f[msk], f[i]);
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int x = 0;
for (int j = K - 1; j >= 0; j--) {
if (a[i] & (1 << j)) continue;
int val = x | (1 << j);
if (f[val].first > i && f[val].second > i) x = val;
}
ans = max(ans, x + a[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
vector<int> bits[1000000];
int num[1 << 21];
int ii;
int doDFS(int m, int b) {
if (num[m] >= 2) return 0;
if (b == bits[ii].size()) {
num[m]++;
return 0;
}
doDFS(m, b + 1);
doDFS(m ^ (1 << bits[ii][b]), b + 1);
return 0;
}
int main() {
int i;
int n;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int j;
int ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j <= 20; j++) {
if (a[i] & (1 << j)) bits[i].push_back(j);
}
}
for (i = n - 1; i >= 0; i--) {
int x = 0;
for (j = 20; j >= 0; j--) {
if (!(a[i] & (1 << j)) && (num[x | (1 << j)] >= 2)) x |= (1 << j);
}
ans = max(ans, a[i] | x);
ii = i;
doDFS(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T>
vector<T> prefixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = 0; i < (int((v).size())); i++) res[i + 1] = res[i] + v[i];
return res;
}
template <typename C, typename T>
vector<T> suffixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = (int((v).size())) - 1; i >= 0; i--) res[i] = v[i] + res[i + 1];
return res;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N;
re(N);
vi a(N);
re(a);
const int MAXB = 21, MAXV = 1 << MAXB;
vpii last(MAXV, make_pair(-1, -1));
for (int i = (N)-1; i >= 0; i--) {
pii& p = last[a[i]];
if (p.first == -1)
p.first = i;
else
ckmax(p.second, i);
}
auto join = [](pii& a, const pii& b) {
if (b.first > a.first) {
a.second = a.first;
a.first = b.first;
ckmax(a.second, b.second);
} else {
ckmax(a.second, b.first);
}
};
for (int j = 0; j < (MAXB); j++) {
for (int i = 0; i < (MAXV); i++)
if (!(i & (1 << j))) {
join(last[i], last[i + (1 << j)]);
}
}
int ans = 0;
for (int i = (N - 2) - 1; i >= 0; i--) {
int here = 0, need = 0;
for (int b = (MAXB)-1; b >= 0; b--) {
if (!(a[i] & (1 << b))) {
if (last[need ^ (1 << b)].second > i) {
need ^= 1 << b;
here ^= 1 << b;
}
} else {
here ^= 1 << b;
}
}
ckmax(ans, here);
}
ps(ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse2,avx")
using namespace std;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
const int N = (1 << 21), K = 20;
int n, a[N], cnt[N], timer, used[N], ans;
queue<int> q;
void add(int x) {
q.push(x);
used[x] = timer;
cnt[x]++;
while (!q.empty()) {
int z = q.front();
q.pop();
for (int i = K; i >= 0; i--) {
if (z & (1 << i)) {
int tmp = (z ^ (1 << i));
if (used[tmp] == timer || cnt[tmp] > 1) {
continue;
}
used[tmp] = timer;
cnt[tmp]++;
q.push(tmp);
}
}
}
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
int x = 0;
for (int j = K; j >= 0; j--) {
if (!(a[i] & (1 << j))) {
if (cnt[(x | (1 << j))] > 1) {
x |= (1 << j);
}
}
}
if (i <= n - 3) {
ans = max(ans, (a[i] | x));
}
timer++;
add(a[i]);
}
cout << ans;
}
signed main() {
int tc = 1;
while (tc--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 21);
int a[maxn], dp[maxn][21];
void update(int x, int k) {
if (k > 20) return;
if (dp[x][k] >= 2) return;
++dp[x][k];
update(x, k + 1);
if (x >> k & 1) update(x ^ (1 << k), k);
}
signed main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 1; i--) {
int res = 0, bit = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] >> j & 1)
res |= 1 << j;
else if (dp[bit | (1 << j)][20] >= 2)
res |= 1 << j, bit |= 1 << j;
}
update(a[i], 0);
if (i <= n - 2) ans = max(ans, res);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, d = 1;
char y = getchar();
while (y < '0' || y > '9') {
if (y == '-') d = -1;
y = getchar();
}
while (y >= '0' && y <= '9') {
x = (x << 3) + (x << 1) + (y ^ '0');
y = getchar();
}
return x * d;
}
const int N = (1 << 21);
int n, root = 0, ans = 0, a[N], dp[N][2];
int F(int x) { return (N - 1) ^ x; }
void insert(int t, int x) {
if (x > dp[t][1])
dp[t][0] = dp[t][1], dp[t][1] = x;
else if (x > dp[t][0])
dp[t][0] = x;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
a[i] = read();
insert(F(a[i]), i);
}
for (register int i = 0; i < 21; i++)
for (register int j = 0; j < N; j++)
if (j & (1 << i)) {
insert(j, dp[j ^ (1 << i)][1]);
insert(j, dp[j ^ (1 << i)][0]);
}
for (register int j = 1; j < n - 1; j++) {
int k = 0;
for (register int i = 20; i >= 0; i--) {
if (a[j] & (1 << i)) continue;
if (dp[F(k | (1 << i))][0] > j) k |= (1 << i);
}
ans = max(ans, a[j] | k);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 22;
const int N = (1 << K);
int b[N];
void add(int x, int k) {
if (b[x] >= 2) return;
b[x]++;
while (k < K) {
if ((x >> k) & 1) {
add(x ^ (1 << k), k + 1);
}
k++;
}
}
int32_t main() {
int n;
scanf("%d", &n);
vector<int> arr(n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
int ans = 0;
for (int i = n - 1; i >= 0; --i) {
int elem = arr[i];
int temp = 0;
for (int k = K - 1; k >= 0; --k) {
if ((1 << k) & elem) continue;
if (b[(temp | (1 << k))] >= 2) temp = temp + (1 << k);
}
add(elem, 0);
if (i < n - 2) ans = max(ans, temp | elem);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2.1e6 + 3;
struct data {
int a, b;
inline friend void merge(data &x, data &y) {
x.b = max(min(x.a, y.a), max(x.b, y.b));
x.a = max(x.a, y.a);
}
};
data f[N];
int a[N];
int main() {
int n, mx = 0, s;
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d", a + i);
mx = max(mx, a[i]);
}
s = 31 - __builtin_clz(mx);
for (register int i = n; i; i--) {
if (!f[a[i]].a)
f[a[i]].a = i;
else if (f[a[i]].a && !f[a[i]].b)
f[a[i]].b = i;
}
for (register int i = 1; i <= mx; i <<= 1)
for (register int j = i; j <= mx; j += i << 1)
for (register int k = j; k < j + i; k++) merge(f[k ^ i], f[k]);
int ans = 0;
for (register int i = 1; i <= n - 2; i++) {
int nw = 0;
for (register int j = s; ~j; j--)
if (a[i] >> j & 1 ^ 1 && f[nw | 1 << j].b > i) nw |= 1 << j;
ans = max(ans, a[i] | nw);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class C>
void min_self(C &a, C b) {
a = min(a, b);
}
template <class C>
void max_self(C &a, C b) {
a = max(a, b);
}
long long mod(long long n, long long m = 1000000007) {
n %= m, n += m, n %= m;
return n;
}
const int MAXN = (1 << 21);
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int n;
vector<pair<int, int>> store;
vector<int> a(MAXN);
void init() {
store.resize(MAXN + 2);
for (int i = 0; i < MAXN; i++) store[i] = {-1, -1};
}
void update(pair<int, int> &p, int ind) {
if (ind > p.first) {
p.second = p.first;
p.first = ind;
} else
p.second = max(p.second, ind);
}
bool check(int mask, int done) {
for (int i = 0; i < n; i++) {
int rem = (a[i] ^ mask) & done;
if (store[rem].second > i) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
update(store[a[i]], i);
}
for (int bit = 0; bit < 21; bit++) {
for (int i = 0; i < MAXN; i++) {
if (i & (1 << bit)) {
update(store[i ^ (1 << bit)], store[i].first);
update(store[i ^ (1 << bit)], store[i].second);
}
}
}
int mask = 0, done = 0;
for (int bit = 20; bit >= 0; bit--) {
int submask = (1 << bit);
done += submask;
if (check(mask + submask, done)) {
mask += submask;
}
}
cout << mask, cout << "\n";
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 50;
const int maxa = 4e6 + 50;
int n, a[maxn];
pair<int, int> dp[maxa];
void updata(int x, int pos) {
if (dp[x].first < pos) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (dp[x].second < pos && pos != dp[x].first)
dp[x].second = pos;
}
void get_dp() {
for (int x = maxa - 1; x >= 0; x--) {
for (int i = 20; i >= 0; i--) {
if (((x >> i) & 1) == 1) {
updata(x ^ (1 << i), dp[x].first);
updata(x ^ (1 << i), dp[x].second);
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
updata(a[i], i);
}
get_dp();
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int w = 0;
for (int j = 20; j >= 0; j--) {
if (((a[i] >> j) & 1) == 0 && dp[w | (1 << j)].first > i &&
dp[w | (1 << j)].second > i)
w = w | (1 << j);
}
if (dp[w].first > i && dp[w].second > i) ans = max(ans, a[i] | w);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool MinPlace(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int dr[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dc[8] = {1, 1, 0, -1, -1, -1, 0, 1};
vector<pair<int, int> > centers;
bool check(int x, vector<vector<int> > &cnt, vector<string> &grid, int n, int m,
int store = 0) {
int dist[n + 1][m + 1];
bool visited[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[i][j] = (long long)1e9;
visited[i][j] = false;
}
}
queue<pair<int, int> > q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cost = (i + x <= n && i - x >= 1 && j + x <= m && j - x >= 1)
? (cnt[i + x][j + x] - cnt[i + x][j - x - 1] -
cnt[i - x - 1][j + x] + cnt[i - x - 1][j - x - 1])
: 0;
if (cost == (2 * x + 1) * (2 * x + 1)) {
dist[i][j] = 0;
q.push({i, j});
visited[i][j] = true;
}
}
}
if (store == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (visited[i][j])
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
return 0;
}
while (!q.empty()) {
auto t = q.front();
q.pop();
int cost = dist[t.first][t.second];
for (int j = 0; j < 8; j++) {
int r1 = t.first + dr[j];
int c1 = t.second + dc[j];
if (r1 >= 1 && r1 <= n && c1 >= 1 && c1 <= m && !visited[r1][c1]) {
dist[r1][c1] = 1 + cost;
visited[r1][c1] = true;
q.push({r1, c1});
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (grid[i][j] == 'X' && dist[i][j] > x) {
flag = 1;
break;
}
}
}
return (flag == 0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
vector<string> grid(n + 1);
vector<vector<int> > cnt(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
string str2 = "$" + str;
grid[i] = str2;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1] +
(grid[i][j] == 'X');
}
}
int low = 0;
int high = max(n, m);
int mid;
while (high >= low) {
mid = low + (high - low) / 2;
if (check(mid, cnt, grid, n, m))
low = mid + 1;
else
high = mid - 1;
}
cout << high << endl;
check(high, cnt, grid, n, m, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, dx[] = {0, 0, 1, 1, 1, -1, -1, -1},
dy[] = {1, -1, 1, 0, -1, 1, 0, -1};
vector<string> a;
vector<vector<long long>> w;
vector<vector<long long>> dist;
bool check(long long x, long long y) {
return x >= 0 && y >= 0 && x <= n + 1 && y <= m + 1;
}
bool checkT(long long T) {
queue<pair<long long, long long>> q;
for (long long i = 0; i < n + 2; ++i) {
fill(dist[i].begin(), dist[i].end(), 1e9);
for (long long j = 0; j < m + 2; ++j) {
if (w[i][j] > T) {
dist[i][j] = 0;
q.push({i, j});
}
}
}
while (!q.empty()) {
long long x = q.front().first, y = q.front().second;
q.pop();
for (long long i = 0; i < 8; ++i) {
long long nx = x + dx[i], ny = y + dy[i];
if (check(nx, ny) && dist[nx][ny] > 1 + dist[x][y]) {
dist[nx][ny] = dist[x][y] + 1;
q.push({nx, ny});
}
}
}
bool f = 1;
for (long long i = 0; i < n + 2; ++i) {
for (long long j = 0; j < m + 2; ++j) {
if (a[i][j] == 'X' && dist[i][j] > T) f = 0;
}
}
return f;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
a.resize(n + 2);
w.resize(n + 2);
dist.resize(n + 2);
queue<pair<long long, long long>> q;
string g;
for (long long i = 0; i < m + 2; ++i) g += '.';
for (long long i = 1; i <= n; ++i) {
w[i].resize(m + 2);
dist[i].resize(m + 2);
fill(w[i].begin(), w[i].end(), 1e9);
cin >> a[i];
a[i] = '.' + a[i] + '.';
}
w[0].resize(m + 2);
w[n + 1].resize(m + 2);
dist[0].resize(m + 2);
dist[n + 1].resize(m + 2);
a[0] = g;
a[n + 1] = g;
for (long long i = 0; i < n + 2; ++i) {
for (long long j = 0; j < m + 2; ++j) {
if (a[i][j] != 'X') {
w[i][j] = 0;
q.push({i, j});
}
}
}
while (!q.empty()) {
long long x = q.front().first, y = q.front().second;
q.pop();
for (long long i = 0; i < 8; ++i) {
long long nx = x + dx[i], ny = y + dy[i];
if (check(nx, ny) && w[x][y] + 1 < w[nx][ny]) {
w[nx][ny] = w[x][y] + 1;
q.push({nx, ny});
}
}
}
long long l = 0, r = max(n + 2, m + 2), med;
while (r - l > 1) {
med = (r + l) / 2;
if (checkT(med))
l = med;
else
r = med;
}
long long res = l;
if (checkT(r)) res = r;
cout << res << '\n';
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= m; ++j) {
if (w[i][j] > res)
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
vector<vector<int> > dst;
vector<vector<int> > prf;
vector<vector<char> > s;
bool dowork(int t, int n, int m) {
queue<pair<int, int> > q;
dst = vector<vector<int> >(n + 1, vector<int>(m + 1, -1));
for (int x = 1 + t; x + t <= n; x++) {
for (int y = 1 + t; y + t <= m; y++) {
int res = prf[x + t][y + t] - prf[x - t - 1][y + t] -
prf[x + t][y - t - 1] + prf[x - t - 1][y - t - 1];
if (res == (2 * t + 1) * (2 * t + 1)) {
dst[x][y] = 0, q.push({x, y});
}
}
}
while (!q.empty()) {
int x, y;
tie(x, y) = q.front();
q.pop();
if (dst[x][y] == t) break;
for (int k = 0; k < 8; k++) {
int nx = x + dx[k], ny = y + dy[k];
if (1 <= nx && nx <= n && 1 <= ny && ny <= m && dst[nx][ny] == -1) {
dst[nx][ny] = dst[x][y] + 1, q.push({nx, ny});
}
}
}
int flag = 1;
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
flag &= (dst[x][y] == -1 && s[x][y] == '.' ||
dst[x][y] != -1 && s[x][y] == 'X');
}
}
return flag;
}
void solve() {
int n, m;
cin >> n >> m;
s = vector<vector<char> >(n + 1, vector<char>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> s[i][j];
}
}
prf = vector<vector<int> >(n + 1, vector<int>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
prf[i][j] =
prf[i - 1][j] + prf[i][j - 1] - prf[i - 1][j - 1] + (s[i][j] == 'X');
}
}
int l = 0, r = max(n, m) / 2, ans = 0;
while (l <= r) {
int t = (l + r) >> 1;
if (dowork(t, n, m)) {
ans = t, l = t + 1;
} else {
r = t - 1;
}
}
cout << ans << "\n";
dowork(ans, n, m);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) cout << (dst[x][y] == 0 ? "X" : ".");
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m;
vector<string> a;
vector<vector<int> > dp;
void precalc(vector<string> &a, vector<vector<int> > &dp) {
dp.assign(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[i][j] = (a[i][j] == 'X');
if (i) dp[i][j] += dp[i - 1][j];
if (j) dp[i][j] += dp[i][j - 1];
if (i && j) dp[i][j] -= dp[i - 1][j - 1];
}
}
}
void normalize(int &x, int &y) {
if (x < 0) x = 0;
if (x >= n) x = n - 1;
if (y < 0) y = 0;
if (y >= m) y = m - 1;
}
int calc(vector<vector<int> > &dp, int x1, int stupid_cmath, int x2, int y2) {
normalize(x1, stupid_cmath);
normalize(x2, y2);
if (x1 > x2 || stupid_cmath > y2) return 0;
int ans = dp[x2][y2];
if (x1) ans -= dp[x1 - 1][y2];
if (stupid_cmath) ans -= dp[x2][stupid_cmath - 1];
if (x1 && stupid_cmath) ans += dp[x1 - 1][stupid_cmath - 1];
return ans;
}
void assign(vector<string> &a, vector<vector<int> > &dp, vector<string> &b,
int T) {
b = a;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) b[i][j] = '.';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (calc(dp, i - T, j - T, i + T, j + T) ==
(2ll * T + 1) * (2ll * T + 1)) {
b[i][j] = 'X';
}
}
}
}
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
bool ok(int T) {
vector<string> b;
assign(a, dp, b, T);
vector<vector<int> > t(n, vector<int>(m, -1));
queue<pair<int, int> > q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (b[i][j] == 'X') {
q.push(make_pair(i, j));
t[i][j] = 0;
}
}
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (t[p.first][p.second] > T) continue;
for (int d = 0; d < 8; d++) {
int x = p.first + dx[d];
int y = p.second + dy[d];
if (x >= 0 && x < n && y >= 0 && y < m && t[x][y] == -1) {
t[x][y] = t[p.first][p.second] + 1;
q.push(make_pair(x, y));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (t[i][j] != -1 && t[i][j] <= T) b[i][j] = 'X';
}
}
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
char TMP[1001000];
int main() {
scanf("%d %d\n", &n, &m);
string tmp = "";
for (int i = 0; i < m + 2; i++) tmp += '.';
a.push_back(tmp);
for (int i = 0; i < n; i++) {
string tmp;
scanf("%s\n", TMP);
tmp = TMP;
a.push_back("." + tmp + ".");
}
a.push_back(tmp);
n += 2;
m += 2;
precalc(a, dp);
int ans = 0;
int l = 1, r = min(n, m);
while (l <= r) {
int mid = (l + r) >> 1;
if (ok(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
vector<string> b;
assign(a, dp, b, ans);
vector<string> res;
for (int i = 1; i + 1 < b.size(); i++) {
string tmp = b[i];
tmp.erase((int)tmp.size() - 1);
tmp.erase(0, 1);
res.push_back(tmp);
}
b = res;
printf("%d\n", ans);
for (int i = 0; i < b.size(); i++) {
for (int j = 0; j < b[i].size(); j++) printf("%c", b[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << " = " << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << " = " << h << ",";
_dbg(sdbg + 1, t...);
}
const int INF = 1e6;
int n, m;
vector<vector<int>> a, s;
vector<pair<int, int>> pos;
bool Check(int t) {
pos.clear();
vector<vector<int>> b = vector<vector<int>>(n + 2, vector<int>(m + 2, 0));
int cnt = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 1) {
int x = i - t, y = j - t, u = i + t, v = j + t;
if (x < 1 || y < 1 || u > n || v > m) {
continue;
}
if (s[u][v] - s[x - 1][v] - s[u][y - 1] + s[x - 1][y - 1] ==
(u - x + 1) * (v - y + 1)) {
b[x][y]++;
b[x][v + 1]--;
b[u + 1][y]--;
b[u + 1][v + 1]++;
pos.push_back({i, j});
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];
if (a[i][j] != (b[i][j] > 0)) {
return false;
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
a = vector<vector<int>>(n + 1, vector<int>(m + 1, 0));
s = vector<vector<int>>(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
char c;
cin >> c;
a[i][j] = (c == 'X');
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
}
}
int lo = 0, hi = INF, ans = 0;
while (lo <= hi) {
int mi = (lo + hi) / 2;
if (Check(mi)) {
ans = mi;
lo = mi + 1;
} else {
hi = mi - 1;
}
}
cout << ans << '\n';
Check(ans);
vector<vector<char>> tab(n + 1, vector<char>(m + 1, '.'));
for (auto p : pos) {
tab[p.first][p.second] = 'X';
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cout << tab[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n);
vector<vector<int>> arr(n, vector<int>(m));
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '.')
arr[i][j] = 0;
else if (i == 0 || j == 0)
arr[i][j] = 1;
else
arr[i][j] =
min(arr[i - 1][j - 1], min(arr[i - 1][j], arr[i][j - 1])) + 1;
vector<vector<int>> b(n, vector<int>(m));
int l = 0, r = 1e6;
while (r - l > 1) {
int mid = (l + r) >> 1;
int x = 2 * mid + 1;
bool flag = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (arr[i][j] >= x)
b[i][j] = x;
else
b[i][j] = 0;
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--) {
if (i > 0) b[i - 1][j] = max(b[i - 1][j], b[i][j] - 1);
if (j > 0) b[i][j - 1] = max(b[i][j - 1], b[i][j] - 1);
if (i > 0 && j > 0) b[i - 1][j - 1] = max(b[i - 1][j - 1], b[i][j] - 1);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (arr[i][j] == 0) continue;
if (b[i][j] == 0) flag = false;
}
if (flag)
l = mid;
else
r = mid;
}
cout << l << '\n';
int x = 2 * l + 1;
vector<string> ans(n, string(m, '.'));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (arr[i][j] >= x) ans[i - l][j - l] = 'X';
for (int i = 0; i < n; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
char s[1000035];
vector<int> mp[1000035], ps[1000035], ot[1000035];
int area(int a, int b, int c, int d) {
return mp[c][d] - mp[a - 1][d] - mp[c][b - 1] + mp[a - 1][b - 1];
}
bool ck(int T, bool fg) {
int len = T * 2 + 1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) ps[i][j] = 0;
for (int(i) = 1; (i) <= (int)(n + 1 - len); (i)++)
for (int(j) = 1; (j) <= (int)(m + 1 - len); (j)++)
if (area(i, j, i, j) == 1) {
if (area(i, j, i + len - 1, j + len - 1) == len * len) {
if (fg) {
ot[i + T][j + T] = 1;
}
ps[i][j]++;
ps[i][j + len]--;
ps[i + len][j]--;
ps[i + len][j + len]++;
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
ps[i][j] += ps[i][j - 1] + ps[i - 1][j] - ps[i - 1][j - 1];
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) {
bool isx = area(i, j, i, j);
bool isy = ps[i][j] >= 1;
if (isx != isy) return 0;
}
return 1;
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (int)(n + 2); (i)++) {
mp[i].resize(m + 5, 0);
ps[i].resize(m + 5, 0);
ot[i].resize(m + 5, 0);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%s", s + 1);
for (int(j) = 1; (j) <= (int)(m); (j)++)
if (s[j] == 'X') mp[i][j] = 1;
for (int(j) = 1; (j) <= (int)(m); (j)++)
mp[i][j] += mp[i][j - 1] + mp[i - 1][j] - mp[i - 1][j - 1];
}
int l = 0, r = min(m, n);
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ck(mid, 0))
l = mid;
else
r = mid - 1;
}
int ans = ck(r, 0) ? r : l;
printf("%d\n", ans);
ck(ans, 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++) printf("%c", ot[i][j] ? 'X' : '.');
puts("");
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e6) + 5;
int n, m;
vector<int> pref[maxn];
vector<string> a;
vector<int> kek[maxn];
int get(int i1, int j1, int i2, int j2, int tp) {
if (tp == 0)
return (pref[i2][j2] - pref[i1 - 1][j2] - pref[i2][j1 - 1] +
pref[i1 - 1][j1 - 1]);
return (kek[min(n, i2)][min(m, j2)] - kek[max(int(0), i1 - 1)][min(m, j2)] -
kek[min(n, i2)][max(int(0), j1 - 1)] +
kek[max(int(0), i1 - 1)][max(int(0), j1 - 1)]);
}
int check(int sz) {
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < m + 1; j++) {
kek[i][j] = 0;
}
}
int block = (2 * sz + 1) * (2 * sz + 1);
for (int i = sz + 1; i <= n - sz; i++) {
for (int j = sz + 1; j <= m - sz; j++) {
if (get(i - sz, j - sz, i + sz, j + sz, 0) == block) {
kek[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
kek[i][j] = kek[i - 1][j] + kek[i][j - 1] - kek[i - 1][j - 1] + kek[i][j];
}
}
int res = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i - 1][j] == 'X') {
if (get(i - sz, j - sz, i + sz, j + sz, 1) == 0) {
res = 0;
}
}
}
}
return res;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
pref[i].assign(m + 1, 0);
kek[i].assign(m + 1, 0);
string cur;
cin >> cur;
cur = "#" + cur;
a.push_back(cur);
}
kek[n].assign(m + 1, 0);
pref[n].assign(m + 1, 0);
for (int i = 0; i < m; i++) {
pref[0][i] = 0;
}
for (int i = 0; i < n; i++) {
pref[i][0] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pref[i][j] = pref[i][j - 1] + pref[i - 1][j] - pref[i - 1][j - 1] +
(a[i - 1][j] == 'X');
}
}
int l = 0, r = min(n, m) / 2 + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
int res = check(mid);
if (res) {
l = mid;
} else {
r = mid;
}
}
cout << l << endl;
int block = (2 * l + 1) * (2 * l + 1);
string ans = "";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i < l + 1 || j < l + 1 || i > n - l || j > m - l) {
ans += ".";
} else if (get(i - l, j - l, i + l, j + l, 0) == block) {
ans += "X";
} else {
ans += ".";
}
}
ans += "\n";
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using pii = std::pair<long long, long long>;
using namespace std;
long long n, m;
char x;
pii dirs[8] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
long long valid(long long i, long long j) {
return (i >= 0 && i < n && j >= 0 && j < m);
}
long long check(long long time, vector<vector<long long>>& dist) {
vector<vector<long long>> newgrid(n, vector<long long>(m, -1));
queue<pii> q;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
if (dist[i][j] > time)
newgrid[i][j] = dist[i][j];
else if (dist[i][j] == time) {
newgrid[i][j] = dist[i][j];
q.push({i, j});
}
}
while (!q.empty()) {
pii pos = q.front();
q.pop();
if (!newgrid[pos.first][pos.second]) continue;
for (auto ne : dirs) {
long long newx = pos.first + ne.first, newy = pos.second + ne.second;
if (valid(newx, newy) && newgrid[newx][newy] == -1) {
q.push({newx, newy});
newgrid[newx][newy] = newgrid[pos.first][pos.second] - 1;
}
}
}
long long good = 1;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if ((newgrid[i][j] >= 0) ^ (dist[i][j] >= 0)) good = 0;
return good;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
vector<vector<long long>> grid(n, vector<long long>(m)),
dist(n, vector<long long>(m, -1)), visited(n, vector<long long>(m, 0)),
pref(n, vector<long long>(m, 0));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
cin >> x;
grid[i][j] = (x == 'X');
pref[i][j] = grid[i][j];
}
for (long long i = 0; i < n; i++)
for (long long j = 1; j < m; j++) pref[i][j] += pref[i][j - 1];
for (long long i = 1; i < n; i++)
for (long long j = 0; j < m; j++) pref[i][j] += pref[i - 1][j];
queue<pii> q;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if (grid[i][j]) {
long long good = 0;
if (i == 0 || i == n - 1 || j == 0 || j == m - 1) good = 1;
if (!good)
for (auto adj : dirs)
if (!grid[i + adj.first][j + adj.second]) good = 1;
if (good) {
q.push({i, j});
dist[i][j] = 0;
}
}
long long madepth = 0;
while (!q.empty()) {
pii pos = q.front();
q.pop();
madepth = max(madepth, dist[pos.first][pos.second]);
for (auto ne : dirs) {
long long newx = pos.first + ne.first, newy = pos.second + ne.second;
if (valid(newx, newy) && grid[newx][newy] && dist[newx][newy] == -1) {
q.push({newx, newy});
dist[newx][newy] = dist[pos.first][pos.second] + 1;
}
}
}
long long lo = 0, hi = madepth, mid;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
if (check(mid, dist))
lo = mid;
else
hi = mid - 1;
}
assert(lo == hi);
long long mintime = lo;
cout << mintime << "\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++)
if (dist[i][j] < mintime)
cout << ".";
else
cout << "X";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool smin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool smax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
vector<vector<int> > a, p, b;
int getf(int pa, int push_back, int c, int d) {
int res = p[c][d];
if (push_back > 0) {
res -= p[c][push_back - 1];
}
if (pa > 0 && push_back > 0) {
res += p[pa - 1][push_back - 1];
}
if (pa > 0) {
res -= p[pa - 1][d];
}
return res;
}
int gets(int pa, int push_back, int c, int d) {
int res = b[c][d];
if (push_back > 0) {
res -= b[c][push_back - 1];
}
if (pa > 0 && push_back > 0) {
res += b[pa - 1][push_back - 1];
}
if (pa > 0) {
res -= b[pa - 1][d];
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int n, m;
cin >> n >> m;
a.resize(n, vector<int>(m));
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
char c;
cin >> c;
a[i][j] = (c == 'X' ? 1 : 0);
}
}
p = a;
b = a;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
if (i > 0) {
p[i][j] += p[i - 1][j];
}
if (j > 0) {
p[i][j] += p[i][j - 1];
}
if (i > 0 && j > 0) {
p[i][j] -= p[i - 1][j - 1];
}
}
}
int l = 0;
int r = n * m + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
b[i][j] = 0;
}
}
for (int i = mid; i + mid < n; ++i) {
for (int j = mid; j + mid < m; ++j) {
int pa, push_back, c, d;
pa = i - mid;
push_back = j - mid;
c = i + mid;
d = j + mid;
int need = (c - pa + 1) * (d - push_back + 1);
if (need == getf(pa, push_back, c, d)) {
b[i][j] = 1;
}
}
}
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
if (i > 0) {
b[i][j] += b[i - 1][j];
}
if (j > 0) {
b[i][j] += b[i][j - 1];
}
if (i > 0 && j > 0) {
b[i][j] -= b[i - 1][j - 1];
}
}
}
bool ok = true;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
int c = min(n - 1, i + mid);
int d = min(m - 1, j + mid);
int pa = max(0, i - mid);
int push_back = max(0, j - mid);
bool t = gets(pa, push_back, c, d) > 0;
ok &= (t == a[i][j]);
}
}
if (ok) {
l = mid;
} else {
r = mid;
}
}
cout << l << '\n';
int mid = l;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
b[i][j] = 0;
}
}
for (int i = mid; i + mid < n; ++i) {
for (int j = mid; j + mid < m; ++j) {
int pa, push_back, c, d;
pa = i - mid;
push_back = j - mid;
c = i + mid;
d = j + mid;
int need = (c - pa + 1) * (d - push_back + 1);
if (need == getf(pa, push_back, c, d)) b[i][j] = 1;
}
}
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
if (b[i][j]) {
cout << "X";
} else {
cout << ".";
}
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
n += 2;
m += 2;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 || j == 0 || i == n - 1 || j == m - 1) {
a[i][j] = '.';
} else {
cin >> a[i][j];
}
}
}
int lo = 0, hi = n + m;
while (hi - lo > 1) {
int t = (lo + hi) / 2;
int pr[n + 1][m + 1];
memset(pr, 0, sizeof(pr));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') {
int x1 = max(0, i - t), y1 = max(0, j - t),
x2 = min(n - 1, i + t) + 1, y2 = min(m - 1, j + t) + 1;
pr[x1][y1]++;
pr[x2][y2]++;
pr[x1][y2]--;
pr[x2][y1]--;
}
}
}
vector<pair<int, int>> to;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i) pr[i][j] += pr[i - 1][j];
if (j) pr[i][j] += pr[i][j - 1];
if (i && j) pr[i][j] -= pr[i - 1][j - 1];
if (!pr[i][j]) to.push_back({i, j});
}
}
memset(pr, 0, sizeof(pr));
for (auto e : to) {
int x1 = e.first - t, y1 = e.second - t, x2 = e.first + t + 1,
y2 = e.second + t + 1;
pr[x1][y1]++;
pr[x1][y2]--;
pr[x2][y1]--;
pr[x2][y2]++;
}
bool ok = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i) pr[i][j] += pr[i - 1][j];
if (j) pr[i][j] += pr[i][j - 1];
if (i && j) pr[i][j] -= pr[i - 1][j - 1];
if ((pr[i][j] && a[i][j] == '.') || (!pr[i][j] && a[i][j] == 'X'))
ok = 0;
}
}
if (ok) {
lo = t;
} else {
hi = t;
}
}
int t = lo;
int pr[n + 1][m + 1];
memset(pr, 0, sizeof(pr));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') {
int x1 = max(0, i - t), y1 = max(0, j - t), x2 = min(n - 1, i + t) + 1,
y2 = min(m - 1, j + t) + 1;
pr[x1][y1]++;
pr[x1][y2]--;
pr[x2][y1]--;
pr[x2][y2]++;
}
}
}
cout << t << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i) pr[i][j] += pr[i - 1][j];
if (j) pr[i][j] += pr[i][j - 1];
if (i && j) pr[i][j] -= pr[i - 1][j - 1];
}
}
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < m - 1; j++) {
cout << (pr[i][j] ? '.' : 'X');
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int frsti, lsti, frstj, lstj, n, m, le, ri, ans, mid;
vector<int> dp[N], dp1[N], a[N], fix[N];
char ch;
int sz(int i, int j, int i1, int j1) {
int len = (i1 - i + 1);
int height = (j1 - j + 1);
return len * height;
}
int cnt(int i, int j, int i1, int j1) {
return dp[i1][j1] - dp[i1][j - 1] - dp[i - 1][j1] + dp[i - 1][j - 1];
}
int getans(int i, int j, int i1, int j1) {
return dp1[i1][j1] - dp1[i1][j - 1] - dp1[i - 1][j1] + dp1[i - 1][j - 1];
}
int check(int t, int ty) {
for (int i = 0; i <= n + 3; i++) {
fix[i].resize(m + 5);
dp1[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
fix[i][j] = 0;
dp1[i][j] = 0;
if (i - t + 1 < 1 || i + t - 1 > n || j - t + 1 < 1 || j + t - 1 > m)
continue;
frsti = i - t + 1;
frstj = j - t + 1;
lsti = i + t - 1;
lstj = j + t - 1;
if (cnt(frsti, frstj, lsti, lstj) == sz(frsti, frstj, lsti, lstj)) {
fix[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp1[i][j] = dp1[i - 1][j] + dp1[i][j - 1] + fix[i][j] - dp1[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
frsti = max(1, i - t + 1);
frstj = max(1, j - t + 1);
lsti = min(n, i + t - 1);
lstj = min(m, j + t - 1);
if (getans(frsti, frstj, lsti, lstj) == 0) return 0;
}
}
}
if (ty == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (fix[i][j])
cout << "X";
else
cout << ".";
}
cout << " ";
}
}
return 1;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 3; i++) {
a[i].resize(m + 5);
dp[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == 'X')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + a[i][j];
}
}
le = 1;
ri = min(n, m);
while (le <= ri) {
mid = (le + ri) / 2;
if (check(mid, 0)) {
ans = mid;
le = mid + 1;
} else
ri = mid - 1;
}
cout << ans - 1 << " ";
int ff = check(ans, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> scanForest() {
int n, m;
cin >> n >> m;
vector<string> f(n, string(m, '0'));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> f[i][j];
return f;
}
void printForest(vector<string> f) {
for (string s : f) cout << s << '\n';
}
vector<string> burnIt(vector<string> f, int t, char x) {
queue<pair<int, int>> burning;
for (int i = 0; i < f.size(); i++)
for (int j = 0; j < f[i].size(); j++)
if (f[i][j] == x) burning.push({i, j});
if (x == '.') {
for (int j = 0; j < f[0].size(); j++) burning.push({-1, j});
for (int j = 0; j < f[0].size(); j++) burning.push({f.size(), j});
for (int i = 0; i < f.size(); i++) burning.push({i, -1});
for (int i = 0; i < f.size(); i++) burning.push({i, f[0].size()});
}
for (int i = 0; i < t && burning.size(); i++) {
int k = burning.size();
while (k--) {
auto cell = burning.front();
burning.pop();
for (int r : {cell.first - 1, cell.first, cell.first + 1}) {
for (int c : {cell.second - 1, cell.second, cell.second + 1}) {
if (r < 0 || r >= f.size() || c < 0 || c >= f[r].size()) {
if (x == '.')
continue;
else
return {};
}
if (f[r][c] == x) continue;
f[r][c] = x;
burning.push({r, c});
}
}
}
}
return f;
}
bool check(vector<string> f, int t) {
vector<string> g = burnIt(f, t, '.');
vector<string> gg = burnIt(g, t, 'X');
return f == gg;
}
int solve(vector<string> f) {
int l = 1, r = min(f.size(), f[0].size()) / 2 + 1;
while (l < r) {
int m = (l + r) / 2;
if (check(f, m))
l = m + 1;
else
r = m;
}
return l - 1;
}
int main() {
iostream::sync_with_stdio(false);
vector<string> f = scanForest();
int t = solve(f);
cout << t << '\n';
printForest(burnIt(f, t, '.'));
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6 + 6;
vector<vector<char>> tp, ans;
vector<vector<int>> pref, cnt;
int n, m;
int get(vector<vector<int>> &arr, int y312312312313131, int x1, int y2,
int x2) {
int res = arr[y2][x2] - arr[y312312312313131 - 1][x2] - arr[y2][x1 - 1] +
arr[y312312312313131 - 1][x1 - 1];
return res;
}
bool check(int t) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
cnt[i][j] = 0;
}
}
int sz = 1 + t * 2;
for (int i = 1; i <= n - sz + 1; i++) {
for (int j = 1; j <= m - sz + 1; j++) {
if (get(pref, i, j, i + sz - 1, j + sz - 1) == sz * sz) {
cnt[i][j]++;
cnt[i][j + sz]--;
cnt[i + sz][j]--;
cnt[i + sz][j + sz]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1] + cnt[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (tp[i][j] == 'X') {
if (!cnt[i][j]) {
return false;
}
}
}
}
return true;
}
void rsz(vector<vector<int>> &a, int n, int m) {
a.resize(n + 5);
for (auto &el : a) {
el.resize(m + 5);
}
}
void rsz(vector<vector<char>> &a, int n, int m) {
a.resize(n + 5);
for (auto &el : a) {
el.resize(m + 5);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
rsz(tp, n, m);
rsz(cnt, n, m);
rsz(pref, n, m);
rsz(ans, n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> tp[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pref[i][j] = pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1] +
(tp[i][j] == 'X');
}
}
int l = 0, r = 1005;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << "\n";
int cur_sz = 1 + l * 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans[i][j] = '.';
}
}
for (int i = 1; i <= n - cur_sz + 1; i++) {
for (int j = 1; j <= m - cur_sz + 1; j++) {
if (get(pref, i, j, i + cur_sz - 1, j + cur_sz - 1) == cur_sz * cur_sz) {
ans[i + cur_sz / 2][j + cur_sz / 2] = 'X';
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ans[i][j];
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool start[1200001];
vector<int> g[1200001];
vector<int> startV;
int cnt = 0;
vector<int> bfs(vector<int> s) {
vector<int> d(cnt + 1, -1);
queue<int> q;
for (auto i : s) q.push(i), d[i] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto to : g[v]) {
if (d[to] == -1) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
return d;
}
bool ok(int T) {
vector<int> d = bfs(startV);
vector<int> s;
for (int i = 1; i <= cnt; i++) {
if (d[i] >= T) s.push_back(i);
}
vector<int> d1 = bfs(s);
for (auto i : startV) {
if (d1[i] > T || d1[i] == -1) return false;
}
return true;
}
bool used[1000011];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int> > a;
a.resize(n + 1);
for (int i = 0; i <= n; i++) a[i].resize(m + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == 'X')
a[i][j] = ++cnt;
else
a[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!a[i][j]) continue;
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
if (!dx && !dy) continue;
if (i + dx >= 1 && j + dy >= 1 && i + dx <= n && j + dy <= m &&
a[i + dx][j + dy])
g[a[i][j]].push_back(a[i + dx][j + dy]);
else
start[a[i][j]] = true;
}
}
}
}
for (int i = 1; i <= cnt; i++) {
if (start[i]) startV.push_back(i);
}
int l = 0;
int r = 1000001;
while (r - l > 1) {
int m = (l + r) / 2;
if (ok(m))
l = m;
else
r = m;
}
int T = l;
cout << T << '\n';
vector<int> d = bfs(startV);
for (int i = 1; i <= cnt; i++) {
if (d[i] >= T) used[i] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (used[a[i][j]])
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cerr << '{';
for (auto &i : x) cerr << (first++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int a, b;
vector<string> t;
vector<vector<int>> pref;
bool check(int v, bool fnl) {
vector<pair<int, int>> start;
for (int i = 0; i < a - 2 * v; i++) {
for (int j = 0; j < b - 2 * v; j++) {
int val = pref[i + 2 * v][j + 2 * v] +
(i - 1 >= 0 && j - 1 >= 0 ? pref[i - 1][j - 1] : 0) -
(i - 1 >= 0 ? pref[i - 1][j + 2 * v] : 0) -
(j - 1 >= 0 ? pref[i + 2 * v][j - 1] : 0);
if (val == (2 * v + 1) * (2 * v + 1)) {
start.push_back({i + v, j + v});
}
}
}
if (start.empty()) return 0;
if (fnl) {
vector<string> ans(a, string(b, '.'));
for (auto &x : start) {
ans[x.first][x.second] = 'X';
}
cout << v << '\n';
for (auto &x : ans) {
cout << x << '\n';
}
return 1;
}
vector<vector<bool>> vis(a, vector<bool>(b));
queue<array<int, 3>> q;
for (const auto &x : start) {
q.push({0, x.first, x.second});
}
auto good = [&](int w, int x, int y) {
return x >= 0 && x < a && y >= 0 && y < b && !vis[x][y] && w <= v;
};
while (q.size()) {
auto [w, x, y] = q.front();
q.pop();
if (vis[x][y]) continue;
vis[x][y] = 1;
if (good(w + 1, x, y + 1)) q.push({w + 1, x, y + 1});
if (good(w + 1, x, y - 1)) q.push({w + 1, x, y - 1});
if (good(w + 1, x + 1, y)) q.push({w + 1, x + 1, y});
if (good(w + 1, x - 1, y)) q.push({w + 1, x - 1, y});
if (good(w + 1, x + 1, y + 1)) q.push({w + 1, x + 1, y + 1});
if (good(w + 1, x + 1, y - 1)) q.push({w + 1, x + 1, y - 1});
if (good(w + 1, x - 1, y + 1)) q.push({w + 1, x - 1, y + 1});
if (good(w + 1, x - 1, y - 1)) q.push({w + 1, x - 1, y - 1});
}
bool ok = 1;
for (int i = 0; i < a && ok; i++) {
for (int j = 0; j < b && ok; j++) {
if (t[i][j] == 'X') {
ok &= vis[i][j];
}
}
}
return ok;
}
void test_case() {
cin >> a >> b;
t.resize(a);
for (auto &x : t) cin >> x;
pref = vector<vector<int>>(a, vector<int>(b, 0));
pref[0][0] = t[0][0] == '.' ? 0 : 1;
for (int i = 1; i < a; i++) {
pref[i][0] += t[i][0] == 'X' ? 1 : 0;
pref[i][0] += pref[i - 1][0];
}
for (int i = 1; i < b; i++) {
pref[0][i] += t[0][i] == 'X' ? 1 : 0;
pref[0][i] += pref[0][i - 1];
}
for (int i = 1; i < a; i++) {
for (int j = 1; j < b; j++) {
pref[i][j] += pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1] +
(t[i][j] == 'X' ? 1 : 0);
}
}
int l = 0, r = 1e6, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid, 0))
ans = max(ans, mid), l = mid + 1;
else
r = mid - 1;
}
check(ans, 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
char p[N];
char v[N];
int u[N];
int z[N];
int n, m;
inline bool solve(int zd) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int t = i * (m + 1) + j;
v[t] = '.';
if (p[t] == 'X') {
int flag = 0;
int rx = i + zd;
int ry = j + zd;
int lx = i - zd;
int ly = j - zd;
if (rx > n || ry > m || lx <= 0 || ly <= 0) flag = 1;
if ((u[rx * (m + 1) + ry] - u[rx * (m + 1) + ly - 1] -
u[(lx - 1) * (m + 1) + ry]) +
u[(lx - 1) * (m + 1) + ly - 1] !=
((zd * 2 + 1) * (zd * 2 + 1)))
flag = 1;
if (!flag) v[t] = 'X';
}
z[t] = (v[t] == 'X' ? 1 : 0) + z[t - 1] + z[t - m - 1] - z[t - m - 2];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int t = i * (m + 1) + j;
if (p[t] == 'X') {
int rx = i + zd;
int ry = j + zd;
int lx = i - zd;
int ly = j - zd;
if (rx > n || ry > m || lx <= 0 || ly <= 0) continue;
if ((z[rx * (m + 1) + ry] - z[rx * (m + 1) + ly - 1] -
z[(lx - 1) * (m + 1) + ry] + z[(lx - 1) * (m + 1) + ly - 1]) == 0)
return false;
}
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int t = i * (m + 1) + j;
scanf(" %c", &p[t]);
u[t] = (p[t] == 'X' ? 1 : 0) + u[t - 1] + u[t - m - 1] - u[t - m - 2];
}
}
int zd = 10000005;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int t = 0;
while (p[i * (m + 1) + j] == 'X') {
j++;
t++;
if (j == m + 1) break;
}
if (t && zd > t) zd = t;
}
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int t = 0;
while (p[i + j * (m + 1)] == 'X') {
j++;
t++;
if (j == n + 1) break;
}
if (t && zd > t) zd = t;
}
}
zd = (zd - 1) / 2;
if (zd == 0) {
printf("0\n");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", p[i * (m + 1) + j]);
printf("\n");
}
return 0;
}
int l = 0, r = zd;
int ans = 0;
while (l <= r) {
int m = (l + r) >> 1;
if (solve(m)) {
l = m + 1;
ans = m;
} else
r = m - 1;
}
printf("%d\n", ans);
solve(ans);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", v[i * (m + 1) + j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int frsti, lsti, frstj, lstj, n, m, le, ri, ans, mid;
vector<int> dp[N], dp1[N], a[N], fix[N];
char ch;
int sz(int i, int j, int i1, int j1) {
int len = (i1 - i + 1);
int height = (j1 - j + 1);
return len * height;
}
int cnt(int i, int j, int i1, int j1) {
return dp[i1][j1] - dp[i1][j - 1] - dp[i - 1][j1] + dp[i - 1][j - 1];
}
int getans(int i, int j, int i1, int j1) {
return dp1[i1][j1] - dp1[i1][j - 1] - dp1[i - 1][j1] + dp1[i - 1][j - 1];
}
int check(int t, int ty) {
for (int i = 0; i <= n + 3; i++) {
fix[i].resize(m + 5);
dp1[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
fix[i][j] = 0;
dp1[i][j] = 0;
if (i - t + 1 < 1 || i + t - 1 > n || j - t + 1 < 1 || j + t - 1 > m)
continue;
frsti = i - t + 1;
frstj = j - t + 1;
lsti = i + t - 1;
lstj = j + t - 1;
if (cnt(frsti, frstj, lsti, lstj) == sz(frsti, frstj, lsti, lstj)) {
fix[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp1[i][j] = dp1[i - 1][j] + dp1[i][j - 1] + fix[i][j] - dp1[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
frsti = max(1, i - t + 1);
frstj = max(1, j - t + 1);
lsti = min(n, i + t - 1);
lstj = min(m, j + t - 1);
if (getans(frsti, frstj, lsti, lstj) == 0) return 0;
}
}
}
if (ty == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (fix[i][j])
cout << "X";
else
cout << ".";
}
cout << "\n";
}
}
return 1;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 3; i++) {
a[i].resize(m + 5);
dp[i].resize(m + 5);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == 'X')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + a[i][j];
}
}
le = 1;
ri = min(n, m);
while (le <= ri) {
mid = (le + ri) / 2;
if (check(mid, 0)) {
ans = mid;
le = mid + 1;
} else
ri = mid - 1;
}
cout << ans - 1 << "\n";
int ff = check(ans, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<bool>> a(n, vector<bool>(m));
vector<vector<bool>> r(n, vector<bool>(m, 0));
vector<vector<int>> sz(n, vector<int>(m));
vector<vector<int>> w(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[i][j] = c != 'X';
sz[i][j] =
a[i][j] ? 0
: (min(i, j) == 0 ? 1
: 1 + min(sz[i - 1][j - 1],
min(sz[i - 1][j], sz[i][j - 1])));
}
deque<pair<int, int>> s;
for (int i = n - 1; i >= 0; i--) {
s.clear();
for (int j = m - 1; j >= 0; j--) {
while (!s.empty() && s.back().first <= sz[i][j]) s.pop_back();
s.push_back({sz[i][j], j - sz[i][j]});
while (!s.empty() && s.front().second >= j) s.pop_front();
w[i][j] = s.empty() ? 0 : s.front().first;
}
}
int out = 1000000000;
for (int j = m - 1; j >= 0; j--) {
s.clear();
for (int i = n - 1; i >= 0; i--) {
while (!s.empty() && s.back().first <= w[i][j]) s.pop_back();
s.push_back({w[i][j], i - w[i][j]});
while (!s.empty() && s.front().second >= i) s.pop_front();
if (!s.empty()) out = min(out, s.front().first);
}
}
out = (out - 1) / 2;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (sz[i][j] >= (2 * out + 1)) r[i - out][j - out] = 1;
cout << out << "\n";
for (auto& y : r) {
for (auto x : y) cout << (x ? 'X' : '.');
cout << "\n";
}
}
|
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[10000100];
long long inv[10000010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
string s[1000200];
vector<vector<long long>> rui;
long long h, w;
bool ch(long long r) {
vector<vector<long long>> imo(h + 2, vector<long long>(w + 2, 0));
long long ma = 2 * r + 1;
for (long long i = 1; i + ma <= h + 1; i++)
for (long long j = 1; j + ma <= w + 1; j++) {
if (rui[i + ma - 1][j + ma - 1] - rui[i - 1][j + ma - 1] -
rui[i + ma - 1][j - 1] + rui[i - 1][j - 1] ==
ma * ma) {
imo[i][j]++;
imo[i][j + ma]--;
imo[i + ma][j]--;
imo[i + ma][j + ma]++;
}
}
for (long long i = 1; i <= h; i++)
for (long long j = 1; j <= w; j++) {
imo[i][j] += imo[i][j - 1] + imo[i - 1][j] - imo[i - 1][j - 1];
if ((imo[i][j] > 0) ^ (s[i][j - 1] == 'X')) return 0;
}
return 1;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
rui.resize(h + 1, vector<long long>(w + 1, 0));
for (long long i = 1; i <= h; i++) {
cin >> s[i];
for (long long j = 1; j <= w; j++)
if (s[i][j - 1] == 'X') rui[i][j] = 1;
}
for (long long i = 1; i <= h; i++)
for (long long j = 1; j <= w; j++)
rui[i][j] += rui[i - 1][j] + rui[i][j - 1] - rui[i - 1][j - 1];
long long ma = 1000000007;
for (long long i = 1; i <= h; i++) {
vector<long long> ve;
for (long long j = 0; j < w; j++)
if (s[i][j] == 'X') {
if (j == 0 || s[i][j - 1] != 'X')
ve.push_back(1);
else
ve.back()++;
}
for (auto v : ve) ma = min(v, ma);
}
for (long long j = 0; j < w; j++) {
vector<long long> ve;
for (long long i = 1; i <= h; i++)
if (s[i][j] == 'X') {
if (i == 1 || s[i - 1][j] != 'X')
ve.push_back(1);
else
ve.back()++;
}
for (auto v : ve) ma = min(v, ma);
}
if (ma % 2 == 0) ma--;
long long ans;
if (ch(ma)) {
ans = ma;
} else {
long long si = 0, ue = ma;
while (ue - si > 1) {
long long me = (ue + si) / 2;
if (ch(me))
si = me;
else
ue = me;
}
ans = si;
}
cout << ans << endl;
ma = 2 * ans + 1;
for (long long i = 1; i <= h; i++) {
for (long long j = 1; j <= w; j++) {
if (i - ma / 2 >= 1 && i + ma / 2 <= h && j - ma / 2 >= 1 &&
j + ma / 2 <= w) {
if (rui[i + ma / 2][j + ma / 2] - rui[i - ma / 2 - 1][j + ma / 2] -
rui[i + ma / 2][j - ma / 2 - 1] +
rui[i - ma / 2 - 1][j - ma / 2 - 1] ==
ma * ma)
cout << "X";
else
cout << ".";
} else
cout << ".";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void GetForest(vector<vector<int> > &Forest, int n, int m);
void Prefix(vector<vector<int> > &Forest, int n, int m);
int good(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T);
void fire(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T);
void ReWrite(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T);
int sum(vector<vector<int> > &Forest, int i0, int j0, int i1, int j1);
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > Forest(n + 4);
GetForest(Forest, n, m);
Prefix(Forest, n, m);
vector<vector<int> > fired(n + 4);
for (int i = 0; i < n + 4; i++) {
for (int j = 0; j < m + 4; j++) {
fired[i].push_back(0);
}
}
int L = 0, R = n, T = 0;
while (L < R) {
T = (L + R + 1) / 2;
if (good(Forest, fired, n, m, T))
L = T;
else
R = T - 1;
}
cout << L << "\n";
ReWrite(Forest, fired, n, m, L);
for (int i = 2; i <= n + 1; i++) {
for (int j = 2; j <= m + 1; j++) {
if (fired[i][j])
cout << "X";
else
cout << ".";
}
cout << "\n";
}
return 0;
}
void GetForest(vector<vector<int> > &Forest, int n, int m) {
string s;
for (int j = 0; j < m + 4; j++) Forest[0].push_back(0);
for (int j = 0; j < m + 4; j++) Forest[1].push_back(0);
for (int i = 2; i <= n + 1; i++) {
cin >> s;
Forest[i].push_back(0);
Forest[i].push_back(0);
for (int j = 1; j <= m; j++) {
if (s[j - 1] == '.')
Forest[i].push_back(0);
else
Forest[i].push_back(1);
}
Forest[i].push_back(0);
Forest[i].push_back(0);
}
for (int j = 0; j < m + 4; j++) Forest[n + 2].push_back(0);
for (int j = 0; j < m + 4; j++) Forest[n + 3].push_back(0);
}
void Prefix(vector<vector<int> > &Forest, int n, int m) {
for (int i = 2; i <= n + 2; i++) {
for (int j = 2; j <= m + 2; j++) {
Forest[i][j] +=
Forest[i - 1][j] + Forest[i][j - 1] - Forest[i - 1][j - 1];
}
}
}
int good(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T) {
fire(Forest, fired, n, m, T);
for (int i = 1; i <= n + 2; i++) {
for (int j = 1; j <= m + 2; j++) {
if (sum(Forest, i, j, i, j) && !fired[i][j] ||
!sum(Forest, i, j, i, j) && fired[i][j])
return 0;
}
}
return 1;
}
void fire(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T) {
for (int i = 0; i < n + 4; i++) {
for (int j = 0; j < m + 4; j++) {
fired[i][j] = 0;
}
}
for (int i = T + 2; i <= n - T + 1; i++) {
for (int j = T + 2; j <= m - T + 1; j++) {
if (sum(Forest, i - T, j - T, i + T, j + T) ==
(2 * T + 1) * (2 * T + 1)) {
fired[i - T][j - T]++;
fired[i - T][j + T + 1]--;
fired[i + T + 1][j - T]--;
fired[i + T + 1][j + T + 1]++;
}
}
}
for (int i = 1; i < n + 4; i++) {
for (int j = 1; j < m + 4; j++) {
fired[i][j] += fired[i - 1][j] + fired[i][j - 1] - fired[i - 1][j - 1];
}
}
}
void ReWrite(vector<vector<int> > &Forest, vector<vector<int> > &fired, int n,
int m, int T) {
for (int i = 0; i < n + 4; i++) {
for (int j = 0; j < m + 4; j++) {
fired[i][j] = 0;
}
}
for (int i = T + 2; i <= n - T + 1; i++) {
for (int j = T + 2; j <= m - T + 1; j++) {
if (sum(Forest, i - T, j - T, i + T, j + T) ==
(2 * T + 1) * (2 * T + 1)) {
fired[i][j] = 1;
}
}
}
}
int sum(vector<vector<int> > &Forest, int i0, int j0, int i1, int j1) {
return Forest[i1][j1] - Forest[i1][j0 - 1] - Forest[i0 - 1][j1] +
Forest[i0 - 1][j0 - 1];
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == 'X') a[i][j] = 1;
}
}
vector<vector<int> > sum(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum[i + 1][j + 1] = sum[i][j + 1] + sum[i + 1][j] - sum[i][j] + a[i][j];
}
}
int l = -1, r = min(n, m) + 10;
vector<pair<int, int> > ans;
while (r - l > 1) {
int mid = (l + r) / 2;
vector<vector<int> > cur(n + 1, vector<int>(m + 1));
vector<pair<int, int> > cur_ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x1 = i - mid, x2 = i + mid;
int y1 = j - mid, y2 = j + mid;
if (x1 < 0 || y1 < 0 || x2 >= n || y2 >= m) continue;
if (sum[x2 + 1][y2 + 1] - sum[x2 + 1][y1] - sum[x1][y2 + 1] +
sum[x1][y1] ==
(x2 - x1 + 1) * (y2 - y1 + 1)) {
cur_ans.push_back({i, j});
cur[x1][y1]++, cur[x2 + 1][y2 + 1]++, cur[x1][y2 + 1]--,
cur[x2 + 1][y1]--;
}
}
}
vector<vector<int> > nw(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
nw[i + 1][j + 1] = nw[i + 1][j] + nw[i][j + 1] - nw[i][j] + cur[i][j];
}
}
bool ok = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!a[i][j] && nw[i + 1][j + 1] || a[i][j] && !nw[i + 1][j + 1]) {
ok = 0;
break;
}
}
}
if (ok) {
l = mid;
ans = cur_ans;
} else {
r = mid;
}
}
cout << l << endl;
vector<vector<char> > mat(n, vector<char>(m, '.'));
for (auto e : ans) {
mat[e.first][e.second] = 'X';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << mat[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
struct P {
int x, y;
};
struct Pd {
int x, y, d;
bool operator<(const Pd &o) const { return d > o.d; }
};
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int h, w;
cin >> h >> w;
vector<vector<bool> > m(h + 2, vector<bool>(w + 2, 0));
vector<vector<int> > d(h + 2, vector<int>(w + 2, 0));
char c;
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
cin >> c;
m[y][x] = c == 'X';
}
}
queue<P> q;
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
if (m[y][x]) {
c = 0;
for (int dy = -1; dy <= 1; ++dy) {
for (int dx = -1; dx <= 1; ++dx) {
if (!m[y + dy][x + dx]) c = 1;
}
}
if (c) {
q.push({x, y});
d[y][x] = 1;
}
}
}
}
int mi = 1;
while (!q.empty()) {
int x = q.front().x;
int y = q.front().y;
mi = d[y][x];
q.pop();
for (int dy = -1; dy <= 1; ++dy) {
for (int dx = -1; dx <= 1; ++dx) {
if (m[y + dy][x + dx] && !d[y + dy][x + dx]) {
q.push({x + dx, y + dy});
d[y + dy][x + dx] = d[y][x] + 1;
}
}
}
}
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
if (m[y][x]) {
c = 1;
for (int dy = -1; dy <= 1; ++dy) {
for (int dx = -1; dx <= 1; ++dx) {
if (d[y + dy][x + dx] > d[y][x]) c = 0;
}
}
if (c) {
mi = min(mi, d[y][x]);
}
}
}
}
{
vector<Pd> v;
int tot = 0;
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
if (m[y][x]) {
tot++;
v.push_back({x, y, d[y][x] - 1});
}
}
}
sort(v.begin(), v.end());
queue<Pd> q;
auto feas = [&](int D) -> bool {
vector<vector<bool> > vis(h + 2, vector<bool>(w + 2, 0));
int hm = 0;
for (auto &i : v) {
if (i.d < D) break;
q.push(i);
hm++;
vis[i.y][i.x] = 1;
}
while (!q.empty()) {
Pd p = q.front();
q.pop();
for (int dy = -1; dy <= 1; ++dy) {
for (int dx = -1; dx <= 1; ++dx) {
if (m[p.y + dy][p.x + dx] && !vis[p.y + dy][p.x + dx]) {
vis[p.y + dy][p.x + dx] = 1;
if (p.d - 1) q.push({p.x + dx, p.y + dy, p.d - 1});
hm++;
}
}
}
}
return hm == tot;
};
int lb = 0, ub = 2 + v[0].d;
while (lb < ub - 1) {
int m = (lb + ub) / 2;
if (feas(m))
lb = m;
else
ub = m;
}
cout << lb << '\n';
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
if (d[y][x] > lb)
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int h, w;
vector<string> g;
vector<string> startfire;
vector<vector<int>> cnt;
long long cntrect(int lx, int ly, int hx, int hy) {
return cnt[hx + 1][hy + 1] - cnt[lx][hy + 1] - cnt[hx + 1][ly] + cnt[lx][ly];
}
vector<vector<int>> have;
vector<vector<int>> delta;
void markrect(int lx, int ly, int hx, int hy) {
++delta[lx][ly], --delta[lx][hy + 1];
--delta[hx + 1][ly], ++delta[hx + 1][hy + 1];
++have[lx][ly];
}
bool can(int t) {
have = vector<vector<int>>(h, vector<int>(w + 1, 0));
delta = vector<vector<int>>(h + 1, vector<int>(w + 1, 0));
startfire = vector<string>(h, string(w, '.'));
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y) {
if (x - 1 >= 0) delta[x][y] += delta[x - 1][y];
if (y - 1 >= 0) have[x][y] += have[x][y - 1];
have[x][y] += delta[x][y];
if (g[x][y] == '.') {
assert(have[x][y] == 0);
continue;
}
int fx = x + t, fy = y + t;
bool can = true;
if (fx - t < 0 || fx + t >= h || fy - t < 0 || fy + t >= w) can = false;
if (can) {
long long actual = cntrect(fx - t, fy - t, fx + t, fy + t);
long long expect = (long long)(2 * t + 1) * (2 * t + 1);
if (actual != expect) can = false;
}
if (!can) {
if (have[x][y] == 0)
return false;
else
continue;
}
startfire[fx][fy] = 'X';
markrect(fx - t, fy - t, fx + t, fy + t);
}
return true;
}
int solve() {
cnt = vector<vector<int>>(h + 1, vector<int>(w + 1, 0));
for (int x = (0); x < (h); ++x)
for (int y = (0); y < (w); ++y)
cnt[x + 1][y + 1] =
cnt[x + 1][y] + cnt[x][y + 1] - cnt[x][y] + (g[x][y] == 'X' ? 1 : 0);
int lo = 0, hi = (min(h, w) - 1) / 2 + 1;
while (lo + 1 < hi) {
int mi = lo + (hi - lo) / 2;
if (can(mi))
lo = mi;
else
hi = mi;
}
assert(can(lo));
return lo;
}
void run() {
scanf("%d%d", &h, &w);
g = vector<string>(h);
for (int x = (0); x < (h); ++x) cin >> g[x];
int ans = solve();
printf("%d\n", ans);
for (int x = (0); x < (((int)(startfire).size())); ++x)
printf("%s\n", startfire[x].c_str());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1000005;
int n, m;
string s[MAXN];
vector<int> in[MAXN], G[MAXN];
int query1(int row1, int col1, int row2, int col2) {
if (row1 <= 0 || row2 > n || col1 <= 0 || col2 > m) return 1;
return in[row2][col2] - in[row2][col1 - 1] - in[row1 - 1][col2] +
in[row1 - 1][col1 - 1];
}
int query2(int row1, int col1, int row2, int col2) {
row2 = min(row2, n);
col2 = min(col2, m);
row1 = max(row1, 1);
col1 = max(col1, 1);
if (row1 <= 0 || row2 > n || col1 <= 0 || col2 > m) return 0;
return G[row2][col2] - G[row2][col1 - 1] - G[row1 - 1][col2] +
G[row1 - 1][col1 - 1];
}
bool check(int r) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (s[i - 1][j - 1] == 'O') continue;
int val = query1(i - r, j - r, i + r, j + r);
if (val >= 1)
G[i][j] = 0;
else
G[i][j] = 1;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
G[i][j] = G[i][j] + G[i - 1][j] + G[i][j - 1] - G[i - 1][j - 1];
}
}
bool bad = false;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (s[i - 1][j - 1] == 'X') {
int val = query2(i - r, j - r, i + r, j + r);
if (val == 0) bad = true;
}
}
}
if (bad) return false;
return true;
}
void backtrack(int r) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (s[i - 1][j - 1] == 'O') {
cout << ".";
continue;
}
int val = query1(i - r, j - r, i + r, j + r);
if (val >= 1)
G[i][j] = 0;
else
G[i][j] = 1;
if (G[i][j] == 0)
cout << ".";
else
cout << "X";
}
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
while (cin >> n >> m) {
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i <= n; ++i) {
G[i].clear();
G[i].resize(m + 5);
in[i].clear();
in[i].resize(m + 5);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (s[i - 1][j - 1] == 'X')
in[i][j] = 0;
else
in[i][j] = 1;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
in[i][j] = in[i - 1][j] + in[i][j - 1] + in[i][j] - in[i - 1][j - 1];
}
}
int l, r, mid;
l = 0;
r = min(n, m);
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << r << '\n';
backtrack(r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e6 + 10;
const int M = 1e3 + 10;
const int MOD = 998244353;
const long double eps = 1e-6;
const pair<int, int> dir[] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int n, m;
vector<int> cnt[N], a[N], b[N];
struct PrefSum {
vector<vector<int>> p;
void build(vector<int>* arr) {
p.resize(n);
for (int i = 0; i < n; i++) {
p[i].resize(m);
for (int j = 0; j < m; j++) {
int x = 0;
if (i) {
x += p[i - 1][j];
}
if (j) {
x += p[i][j - 1];
}
if (i && j) {
x -= p[i - 1][j - 1];
}
p[i][j] = x + arr[i][j];
}
}
}
int sum(int i, int j, int x, int y) {
i = max(i, 0);
j = max(j, 0);
x = min(x, n - 1);
y = min(y, m - 1);
int res = p[x][y];
if (i) {
res -= p[i - 1][y];
}
if (j) {
res -= p[x][j - 1];
}
if (i && j) {
res += p[i - 1][j - 1];
}
return res;
}
} ap;
inline bool check(int i, int j, int mid) {
if (i - mid < 0 || i + mid >= n || j - mid < 0 || j + mid >= m) {
return false;
}
return ap.sum(i - mid, j - mid, i + mid, j + mid) ==
(2 * mid + 1) * (2 * mid + 1);
}
int calc(int i, int j) {
int left = 0, right = min(n, m) / 2 + 1, mid;
while (right - left > 1) {
mid = (left + right) / 2;
if (check(i, j, mid)) {
left = mid;
} else {
right = mid;
}
}
return left;
}
bool check(int t) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cnt[i][j] >= t) {
b[i][j] = 1;
} else {
b[i][j] = 0;
}
}
}
PrefSum bp;
bp.build(b);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] && bp.sum(i - t, j - t, i + t, j + t) == 0) {
return false;
}
}
}
return true;
}
signed main() {
cout << fixed << setprecision(9);
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
a[i].resize(m);
b[i].resize(m);
cnt[i].resize(m);
for (int& x : a[i]) {
char c;
cin >> c;
x = (c == 'X');
}
}
ap.build(a);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) {
cnt[i][j] = calc(i, j);
} else {
cnt[i][j] = -1;
}
}
}
int left = 0, right = min(n, m) / 2 + 1, mid;
while (right - left > 1) {
mid = (left + right) / 2;
;
if (check(mid)) {
left = mid;
} else {
right = mid;
}
}
cout << left << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cnt[i][j] >= left) {
cout << 'X';
} else {
cout << '.';
}
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2, class T3 = hash<T1>>
using umap = unordered_map<T1, T2, T3>;
template <class T>
using uset = unordered_set<T>;
template <class T>
using vec = vector<T>;
const long long infll = numeric_limits<long long>::max() >> 1;
const int inf = numeric_limits<int>::max() >> 1;
const int N = 1e6 + 1;
int n, m;
string t[N];
vec<int> dst[N];
vec<int> tmp[N];
pair<int, int> adj[8] = {{1, 1}, {1, 0}, {1, -1}, {0, 1},
{0, -1}, {-1, 1}, {-1, 0}, {-1, -1}};
void input() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
t[i] = '#' + t[i];
}
for (int i = 1; i <= n; ++i) {
dst[i].resize(m + 1);
for (int j = 1; j <= m; ++j) {
dst[i][j] = inf;
}
}
}
int dijkstra() {
auto cmp = [](pair<int, int> x, pair<int, int> y) {
return dst[x.first][x.second] > dst[y.first][y.second];
};
priority_queue<pair<int, int>, vec<pair<int, int>>, decltype(cmp)> pq(cmp);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (t[i][j] != 'X') {
continue;
}
if (i == 1 || j == 1 || i == n || j == m) {
dst[i][j] = 0;
pq.push({i, j});
} else {
for (pair<int, int> p : adj) {
int ix = i + p.first;
int jx = j + p.second;
if (t[ix][jx] == '.') {
dst[i][j] = 0;
pq.push({i, j});
break;
}
}
}
}
}
int res = 0;
while (!pq.empty()) {
int i = pq.top().first;
int j = pq.top().second;
pq.pop();
res = max(res, dst[i][j]);
for (pair<int, int> p : adj) {
int ix = i + p.first;
int jx = j + p.second;
if (ix > 0 && ix <= n && jx > 0 && jx <= m) {
if (t[ix][jx] == '.') {
continue;
}
if (dst[ix][jx] > dst[i][j] + 1) {
dst[ix][jx] = dst[i][j] + 1;
pq.push({ix, jx});
}
}
}
}
return res;
}
bool test(int k) {
queue<pair<int, int>> q;
for (int i = 1; i <= n; ++i) {
tmp[i].resize(m + 1);
for (int j = 1; j <= m; ++j) {
tmp[i][j] = inf;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (t[i][j] == 'X' && dst[i][j] >= k) {
tmp[i][j] = 0;
q.push({i, j});
}
}
}
while (!q.empty()) {
int i = q.front().first;
int j = q.front().second;
q.pop();
for (pair<int, int> p : adj) {
int ix = i + p.first;
int jx = j + p.second;
if (ix > 0 && ix <= n && jx > 0 && jx <= m) {
if (tmp[ix][jx] > tmp[i][j] + 1) {
tmp[ix][jx] = tmp[i][j] + 1;
q.push({ix, jx});
}
}
}
}
int res = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (t[i][j] == 'X' && tmp[i][j] == inf) {
return 0;
}
if (t[i][j] == 'X') {
res = max(res, tmp[i][j]);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (t[i][j] == '.' && tmp[i][j] <= res) {
return 0;
}
}
}
return 1;
}
int bin_search(int l, int r) {
if (l == r) {
return l;
}
int q = l + r + 1 >> 1;
if (test(q)) {
return bin_search(q, r);
} else {
return bin_search(l, q - 1);
}
}
void solve() {
int q = dijkstra();
int k = bin_search(0, N);
cout << k << "\n";
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (dst[i][j] >= k) {
cout << t[i][j];
} else {
cout << ".";
}
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
input();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6 + 6;
vector<vector<char>> tp, ans;
vector<vector<int>> pref, cnt;
int n, m;
int get(vector<vector<int>> &arr, int y312312312313131, int x1, int y2,
int x2) {
int res = arr[y2][x2] - arr[y312312312313131 - 1][x2] - arr[y2][x1 - 1] +
arr[y312312312313131 - 1][x1 - 1];
return res;
}
bool check(int t) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
cnt[i][j] = 0;
}
}
int sz = 1 + t * 2;
for (int i = 1; i <= n - sz + 1; i++) {
for (int j = 1; j <= m - sz + 1; j++) {
if (get(pref, i, j, i + sz - 1, j + sz - 1) == sz * sz) {
cnt[i][j]++;
cnt[i][j + sz]--;
cnt[i + sz][j]--;
cnt[i + sz][j + sz]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1] + cnt[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (tp[i][j] == 'X') {
if (!cnt[i][j]) {
return false;
}
}
}
}
return true;
}
void rsz(vector<vector<int>> &a, int n, int m) {
a.resize(n + 5);
for (auto &el : a) {
el.resize(m + 5);
}
}
void rsz(vector<vector<char>> &a, int n, int m) {
a.resize(n + 5);
for (auto &el : a) {
el.resize(m + 5);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
rsz(tp, n, m);
rsz(cnt, n, m);
rsz(pref, n, m);
rsz(ans, n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> tp[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pref[i][j] = pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1] +
(tp[i][j] == 'X');
}
}
int l = 0, r = 1005;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << "\n";
int cur_sz = 1 + l * 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans[i][j] = '.';
}
}
for (int i = 1; i <= n - cur_sz + 1; i++) {
for (int j = 1; j <= m - cur_sz + 1; j++) {
if (get(pref, i, j, i + cur_sz - 1, j + cur_sz - 1) == cur_sz * cur_sz) {
ans[i + cur_sz / 2][j + cur_sz / 2] = 'X';
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ans[i][j];
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
char s[1000035];
vector<int> mp[1000035], ps[1000035], ot[1000035];
int area(int a, int b, int c, int d) {
return mp[c][d] - mp[a - 1][d] - mp[c][b - 1] + mp[a - 1][b - 1];
}
bool ck(int T, bool fg) {
int len = T * 2 + 1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) ps[i][j] = 0;
for (int(i) = 1; (i) <= (int)(n + 1 - len); (i)++)
for (int(j) = 1; (j) <= (int)(m + 1 - len); (j)++)
if (area(i, j, i, j) == 1) {
if (area(i, j, i + len - 1, j + len - 1) == len * len) {
if (fg) {
ot[i + T][j + T] = 1;
}
ps[i][j]++;
ps[i][j + len]--;
ps[i + len][j]--;
ps[i + len][j + len]++;
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
ps[i][j] += ps[i][j - 1] + ps[i - 1][j] - ps[i - 1][j - 1];
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
for (int(j) = 1; (j) <= (int)(m); (j)++) {
bool isx = area(i, j, i, j);
bool isy = ps[i][j] >= 1;
if (isx != isy) return 0;
}
return 1;
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (int)(n + 2); (i)++) {
mp[i].resize(m + 5, 0);
ps[i].resize(m + 5, 0);
ot[i].resize(m + 5, 0);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%s", s + 1);
for (int(j) = 1; (j) <= (int)(m); (j)++)
if (s[j] == 'X') mp[i][j] = 1;
for (int(j) = 1; (j) <= (int)(m); (j)++)
mp[i][j] += mp[i][j - 1] + mp[i - 1][j] - mp[i - 1][j - 1];
}
int l = 0, r = max(m, n);
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ck(mid, 0))
l = mid;
else
r = mid - 1;
}
int ans = ck(r, 0) ? r : l;
printf("%d\n", ans);
ck(ans, 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++) printf("%c", ot[i][j] ? 'X' : '.');
puts("");
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > vis;
vector<string> second;
int n, m;
int main() {
cin >> n >> m;
second.resize(n);
for (int i = 0; i < n; i++) cin >> second[i];
int rmin = m, rsum[n][m], csum[n][m];
memset(rsum, 0, sizeof(rsum));
memset(csum, 0, sizeof(csum));
for (int i = 0; i < n; i++) {
int cur = 0, cnt = 0;
for (int j = 0; j < m; j++) {
if (second[i][j] == 'X') {
rsum[i][j]++;
cnt++;
} else {
if (cnt) rmin = min(rmin, cnt);
cnt = 0;
}
if (j > 0) rsum[i][j] += rsum[i][j - 1];
}
if (cnt) rmin = min(rmin, cnt);
}
int cmin = n;
for (int i = 0; i < m; i++) {
int cur = 0, cnt = 0;
for (int j = 0; j < n; j++) {
if (second[j][i] == 'X')
cnt++, csum[j][i]++;
else {
if (cnt) cmin = min(cmin, cnt);
cnt = 0;
}
if (j > 0) csum[j][i] += csum[j - 1][i];
}
if (cnt) cmin = min(cmin, cnt);
}
int sm[n][m];
memset(sm, 0, sizeof(sm));
int mn = min(cmin, rmin);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i - 1 >= 0 and j - 1 >= 0) sm[i][j] = sm[i - 1][j - 1];
if (i - 1 >= 0) sm[i][j] += csum[i - 1][j];
if (j - 1 >= 0) sm[i][j] += rsum[i][j - 1];
if (second[i][j] == 'X') sm[i][j]++;
}
}
int l = 0, h = n;
int ans[n][m], an;
vis.resize(n);
for (int i = 0; i < n; i++) vis[i].resize(m);
memset(ans, 0, sizeof(ans));
vector<pair<int, int> > fn;
while (l <= h) {
int mid = (l + h) / 2;
vector<pair<int, int> > cr;
queue<array<int, 3> > qu;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (second[i][j] == '.') continue;
int nx = i + 2 * mid, ny = j + 2 * mid;
if (nx < n and ny < m) {
int s1 = sm[nx][ny];
if (i - 1 >= 0) s1 -= sm[i - 1][ny];
if (j - 1 >= 0) s1 -= sm[nx][j - 1];
if (i - 1 >= 0 and j - 1 >= 0) s1 += sm[i - 1][j - 1];
if (s1 == (nx - i + 1) * (ny - j + 1)) {
cr.push_back({i + mid, j + mid});
qu.push({i + mid, j + mid, 0});
vis[i + mid][j + mid] = 1;
}
}
}
}
while (!qu.empty()) {
array<int, 3> &cur = qu.front();
int dx[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy[] = {1, -1, 1, -1, 0, 1, -1, 0};
for (int i = 0; i < 8; i++) {
int nx = cur[0] + dx[i], ny = cur[1] + dy[i];
if (nx < 0 or ny < 0 or nx >= n or ny >= m or vis[nx][ny] or
cur[2] >= mid)
continue;
vis[nx][ny] = 1;
qu.push({nx, ny, cur[2] + 1});
}
if (cur[2] >= mid) break;
qu.pop();
}
int no = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!vis[i][j] and second[i][j] == 'X') no = 1;
vis[i][j] = 0;
}
}
if (no)
h = mid - 1;
else {
an = mid, l = mid + 1, fn = cr;
}
}
cout << an << "\n";
for (pair<int, int> &pr : fn) ans[pr.first][pr.second] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ans[i][j])
cout << "X";
else
cout << ".";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> sum;
vector<vector<bool>> used;
int n, m;
int g = 0;
int k = 0;
vector<pair<int, int>> p = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void dfs(int first, int second, const int &r1, const int &r2, const int &l1,
const int &l2) {
if (first <= r1 || first > r2 || second <= l1 || second > l2 ||
used[first][second])
return;
used[first][second] = true;
k++;
for (int i = 0; i < 4; i++)
dfs(first + p[i].first, second + p[i].second, r1, r2, l1, l2);
}
bool f(int r) {
r = r * 2 + 1;
k = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) used[i][j] = false;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (i >= r && j >= r &&
sum[i][j] - sum[i - r][j] - sum[i][j - r] + sum[i - r][j - r] ==
r * r) {
dfs(i, j, i - r, i, j - r, j);
}
if (k == g)
return true;
else
return false;
}
int main() {
cin >> n >> m;
sum.resize(n + 1, vector<int>(m + 1, 0));
used.resize(n + 1, vector<bool>(m + 1, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
sum[i + 1][j + 1] = sum[i][j + 1] + sum[i + 1][j] - sum[i][j];
if (c == 'X') sum[i + 1][j + 1]++;
}
g = sum.back().back();
int l = 0, r = min(n / 2 + 2, m / 2 + 2);
while (l + 1 < r) {
int c = (l + r) / 2;
if (f(c))
l = c;
else
r = c;
}
cout << l << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i >= l + 1 && j >= l + 1 && i + l <= n && j + l <= m &&
sum[i + l][j + l] - sum[i - l - 1][j + l] - sum[i + l][j - l - 1] +
sum[i - l - 1][j - l - 1] ==
(2 * l + 1) * (2 * l + 1))
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& o, const vector<T>& v) {
int b = 0;
for (const auto& a : v) o << (b++ ? ", " : "") << a;
return o;
}
template <typename T>
ostream& operator<<(ostream& o, const set<T>& v) {
int b = 0;
for (const auto& a : v) o << (b++ ? ", " : "") << a;
return o;
}
template <typename T, typename U>
ostream& operator<<(ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
vector<vector<char>> D;
vector<vector<int>> pref;
pair<int, int> marked[1000000];
int len_marked;
int N, M;
vector<vector<bool>> seen;
int f(int i, int j) {
if (i < 0 || j < 0) return 0;
auto& x = pref[i][j];
if (x != -1) return x;
return x = f(i - 1, j) + f(i, j - 1) - f(i - 1, j - 1) + (D[i][j] == 'X');
}
int size(int t) { return 2 * (t + 1) - 1; }
int in_region(int x, int y, int t) {
int s = size(t);
return pref[x][y] - ((x - s) >= 0 ? pref[x - s][y] : 0) -
((y - s) >= 0 ? pref[x][y - s] : 0) +
(((x - s) >= 0 && (y - s) >= 0) ? pref[x - s][y - s] : 0);
}
pair<int, int> center(int T, pair<int, int> coord) {
int q = size(T) / 2;
return {coord.first - q, coord.second - q};
}
bool in_bounds(int r, int c) { return r >= 0 && c >= 0 && r < N && c < M; }
int run_bfs(int t) {
int n_visited = 0;
queue<pair<int, pair<int, int>>> Q;
seen.assign(N, vector<bool>(M, false));
for (int i = 0; i < len_marked; i++) {
Q.push({0, marked[i]});
}
while (!Q.empty()) {
auto [i, p] = Q.front();
Q.pop();
auto [r, c] = p;
if (i > t) break;
if (seen[r][c]) continue;
seen[r][c] = true;
n_visited++;
for (int _r : {-1, 0, 1}) {
for (int _c : {-1, 0, 1}) {
if (in_bounds(r + _r, c + _c) && !seen[r + _r][c + _c])
Q.push({i + 1, {r + _r, c + _c}});
}
}
}
return n_visited;
}
bool check(int T, int count) {
len_marked = 0;
int s = size(T) * size(T);
int i = 0;
for (int r = 0; r < N; r++) {
for (int c = 0; c < M; c++) {
if (in_region(r, c, T) == s) {
marked[i++] = center(T, {r, c});
len_marked++;
}
}
}
int b = run_bfs(T);
return b == count;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
D = vector<vector<char>>(N, vector<char>(M));
pref = vector<vector<int>>(N, vector<int>(M, -1));
seen.resize(N, vector<bool>(M));
int count = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> D[i][j];
if (D[i][j] == 'X') count++;
}
}
f(N - 1, M - 1);
int lo = 1, hi = min(N, M);
while (hi - lo > 2) {
int mid = (hi + lo) / 2;
(check(mid, count) ? lo : hi) = mid;
}
while (check(lo, count)) lo++;
lo--;
check(lo, count);
D = vector<vector<char>>(N, vector<char>(M, '.'));
for (int i = 0; i < len_marked; i++) {
D[marked[i].first][marked[i].second] = 'X';
}
cout << lo << endl;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cout << D[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m >> n;
vector<vector<int>> a(m + 5, vector<int>(n + 5)),
s(m + 5, vector<int>(n + 5)), atam(m + 5, vector<int>(n + 5));
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
char x;
cin >> x;
if (x == 'X')
a[i][j] = 0;
else
a[i][j] = 1;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
int mn = 1e9;
int left = 0, right = min(n, m) / 2;
while (left <= right) {
int mid = (left + right) >> 1;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) atam[i][j] = 0;
queue<pair<int, int>> qu;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
bool ok = 1;
int u = i - mid, d = i + mid, l = j - mid, r = j + mid;
if (u < 1 || d > m || l < 1 || r > n)
ok = 0;
else if (s[d][r] + s[u - 1][l - 1] - s[d][l - 1] - s[u - 1][r])
ok = 0;
if (ok) qu.push(make_pair(i, j)), atam[i][j] = 1;
}
while (!qu.empty()) {
pair<int, int> res = qu.front();
qu.pop();
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (res == make_pair(res.first + i, res.second + j)) continue;
int x = res.first + i, y = res.second + j;
if (x < 1 || x > m || y < 1 || y > n || atam[x][y]) continue;
if (atam[res.first][res.second] > mid) continue;
atam[x][y] = atam[res.first][res.second] + 1;
qu.push(make_pair(x, y));
}
}
bool ok = 1;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if ((!a[i][j]) ^ bool(atam[i][j])) ok = 0;
if (ok)
left = mid + 1;
else
right = mid - 1;
}
cout << right << "\n";
for (int i = 1; i <= m; i++, cout << "\n")
for (int j = 1; j <= n; j++) {
bool ok = 1;
int u = i - right, d = i + right, l = j - right, r = j + right;
if (u < 1 || d > m || l < 1 || r > n)
ok = 0;
else if (s[d][r] + s[u - 1][l - 1] - s[d][l - 1] - s[u - 1][r])
ok = 0;
if (ok)
cout << 'X';
else
cout << '.';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
int t, mx[2][N], p[N], n, m;
vector<pair<int, int> > c;
vector<int> a[N];
bool ok(int x, int y) {
if (x > n || y > m || min(x, y) < 1) return 0;
return 1;
}
int sum(int i, int j, int x) {
return a[i + x][j + x] - a[i - 1][j + x] - a[i + x][j - 1] + a[i - 1][j - 1];
}
bool check(int x) {
c.clear();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) p[j] = 0;
for (int j = 1; j <= m; j++) {
mx[1][j] = max(0, mx[0][j] - 1);
if (ok(i + x, j + x) && sum(i, j, x) == 2 * x + 1 + x * x) {
mx[1][j] = x + 1;
c.push_back({i, j});
}
if (mx[1][j]) p[j]++, p[j + x + 1]--;
mx[0][j] = mx[1][j];
}
for (int j = 1; j <= m; j++) {
p[j] += p[j - 1];
if (!p[j] && sum(i, j, 0)) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int j = 0; j <= m; j++) a[0].push_back(0);
for (int i = 1; i <= n; i++) {
a[i].push_back(0);
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
a[i].push_back(0);
a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
if (c == 'X') a[i][j]++;
}
}
int l = 0, r = min((n + 1) / 2, (m + 1) / 2) - 1, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(2 * mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
check(2 * ans);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = 0;
for (int i = 0; i < c.size(); i++) {
a[c[i].first + ans][c[i].second + ans] = 1;
}
cout << ans << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j])
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using namespace std;
long long n, m;
char read() {
char c;
cin >> c;
return c;
}
vector<vector<long long> > s, f;
vector<vector<char> > a;
bool chk(long long i, long long j, long long x, long long y) {
if (i < 1 || j < 1 || x > n || y > m) return false;
--i;
--j;
return 1ll * (x - i) * (y - j) == s[x][y] - s[x][j] - s[i][y] + s[i][j];
}
void cover(long long i, long long j, long long x, long long y) {
f[i][j]++;
f[i][++y]--;
f[++x][j]--;
f[x][y]++;
}
bool check(long long mid) {
for (long long i = 0; i <= n + 1; i++)
for (long long j = 0; j <= m + 1; j++) f[i][j] = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++)
if (a[i][j] == 'X' && chk(i - mid, j - mid, i + mid, j + mid)) {
cover(i - mid, j - mid, i + mid, j + mid);
}
for (long long i = 1; i <= n + 1; i++)
for (long long j = 1; j <= m + 1; j++)
f[i][j] = f[i][j] + f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1];
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (a[i][j] == '.' && f[i][j] > 0) {
return false;
}
if (a[i][j] == 'X' && f[i][j] == 0) {
return false;
}
}
return true;
}
void solve(long long mid) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] == 'X') {
if (chk(i - mid, j - mid, i + mid, j + mid)) {
a[i][j] = 'X';
} else {
a[i][j] = '.';
}
}
}
}
}
signed main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
a.resize(n + 1);
f.resize(n + 2);
s.resize(n + 1);
for (long long i = 0; i <= n; i++) {
a[i].resize(m + 1);
f[i].resize(m + 2);
s[i].resize(m + 1);
}
f[n + 1].resize(m + 2);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
a[i][j] = read();
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (a[i][j] == 'X');
}
}
long long l = 0, r = 1e6, ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
cout << ans << '\n';
solve(ans);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cout << a[i][j];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int power(int first, unsigned int second, unsigned int m) {
if (second == 0) return 1;
int p = power(first, second / 2, m) % m;
p = (p * p) % m;
return (second % 2 == 0) ? p : (first * p) % m;
}
int modInverse(int a, int m) {
{ return power(a, m - 2, m); }
}
const int maxn = 1000003;
char *a[maxn];
int n, m;
int *f[maxn];
int *pre[maxn];
bool *place[maxn];
bool check(int l) {
l = l << 1 | 1;
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m; j++) {
f[i][j] = 0;
place[i][j] = 0;
}
}
for (int i = 1; i <= n - l + 1; i++) {
for (int j = 1; j <= m - l + 1; j++) {
if (pre[i + l - 1][j + l - 1] - pre[i + l - 1][j - 1] -
pre[i - 1][j + l - 1] + pre[i - 1][j - 1] ==
l * l) {
place[i + (l >> 1)][j + (l >> 1)] = 1;
f[i][j]++;
f[i + l][j]--;
f[i][j + l]--;
f[i + l][j + l]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] += f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1];
if (!f[i][j] && a[i][j] == 'X') return false;
}
}
return true;
}
void solve() {
cin >> n >> m;
char p;
for (int i = 0; i <= n + 3; i++) {
f[i] = new int[m + 3];
place[i] = new bool[m + 3];
pre[i] = new int[m + 3];
a[i] = new char[m + 4];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
pre[i][j] = 0;
if (a[i][j] == 'X') pre[i][j] = 1;
pre[i][j] += pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1];
}
}
int l = 0, r = min(n, m);
int ans = 0;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
check(ans);
cout << ans << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (place[i][j])
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 4 * atan((long double)1);
const int mod = 1e9 + 7;
const int nax = 0;
struct info {
int x, y, times;
};
int n, m;
vector<vector<int>> pref, vis, res, ans, a;
int baris[] = {0, 0, 1, -1, 1, -1, 1, -1};
int kolom[] = {1, -1, 0, 0, 1, 1, -1, -1};
void init() {
pref.resize(n + 5, vector<int>(m + 5));
res.resize(n + 5, vector<int>(m + 5));
a.resize(n + 5, vector<int>(m + 5));
vis.resize(n + 5, vector<int>(m + 5));
ans.resize(n + 5, vector<int>(m + 5));
}
int is_burn(int x, int y, int sz) {
if (x - sz <= 0 || x + sz > n || y - sz <= 0 || y + sz > m) {
return -1;
}
int ret = pref[x + sz][y + sz] - pref[x - sz - 1][y + sz] -
pref[x + sz][y - sz - 1] + pref[x - sz - 1][y - sz - 1];
return ret;
}
void bfs(int lim) {
queue<info> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (res[i][j]) {
q.push({i, j, 0});
vis[i][j] = 1;
}
}
}
while (!q.empty()) {
auto cur = q.front();
q.pop();
ans[cur.x][cur.y] = 1;
if (cur.times + 1 <= lim) {
for (int i = 0; i < 8; i++) {
int nx = cur.x + baris[i];
int ny = cur.y + kolom[i];
if (!vis[nx][ny]) {
vis[nx][ny] = 1;
q.push({nx, ny, cur.times + 1});
}
}
}
}
}
void cler() {
for (int i = 0; i < n + 5; i++) {
for (int j = 0; j < m + 5; j++) {
vis[i][j] = 0;
res[i][j] = 0;
ans[i][j] = 0;
}
}
}
int que(int sz) {
cler();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (is_burn(i, j, sz) == (2 * sz + 1) * (2 * sz + 1)) {
res[i][j] = 1;
}
}
}
bfs(sz);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ans[i][j] != a[i][j]) {
return 0;
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == 'X') {
a[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pref[i][j] =
pref[i][j - 1] + pref[i - 1][j] - pref[i - 1][j - 1] + a[i][j];
}
}
int l = 0, r = 5e5, ret = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (que(mid)) {
l = mid + 1;
ret = max(ret, mid);
} else {
r = mid - 1;
}
}
cout << ret << '\n';
que(ret);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (res[i][j]) {
cout << "X";
} else {
cout << ".";
}
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 2e5 + 5;
const int64_t INF = 1e18 + 7;
const int64_t MOD = 1e9 + 7;
int64_t n, m;
vector<vector<int64_t>> a;
vector<vector<int64_t>> pref;
vector<vector<int64_t>> ans;
vector<vector<bool>> used;
vector<pair<int64_t, int64_t>> moves = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
int64_t get(int64_t x1, int64_t y1, int64_t x2, int64_t y2) {
return pref[x2][y2] - (x1 ? pref[x1 - 1][y2] : 0) -
(y1 ? pref[x2][y1 - 1] : 0) + (x1 && y1 ? pref[x1 - 1][y1 - 1] : 0);
}
bool norm(int64_t x, int64_t y) {
if (x >= 0 && x < n && y >= 0 && y < m && !used[x][y]) return true;
return false;
}
bool check(int64_t len) {
vector<vector<int64_t>> dst(n, vector<int64_t>(m, INF));
queue<pair<int64_t, int64_t>> q;
for (int32_t i = 0; i < n; i++)
for (int32_t j = 0; j < m; j++) ans[i][j] = 0, used[i][j] = false;
for (int32_t i = 0; i < n; i++) {
for (int32_t j = 0; j < m; j++) {
if (a[i][j]) {
if (i - len < 0) continue;
if (i + len >= n) continue;
if (j - len < 0) continue;
if (j + len >= m) continue;
int64_t x1 = i - len, y1 = j - len, x2 = i + len, y2 = j + len;
int64_t second = (x2 - x1 + 1) * (y2 - y1 + 1);
int64_t sum = get(x1, y1, x2, y2);
if (second != sum) continue;
ans[i][j] = 1;
q.push({i, j});
dst[i][j] = 0;
used[i][j] = true;
}
}
}
while (q.size()) {
pair<int64_t, int64_t> e = q.front();
q.pop();
int64_t x = e.first, y = e.second;
for (auto u : moves) {
int64_t nx = x + u.first, ny = y + u.second;
if (norm(nx, ny)) {
q.push({nx, ny});
dst[nx][ny] = dst[x][y] + 1;
used[nx][ny] = true;
}
}
}
bool ok = true;
for (int32_t i = 0; i < n; i++) {
for (int32_t j = 0; j < m; j++) {
if (a[i][j] == 1 && dst[i][j] > len) ok = false;
}
}
return ok;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
a.resize(n, vector<int64_t>(m, 0));
pref.resize(n, vector<int64_t>(m, 0));
ans.resize(n, vector<int64_t>(m, 0));
used.resize(n, vector<bool>(m, false));
for (int32_t i = 0; i < n; i++) {
for (int32_t j = 0; j < m; j++) {
char x;
cin >> x;
if (x == 'X') a[i][j] = pref[i][j] = 1;
}
}
for (int32_t i = 1; i < n; i++) pref[i][0] += pref[i - 1][0];
for (int32_t i = 1; i < m; i++) pref[0][i] += pref[0][i - 1];
for (int32_t i = 1; i < n; i++)
for (int32_t j = 1; j < m; j++)
pref[i][j] += pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1];
int64_t l = 0, r = min(n, m);
while (r - l > 1) {
int64_t mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
if (check(r)) {
cout << r << endl;
for (int32_t i = 0; i < n; i++) {
for (int32_t j = 0; j < m; j++) {
if (ans[i][j] == 1)
cout << "X";
else
cout << ".";
}
cout << '\n';
}
} else if (check(l)) {
cout << l << endl;
for (int32_t i = 0; i < n; i++) {
for (int32_t j = 0; j < m; j++) {
if (ans[i][j] == 1)
cout << "X";
else
cout << ".";
}
cout << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& a) {
for (T& ai : a) is >> ai;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> const& a) {
os << "[ ";
for (const T& ai : a) os << ai << " ";
return os << "]";
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& a) {
return is >> a.first >> a.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> const& a) {
return os << "(" << a.first << ", " << a.second << ")";
}
class Solution {
public:
void parse() {
cin >> _n >> _m;
_s.resize(_n);
cin >> _s;
}
void solve() {
compute_partial();
int x = -1, y = (min(_n, _m) + 1) >> 1;
while (x + 1 < y) {
int z = (x + y) >> 1;
if (attempt(z))
x = z;
else
y = z;
}
cout << x << "\n";
for (const string& ri : _r) cout << ri << "\n";
}
private:
void compute_partial() {
_p.resize(_n + 1, vector<int>(_m + 1));
for (int i = 0; i < _n; ++i) {
for (int j = 0; j < _m; ++j) {
_p[i + 1][j + 1] = _p[i + 1][j] + _p[i][j + 1] - _p[i][j];
if (_s[i][j] == 'X') ++_p[i + 1][j + 1];
}
}
}
bool attempt(int t) {
int k = 2 * t + 1;
vector<vector<int> > c(_n + 1, vector<int>(_m + 1));
for (int i = 0; i < _n; ++i) {
for (int j = 0; j < _m; ++j) {
c[i + 1][j + 1] = c[i + 1][j] + c[i][j + 1] - c[i][j];
if (_s[i][j] != 'X') continue;
if (i + k <= _n && j + k <= _m) {
int damaged =
_p[i + k][j + k] + _p[i][j] - _p[i + k][j] - _p[i][j + k];
if (damaged == k * k) ++c[i + 1][j + 1];
}
int ii = max(0, i + 1 - k), jj = max(0, j + 1 - k);
int centers = c[i + 1][j + 1] + c[ii][jj] - c[i + 1][jj] - c[ii][j + 1];
if (centers == 0) return false;
}
}
_r.clear();
_r.resize(_n, string(_m, '.'));
for (int i = 0; i < _n; ++i) {
for (int j = 0; j < _m; ++j) {
if (c[i + 1][j + 1] + c[i][j] - c[i + 1][j] - c[i][j + 1]) {
_r[i + t][j + t] = 'X';
}
}
}
return true;
}
private:
int _n, _m;
vector<string> _s;
vector<vector<int> > _p;
vector<string> _r;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solution soln;
soln.parse();
soln.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n + 2);
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = '.' + s[i] + '.';
}
s[0] = s[n + 1] = string(m + 2, '.');
vector<vector<int>> d(n + 2, vector<int>(m + 2, 1e9));
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
for (int i = 0; i < n + 2; i++) {
for (int j = 0; j < m + 2; j++) {
if (s[i][j] == '.') {
d[i][j] = 0;
pq.push({0, {i, j}});
}
}
}
while (!pq.empty()) {
int dis = pq.top().first;
int i, j;
tie(i, j) = pq.top().second;
pq.pop();
if (dis > d[i][j]) continue;
for (int di = -1; di <= 1; di++) {
if (i == 0 && di == -1) continue;
if (i == n + 1 && di == 1) continue;
for (int dj = -1; dj <= 1; dj++) {
if (j == 0 && dj == -1) continue;
if (j == m + 1 && dj == 1) continue;
if (d[i + di][j + dj] > d[i][j] + 1) {
d[i + di][j + dj] = d[i][j] + 1;
pq.push({d[i + di][j + dj], {i + di, j + dj}});
}
}
}
}
int mx = 0;
vector<vector<pair<int, int>>> x(2000);
for (int i = 0; i < n + 2; i++) {
for (int j = 0; j < m + 2; j++) {
mx = max(mx, d[i][j]);
if (d[i][j] > 0) {
x[d[i][j]].emplace_back(i, j);
}
}
}
vector<vector<int>> e;
int ans = mx;
int lo = 1, hi = mx + 1;
while (lo + 1 < hi) {
e = vector<vector<int>>(n + 2, vector<int>(m + 2));
for (int i = 0; i < n + 2; i++) e[i][0] = e[i][m + 1] = 1e9;
for (int i = 0; i < m + 2; i++) e[0][i] = e[n + 1][i] = 1e9;
int mid = (lo + hi) / 2;
queue<pair<int, int>> que;
for (auto p : x[mid]) {
if (d[p.first][p.second] == mid) {
que.push({p.first, p.second});
e[p.first][p.second] = mid;
ans = mid;
}
}
int tmp = mid - 1;
while (que.size() && tmp) {
for (int jj = que.size(); jj > 0; jj--) {
int i, j;
tie(i, j) = que.front();
que.pop();
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (e[i + di][j + dj] != mid) {
e[i + di][j + dj] = mid;
que.push({i + di, j + dj});
}
}
}
}
tmp--;
}
bool ok = true;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
if (d[i][j] != 0 && d[i][j] < mid && e[i][j] == 0) {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) {
lo = mid;
} else {
hi = mid;
}
}
ans = lo - 1;
vector<string> res(n, string(m, '.'));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'X') {
if (d[i][j] > ans) {
res[i - 1][j - 1] = 'X';
}
}
}
}
cout << ans << '\n';
for (int i = 0; i < n; i++) {
cout << res[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
vector<vector<int>> sum(n, vector<int>(m));
sum[0][0] = (s[0][0] == 'X');
for (int j = 1; j < m; ++j) {
sum[0][j] = sum[0][j - 1] + (s[0][j] == 'X');
}
for (int i = 1; i < n; ++i) {
sum[i][0] = sum[i - 1][0] + (s[i][0] == 'X');
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (s[i][j] == 'X');
}
}
auto calc = [&](int i1, int j1, int i2, int j2) {
int ret = sum[i2][j2];
if (i1 > 0) {
ret -= sum[i1 - 1][j2];
}
if (j1 > 0) {
ret -= sum[i2][j1 - 1];
}
if (i1 > 0 && j1 > 0) {
ret += sum[i1 - 1][j1 - 1];
}
return ret;
};
int low = 0;
int high = 1e6 + 7;
while (low + 1 < high) {
int mid = (low + high) >> 1;
vector<vector<int>> d(n, vector<int>(m, -1));
queue<pair<int, int>> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int le = j - mid;
if (le < 0) continue;
int ri = j + mid;
if (ri >= m) continue;
int up = i - mid;
if (up < 0) continue;
int dn = i + mid;
if (dn >= n) continue;
if (calc(up, le, dn, ri) == (ri - le + 1) * 1ll * (dn - up + 1)) {
q.emplace(i, j);
d[i][j] = 0;
}
}
}
while (!q.empty()) {
auto [i, j] = q.front();
q.pop();
for (int di = -1; di <= 1; ++di) {
for (int dj = -1; dj <= 1; ++dj) {
int ni = i + di;
int nj = j + dj;
if (0 <= ni && ni < n && 0 <= nj && nj < m && d[ni][nj] == -1) {
d[ni][nj] = d[i][j] + 1;
q.emplace(ni, nj);
}
}
}
}
bool ok = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'X') {
ok &= (d[i][j] <= mid && d[i][j] != -1);
} else {
ok &= (d[i][j] > mid || d[i][j] == -1);
}
}
}
ok ? low = mid : high = mid;
}
cout << low << '\n';
vector<vector<char>> ret(n, vector<char>(m, '.'));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int le = j - low;
if (le < 0) continue;
int ri = j + low;
if (ri >= m) continue;
int up = i - low;
if (up < 0) continue;
int dn = i + low;
if (dn >= n) continue;
if (calc(up, le, dn, ri) == (ri - le + 1) * 1ll * (dn - up + 1)) {
ret[i][j] = 'X';
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ret[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int y, x;
vector<vector<int>> dp, matr;
void scanf__() {
scanf("%i%i", &n, &m);
y = n + 1, x = m + 1;
dp = matr = vector<vector<int>>(y, vector<int>(x));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == 'X')
matr[i + 1][j + 1] = 1;
else
matr[i + 1][j + 1] = 0;
}
}
}
int max_square() {
int maxi = 0;
for (int i = 1; i < y; i++) {
for (int j = 1; j < x; j++) {
if (matr[i][j] != 0)
dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
maxi = max(maxi, dp[i][j]);
}
}
return maxi;
}
pair<int, int> get_coord(int ly, int lx, int ry, int rx) {
return {(ry - ly) / 2, (rx - lx) / 2};
}
vector<vector<int>> _data, pref;
void out(vector<vector<int>> a) {
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)a[i].size(); j++) {
printf("%i ", a[i][j]);
}
printf("\n");
}
}
bool can(int sz) {
_data = pref = vector<vector<int>>(y, vector<int>(x));
for (int i = 1; i < y - sz; i++) {
for (int j = 1; j < x - sz; j++) {
if (matr[i][j] != 0) {
if (dp[i + sz][j + sz] > sz) {
_data[i + sz / 2][j + sz / 2] = 1;
}
}
}
}
for (int i = 1; i < y; i++) {
for (int j = 1; j < x; j++) {
pref[i][j] =
pref[i - 1][j] + pref[i][j - 1] + _data[i][j] - pref[i - 1][j - 1];
}
}
for (int i = 1; i < y; i++) {
for (int j = 1; j < x; j++) {
if (matr[i][j] != 0) {
int ycrd = min(y - 1, i + sz / 2), xcrd = min(x - 1, j + sz / 2);
int yst = max(1, i - sz / 2), xst = max(1, j - sz / 2);
int cnt = pref[ycrd][xcrd] - pref[yst - 1][xcrd] - pref[ycrd][xst - 1] +
pref[yst - 1][xst - 1];
if (cnt == 0) {
return false;
}
}
}
}
return true;
}
void solve() {
scanf__();
int l = 0, r = max_square();
if (r % 2 != 0) r--;
vector<int> arrEven;
for (int i = 0; i <= r; i += 2) {
arrEven.push_back(i);
}
r = (int)arrEven.size();
while (r > l + 1) {
int midSZ = (r + l) / 2;
int midEl = arrEven[midSZ];
bool check = can(midEl);
if (check) {
l = midSZ;
} else
r = midSZ;
}
vector<string> cnt(y);
for (int i = 0; i < y; i++) {
string str = "";
for (int j = 0; j < x; j++) str += ".";
cnt[i] = str;
}
int needsz = 0;
if (can(arrEven[r - 1]))
needsz = arrEven[r - 1];
else
needsz = arrEven[l];
for (int i = 1; i < y - needsz; i++) {
for (int j = 1; j < x - needsz; j++) {
if (matr[i][j] != 0 && dp[i + needsz][j + needsz] >= needsz + 1) {
pair<int, int> gc = get_coord(i, j, i + needsz, j + needsz);
cnt[gc.first + i][gc.second + j] = 'X';
}
}
}
printf("%i\n", needsz / 2);
for (int i = 1; i < y; i++) {
for (int j = 1; j < x; j++) {
cout << cnt[i][j];
}
cout << "\n";
}
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
vector<string> scanForest() {
int n, m;
cin >> n >> m;
vector<string> f(n, string(m, '0'));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> f[i][j];
return f;
}
void printForest(vector<string> f) {
for (string s : f) cout << s << '\n';
}
vector<string> burnIt(vector<string> f, int t, char x) {
queue<pair<int, int>> burning;
for (int i = 0; i < f.size(); i++)
for (int j = 0; j < f[i].size(); j++)
if (f[i][j] == x) burning.push({i, j});
if (x == '.') {
for (int j = 0; j < f[0].size(); j++) burning.push({-1, j});
for (int j = 0; j < f[0].size(); j++) burning.push({f.size(), j});
for (int i = 0; i < f.size(); i++) burning.push({i, -1});
for (int i = 0; i < f.size(); i++) burning.push({i, f[0].size()});
}
for (int i = 0; i < t && burning.size(); i++) {
int k = burning.size();
while (k--) {
auto cell = burning.front();
burning.pop();
for (int r : {cell.first - 1, cell.first, cell.first + 1}) {
for (int c : {cell.second - 1, cell.second, cell.second + 1}) {
if (r < 0 || r >= f.size() || c < 0 || c >= f[r].size()) {
if (x == '.')
continue;
else
return {};
}
if (f[r][c] == x) continue;
f[r][c] = x;
burning.push({r, c});
}
}
}
}
return f;
}
bool check(vector<string> f, int t) {
vector<string> g = burnIt(f, t, '.');
return f == burnIt(g, t, 'X');
}
int solve(vector<string> f) {
int l = 1, r = min(f.size(), f[0].size()) / 2 + 1;
while (l < r) {
int m = (l + r) / 2;
if (check(f, m))
l = m + 1;
else
r = m;
}
return l - 1;
}
int main() {
iostream::sync_with_stdio(false);
vector<string> f = scanForest();
int t = solve(f);
cout << t << '\n';
printForest(burnIt(f, t, '.'));
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
int n, m;
int fs(int lx, int ly, int rx, int ry, vector<vector<int>> &ps) {
return ps[rx][ry] - ps[rx][ly] - ps[lx][ry] + ps[lx][ly];
}
int ck(int x, int y, int d, vector<vector<int>> &ps) {
return x >= d && x + d <= n && y >= d && y + d <= m &&
fs(x - d, y - d, x + d + 1, y + d + 1, ps) ==
(2 * d + 1) * (2 * d + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
vector<vector<int>> a(n + 2, vector<int>(m + 2)),
ps(n + 2, vector<int>(m + 2)), ns;
string s;
for (int i = 0; i < (n); i++) {
cin >> s;
for (int j = 0; j < (m); j++)
if (s[j] == 'X') a[i + 1][j + 1] = 1;
}
for (int i = 0; i < (n + 1); i++)
for (int j = 0; j < (m + 1); j++)
ps[i + 1][j + 1] = ps[i][j + 1] + ps[i + 1][j] - ps[i][j] + a[i][j];
int l = 0, r = min(n, m) + 1, md;
while (r - l > 1) {
md = (l + r) / 2;
ns.assign(n + 2, vector<int>(m + 2, 0));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ck(i, j, md, ps)) {
ns[i][j] = 1;
}
for (int i = 0; i < (n + 1); i++)
for (int j = 0; j < (m + 1); j++)
ns[i + 1][j + 1] += ns[i][j + 1] + ns[i + 1][j] - ns[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && fs(max(i - md - 1, 0), max(j - md - 1, 0),
min(i + md, n + 1), min(j + md, m + 1), ns) == 0) {
r = md;
}
if (r != md) l = md;
}
cout << l << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << (ck(i, j, l, ps) ? 'X' : '.');
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> g(n);
for (int i = 0; i < n; ++i) cin >> g[i];
vector<vector<int>> sum(n + 1);
for (int i = 0; i <= n; ++i) sum[i].resize(m + 1);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
sum[i + 1][j + 1] =
sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (g[i][j] == 'X');
vector<vector<int>> a(n + 1);
auto check = [&](int r) {
int d = 2 * r + 1;
for (int i = 0; i <= n; ++i) a[i].assign(m + 1, 0);
for (int i = 0; i + d <= n; ++i) {
for (int j = 0; j + d <= m; ++j) {
if (sum[i + d][j + d] - sum[i + d][j] - sum[i][j + d] + sum[i][j] ==
d * d) {
++a[i][j];
--a[i][j + d];
--a[i + d][j];
++a[i + d][j + d];
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i > 0) a[i][j] += a[i - 1][j];
if (j > 0) a[i][j] += a[i][j - 1];
if (i > 0 && j > 0) a[i][j] -= a[i - 1][j - 1];
if (g[i][j] == 'X' && a[i][j] == 0) return false;
}
}
return true;
};
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l << "\n";
int d = 2 * l + 1;
for (int i = 0; i < n; ++i, cout << "\n")
for (int j = 0; j < m; ++j)
cout << ".X"[i >= l && i + l < n && j >= l && j + l < m &&
sum[i + l + 1][j + l + 1] - sum[i + l + 1][j - l] -
sum[i - l][j + l + 1] + sum[i - l][j - l] ==
d * d];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000005;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int n, m, ans, c1, c2;
char s[M];
int dx[8] = {-1, 1, 0, 0, 1, -1, 1, -1}, dy[8] = {0, 0, -1, 1, 1, -1, -1, 1};
vector<int> f[M], a[M];
struct node {
int x, y, d;
};
bool check(int x) {
queue<node> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
f[i][j] = 0;
if (i - x >= 1 && j - x >= 1 && i + x <= n && j + x <= m) {
int t = a[i + x][j + x] + a[i - x - 1][j - x - 1] -
a[i - x - 1][j + x] - a[i + x][j - x - 1];
if (t == (2 * x + 1) * (2 * x + 1)) {
f[i][j] = 1;
q.push(node{i, j, 0});
}
}
}
c2 = 0;
while (!q.empty()) {
node t = q.front();
c2++;
q.pop();
if (t.d == x) continue;
for (int i = 0; i < 8; i++) {
int tx = t.x + dx[i], ty = t.y + dy[i];
if (tx >= 1 && tx <= n && ty >= 1 && ty <= m && !f[tx][ty]) {
f[tx][ty] = 1;
q.push(node{tx, ty, t.d + 1});
}
}
}
return c1 == c2;
}
void dich(int l, int r) {
if (l > r) return;
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
dich(mid + 1, r);
} else
dich(l, mid - 1);
}
signed main() {
n = read();
m = read();
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
f[i].push_back(0);
a[i].push_back(0);
}
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) {
if (s[j] == 'X') c1++;
a[i][j] = (s[j] == 'X' ? 1 : 0);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
dich(0, max(n, m));
printf("%d\n", ans);
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1, x = ans; j <= m; j++)
if (i - x >= 1 && j - x >= 1 && i + x <= n && j + x <= m) {
int t = a[i + x][j + x] + a[i - x - 1][j - x - 1] -
a[i - x - 1][j + x] - a[i + x][j - x - 1];
if (t == (2 * x + 1) * (2 * x + 1))
printf("X");
else
printf(".");
} else
printf(".");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > b(1e6 + 10);
void bfs(int dist) {
queue<pair<int, int> > q;
vector<int> d;
int x[] = {1, 1, 1, 0, 0, -1, -1, -1};
int y[] = {1, -1, 0, 1, -1, -1, 0, 1};
int k = 8;
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++)
if (b[i][j] == 1) {
q.push(make_pair(i, j));
d.push_back(0);
}
int o = -1;
while (q.size() > 0) {
o++;
if (d[o] == dist) break;
for (int i = 0; i < 8; i++) {
int i1 = q.front().first + x[i], j1 = q.front().second + y[i];
if (!(i1 > n + 1 || i1 < 0 || j1 > m + 1 || j1 < 0))
if (b[i1][j1] == 0) {
q.push(make_pair(i1, j1));
d.push_back(d[o] + 1);
b[i1][j1] = 1;
}
}
q.pop();
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
vector<string> s(n);
vector<vector<int> > a(1e6 + 10);
int pref1[n + 2][m + 2], pref2[n + 2][m + 2], pref3[n + 2][m + 2],
pref4[n + 2][m + 2];
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
b[i].push_back(0);
a[i].push_back(0);
pref1[i][j] = 0;
pref2[i][j] = 0;
pref3[i][j] = 0;
pref4[i][j] = 0;
}
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++)
if (s[i][j] == '.')
a[i + 1][j + 1] = 0;
else
a[i + 1][j + 1] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] == 0) {
pref1[i][j] = 1;
pref2[i][j] = 1;
}
pref1[i][j] += pref1[i][j - 1];
pref2[i][j] += pref2[i - 1][j];
}
for (int i = n; i >= 0; i--)
for (int j = m; j >= 0; j--) {
if (a[i][j] == 0) {
pref3[i][j] = 1;
pref4[i][j] = 1;
}
pref3[i][j] += pref3[i][j + 1];
pref4[i][j] += pref4[i + 1][j];
}
int dp1[n + 2][m + 2], dp2[n + 2][m + 2], dp3[n + 2][m + 2],
dp4[n + 2][m + 2];
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
dp1[i][j] = 0;
dp2[i][j] = 0;
dp3[i][j] = 0;
dp4[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == 1)
dp1[i][j] = min(min(dp1[i - 1][j] + 1, dp1[i][j - 1] + 1),
dp1[i - 1][j - 1] + 1);
for (int i = n; i > 0; i--)
for (int j = m; j > 0; j--)
if (a[i][j] == 1)
dp2[i][j] = min(min(dp2[i + 1][j] + 1, dp2[i][j + 1] + 1),
dp2[i + 1][j + 1] + 1);
for (int i = 1; i <= n; i++)
for (int j = m; j > 0; j--)
if (a[i][j] == 1)
dp3[i][j] = min(min(dp3[i - 1][j] + 1, dp3[i][j + 1] + 1),
dp3[i - 1][j + 1] + 1);
for (int i = n; i > 0; i--)
for (int j = 1; j <= m; j++)
if (a[i][j] == 1)
dp4[i][j] = min(min(dp4[i + 1][j] + 1, dp4[i][j - 1] + 1),
dp4[i + 1][j - 1] + 1);
int l = 0, r = min(n, m) + 2, mid;
while (l < r) {
mid = (l + r) / 2;
if (l == r - 1) mid++;
bool o = true;
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++)
if (min(dp1[i][j], min(dp2[i][j], min(dp3[i][j], dp4[i][j]))) > mid)
b[i][j] = 1;
else
b[i][j] = 0;
}
bfs(mid);
if (b == a)
l = mid;
else
r = mid - 1;
}
cout << l << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (min(dp1[i][j], min(dp2[i][j], min(dp3[i][j], dp4[i][j]))) > l)
cout << 'X';
else
cout << '.';
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int N, M;
vector<pii> cur, nxt;
inline bool Ok(int ni, int nj) {
return ni >= 0 and ni < N and nj >= 0 and nj < M;
}
inline vector<vector<char>> Forward(vector<vector<char>> f, int t) {
cur.clear();
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
if (f[i][j]) {
cur.emplace_back(i, j);
}
}
}
while (t--) {
nxt.clear();
for (auto [i, j] : cur) {
for (int di(-1); di <= 1; ++di) {
for (int dj(-1); dj <= 1; ++dj) {
int ni(i + di), nj(j + dj);
if (!Ok(ni, nj) or f[ni][nj]) continue;
f[ni][nj] = true;
nxt.emplace_back(ni, nj);
}
}
}
cur.swap(nxt);
}
return f;
}
inline vector<vector<char>> Backward(vector<vector<char>> f, int t) {
cur.clear();
for (int i(-1); i <= N; ++i) {
cur.emplace_back(i, -1);
cur.emplace_back(i, M);
}
for (int j(-1); j <= M; ++j) {
cur.emplace_back(-1, j);
cur.emplace_back(N, j);
}
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
if (f[i][j]) continue;
cur.emplace_back(i, j);
}
}
while (t--) {
nxt.clear();
for (auto [i, j] : cur) {
for (int di(-1); di <= 1; ++di) {
for (int dj(-1); dj <= 1; ++dj) {
int ni(i + di), nj(j + dj);
if (Ok(ni, nj) and f[ni][nj]) {
f[ni][nj] = false;
nxt.emplace_back(ni, nj);
}
}
}
}
cur.swap(nxt);
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
vector<vector<char>> f(N, vector<char>(M));
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
char c;
cin >> c;
f[i][j] = c == 'X';
}
}
int l(0), r(min(N, M));
while (l + 1 < r) {
int m((l + r) / 2);
if (Forward(Backward(f, m), m) == f)
l = m;
else
r = m;
}
cout << l << '\n';
for (auto& line : Backward(f, l)) {
for (auto x : line) cout << (x ? 'X' : '.');
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char *a[1000020];
int *f[1000020], *g[1000020];
bool *o[1000020];
bool Check(int l) {
int i, j;
for (i = 0; i <= n; i++)
for (j = 0; j <= m; j++) g[i][j] = o[i][j] = 0;
l = l << 1 | 1;
for (i = 1; i <= n - l + 1; i++)
for (j = 1; j <= m - l + 1; j++)
if (f[i + l - 1][j + l - 1] - f[i + l - 1][j - 1] - f[i - 1][j + l - 1] +
f[i - 1][j - 1] ==
l * l) {
o[i + (l >> 1)][j + (l >> 1)] = true;
g[i][j]++;
g[i + l][j]--;
g[i][j + l]--;
g[i + l][j + l]++;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
g[i][j] += g[i - 1][j] + g[i][j - 1] - g[i - 1][j - 1];
if (!g[i][j] && a[i][j] == 'X') return false;
}
return true;
}
int main(void) {
int i, j, l, r;
scanf("%d %d", &n, &m);
for (i = 0; i <= n + 1; i++) {
f[i] = new int[m + 2];
g[i] = new int[m + 2];
o[i] = new bool[m + 2];
}
for (i = 1; i <= n; i++) {
a[i] = new char[m + 2];
scanf("%s", a[i] + 1);
for (j = 1; j <= m; j++)
f[i][j] = (a[i][j] == 'X') + f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1];
}
for (l = 0, r = min(n, m) + 1; l + 1 < r;)
if (Check((l + r) >> 1))
l = (l + r) >> 1;
else
r = (l + r) >> 1;
printf("%d\n", l);
Check(l);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) putchar(o[i][j] ? 'X' : '.');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<char>> a;
vector<vector<int>> p;
int n, m;
int cnt(int i, int j, int x, int y) {
int s = p[x][y];
if (i > 0) s -= p[i - 1][y];
if (j > 0) s -= p[x][j - 1];
if (i > 0 && j > 0) s += p[i - 1][j - 1];
return s;
}
struct pos {
int i, j, T;
};
bool check(int t) {
queue<pos> q;
auto b = a;
b.assign(n, vector<char>(m, '.'));
for (int i = t; i < n - t; i++) {
for (int j = t; j < m - t; j++) {
if (cnt(i - t, j - t, i + t, j + t) == 1ll * (t * 2 + 1) * (t * 2 + 1)) {
q.push({i, j, t});
b[i][j] = 'X';
}
}
}
while ((int)(q).size()) {
pos cur = q.front();
q.pop();
if (cur.T == 0) continue;
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (cur.i + i >= 0 && cur.i + i < n && cur.j + j >= 0 &&
cur.j + j < m && b[i + cur.i][j + cur.j] == '.') {
q.push({cur.i + i, cur.j + j, cur.T - 1});
b[cur.i + i][cur.j + j] = 'X';
}
}
}
}
return b == a;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m;
p.resize(n, vector<int>(m));
a.resize(n, vector<char>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
p[i][j] = a[i][j] == 'X';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i > 0) p[i][j] += p[i - 1][j];
if (j > 0) p[i][j] += p[i][j - 1];
if (i > 0 && j > 0) p[i][j] -= p[i - 1][j - 1];
}
}
int left = 0, right = min(n, m) + 1;
while (left + 1 < right) {
int x = (left + right) / 2;
if (check(x)) {
left = x;
} else {
right = x;
}
}
int t = left;
cout << t << '\n';
a.assign(n, vector<char>(m, '.'));
for (int i = t; i < n - t; i++) {
for (int j = t; j < m - t; j++) {
if (cnt(i - t, j - t, i + t, j + t) == 1ll * (t * 2 + 1) * (t * 2 + 1)) {
a[i][j] = 'X';
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << a[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool MinPlace(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int dr[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dc[8] = {1, 1, 0, -1, -1, -1, 0, 1};
vector<pair<int, int> > centers;
bool check(int x, vector<int> cnt[], vector<char> grid[], int n, int m,
int store = 0) {
int dist[n + 1][m + 1];
bool visited[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dist[i][j] = (long long)1e9;
visited[i][j] = false;
}
}
queue<pair<int, int> > q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cost = (i + x <= n && i - x >= 1 && j + x <= m && j - x >= 1)
? (cnt[i + x][j + x] - cnt[i + x][j - x - 1] -
cnt[i - x - 1][j + x] + cnt[i - x - 1][j - x - 1])
: 0;
if (cost == (2 * x + 1) * (2 * x + 1)) {
dist[i][j] = 0;
q.push({i, j});
visited[i][j] = true;
}
}
}
if (store == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (visited[i][j])
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
return 0;
}
while (!q.empty()) {
auto t = q.front();
q.pop();
int cost = dist[t.first][t.second];
for (int j = 0; j < 8; j++) {
int r1 = t.first + dr[j];
int c1 = t.second + dc[j];
if (r1 >= 1 && r1 <= n && c1 >= 1 && c1 <= m && !visited[r1][c1]) {
dist[r1][c1] = 1 + cost;
visited[r1][c1] = true;
q.push({r1, c1});
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (grid[i][j] == 'X' && dist[i][j] > x) {
flag = 1;
break;
}
}
}
return (flag == 0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
vector<char> grid[n + 1];
vector<int> cnt[n + 1];
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
grid[i].push_back('$');
for (auto k : str) {
grid[i].push_back(k);
}
}
for (int i = 0; i <= n; i++) {
cnt[i].resize(m + 1);
fill(cnt[i].begin(), cnt[i].end(), 0);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1] +
(grid[i][j] == 'X');
}
}
int low = 0;
int high = max(n, m);
int mid;
while (high >= low) {
mid = low + (high - low) / 2;
if (check(mid, cnt, grid, n, m))
low = mid + 1;
else
high = mid - 1;
}
cout << high << endl;
check(high, cnt, grid, n, m, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f *= -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline char gchar() {
char s = getchar();
while (s != 'X' && s != '.') s = getchar();
return s;
}
int n = read(), m = read(), d[8][2] = {{0, -1}, {-1, -1}, {-1, 0}, {-1, 1},
{0, 1}, {1, 1}, {1, 0}, {1, -1}};
int main() {
bool p[n + 5][m + 5], h[n + 5][m + 5], l[n + 5][m + 5], e[n + 5][m + 5],
f[n + 5][m + 5];
int v[n + 5][m + 5];
memset(p, 0, sizeof(p));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (gchar() == 'X') p[i][j] = 1;
h[i][j] = l[i][j] = e[i][j] = f[i][j] = 0;
}
}
int s = min(n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (p[i][j] && !h[i][j]) {
if (!p[i][j - 1]) {
int len;
for (len = 1; j + len - 1 < m; len++) {
h[i][j + len - 1] = 1;
if (!p[i][j + len]) break;
}
s = min(len, s);
j += len;
}
}
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
if (p[i][j] && !l[i][j]) {
if (!p[i - 1][j]) {
int len;
for (len = 1; i + len - 1 < n; len++) {
l[i + len - 1][j] = 1;
if (!p[i + len][j]) break;
}
s = min(len, s);
i += len;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (p[i][j] && !e[i][j]) {
if (!p[i - 1][j - 1] && !p[i][j - 1] && !p[i - 1][j]) {
int len;
for (len = 1; j + len - 1 < m && i + len - 1 < n; len++) {
e[i + len - 1][j + len - 1] = 1;
if (!p[i + len][j + len]) break;
}
s = min(len, s);
}
if (!p[i + 1][j + 1] && !p[i + 1][j] && !p[i][j + 1]) {
int len;
for (len = 1; j - len > 0 && i - len > 0; len++) {
e[i - len + 1][j - len + 1] = 1;
if (!p[i - len][j - len]) break;
}
s = min(len, s);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j > 0; j--) {
if (p[i][j] && !f[i][j]) {
if (!p[i - 1][j + 1] && !p[i][j + 1] && !p[i - 1][j]) {
int len;
for (len = 1; j - len > 0 && i + len - 1 < n; len++) {
f[i + len - 1][j - len + 1] = 1;
if (!p[i + len][j - len]) break;
}
s = min(len, s);
}
if (!p[i + 1][j - 1] && !p[i][j - 1] && !p[i + 1][j]) {
int len;
for (len = 1; j + len - 1 < m && i - len > 0; len++) {
f[i - len + 1][j + len - 1] = 1;
if (!p[i - len][j + len]) break;
}
s = min(len, s);
}
}
}
}
int t = (s - 1) >> 1;
printf("%d\n", t);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (p[i][j]) v[i][j] = max(n, m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (p[i][j]) {
for (int k = 0; k < 4; k++) {
if (!p[i + d[k][0]][j + d[k][1]])
v[i][j] = min(v[i][j], 1);
else
v[i][j] = min(v[i][j], v[i + d[k][0]][j + d[k][1]] + 1);
}
}
}
for (int i = n; i > 0; i--)
for (int j = m; j > 0; j--) {
if (p[i][j]) {
for (int k = 4; k < 8; k++) {
if (!p[i + d[k][0]][j + d[k][1]])
v[i][j] = min(v[i][j], 1);
else
v[i][j] = min(v[i][j], v[i + d[k][0]][j + d[k][1]] + 1);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!p[i][j])
putchar('.');
else if (v[i][j] <= t)
putchar('.');
else
putchar('X');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<vector<int>> grid, mark, dp;
queue<pair<int, int>> q;
int get(int x, int y, int a, int b) {
return dp[a][b] - dp[a][y - 1] - dp[x - 1][b] + dp[x - 1][y - 1];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
grid.assign(n + 5, vector<int>(m + 5, 0));
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
for (int j = 1; j <= m; ++j) {
if (s[j - 1] == '.')
grid[i][j] = 0;
else
grid[i][j] = 1;
}
}
dp.assign(n + 5, vector<int>(m + 5, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dp[i][j] = grid[i][j] + dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
}
}
int l = 0, r = max(n, m), ans = -1;
vector<vector<int>> F;
F.assign(n + 5, vector<int>(m + 5, 0));
while (l <= r) {
int mid = (l + r) >> 1;
int sz = (2 * mid + 1) * (2 * mid + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (grid[i][j] == 0) {
F[i][j] = 0;
continue;
}
int x = i - mid, y = j - mid;
int u = i + mid, v = j + mid;
if (x <= 0 || y <= 0 || u > n || v > m) {
F[i][j] = 0;
continue;
}
if (get(x, y, u, v) == sz) {
F[i][j] = 1;
} else
F[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
F[i][j] = F[i - 1][j] + F[i][j] + F[i][j - 1] - F[i - 1][j - 1];
}
}
bool ok = true;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (grid[i][j]) {
int x = i - mid, y = j - mid;
int u = i + mid, v = j + mid;
x = max(x, 1);
y = max(y, 1);
u = min(u, n), v = min(v, m);
if (F[u][v] - F[u][y - 1] - F[x - 1][v] + F[x - 1][y - 1] == 0) {
ok = false;
goto tag;
}
}
}
tag:;
if (ok)
l = mid + 1, ans = mid;
else
r = mid - 1;
}
cout << ans << '\n';
int s = (2 * ans + 1) * (2 * ans + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (grid[i][j] == 0) {
cout << ".";
continue;
}
int x = i - ans, y = j - ans;
int u = i + ans, v = j + ans;
if (x <= 0 || y <= 0 || u > n || v > m) {
cout << ".";
continue;
}
if (get(x, y, u, v) == s)
cout << "X";
else
cout << ".";
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e6 + 5;
vector<int> a[Nmax];
vector<int> s[Nmax];
vector<int> p[Nmax];
vector<bool> flag[Nmax];
int n, m;
int sum(int x, int y, int u, int v) {
return s[u][v] + s[x - 1][y - 1] - s[u][y - 1] - s[x - 1][v];
}
void add(int x, int y, int u, int v) {
p[x][y]++;
p[u + 1][v + 1]++;
p[u + 1][y]--;
p[x][v + 1]--;
}
bool solve(int d) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[i][j] = 0;
}
for (int i = d + 1; i <= n - d; i++)
for (int j = d + 1; j <= m - d; j++) {
if (sum(i - d, j - d, i + d, j + d)) continue;
add(i - d, j - d, i + d, j + d);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
p[i][j] += p[i - 1][j] + p[i][j - 1] - p[i - 1][j - 1];
if (!a[i][j] && !p[i][j]) {
return false;
}
}
return true;
}
void trace(int d) {
for (int i = d + 1; i <= n - d; i++)
for (int j = d + 1; j <= m - d; j++) {
if (sum(i - d, j - d, i + d, j + d)) continue;
flag[i][j] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << (flag[i][j] ? 'X' : '.');
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 1; i++) {
a[i].resize(m + 2);
s[i].resize(m + 2);
p[i].resize(m + 2);
flag[i].resize(m + 2);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
a[i][j] = (c != 'X');
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
}
int l = 0;
int r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (solve(mid))
l = mid;
else
r = mid;
}
cout << l << "\n";
trace(l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int em(long long int x, long long int Mod, long long int n) {
if (n == 0)
return 1ll;
else if (n % 2 == 0)
return em((x % Mod * x % Mod) % Mod, Mod, n / 2) % Mod;
else
return (x % Mod * em((x % Mod * x % Mod) % Mod, Mod, (n - 1) / 2)) % Mod;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, j, k, l;
cin >> n >> m;
char arr[n + 2][m + 2];
long long int s1[n + 2][m + 2], s2[n + 2][m + 2];
memset((s1), 0, sizeof(s1));
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
cin >> arr[i][j];
if (arr[i][j] == 'X') s1[i][j] = 1;
}
}
for (long long int j = (long long int)1; j < (long long int)m + 1; j++)
s1[1][j] += s1[1][j - 1];
for (long long int j = (long long int)1; j < (long long int)n + 1; j++)
s1[j][1] += s1[j - 1][1];
for (long long int i = (long long int)2; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)2; j < (long long int)m + 1; j++)
s1[i][j] += s1[i - 1][j] + s1[i][j - 1] - s1[i - 1][j - 1];
}
long long int lo = 0, hi = max(n, m) + 1;
long long int ans[n + 2][m + 2], canbe[n + 2][m + 2], dis = -1;
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
memset((s2), 0, sizeof(s2));
memset((canbe), 0, sizeof(canbe));
for (long long int i = (long long int)mid + 1; i < (long long int)n + 1;
i++) {
for (long long int j = (long long int)mid + 1; j < (long long int)m + 1;
j++) {
long long int hx, hy, lx, ly;
if (i + mid > n || j + mid > m) continue;
hx = i + mid;
hy = j + mid;
lx = i - mid;
ly = j - mid;
if (arr[i][j] == 'X' &&
(s1[hx][hy] - s1[hx][ly - 1] - s1[lx - 1][hy] +
s1[lx - 1][ly - 1]) == (hx - lx + 1) * (hy - ly + 1))
canbe[i][j] = s2[i][j] = 1;
}
}
for (long long int j = (long long int)1; j < (long long int)m + 1; j++)
s2[1][j] += s2[1][j - 1];
for (long long int j = (long long int)1; j < (long long int)n + 1; j++)
s2[j][1] += s2[j - 1][1];
for (long long int i = (long long int)2; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)2; j < (long long int)m + 1; j++)
s2[i][j] += s2[i - 1][j] + s2[i][j - 1] - s2[i - 1][j - 1];
}
long long int flag = 1;
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
long long int hx, hy, lx, ly;
hx = min(n, i + mid);
hy = min(m, j + mid);
lx = max(1ll, i - mid);
ly = max(1ll, j - mid);
if (arr[i][j] == 'X' && (s2[hx][hy] - s2[hx][ly - 1] - s2[lx - 1][hy] +
s2[lx - 1][ly - 1]) < 1) {
flag = 0;
break;
}
}
}
if (flag == 0)
hi = mid - 1;
else {
if (mid > dis) {
dis = mid;
for (long long int i = (long long int)1; i < (long long int)n + 1;
i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1;
j++)
ans[i][j] = canbe[i][j];
}
}
lo = mid + 1;
}
}
cout << dis << "\n";
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
if (ans[i][j] == 1)
cout << "X";
else
cout << ".";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
string str[1000006], txt, tt[1000006];
vector<int> vec[1000006];
vector<pair<int, int> > temp;
int n, m;
bool vis[1000006];
bool chck(int x, int y, int r) {
int tot = (r * 2 + 1);
tot *= tot;
if (x - r > 0 && x + r <= n && y - r > 0 && y + r <= m &&
(vec[x + r][y + r] + vec[x - r - 1][y - r - 1] - vec[x - r - 1][y + r] -
vec[x + r][y - r - 1]) == tot)
return 1;
return 0;
}
bool match() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (str[i][j] != tt[i][j]) {
return 0;
}
return 1;
}
int dirx[] = {1, -1, 0, 0, -1, -1, 1, 1};
int diry[] = {0, 0, 1, -1, 1, -1, 1, -1};
void bfs(int r) {
queue<pair<pair<int, int>, int> > q;
memset(vis, 0, sizeof vis);
for (int i = 0; i < temp.size(); i++) {
pair<int, int> p = temp[i];
tt[p.first][p.second] = 'X';
vis[(p.first - 1) * m + p.second] = 1;
q.push({p, 0});
}
while (!q.empty()) {
pair<pair<int, int>, int> p = q.front();
q.pop();
int x = p.first.first;
int y = p.first.second;
int z = p.second;
if (z == r) continue;
for (int i = 0; i < 8; i++) {
int a = x + dirx[i];
int b = y + diry[i];
if (!vis[(a - 1) * m + b])
vis[(a - 1) * m + b] = 1, q.push({{a, b}, z + 1}), tt[a][b] = 'X';
}
}
return;
}
bool func(int r) {
for (int i = 1; i <= n; i++) {
tt[i].clear();
for (int j = 0; j <= m; j++) tt[i] += '.';
}
temp.clear();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (str[i][j] == 'X' && chck(i, j, r)) temp.push_back({i, j});
bfs(r);
return match();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i <= m; i++) vec[0].push_back(0);
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++) {
cin >> txt;
str[i] = "." + txt;
vec[i].push_back(0);
for (int j = 1; j <= m; j++) {
if (str[i][j] == 'X')
vec[i].push_back(1), ans.push_back({i, j});
else
vec[i].push_back(0);
}
}
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++) vec[i][j] += vec[i - 1][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) vec[i][j] += vec[i][j - 1];
int res = 0, lo = 1, hi = min(n, m) >> 1;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (func(mid))
res = mid, lo = mid + 1, ans = temp;
else
hi = mid - 1;
}
func(res);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) tt[i][j] = '.';
for (int i = 0; i < ans.size(); i++) tt[ans[i].first][ans[i].second] = 'X';
cout << res << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << tt[i][j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6;
int n, m;
string grid[mx + 1];
vector<vector<long long>> psum;
vector<int> dx = {1, 0, -1, 0, 1, 1, -1, -1};
vector<int> dy = {0, 1, 0, -1, 1, -1, 1, -1};
bool ok(int a, int b) {
if (a >= 0 && a < n && b >= 0 && b < m) {
return true;
}
return false;
}
bool good(long long t) {
vector<vector<bool>> visited(n, vector<bool>(m));
queue<pair<int, int>> bfs;
for (int q = 0; q < n; q++) {
for (int w = 0; w < m; w++) {
int tm = t - 1;
if (!ok(q - tm, w - tm) || !ok(q + tm, w + tm)) {
continue;
}
int lq = q + tm;
int lw = w + tm;
int uq = q - tm;
int uw = w - tm;
long long val = psum[lq + 1][lw + 1] -
(psum[lq + 1][uw] + psum[uq][lw + 1] - psum[uq][uw]);
if (val == (2 * tm + 1) * (2 * tm + 1) && !visited[q][w]) {
visited[q][w] = true;
bfs.push({q, w});
}
}
}
for (int q = 2; q <= t; q++) {
int sz = bfs.size();
for (int w = 0; w < sz; w++) {
auto t = bfs.front();
bfs.pop();
int x, y;
tie(x, y) = t;
for (int e = 0; e < 8; e++) {
int nx = x + dx[e];
int ny = y + dy[e];
if (!visited[nx][ny]) {
visited[nx][ny] = true;
bfs.push({nx, ny});
}
}
}
}
for (int q = 0; q < n; q++) {
for (int w = 0; w < m; w++) {
if (grid[q][w] == '.' && visited[q][w] == true) {
return false;
}
if (grid[q][w] == 'X' && visited[q][w] == false) {
return false;
}
}
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
psum.resize(n + 1, vector<long long>(m + 1));
for (int q = 0; q < n; q++) {
cin >> grid[q];
}
for (int q = 1; q <= n; q++) {
for (int w = 1; w <= m; w++) {
psum[q][w] = psum[q - 1][w] + psum[q][w - 1] - psum[q - 1][w - 1] +
(grid[q - 1][w - 1] == 'X' ? 1 : 0);
}
}
int lo = 1, hi = 1e6;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (good(mid)) {
lo = mid;
} else {
hi = mid;
}
}
vector<vector<bool>> ans(n, vector<bool>(m));
for (int q = 0; q < n; q++) {
for (int w = 0; w < m; w++) {
int tm = lo - 1;
if (!ok(q - tm, w - tm) || !ok(q + tm, w + tm)) {
continue;
}
int lq = q + tm;
int lw = w + tm;
int uq = q - tm;
int uw = w - tm;
long long val = psum[lq + 1][lw + 1] -
(psum[lq + 1][uw] + psum[uq][lw + 1] - psum[uq][uw]);
if (val == (2 * tm + 1) * (2 * tm + 1) && !ans[q][w]) {
ans[q][w] = true;
}
}
}
cout << (lo - 1) << "\n";
for (int q = 0; q < n; q++) {
for (int w = 0; w < m; w++) {
cout << (ans[q][w] == true ? 'X' : '.');
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 7;
int N, M;
vector<int> mp[maxN], t[maxN];
vector<bool> X[maxN];
char s[maxN];
int Area(int lx, int ly, int rx, int ry) {
return mp[rx][ry] - mp[lx - 1][ry] - mp[rx][ly - 1] + mp[lx - 1][ly - 1];
}
inline bool In_map(int x, int y) {
return x >= 1 && y >= 1 && x <= N && y <= M;
}
inline bool check(int lim) {
for (int i = 0; i <= N + 1; i++) t[i].clear();
for (int i = 0; i <= M + 1; i++) t[0].push_back(0);
for (int i = 1; i <= N + 1; i++)
for (int j = 0; j <= M + 1; j++) t[i].push_back(0);
int SS = (2 * lim + 1) * (2 * lim + 1);
for (int i = lim + 1, x1, y1, x2, y2; i + lim <= N; i++) {
for (int j = lim + 1; j + lim <= M; j++) {
x1 = i - lim;
y1 = j - lim;
x2 = i + lim;
y2 = j + lim;
if (In_map(x1, y1) && In_map(x2, y2) && Area(x1, y1, x2, y2) == SS) {
t[x1][y1]++;
t[x1][y2 + 1]--;
t[x2 + 1][y1]--;
t[x2 + 1][y2 + 1]++;
}
}
}
for (int x = 1; x <= N; x++) {
for (int y = 1; y <= M; y++) {
t[x][y] = t[x][y] + t[x - 1][y] + t[x][y - 1] - t[x - 1][y - 1];
if (X[x][y] && !t[x][y]) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i <= M; i++) {
mp[0].push_back(0);
mp[N + 1].push_back(0);
}
for (int i = 1, val; i <= N; i++) {
mp[i].push_back(0);
X[i].push_back(false);
scanf("%s", s + 1);
for (int j = 1; j <= M; j++) {
val = mp[i - 1][j] + mp[i][j - 1] - mp[i - 1][j - 1];
if (s[j] == 'X') {
val++;
X[i].push_back(true);
} else
X[i].push_back(false);
mp[i].push_back(val);
}
}
int l = 0, r = min(N, M), mid, ans = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
l = mid + 1;
ans = mid;
} else
r = mid - 1;
}
printf("%d\n", ans);
int SS = (2 * ans + 1) * (2 * ans + 1);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (X[i][j] && In_map(i - ans, j - ans) && In_map(i + ans, j + ans) &&
Area(i - ans, j - ans, i + ans, j + ans) == SS)
printf("X");
else
printf(".");
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e9 + 7;
long long MOD = 998244353;
long long dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
long long dy[8] = {1, -1, 0, 0, -1, 1, 1, -1};
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
char arr[n][m];
bool v[n][m];
long long d[n][m];
queue<pair<long long, long long> > q;
memset(v, 0, sizeof v);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> arr[i][j];
if (arr[i][j] == '.') {
v[i][j] = 1;
d[i][j] = 0;
q.push(pair<long long, long long>(i, j));
}
}
}
auto in = [&](long long x, long long y) {
return min({x, y, n - x - 1, m - y - 1}) >= 0;
};
for (long long i = 0; i < n; i++) {
q.push(pair<long long, long long>(i, -1));
q.push(pair<long long, long long>(i, m));
}
for (long long j = 0; j < m; j++) {
q.push(pair<long long, long long>(-1, j));
q.push(pair<long long, long long>(n, j));
}
while (!q.empty()) {
pair<long long, long long> pre = q.front();
q.pop();
long long X = pre.first, Y = pre.second;
long long dist;
if (in(X, Y)) {
dist = d[X][Y];
} else {
dist = 0;
}
for (long long k = 0; k < 8; k++) {
long long x = X + dx[k], y = Y + dy[k];
if (in(x, y) && !v[x][y]) {
v[x][y] = 1;
d[x][y] = dist + 1;
q.push(pair<long long, long long>(x, y));
}
}
}
long long ans = 0;
vector<pair<long long, pair<long long, long long> > > ar;
long long posa = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (arr[i][j] == 'X') {
ar.push_back(pair<long long, pair<long long, long long> >(
d[i][j], pair<long long, long long>(i, j)));
ans = max(ans, d[i][j]);
posa++;
}
}
}
long long l = 0, r = ans;
ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
long long POSA = posa;
queue<pair<long long, long long> > q;
memset(v, 0, sizeof v);
long long dis[n][m];
memset(dis, 0, sizeof dis);
for (auto x : ar) {
if (x.first > mid) {
v[x.second.first][x.second.second] = 1;
q.push(pair<long long, long long>(x.second.first, x.second.second));
POSA--;
}
}
while (!q.empty()) {
pair<long long, long long> pre = q.front();
q.pop();
long long X = pre.first, Y = pre.second;
long long dist = dis[X][Y];
if (dist == mid) {
continue;
}
for (long long k = 0; k < 8; k++) {
long long x = X + dx[k], y = Y + dy[k];
if (in(x, y) && !v[x][y] && arr[x][y] == 'X') {
v[x][y] = 1;
POSA--;
dis[x][y] = dist + 1;
q.push(pair<long long, long long>(x, y));
}
}
}
if (POSA == 0) {
l = mid + 1;
ans = max(ans, mid);
} else {
r = mid - 1;
}
}
cout << ans << "\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (d[i][j] > ans) {
cout << "X";
} else {
cout << ".";
}
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int n, m;
char **a;
int **p;
int **pp;
int **u;
void pre() {
u = new int *[n + 6];
for (int i = 0; i < n + 6; ++i) {
u[i] = new int[m + 6];
}
for (int i = 0; i < n + 6; ++i) {
for (int j = 0; j < m + 6; ++j) {
u[i][j] = 0;
}
}
pp = new int *[n + 6];
for (int i = 0; i < n + 6; ++i) {
pp[i] = new int[m + 6];
}
for (int i = 0; i < n + 6; ++i) {
for (int j = 0; j < m + 6; ++j) {
pp[i][j] = 0;
}
}
p = new int *[n + 6];
for (int i = 0; i < n + 6; ++i) {
p[i] = new int[m + 6];
}
for (int i = 0; i < n + 6; ++i) {
for (int j = 0; j < m + 6; ++j) {
p[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
p[i][j] = p[i - 1][j] + p[i][j - 1] - p[i - 1][j - 1];
if (a[i][j] == '.') ++p[i][j];
}
}
}
bool stgg(int x1, int x2, int y1, int y2) {
if (x1 <= 0) return false;
if (x2 > n) return false;
if (y1 <= 0) return false;
if (y2 > m) return false;
return (p[x2][y2] - p[x2][y1 - 1] - p[x1 - 1][y2] + p[x1 - 1][y1 - 1] == 0);
}
bool stg(int k) {
for (int i = 0; i < n + 6; ++i) {
for (int j = 0; j < m + 6; ++j) {
pp[i][j] = 0;
}
}
for (int i = 0; i < n + 6; ++i) {
for (int j = 0; j < m + 6; ++j) {
u[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (stgg(i - k, i + k, j - k, j + k)) {
u[i - k][j - k]++;
u[i + k + 1][j + k + 1]++;
u[i - k][j + k + 1]--;
u[i + k + 1][j - k]--;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
pp[i][j] = pp[i - 1][j] + pp[i][j - 1] - pp[i - 1][j - 1];
pp[i][j] += u[i][j];
if (a[i][j] == 'X' && pp[i][j] == 0) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
a = new char *[n + 6];
for (int i = 0; i < n + 6; ++i) a[i] = new char[m + 6];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf(" %c", &a[i][j]);
}
}
pre();
int l = 0, r = n;
int ans;
while (l <= r) {
int m = (l + r) / 2;
if (stg(m)) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (stgg(i - ans, i + ans, j - ans, j + ans)) {
printf("X");
} else {
printf(".");
}
}
printf("\n");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.