Codeforces 671E Organizing a Race (贪心、线段树)

题目链接

https://codeforces.com/contest/671/problem/E

题解

完全不会做……基本是抄lk的代码
ruogu的题解: https://www.luogu.com.cn/blog/ruogu-pupil/cf671esoj809-tan-xin-er-fen-tan-suo-shen-xian#
Orz lk & ruogu
注: 本文中\(a,b,m\)分别表示原题中的\(g,w,k\)
首先考虑如何分配方案，有一个显然的贪心是从左往右遇到不得不加油的时候就加上，保证从左到右合法，最后剩下的钱全都加到右端点，以尽可能地保证从右往左合法。
设\(f_i=f_{i-1}+a_{i-1}-b_{i-1},g_i=g_{i-1}+b_{i-1}-a_i\)
不考虑\(a\)的增加，区间\([l,r]\)合法当且仅当\(f_l=\min^r_{i=l}f_i, g_r=\min^r_{i=l}g_i\)
若\(a_i\)增加\(1\), 则对于\(j\ge i\), \(f_j\)增加\(1\), 对于\(j\gt i\), \(g_j\)减少\(1\), 设改变后的\(g\)为\(h\)数组
我们从后往前枚举\(l\), 顺便维护单调栈，考虑从\(l\)往右可达的最大的\(r\)可以直接在单调栈上二分求出，记为\(R\). 我们在维护单调栈的同时也可以利用线段树区间加维护出\(h\)
则对于\(r\)有\(h_r=g_r+m\)，要查询满足\(g_r-m\le min^{r-1}_{i=l}h_i\)且\(l\le i\le R\)的最大\(r\)
（所以其实使用前缀和而非后缀和是一个很妙的思路，它保证了当\(r\)取不同值时\(g_r\)的增加量恒为\(m\)）
考虑直接线段树上二分，当走到线段树上一个节点时，若\(R>mid\)且左半边的\(h\)的最小值大于等于右边\(g\)的最小值\(-k\), 那么就递归右边，右边一定有答案（但不一定在\(R\)的左边）。这是因为显然左半边的\(h_i\ge g_i-k\), 右半边的点都满足\(h_i\le g_i-k\le g_r-k\). 如果找到的点在\(R\)的右边，那么返回无解，这种情况只会发生一次，不影响复杂度。如果右边返回无解或\(R\le mid\), 在这种情况下，若当前最小的\(h\)大于等于左边\(g\)的最小值\(-m\)则递归左边, 否则仍然返回无解。对于一次向左递归，能够保证找到解，因此复杂度正确。（可能讲得不清楚……详见代码）
时间复杂度\(O(n\log n)\).

代码

#include<bits/stdc++.h>
#define llong long long
#define mkpr make_pair
#define riterator reverse_iterator
using namespace std;

inline int read()
{
    int x=0,f=1; char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) {if(ch=='-') f = -1;}
    for(; isdigit(ch);ch=getchar()) {x = x*10+ch-'0';}
    return x*f;
}

const int N = 1e6;
const llong INF = 1e16;
llong a[N+3],b[N+3],f[N+3],g[N+3];
int stk[N+3];
int n,tp; llong m; int ans;

struct SgTNode
{
    llong h,g,tag;
    SgTNode() {h = INF,g = -INF;}
} sgt[(N<<2)+3];
void pushdown(int u)
{
    if(!sgt[u].tag) return; llong tag = sgt[u].tag;
    sgt[u<<1].h += tag,sgt[u<<1].tag += tag;
    sgt[u<<1|1].h += tag,sgt[u<<1|1].tag += tag;
    sgt[u].tag = 0ll;
}
void updateg(int u,int le,int ri,int pos)
{
    if(le==ri) {sgt[u].g = sgt[u].h = g[pos]; return;}
    int mid = (le+ri)>>1; pushdown(u);
    if(pos<=mid) {updateg(u<<1,le,mid,pos);}
    else {updateg(u<<1|1,mid+1,ri,pos);}
    sgt[u].g = min(sgt[u<<1].g,sgt[u<<1|1].g); sgt[u].h = min(sgt[u<<1].h,sgt[u<<1|1].h);
}
void addh(int u,int le,int ri,int lb,int rb,llong x)
{
    if(le>=lb && ri<=rb) {sgt[u].h += x,sgt[u].tag += x; return;}
    int mid = (le+ri)>>1; pushdown(u);
    if(lb<=mid) {addh(u<<1,le,mid,lb,rb,x);}
    if(rb>mid) {addh(u<<1|1,mid+1,ri,lb,rb,x);}
    sgt[u].h = min(sgt[u<<1].h,sgt[u<<1|1].h);
}
int query(int u,int le,int ri,int rb,llong x)
{
    if(le>rb) {return -1;}
    if(le==ri) {return le;}
    int mid = (le+ri)>>1; pushdown(u);
    llong lv = min(x,sgt[u<<1].h);
    if(rb>mid && lv>=sgt[u<<1|1].g-m)
    {
        int ret = query(u<<1|1,mid+1,ri,rb,lv);
        if(ret!=-1) return ret;
    }
    if(sgt[u<<1].g-m<=x) return query(u<<1,le,mid,rb,x);
    return -1;
}

int main()
{
    scanf("%d%I64d",&n,&m);
    for(int i=1; i<n; i++) scanf("%I64d",&b[i]);
    for(int i=1; i<=n; i++) scanf("%I64d",&a[i]);
    for(int i=1; i<=n; i++) f[i] = f[i-1]+a[i-1]-b[i-1];
    for(int i=1; i<=n; i++) g[i] = g[i-1]+b[i-1]-a[i];
    stk[0] = n+1; f[n+1] = -INF;
    for(int i=n; i>=1; i--)
    {
        updateg(1,1,n,i);
        while(tp>0 && f[stk[tp]]>=f[i])
        {
            if(tp>1)
            {
                addh(1,1,n,stk[tp-1]-1,n,f[stk[tp]]-f[stk[tp-1]]);
            }
            tp--;
        }
        tp++; stk[tp] = i;
        if(tp>1)
        {
            addh(1,1,n,stk[tp-1]-1,n,f[stk[tp-1]]-f[stk[tp]]);
        }
        int left = 0,right = tp;
        while(left<right)
        {
            int mid = (left+right+1)>>1;
            if(f[i]-f[stk[mid]]>m) {left = mid;}
            else {right = mid-1;}
        }
        int r = stk[left]-1;
        int ret = query(1,1,n,r,INF);
        ans = max(ans,ret-i+1);
    }
    printf("%d\n",ans);
    return 0;
}