洛谷 P3124 [USACO15OPEN]Trapped in the Haybales S（分别向左右枚举，窗口边界问题，双变量。。

洛谷 P3124

先给大家表演一波错误的思路：
从初始位置出发向左右两边分别破障，取最小值。
错误的思路加上理解题意错误，题意只能增加一捆稻草。
导致浪费时间+自闭自闭自闭

具体代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <math.h>
#include <stdlib.h>
#include <functional>
#include <string>
#include <vector>
#include <map>
#include <stack>
#include <cstdio>
#include <deque>
#include <list>
#include <queue>
#include <set>
#include <unordered_map>
#define ll long long
using namespace std;

ll n,m;
ll r,l,length=0;
ll minn=10000000000;
typedef struct{
    ll num,weight;
}node;
node k[110000];
bool cmp(node x,node y){
    return x.num<y.num;
}

int main(){
    cin>>n>>m;
    ll i;
    for(i=1;i<=n;i++) cin>>k[i].weight>>k[i].num;
    sort(k+1,k+n+1,cmp);
    k[0].weight=10000000000;
    k[n+1].weight=10000000000;
    for(i=1;i<n;i++) {
        if(k[i].num<m&&m<k[i+1].num) l=i,r=i+1,length=k[i+1].num-k[i].num;
    }
    while(1){
        if(length<=k[l].weight&&length<=k[r].weight) //小于两边
            break;
        if(length>k[l].weight&&length>k[r].weight){//大于两边
            minn=min(minn,length-k[l].weight+length-k[r].weight);
            length+=(k[l].num-k[l-1].num+k[r+1].num-k[r].num);
            l--;
            r++;
        }
        else if(length>k[l].weight&&length<=k[r].weight){
            minn=min(minn,length-k[l].weight);
            length+=(k[l].num-k[l-1].num);
            l--;
        }
        else if(length<=k[l].weight&&length>k[r].weight){
            minn=min(minn,length-k[r].weight);
            length+=(k[r+1].num-k[r].num);
            r++;
        }
    }
    if(l>=1&&r<=n) cout<<-1;
    else cout<<minn;
}

WA WA WA
这就是思路不清晰的后果，
一定要想好了再动手！！！！想好了再动手！！！
————————分割线—————————————
以下为正文：
题意：
问题要求我们加固其中一个草堆以避免Bessie逃出草堆。并且当连续跑动的距离大于该草堆的大小就能打破该草堆。那么需要加固该草堆的size就等于跑动的距离减去该草堆的大小。那么我们思考某一个草堆能够被撞击的最大加速值是在不打破该草堆的前提下让Bessie随意倒腾能够开辟出的最大空间。

思路：
既然只能改动一个草垛的高度，很容易想到枚举，分别向左向右枚举每一个草垛的情况。
对于其中的一个草垛，它有可能不被击破，有可能因为另一半被击破，随着距离的增加而被击破。
所以我们先不考虑这个草垛本身的情况。
我们假设加高这个草垛，那么当务之急是找到另一边最近的不被击破的草垛的位置。
在确定一个草垛的情况下，另一个草垛有两种情况：不被击破或者被击破。
1.不被击破，那么根据这两个草垛之间的距离可以求出当前情况下该草垛应该增加的高度（有可能是负值，因为高度可能比撞击该草堆的最大加速值还要大，不管他）。
2.被击破，继续向边界搜索，直到越界（如果左右两边都越界，输出-1）。

另外：
什么时候输出0什么时候输出-1？
输出0是指枚举完了左端点或右端点，但是另一边的位置极值始终不能到达0和n+1的情况。会导致ans的值被更新成负数，输出时用max调整一下就行。在我们的算法中表现为另一边搜到“一堵墙”时一边刚好也是“一堵墙”，这样导致minn是负值。
输出-1只当Bessie向任意一边跑，但是甚至不用撞破另一边的草堆的时候就能逃离的时候输出。这时ans的值不会被更新。在我们的算法中表现为分别向两边搜时都没有搜到墙，两个都出界了。
代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <math.h>
#include <stdlib.h>
#include <functional>
#include <string>
#include <vector>
#include <map>
#include <stack>
#include <cstdio>
#include <deque>
#include <list>
#include <queue>
#include <set>
#include <unordered_map>
#define ll long long
using namespace std;

ll n,m;
ll r,l;
ll minn=10000000000;//minn有可能为负值，不用增加高度就走不出去了
typedef struct{
    ll num,weight;
}node;
node k[110000];
bool cmp(node x,node y){
    return x.num<y.num;
}

int main(){
    cin>>n>>m;
    ll i;
    for(i=1;i<=n;i++) cin>>k[i].weight>>k[i].num;
    sort(k+1,k+n+1,cmp);
    for(i=1;i<n;i++) {
        if(k[i].num<m&&m<k[i+1].num) l=i,r=i+1;
    }
    ll pl=l,pr=r;
    for(;pl>=1;pl--){//枚举左边
        while(pr<=n&&k[pr].num-k[pl].num>k[pr].weight) pr++;
        if(pr>n) break;
        minn=min(minn,k[pr].num-k[pl].num-k[pl].weight);
    }
    pl=l,pr=r;
    for(;pr<=n;pr++){//枚举右边
        while(pl>=1&&k[pr].num-k[pl].num>k[pl].weight) pl--;
        if(pl<1) break;
        minn=min(minn,k[pr].num-k[pl].num-k[pr].weight);
    }
    if(minn==10000000000) cout<<-1;//两边都没能找到
    else cout<<max(minn,minn*0);//如果为负值输出0
}

好的算法胜过一下午低质量的学习。
多思考才能少动手啊！