【CF671E】Organizing a Race
题意：n个城市排成一排，每个城市内都有一个加油站，赛车每次经过第i个城市时都会获得$g_i$升油。相邻两个城市之间由道路连接，第i个城市和第i+1个城市之间的道路长度为$w_i$，走一单位的路要花1升油。你想在某两个城市之间举办一场锦标赛。如果你选择的两个城市分别是a和b（a<b），则具体过程如下：
1. 赛车从a开始往右走一直走到b，走过城市时会在加油站加油，走过道路时会消耗油，且一开始时就已经在a处加完油了。你需要满足赛车能有足够的油能从a走到b，即不能出现在走到道路的中途时出现没有油的情况。
2. 赛车从b开始往左走一直走到a，过程同上。
你可以认为赛车的油箱是无限大的。
一场锦标赛所经过的城市越多，则这场锦标赛就越成功，即你希望最大化b-a+1。
现在你有k个机会，每个机会是：你可以使任意一个城市的$g_i$增加1。现在你需要合理利用这k次机会，从而最大化b-a+1。
$n\le 100000,k,w_i,g_i\le 10^9$
题解：先考虑从a走到b的这段。我们先维护个前缀和：pre[i]=pre[i-1]+g[i]-w[i]。则在不加油的情况下，一辆车i最远能走到的j 就是 i右面第一个满足pre[j-1]<pre[i-1]的j，我们可以用单调栈来搞一搞，并设i右面第一个走不到的j为next[i]。从i走到next[i]需要的花费就是pre[i-1]-pre[next[i]-1]。根据贪心的想法，如果我们最终选择的城市是a和b，那么在从a走到b的途中，我们应尽可能给右边的城市增加权值。即我们每次可以直接走到next，然后给next的权值增加pre[i-1]-pre[next-1]即可。
下面是一步非常神的操作，我们将所有的i和next[i]连边。然后DFS一遍这棵树，假如当前走到了i。我们令cost[j]表示从i沿着next一直走到j需要的花费，那么如何维护cost[j]呢？我们在进入i这棵子树的时候，将next[i]..n的所有cost都增加，在退出i的子树时再将cost都减回去，则用线段树维护即可。现在我们已经知道了往右走的花费，那如何计算往左走的花费呢？我们再维护个前缀和：suf[i]=suf[i-1]+g[i]-w[i-1]（修改时用线段树维护）。根据贪心，如果我们在返回来时需要花费k次机会，则一定是在一开始就直接用完所有的机会。那么从j返回i的花费就是$max\{suf[k],i\le k< j\}-suf[j]$，总花费就是$max\{suf[k],i\le k< j\}-suf[j]+cost[j]$。
现在我们要做的就是找出右面最后一个满足$max\{suf[k],i\le k< j\}-suf[j]+cost[j]\le K$的j。但是左边这坨东西如何搞呢？
我们在线段树上维护这3个东西：
max_p[x]：令p[i]表示cost[i]-suf[i]。max_p[x]维护区间内p的最大值。
max_suf[x]：区间x内suf的最大值。
max_s[x]：如果当前区间是[l,r]，则$max_s[x]=min\{max\{suf[j],l\le j<i\}+p[i],mid<i\le r\}$。
具体维护过程过于复杂，请见代码。
#include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #define lson x<<1 #define rson x<<1|1 using namespace std; const int maxn=100010; typedef long long ll; int n,K,top,cnt,ans; int st[maxn],to[maxn],nxt[maxn],head[maxn],nt[maxn]; ll g[maxn],w[maxn],pre[maxn],suf[maxn]; ll mp[maxn<<2],sp[maxn<<2]; //mp:max_p(p=cost-suf),sp:min_{max_suf{l..j-1}+p} ll ms[maxn<<2],tag[maxn<<2]; //ms:max_suf,tag:区间+标记,cost+=tag,suf+=tag,所以p不变。 inline void add(int,int); inline void upd(int,ll); inline void pushdown(int); ll calc(int,int,int,ll); inline void pushup(int,int,int); void build(int,int,int); void updata(int,int,int,int,int,ll); int solve(int,int,int,ll); int query(int,int,int,ll); void dfs(int); inline int rd(); int main() { memset(head,-1,sizeof(head)); n=rd(),K=rd(); int i; for(i=1;i<n;i++) w[i]=rd(); w[n]=1e17; for(i=1;i<=n;i++) g[i]=rd(),pre[i]=pre[i-1]+g[i]-w[i],suf[i]=suf[i-1]+g[i]-w[i-1]; //预处里pre,suf for(st[top=0]=n,i=n-1;i>=0;i--) //求next { while(top&&pre[st[top]]>=pre[i]) top--; nt[i+1]=st[top]+1,add(st[top]+1,i+1),st[++top]=i; } build(1,n,1); top=0,dfs(n+1); printf("%d",ans); return 0; } //------------------------------按照顺序从往下看------------------------------ inline void add(int a,int b) //略 { to[cnt]=b,nxt[cnt]=head[a],head[a]=cnt++; } void dfs(int x) //首先按照之前说的,我们先建出next树,然后遍历next树。 { st[++top]=x; if(x!=n+1) { updata(1,n,1,1,x-1,-1e17); //排除掉i左面的点的干扰 updata(1,n,1,nt[x]-1,n,pre[x-1]-pre[nt[x]-1]); //维护cost和suf int l=1,r=top,mid; while(l<r) { mid=(l+r)>>1; if(pre[x-1]-pre[st[mid]-1]<=K) r=mid; else l=mid+1; } updata(1,n,1,st[r-1],n,1e17); //二分,排除掉i右面过远的点的干扰（如果往右走过不去,则不考虑往左走的情况）。 ans=max(ans,query(1,n,1,-1e17)-x+1); //更新答案 updata(1,n,1,st[r-1],n,-1e17); //复原 updata(1,n,1,1,x-1,1e17); } for(int i=head[x];i!=-1;i=nxt[i]) dfs(to[i]); if(x!=n+1) { updata(1,n,1,nt[x]-1,n,-(pre[x-1]-pre[nt[x]-1])); //复原 } top--; } void build(int l,int r,int x) //预处理结束时,构建线段树。 { if(l==r) { ms[x]=suf[l]; mp[x]=-suf[l]; return ; } int mid=(l+r)>>1; build(l,mid,lson),build(mid+1,r,rson); pushup(l,r,x),mp[x]=min(mp[lson],mp[rson]); } void updata(int l,int r,int x,int a,int b,ll t) //区间加操作也跟普通线段树没什么区别。 { if(a>b) return ; if(a<=l&&r<=b) { upd(x,t); return ; } pushdown(x); int mid=(l+r)>>1; if(a<=mid) updata(l,mid,lson,a,b,t); if(b>mid) updata(mid+1,r,rson,a,b,t); pushup(l,r,x); } inline void pushup(int l,int r,int x) //pushup和pushdown两个操作慢慢讲。 { ms[x]=max(ms[lson],ms[rson]); //ms(max_suf)：直接取最值即可,max_p:由于永远不会改变,所以不用维护。 int mid=(l+r)>>1; sp[x]=calc(mid+1,r,rson,ms[lson]); //sp数组维护起来比较复杂,我们引入calc函数,下面讲。 } inline void pushdown(int x) //pushdown比较简单 { if(tag[x]) { upd(lson,tag[x]),upd(rson,tag[x]); tag[x]=0; } } inline void upd(int x,ll y) //比较简单 { tag[x]+=y,ms[x]+=y,sp[x]+=y; } ll calc(int l,int r,int x,ll t) //***关键函数*** calc(...,t)=min{max(max_suf{l..i-1},t)+p[i],l<=i<=r} 即我们已知了左边 //的max_suf,现在要求这个区间中答案的最小值。如何计算呢？ { if(l==r) return t+mp[x]; pushdown(x); int mid=(l+r)>>1; if(ms[lson]>=t) return min(calc(l,mid,lson,t),sp[x]); //如果max_suf{l,mid}>=t,则t对[mid+1,r]的答案都没有影响, //所以直接调用之前的答案sp即可（注意sp维护的是什么！）。 //然后我们只递归左边就行了。 return min(t+mp[lson],calc(mid+1,r,rson,t)); //否则,左边的max_suf{l..i-1}都应该取t,则用t+max_p{l,mid}更新答案 //然后只递归右面就行了。 } //整个calc的复杂度是O(log)的。 //--------------------分割线-------------------- 上面主要是修改,下面主要是查询。 int query(int l,int r,int x,ll t) //***关键函数*** 查询函数（即树上二分操作）,我们想找到最右面那个答案<=m的点 //t的定义和calc()里的一样,我们已知了左边的max_suf{l..i-1}=t。实现过程也和calc类似。 { if(l==r) return t+mp[x]<=K?l:0; pushdown(x); int mid=(l+r)>>1; if(ms[lson]>=t) //讨论：如果max_suf{l,mid}>=t,则t对[mid+1,r]没有影响,我们可以直接调用sp数组。 { if(sp[x]<=K) return query(mid+1,r,rson,ms[lson]); //如果[mid+1,r]中的最小值<=K,显然我们应该进入右面查询。 else return query(l,mid,lson,t); //否则呢,显然右面的都不合法，我们进入左边查询。 } else //如果max_suf{l,mid}<t，则左面的max_suf都应该取t,我们引入solve函数，表示的就是 //当一个区间的max_suf{..i-1}都取t时的查询结果。而对于右面的，我们还需要递归查询。 { return max(solve(l,mid,lson,t),query(mid+1,r,rson,t)); } } int solve(int l,int r,int x,ll t) //说白了就是已知区间的max_suf{..i-1}=t时的query函数，但是相对简单一些。 { if(l==r) return t+mp[x]<=K?l:0; pushdown(x); int mid=(l+r)>>1; if(t+mp[rson]<=K) return solve(mid+1,r,rson,t); //如果右边的答案<=K,则去右面 return solve(l,mid,lson,t); //否则去左边 } //一次solve的复杂度是O(log)的 inline int rd() { int ret=0,f=1; char gc=getchar(); while(gc<‘0‘||gc>‘9‘) {if(gc==‘-‘) f=-f; gc=getchar();} while(gc>=‘0‘&&gc<=‘9‘) ret=ret*10+(gc^‘0‘),gc=getchar(); return ret*f; } //所以呢，我们的总复杂度就是O(n\log^2n)的。