bzoj 2726: [SDOI2012]任务安排

题意

机器上有N个需要处理的任务，它们构成了一个序列。这些任务被标号为1到N，因此序列的排列为1,2,3…N。这N个任务被分成若干批，每批包含相邻的若干任务。从时刻0开始，这些任务被分批加工，第i个任务单独完成所需的时间是Ti。在每批任务开始前，机器需要启动时间S，而完成这批任务所需的时间是各个任务需要时间的总和。注意，同一批任务将在同一时刻完成。每个任务的费用是它的完成时刻乘以一个费用系数Fi。请确定一个分组方案，使得总费用最小。

题解

先考虑普通DP
这里我们不妨倒着做

f[i]=min(f[i],f[j]+(T[i]-T[j]+s)*F[i]);

其中T，F为后缀和。
要注意的是，这里的F是单调的，但T不是
然后我们考虑，如果T也是单调的，那么就可以用斜率优化来做了
然而并不是。。
于是我们考虑分治
设$y=f[j]+(T[i]-T[j]+s)*F[i]=f[j]+F[i]*T[i]-T[j]*F[i]+s*F[i]$
把关于$i$常数项提出，得到$y'=f[j]-T[j]*F[i]$
然后我们可以看做一条斜率是$-T[j]$，截距是$f[j]$的直线
明显地，答案肯定在一个下凸包上
我们分治的时候，对于右边，维护凸包
然后由于F是单调的，所以左边可以单调地在凸包上面选择
然后就可以了

然后不知道为什么，下面这个代码，你把$st,ed$定义在函数里面，就会RE，定义在全局才可以过。。
搞了我一个多小时都没搞出来QAQ浪费我时间
CODE:

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long LL;
const LL N=300010;
LL n,s;
LL T[N],F[N];
LL f[N];
LL q[N];
bool cmp (LL x,LL y){return T[x]>=T[y];}
LL Q[N];//下凸包 
void solve (LL l,LL r)
{
    if (l==r) return ;
    LL mid=(l+r)>>1;
    solve(mid+1,r);
    sort(q+mid+1,q+1+r,cmp);
     st=1,ed=0;
    for(LL i=r;i>mid;i--)
    {
        while(st<ed&&(f[q[i]]-f[Q[ed]])*(T[Q[ed]]-T[Q[ed-1]])<=(f[Q[ed]]-f[Q[ed-1]])*(T[q[i]]-T[Q[ed]])) ed--;
        Q[++ed]=q[i];
    }
    for (LL u=mid;u>=l;u--)
    {
    //  while (st<ed&&(f[Q[st+1]]-f[Q[st]])<=F[u]*(T[Q[st+1]]-T[Q[st]])) st++;
      while(st<ed&&((T[Q[st+1]]-T[Q[st]])*F[u]>=(f[Q[st+1]]-f[Q[st]]))) st++;
        LL j=Q[st];
        f[u]=min(f[u],f[j]+(T[u]-T[j]+s)*F[u]);
    }
    solve(l,mid);
}
LL read()
{
    LL x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int main()
{
    n=read();s=read();
    for (LL u=1;u<=n;u++)  T[u]=read(),F[u]=read();
    for (LL u=n;u>=1;u--) T[u]=T[u+1]+T[u],F[u]=F[u+1]+F[u];
    for (LL u=1;u<=n;u++) f[u]=(s+T[u])*F[u];
    for (LL u=1;u<=n;u++) q[u]=u;
    solve(1,n);
    printf("%lld\n",f[1]);
    return 0;
}