Description:
二维平面上有一些点,我们可以把过这个点且平行于坐标轴的直线和边框夹成的区域涂黑。问最后剩下白色区域的最大周长(显然是一个矩形)。
Solution:
我们可以发现这个矩形肯定经过
x=w2或者y=h2
x
=
w
2
或
者
y
=
h
2
。那么我们可以考虑枚举上下边界,这样可以做到
O(n2)
O
(
n
2
)
。然后考虑优化这个过程。对于一个上边界,我们希望取到最大值。
我们维护一个线段树,维护每个位置的宽度和距离当前枚举点的长度。假设当前经过
x=w2
x
=
w
2
,那么自然希望从这条直线尽量向两边拓展,最大宽度也就是距离这条线左右两侧最近的两个点的距离,那么维护两个单调栈即可。
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int maxn = 3e5 + 5;
int w, h, n, ans;
int mx[maxn * 4], tag[maxn * 4];
PII a[maxn], b[maxn], p[maxn];
void pushdown(int x) {
tag[x << 1] += tag[x];
tag[x << 1 | 1] += tag[x];
mx[x << 1] += tag[x];
mx[x << 1 | 1] += tag[x];
tag[x] = 0;
}
void update(int l, int r, int x, int a, int b, int d) {
if(l > b || r < a) {
return;
}
if(l >= a && r <= b) {
tag[x] += d;
mx[x] += d;
return;
}
pushdown(x);
int mid = (l + r) >> 1;
update(l, mid, x << 1, a, b, d);
update(mid + 1, r, x << 1 | 1, a, b, d);
mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
void solve() {
memset(mx, 0, sizeof(mx));
memset(tag, 0, sizeof(tag));
sort(p + 1, p + n + 1);
int l = 0, r = 0;
for(int i = 1; i < n; ++i) {
if(p[i].y <= h / 2) {
int nxt = i - 1;
while(l && p[i].y > a[l].y) {
update(1, n, 1, a[l].x, nxt, a[l].y - p[i].y);
nxt = a[l].x - 1;
--l;
}
if(nxt != i - 1) {
a[++l] = PII(nxt + 1, p[i].y);
}
} else {
int nxt = i - 1;
while(r && p[i].y < b[r].y) {
update(1, n, 1, b[r].x, nxt, p[i].y - b[r].y);
nxt = b[r].x - 1;
--r;
}
if(nxt != i - 1) {
b[++r] = PII(nxt + 1, p[i].y);
}
}
a[++l] = PII(i, 0);
b[++r] = PII(i, h);
update(1, n, 1, i, i, h - p[i].x);
ans = max(ans, p[i + 1].x + mx[1]);
}
}
int main() {
scanf("%d%d%d", &w, &h, &n);
for(int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].x, &p[i].y);
}
p[++n] = PII(0, 0);
p[++n] = PII(w, h);
solve();
for(int i = 1; i <= n; ++i) {
swap(p[i].x, p[i].y);
}
swap(w, h);
solve();
printf("%d\n", ans << 1);
return 0;
}