洛谷P2698 花盆Flowerpot【单调队列】

题目描述

Farmer John has been having trouble making his plants grow, and needs your help to water them properly. You are given the locations of N raindrops (1 <= N <= 100,000) in the 2D plane, where y represents vertical height of the drop, and x represents its location over a 1D number line:

Each drop falls downward (towards the x axis) at a rate of 1 unit per second. You would like to place Farmer John's flowerpot of width W somewhere along the x axis so that the difference in time between the first raindrop to hit the flowerpot and the last raindrop to hit the flowerpot is at least some amount D (so that the flowers in the pot receive plenty of water). A drop of water that lands just on the edge of the flowerpot counts as hitting the flowerpot.

Given the value of D and the locations of the N raindrops, please compute the minimum possible value of W.

老板需要你帮忙浇花。给出N滴水的坐标，y表示水滴的高度，x表示它下落到x轴的位置。

每滴水以每秒1个单位长度的速度下落。你需要把花盆放在x轴上的某个位置，使得从被花盆接着的第1滴水开始，到被花盆接着的最后1滴水结束，之间的时间差至少为D。

我们认为，只要水滴落到x轴上，与花盆的边沿对齐，就认为被接住。给出N滴水的坐标和D的大小，请算出最小的花盆的宽度W。

输入输出格式

输入格式：

第一行2个整数 N 和 D。

第2.. N+1行每行2个整数，表示水滴的坐标(x,y)。

输出格式：

仅一行1个整数，表示最小的花盆的宽度。如果无法构造出足够宽的花盆，使得在D单位的时间接住满足要求的水滴，则输出-1。

输入输出样例

输入样例#1： 复制

4 5
6 3
2 4
4 10
12 15

输出样例#1： 复制

2

说明

【样例解释】

有4滴水， (6,3), (2,4), (4,10), (12,15).水滴必须用至少5秒时间落入花盆。花盆的宽度为2是必须且足够的。把花盆放在x=4..6的位置，它可以接到1和3水滴, 之间的时间差为10-3 = 7满足条件。

【数据范围】

40%的数据：1 ≤ N ≤ 1000，1 ≤ D ≤ 2000；

100%的数据：1 ≤ N ≤ 100000，1 ≤ D ≤ 1000000，0≤x,y≤10^6。

题意：

用一个宽度最小的花盆接雨滴，使得这个区间内的雨滴的纵坐标最大值和最小值之差大于等于d

思路：

一眼思路是用线段树维护区间最大值和最小值，二分答案。当然T了，而且WA，才拿了20分。好菜啊。

讲道理顶多会T，怎么会WA呢我好菜啊哭。

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define inf 0x7f7f7f7f

const int maxn = 1e5 + 5;
const int maxd = 1e6 + 5;
int n, d, mmx, mmin;
int height[maxd];
int tree_max[maxd << 2], tree_min[maxd << 2];

void pushup(int rt)
{
    tree_max[rt] = max(tree_max[rt << 1], tree_max[rt << 1 | 1]);
    tree_min[rt] = min(tree_min[rt << 1], tree_min[rt << 1 | 1]);
}

void build(int rt, int l, int r)
{
    if(l == r){
        if(height[l] == -1){
            tree_max[rt] = -inf;
            tree_min[rt] = inf;
        }
        else{
            tree_max[rt] = tree_min[rt] = height[l];
        }
        return;
    }
    int mid = (l + r) / 2;
    build(rt << 1, l, mid);
    build(rt << 1 | 1, mid + 1, r);
    pushup(rt);
}

int query_max(int L, int R, int l, int r, int rt)
{
    if(L <= l && R >= r){
        return tree_max[rt];
    }
    int mid = (l + r) / 2;
    int res = -inf;
    if(L <= mid){
        res = max(res, query_max(L, R, l, mid, rt << 1));
    }
    if(R > mid){
        res = max(res, query_max(L, R, mid + 1, r, rt << 1 | 1));
    }
    return res;
}

int query_min(int L, int R, int l, int r, int rt)
{
    if(L <= l && R >= r){
        return tree_min[rt];
    }
    int mid = (l + r) / 2;
    int res = inf;
    if(L <= mid){
        res = min(res, query_min(L, R, l, mid, rt << 1));
    }
    if(R > mid){
        res = min(res, query_min(L, R, mid + 1, r, rt << 1 | 1));
    }
    return res;
}

bool check(int len)
{
    for(int i = mmin; i <= mmx; i++){
        //cout<<query_max(i, i + len, 1, mmx, 1)<<endl;
        //cout<<query_min(i, i + len, 1, mmx, 1)<<endl;
        if(query_max(i, i + len, 1, mmx, 1) - query_min(i, i + len, 1, mmx, 1) >= d)return true;
    }
    return false;
}

int main()
{
    scanf("%d%d", &n, &d);
    mmx = -inf;
    mmin = inf;
    memset(tree_max, -inf, sizeof(tree_max));
    memset(tree_min, inf, sizeof(tree_min));
    memset(height, -1, sizeof(height));
    for(int i = 0; i < n; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        height[x] = y;
        mmx = max(mmx, x);
        mmin = min(mmin, x);
    }

    build(1, 1, mmx);

    int ans = -1, st = mmin, ed = mmx;
    while(st <= ed){
        int mid = (st + ed) / 2;
        if(check(mid)){
            ed = mid - 1;
            ans = mid;
        }
        else{
            st = mid + 1;
        }
    }

    printf("%d
", ans);
    return 0;
}

好吧既然是单调队列专题，就去学习一下单调队列吧。

其实刚开始想到了如果加入了一个雨滴之后，他和队头的高度差小于前面的，并且距离差也变大了的话，那这个雨滴肯定是没用的。之后就不会了。

应该要想到的是，当我们加入了一个雨滴之后，这一段的最大值只有可能增大或不变，最小值只有可能减小或者不变。他们都是单调的。

可以用一个单调队列来维护最大最小值，队头元素是最小值，队尾元素是最大值。

先按照横坐标对雨滴排个序，然后一个个加入，当队头和队尾纵坐标之差大于等于d的时候就把队头丢掉。因为之后加入队列的那个元素和队头虽然也会满足大于等于d但是宽度就不是最小的了。

但是这样只是找到了从左到右的一个单调序列，还应该再考虑一下从右到左。其实就相当于纪要考虑从左到右递增的，也要考虑从左到右递减的。

虽然这道题数据有问题，只考虑从左到右也能AC

#include <iostream>
#include <set>
#include <cmath>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define inf 0x7f7f7f7f

const int maxn = 1e5 + 5;
const int maxd = 1e6 + 5;
int n, d, mmx, mmin;
int height[maxd];

struct node{
    int x, y;
}drop[maxn], que1[maxn], que2[maxn];

bool cmp(node a, node b)
{
    return a.x < b.x;
}

int main()
{
    scanf("%d%d", &n, &d);
    for(int i = 0; i < n; i++){
        scanf("%d%d", &drop[i].x, &drop[i].y);
    }
    sort(drop, drop + n, cmp);

    int tail = 0, head = 1, ans = inf;
    for(int i = 0; i < n; i++){
        while(que1[tail].y >= drop[i].y && head <= tail)tail--;
        que1[++tail] = drop[i];
        //cout<<"head"<<que[head].x<<" tail"<<que[tail].x<<endl;
        while(que1[tail].y - que1[head].y >= d){
            ans = min(ans, que1[tail].x - que1[head].x);
            head++;
        }
    }
    //cout<<ans<<endl;
    tail = 0;
    head = 1;
    for(int i = n - 1; i >= 0; i--){
        while(que2[tail].y >= drop[i].y && head <= tail)tail--;
        que2[++tail] = drop[i];
        while(que2[tail].y - que2[head].y >= d){
            ans = min(ans, que2[head].x - que2[tail].x);
            head++;
        }
    }

    if(ans == inf){
        printf("-1
");
    }
    else{
        printf("%d
", ans);
    }
    return 0;
}