题目大意
用边长为 (k) 的正方形在平面内覆盖，求它能覆盖的最大点权和
思路
(60) 分：其实很容易想到按它们的横坐标先后排序，然后单调队列维护。复杂度 (O(n k log k))
然而考试时我直接修改了队列，导致 (WA) 到了 (10) 分！改后又由于各种问题使它只 (TLE) 到 (50) 分
(100) 分：
接下来讲解两种做法（本质上是一样的）
一：我们圈出了横坐标差为 (k) 的一个区间，如图：
考虑处理纵坐标
很容易想到线段树维护纵坐标各处权值
我们这 (t_i) 表示纵坐标为 ([i..{i+k}]) 上的权值和（不用考虑横坐标了）
每插入一个点，它会对 (t) 中 (i..{i-k}) 都产生贡献
那么我们区间修改即可
每次修改后，取全局最大值
线段树同时维护最大值即可
(Code)
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 5e4 + 5;
int m , n , k , ans;
struct point{
int a , b , c;
}a[N] , d[N];
inline bool cmp(point x , point y){return x.a < y.a ? 1 : (x.a == y.a ? x.b < y.b : 0);}
struct Segment_tree{
int tag[N << 2] , mx[N << 2];
void update(int k , int l , int r , int x , int y , int v)
{
if (x <= l && r <= y)
{
tag[k] += v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) update(k << 1 , l , mid , x , y , v);
if (y > mid) update(k << 1 | 1 , mid + 1 , r , x , y , v);
mx[k] = max(mx[k << 1] + tag[k << 1] , mx[k << 1 | 1] + tag[k << 1 | 1]);
}
}seg;
int main()
{
scanf("%d%d%d" , &m , &n , &k);
for(register int i = 1; i <= n; i++) scanf("%d%d%d" , &a[i].a , &a[i].b , &a[i].c);
sort(a + 1 , a + n + 1 , cmp);
int h = 0 , t = 0;
for(register int i = 1; i <= n; i++)
{
while (a[i].a - d[h].a > k && h <= t) seg.update(1 , 1 , m , max(1 , d[h].b - k) , d[h].b , -d[h].c) , h++;
if (h == 0) h++;
d[++t] = a[i] , seg.update(1 , 1 , m , max(1 , a[i].b - k) , a[i].b , a[i].c);
ans = max(ans , seg.mx[1]);
}
printf("%d" , ans);
}
二：扫描线做法
先转化成扫描线可做的模型
我们把以一个点为左下角的矩形画出来，并给纵条边赋上边权为它的正（负）点权，表示它对这个矩形产生的贡献
如图：
那么在一个矩形内，含有的纵向线段（只要有一部分）权值之和就是可能的答案
那么我们在扫描时就把纵向线段权值加入线段树中
注意加入后它是一个区间，那么多个区间重叠的部分就是我们矩形的贡献
于是我们维护每个矩形的贡献最大值就变成了维护最大值（一个矩形是我们能覆盖的最大的二维区间，所以只取每个矩形的贡献最大值）
而矩形的靠右的纵向边是不能纳入本矩形的贡献，所以它要在 (X=x+k+1) 的直线上
扫描线扫过靠右的纵向边后，靠左的纵向边就不能再产生贡献了，所以其值设为负的
(Code)
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 5e4 + 5;
int m , n , k , ans;
struct line{
int x , l , r , v;
}l[N << 2];
inline bool cmp(line x , line y){return x.x < y.x ? 1 : (x.x == y.x ? x.v < y.v : 0);}
struct Segment_tree{
int tag[N << 2] , mx[N << 2];
void update(int k , int l , int r , int x , int y , int v)
{
if (y < l || r < x) return;
if (x <= l && r <= y)
{
tag[k] += v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) update(k << 1 , l , mid , x , y , v);
if (y > mid) update(k << 1 | 1 , mid + 1 , r , x , y , v);
mx[k] = max(mx[k << 1] + tag[k << 1] , mx[k << 1 | 1] + tag[k << 1 | 1]);
}
}seg;
int main()
{
scanf("%d%d%d" , &m , &n , &k);
int x , y , z;
for(register int i = 1; i <= n; i++)
{
scanf("%d%d%d" , &x , &y , &z);
l[(i << 1) - 1] = (line){x , y , y + k , z};
l[i << 1] = (line){x + k + 1 , y , y + k , -z};
}
n <<= 1;
sort(l + 1 , l + n + 1 , cmp);
for(register int i = 1; i <= n; i++)
{
seg.update(1 , 1 , m , l[i].l , l[i].r , l[i].v);
ans = max(ans , seg.mx[1] + seg.tag[1]);
}
printf("%d" , ans);
}
其实两者的时间复杂度是几乎相同的（因为你发现两者代码也几乎相同）
感性地理解并发现，后者速度似乎更快（常数小）
所以我打的两个都差不多
后者思考方式不一样
建议两者都思考一下