洛谷P3088 挤奶牛

传送门啦

这个题也是一个单调队列来优化的 $ dp $ ，我们考虑这个题，这个题让我们求出有多少奶牛会觉得拥挤，如果我们还像琪露诺那个题那样单纯用一次单调队列肯定是不行的，因为牛觉不觉得拥挤是受左右的影响，所以我们选择从前往后、从后往前用两遍单调队列。

一开始就是在 $ push $ 元素的时候，如果要 $ push $ 的元素是队尾元素高度的两倍，那么就给队尾的元素打一个标记，然后 $ tail-- $

但是这样的做法会造成漏判，所以，我们要换一种判断的方法。就是把判断从当前元素判断队中的元素变为队中的元素判断当前元素。(先后问题)

在循环中，合法性判断完之后，如果队头的元素是当前元素高度的两倍，那么把当前元素打一个标记，这样就完美解决了漏判的问题

#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 50005;

inline int read(){
    char ch = getchar();
    int f = 1 , x = 0;
    while(ch > '9' || ch < '0'){if(ch == '-')f = -1; ch = getchar();}
    while(ch >= '0' &&ch <= '9'){x = (x << 1) + (x << 3) + ch - '0';ch = getchar();}
    return x * f;
}

int n,d;
int q[maxn],head,tail;
bool l[maxn],r[maxn];

struct Edge{
    int x,high;
}e[maxn];

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

int main(){
    n = read(); d = read();
    for(int i=1;i<=n;i++){
        e[i].x = read();
        e[i].high = read();
    }
    sort(e + 1 , e + 1 + n , cmp);
    head = 1; tail = 0;
    for(int i=1;i<=n;i++){
        while(head <= tail && e[i].high >= e[q[tail]].high)
            tail--;
        q[++tail] = i;
        while(head <= tail && e[i].x - e[q[head]].x > d)
            head++;
        if(e[q[head]].high >= 2 * e[i].high)
            l[i] = 1;
    }
    head = 1; tail = 0;
    for(int i=n;i>=1;i--){
        while(head <= tail && e[i].high >= e[q[tail]].high)
            tail--;
        q[++tail] = i;
        while(head <= tail && e[q[head]].x - e[i].x > d)
            head++;
        if(e[q[head]].high >= 2 * e[i].high)
            r[i] = 1;
    }
    int ans = 0;
    for(int i=1;i<=n;i++)
        if(l[i] && r[i])  ans++;
    printf("%d",ans);
    return 0;
}

转载于:https://www.cnblogs.com/Stephen-F/p/9869649.html