题意：
给出N滴水的坐标，y表示水滴的高度，x表示它下落到x轴的位置。
每滴水以每秒1个单位长度的速度下落。你需要把花盆放在x轴上的某个位置，使得从被花盆接着的第1滴水开始，到被花盆接着的最后1滴水结束，之间的时间差至少为D。
我们认为，只要水滴落到x轴上，与花盆的边沿对齐，就认为被接住。给出N滴水的坐标和D的大小，请算出最小的花盆的宽度W。
数据范围：
40%的数据：1 ≤ N ≤ 1000，1 ≤ D ≤ 2000；
100%的数据：1 ≤ N ≤ 100000，1 ≤ D ≤ 1000000，0≤x,y≤10^6。
--------------------------------------------------我是分割线----------------------------------------------------
题解：对于40%的数据，二分花盆的宽度，朴素O（N^2）检验宽度len能否满足条件，总时间复杂度O（N^2logN），期望得分40，实际得分50。
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
using namespace std;
typedef pair<int, int> pii;
typedef double db;
const int N = 1e6 + 50;
struct node{ int x, y; } a[N];
int n, d, l = 1, r, ans = -1;
inline int read(){
int x = 0, f = 1;
char ch = getchar();
while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar();}
while(ch >='0' && ch <='9') { x = (x<<3)+(x<<1)+(ch^48); ch = getchar();}
return x*f;
}
bool mycmp(node a, node b){ return a.x < b.x; }
void init(){
n = read(); d = read();
rep(i, 1, n) a[i].x = read(), a[i].y = read(), r = max(r, a[i].x);
sort(a+1, a+n+1, mycmp);
}
bool check(int len){
int dist = 0;
rep(i, 1, n){
int t = a[i].y, maxx = 0;
maxx = max(maxx, a[i].y);
rep(j, i+1, n){
if(i == j) continue;
if(a[j].x >= a[i].x && a[j].x <= a[i].x + len) {
maxx = max(maxx, a[j].y);
t = min(t, a[i].y);
}
}
dist = max(dist, abs(maxx - t));
if(dist >= d) return true;
}
return false;
}
void work(){
while(l < r){
int mid = (l+r) >> 1;
if(check(mid)) r = mid, ans = mid;
else l = mid + 1;
}
printf("%d
", ans);
}
int main(){
init();
work();
return 0;
}
考虑对朴素算法进行优化，我们发现，检验的过程max-min的值我们可以预处理维护的，于是把整条x轴看成一个区间，每个水滴的y值看成是区间下标的权值，于是我们就不难想到ST表，运用ST表预处理区间的最大值和最小值，于是可以O（N）检验。总时间复杂度O（NlogN），常数略大。
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
using namespace std;
typedef pair<int, int> pii;
typedef double db;
const int N = 1e5 + 50;
struct node{ int x, y; } a[N];
int n, d, l = 1, r, ans = -1, maxn;
int Max[N*10][21], Min[N*10][21];
inline int read(){
int x = 0, f = 1;
char ch = getchar();
while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar();}
while(ch >='0' && ch <='9') { x = (x<<3)+(x<<1)+(ch^48); ch = getchar();}
return x*f;
}
int ask_max(int l, int r){
int k = log2(r-l+1);
return max(Max[l][k], Max[r - (1<<k) + 1][k]);
}
int ask_min(int l, int r){
int k = log2(r-l+1);
return min(Min[l][k], Min[r - (1<<k) + 1][k]);
}
void init(){
memset(Min, 0x3f, sizeof(Min));
n = read(); d = read();
rep(i, 1, n){
a[i].x = read(), a[i].y = read(), maxn = max(maxn, a[i].x);
Max[a[i].x][0] = max(Max[a[i].x][0], a[i].y);
Min[a[i].x][0] = min(Min[a[i].x][0], a[i].y);
}
int t = log2(maxn);
rep(j, 1, t) rep(i, 1, maxn - (1<<j) + 1) {
Max[i][j] = max(Max[i][j-1], Max[i + (1<<(j-1))][j-1]);
Min[i][j] = min(Min[i][j-1], Min[i + (1<<(j-1))][j-1]);
}
}
bool check(int len){
rep(i, 1, maxn-len){
if(ask_max(i, i+len) - ask_min(i, i+len) >= d) return true;
}
return false;
}
void work(){
r = maxn;
while(l <= r){
int mid = (l+r) >> 1;
if(check(mid)) r = mid-1, ans = mid;
else l = mid + 1;
}
printf("%d
", ans);
}
int main(){
init();
work();
return 0;
}
这里再介绍一种新的维护方法，即动态维护区间最大值和最小值的基本套路。
当我们二分到一个长度时，对于这个长度所能产生的最大的贡献即为max{max[i，i+len] - min[i，i+len] }。
这时，我们就可以使用单调队列。
维护两个单调队列，分别是单调不降和单调不升的队列，两个队头{min，max}即为所需求的答案。
至于怎么维护，维护单调队列的基本形式，如果队头没有下一个元素优，那么就弹出队头，直到符合单调性为止，然后对队尾操作，使得队列包含的区间长度等于len+1。
总时间复杂度O（NlogN），常数较小。
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
using namespace std;
typedef pair<int, int> pii;
typedef double db;
const int N = 1e6 + 50;
struct node{ int x, y; } a[N];
int n, d, maxx, ans = -1, b[N], k[N];
struct npp{ int z, id; } ql[N], qh[N];
inline int read(){
int x = 0, f = 1;
char ch = getchar();
while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar();}
while(ch >='0' && ch <='9') { x = (x<<3)+(x<<1)+(ch^48); ch = getchar();}
return x*f;
}
void init(){
memset(k, 0x3f, sizeof(k));
n = read(); d = read();
rep(i, 1, n) a[i].x = read(), a[i].y = read(), maxx = max(maxx, a[i].x);
rep(i, 1, n) b[a[i].x] = max(b[a[i].x], a[i].y);
rep(i, 1, n) k[a[i].x] = min(k[a[i].x], a[i].y);
}
bool check(int len){
len++;
int ls = 1, rs = 0, lh = 1, rh = 0, sum = 0;
rep(i, 1, maxx) {
while(ls <= rs && k[i] <= ql[rs].z) rs--;
while(lh <= rh && b[i] >= qh[rh].z) rh--;
while(ql[ls].id <= i-len) ls++;
while(qh[lh].id <= i-len) lh++;
ql[++rs].z = k[i], ql[rs].id = i;
qh[++rh].z = b[i], qh[rh].id = i;
if(i >= len) sum = max(sum, qh[lh].z - ql[ls].z);
if(sum >= d) return true;
}
return false;
}
void work(){
int l = 1, r = maxx;
while(l <= r){
int mid = (l+r) >> 1;
if(check(mid)) r = mid-1, ans = mid;
else l = mid+1;
}
printf("%d
", ans);
}
int main(){
init();
work();
return 0;
}
其实除了单调队列以外，动态维护区间最值还可以用STL的<set>，或者堆，不过时间复杂度要多一个log，可能会被卡常，推荐使用单调队列。