[BZOJ2138]stone/[JZOJ5152]本无不散之宴

题目大意

给定一个长度为$n$的序列$\{a_n\}$，以及$q$个操作。
操作顺次执行，第$i$次操作要求把下标在区间$[l_i,r_i]$内的数都各自减去一个非负整数（可以不同），使得减了之后这些数依然非负，并且减去的数之和为$K_i$。如果这个区间的和都要比$K_i$小，那就要把这个区间的数全部变成$0$（即每个数都减去自己）。保证给定的任意两个区间都不存在包含关系。
一个操作的选择不同，显然可能会导致后面的操作实际减去的数之和不一样。现在要你计算出在最优决策下，字典序最大的实际减数和序列。

$1\le q\le n\le4\times10^4,1\le l_i\le r_i\le n,0\le a_i\le500$

---

题目分析

先考虑如果我们确定了每次减去的数的和，我们怎么判定这个方案是否合法。
显然我们可以网络流跑一下看看是否满流，而且如果我们把点拆开来就是一个二分图最大匹配。
我们相当于要判断是否存在完全覆盖$X$集合的匹配方案。
考虑使用$Hall$定理：枚举$X$的任意子集，看看它在$Y$集合的相邻节点数量是否大于等于子集大小。可是这个复杂度不兹瓷啊。
怎么办？$Hall$定理有一个很套路的推广：如果每个点的连边都是向一个区间连的，而且任意两个区间不存在包含关系，那么我们只需要对任意区间检查$Hall$定理就好了。
证明挺简单的。此处略，你可以看Werkeytom_FTD的blog。
怎么判断一个区间是否满足$Hall$定理呢？首先我们把$a$序列中没有被任何区间覆盖的数丢掉，然后把所有操作按照右端点排序。令$A$为$a$数组的前缀和数组，令$b_i$表示第$i$次操作实际删除个数，$B$是$b_i$的前缀和数组。那么我们相当于要满足

$$\forall i\le j,B_j-A_{r_j}\ge B_{i-1}-A_{l_i-1}$$
再令 $C_i=B_i-A_{r_i}$， $D_i=B_{i-1}-A_{l_i-1}$，那么相当于要满足
$$\forall i\le j,C_j\le D_i$$
考虑按照时间顺序计算操作 $x$，如果$B_x=y$，那么 $C_i$至 $C_q$、 $D_{i+1}$至 $D_q$就要加上 $y$。
再看看为了保证合法$x$的范围应该是多少，观察发现，只有 $i\in[1,x],j\in[x,q]$时的 $i$和$j$会对 $x$有所限制，随便推推就可以得到$x\le D_i-C_j$，我们直接区间查询最小的 $D$最大的$C$就可以得到 $x$可以达到的最大值，然后再区间加一下就好了。
使用简单的线段树就可以兹瓷所有这些操作。时间复杂度$O(q\log q)$。

---

代码实现

#include <algorithm>
#include <iostream>
#include <climits>
#include <cstring>
#include <cctype>
#include <cstdio>

using namespace std;

typedef long long LL;

LL sqr(int x){return 1ll*x*x;}

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

int buf[30];

void write(int x)
{
    if (x<0) putchar('-'),x=-x;
    for (;x;x/=10) buf[++buf[0]]=x%10;
    if (!buf[0]) buf[++buf[0]]=0;
    for (;buf[0];putchar('0'+buf[buf[0]--]));
}

const int INF=INT_MAX/2;
const int N=40050;
const int Q=40050;
const int S=Q<<2;

struct query
{
    int l,r,id,K;

    bool operator<(query const x)const{return r<x.r;}
}qy[Q];

int a[N],A[N],tag[N],idx[N],pos[N];
int C[Q],D[Q];
int n,q;

struct segment_tree
{
    int mx[S],mi[S],tag[S][2];

    void init(){mx[0]=-INF,mi[0]=INF;}

    void ADD(int x,int y,bool tp){tp?mi[x]+=y:mx[x]+=y,tag[x][tp]+=y;}

    void clear(int x,int l,int r)
    {
        for (int i=0;i<2;++i)
            if (tag[x][i])
            {
                if (l!=r) ADD(x<<1,tag[x][i],i),ADD(x<<1|1,tag[x][i],i);
                tag[x][i]=0;
            }
    }

    void update(int x){mx[x]=max(mx[x<<1],mx[x<<1|1]),mi[x]=min(mi[x<<1],mi[x<<1|1]);}

    void modify(int x,int st,int en,int l,int r,bool tp,int delta)
    {
        if (st>en) return;
        clear(x,l,r);
        if (st==l&&en==r)
        {
            ADD(x,delta,tp),clear(x,l,r);
            return;
        }
        int mid=l+r>>1;
        if (en<=mid) modify(x<<1,st,en,l,mid,tp,delta);
        else if (mid+1<=st) modify(x<<1|1,st,en,mid+1,r,tp,delta);
        else modify(x<<1,st,mid,l,mid,tp,delta),modify(x<<1|1,mid+1,en,mid+1,r,tp,delta);
        update(x);
    }

    int query(int x,int st,int en,int l,int r,bool tp)
    {
        clear(x,l,r);
        if (st==l&&en==r) return tp?mi[x]:mx[x];
        int mid=l+r>>1;
        if (en<=mid) return query(x<<1,st,en,l,mid,tp);
        else if (mid+1<=st) return query(x<<1|1,st,en,mid+1,r,tp);
        else
        {
            int ret=query(x<<1,st,mid,l,mid,tp),ret_=query(x<<1|1,mid+1,en,mid+1,r,tp);
            return tp?min(ret,ret_):max(ret,ret_);
        }
    }

    void build(int x,int l,int r)
    {
        if (l==r)
        {
            mi[x]=D[l],mx[x]=C[l];
            return;
        }
        int mid=l+r>>1;
        build(x<<1,l,mid),build(x<<1|1,mid+1,r),update(x);
    }
}t;

void loada()
{
    int x=read(),y=read(),z=read(),P=read();
    for (int i=1;i<=n;++i) a[i]=((sqr(i-x)+sqr(i-y))%P+sqr(i-z))%P;
}

void loadk()
{
    q=read(),qy[1].K=read(),qy[2].K=read();
    for (int x=read(),y=read(),z=read(),P=read(),i=3;i<=q;++i) qy[i].K=(1ll*qy[i-1].K*x+1ll*qy[i-2].K*y+z)%P;
}

void process()
{
    for (int i=1;i<=q;++i) ++tag[qy[i].l],--tag[qy[i].r+1];
    int n_=0;
    for (int i=1;i<=n;++i)
    {
        tag[i]+=tag[i-1];
        if (tag[i]) a[idx[i]=++n_]=a[i];
    }
    n=n_;
    for (int i=1;i<=n;++i) A[i]=A[i-1]+a[i];
    for (int i=1;i<=q;++i) qy[i].l=idx[qy[i].l],qy[i].r=idx[qy[i].r];
    sort(qy+1,qy+q+1);
    for (int i=1;i<=q;++i) C[i]=-A[qy[i].r],D[i]=-A[qy[i].l-1],pos[qy[i].id]=i;
}

void solve()
{
    if (!q) return;
    t.init(),t.build(1,1,q);
    for (int i=1;i<=q;++i)
    {
        int j=pos[i],d=t.query(1,1,j,1,q,1),c=t.query(1,j,q,1,q,0),x=min(d-c,qy[j].K);
        write(x),putchar('\n'),t.modify(1,j,q,1,q,0,x),t.modify(1,j+1,q,1,q,1,x);
    }
}

int main()
{
    freopen("forget.in","r",stdin),freopen("forget.out","w",stdout);
    n=read(),loada(),loadk();
    for (int i=1;i<=q;++i) qy[i].l=read(),qy[i].r=read(),qy[i].id=i;
    process(),solve();
    fclose(stdin),fclose(stdout);
    return 0;
}