[BZOJ2040][清橙A1205]拯救Protoss的故乡-线段树模拟最小费用最大流

拯救Protoss的故乡

Description

在星历2012年，星灵英雄Zeratul预测到他所在的Aiur行星在M天后会发生持续性暴雨灾害，尤其是他们的首都。而Zeratul作为星灵族的英雄，当然是要尽自己最大的努力帮助星灵族渡过这场自然灾害。

要渡过这场自然灾害，Zeratul自然要安排很多很多事情，其中一件就是将雨水疏导到大海里去。星灵族在重建家园的时候建造了N条河流，这些河流连接了共N+1个城市，当然其中包括了星灵首都。城市的编号为0…N，星灵首都的编号为0。

当然水流是有方向的，除了星灵首都以外，其余的城市都有且仅有一条河流流入。如果一个城市没有流出去的河流，那么这个城市就是一个沿海城市，可以认为流入这个城市的河流是直接流入大海的。

聪明的星灵族在建造河流的时候是不会让其出现环状结构的，也就是说所有的河流都是能够流入大海的。每一条河流都是有一个最大流量的，一旦超过这个最大流量，就会发生洪水灾害。因此从星灵首都流入大海的总水流量是有一个最大值的。

例如有3条河流：第一条是从城市0流向城市1，最大流量为4；第二条是从城市1流向城市2，最大流量为2；第三条是从城市1流向城市3，最大流量为3。此时从星灵首都(城市0)流入大海的总水流量最大为4，方案有两种：
A. 第一条河流的流量为4，第二条河流的流量为2，第三条河流的流量为2。
B. 第一条河流的流量为4，第二条河流的流量为1，第三条河流的流量为3。

由于离暴雨到来还有时间，因此Zeratul可以扩大某些河流的最大流量来使得从星灵首都流入大海的总水流量增大。比如将上面这个例子的第一条河流的最大流量增大1，那么从星灵首都流入大海的总流水量也可以增大1，变成了5。

当然将河流的最大流量扩大是需要时间的，将一条河流的最大流量扩大1所需要的时间为1天。离暴雨到来还有M天，因此Zeratul也有M天的时间来扩大河流的最大流量。不过由于河流周围的地形限制，每条河流并不是能够无限扩大的，因此每条河流的可以扩大到的最大流量也是有限制的。

而此时Zeratul正忙着安排别的工作，因此他将这个艰巨的任务交给了你。你需要安排一种方案，使得从星灵首都流入大海的总水流量最大。不过现在你只需要告诉Zeratul这个最大值即可。

Input

第一行包含一个正整数N和一个非负整数M。其中N表示河流的个数，M表示离暴雨到来还剩下的天数。接下来N行，每行四个正整数U、V、A、B。其中U和V为该河流所连接的两个城市，且河流的水流方向为从城市U流向城市V，A和B表示该河流当前的最大流量和可以扩大到的最大流量的上限。输入数据保证合法。

Output

仅包含一个整数，表示从星灵首都流入大海的最大总水流量。

Sample Input

5 7
0 1 4 8
0 4 1 6
1 2 2 10
1 3 3 5
4 5 6 6

Sample Output

11

HINT

将第一条河流的最大流量扩大1，变为5。
将第二条河流的最大流量扩大5，变为6。
第三条河流的最大流量不扩大，仍然为2。
第四条河流的最大流量不扩大，仍然为3。
第五条河流的最大流量不扩大，仍然为6。此时从星灵首都流入大海的总水流量6+3+2=11。

1≤A≤B≤100000 N< = 10000 M< = 1000000

---

有史以来咱做题写过的最长代码(下面放的还是整理过的删减版)(事实上长度不及咱写的游戏的十一)
写了一上午，调了一下午，300余行又臭又长……

(╯‵□′)╯︵┻━┻

---

思路:
这很明显是个最小费用流，题面描述都是河流了……
具体建图为，对于每条边拆成费用为0，流量为A的边和费用为1，流量为B-A的边。
不停增广直到费用为m为止。
对这张图增广首先会使未被扩大流量过的原树满流，然后逐步增大流量，得出的答案显然是最优解。

考虑在树上跑费用流的方式:
树链剖分后建出线段树，维护两个值:最小流量和最小费用。

然后，对于每个线段树上的叶子节点，初始化最小流量为A，若不是原树中的叶子结点，那么就把最小费用设为Inf，否则暂时设为0。

显然这样咱只需要找到一个最小费用不为Inf的线段树的叶子结点就可以定位原树上一条路径的最末端了。

那么对于每次增广，在线段树上跑到底，找到这个最小位置在原树上的节点编号。
接着，查询咱找到的这个节点到根节点路径上的最小费用——沿重链跳到根节点，边跳边记录最小值即可。
把查询到的流量和费用相乘加入答案。

接着增广。
沿着增广路自下而上走，对于每条链的流量在线段树上减少这次被增广掉的流量的值。
在走的过程中，把沿路流量被减为0的所有节点压入一个栈中。
然后用一个数组，记录某个节点共被压入栈中几次，扫描栈中每个节点，若这是当前节点第一次被压入栈，并且其在原树上的父亲边的B大于A，那么重设其流量为B-A，否则这条边满流，把其子树内所有节点的最小费用设为Inf，对应线段树上的一段区间修改。

最后一直同上增广到费用为m即可得出答案。

注意事项:
不能把树的根节点加入线段树，因为咱维护的每个节点的最小流量和最小费用事实上都是其父亲边的值，而根节点……没有父亲。
同时，如果某次增广得到的对答案贡献与已有贡献的和大于m，则手动减少这次增广的流量使费用不超过m。
最后……lazytag大法好，然而一出bug就会调得令人崩溃……

是时候结束这个和代码一样长的要命的思路板块了……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || '9'<ch){if(ch=='-')f=-1;ch=getchar();}
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x*f;
}

inline int minn(int a,int b){if(a<b)return a;return b;}
inline int maxx(int a,int b){if(a>b)return a;return b;}

const int N=10009;
const int M=33009;
const int Inf=~0U>>1;

int n,m,ans;
int to[N],nxt[N],beg[N],tot;
int fa[N],wa[N],wb[N];
int dep[N],siz[N],son[N],top[N];
int id[N],eid[N],seq[N],dfn;

int mcost[M],mflow[M],tcost[M],tflow[M],td[M],clear[N];
int stk[N],stop;

inline void add(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

inline void dfs1(int u)
{
    siz[u]=1;
    son[u]=0;

    for(int i=beg[u],v;i;i=nxt[i])
        if((v=to[i])!=fa[u])
        {
            dep[v]=dep[u]+1;
            dfs1(v);
            siz[u]+=siz[v];
            if(!son[u] || siz[son[u]]<siz[v])
                son[u]=v;
        }
}

inline void dfs2(int u)
{
    seq[id[u]=++dfn]=u;

    if(son[u])
    {
        top[son[u]]=top[u];
        dfs2(son[u]);
        for(int i=beg[u],v;i;i=nxt[i])
            if((v=to[i])!=fa[u] && v!=son[u])
            {
                top[v]=v;
                dfs2(v);
            }
    }

    eid[u]=dfn;
}

inline void update(int x)
{
    mflow[x]=minn(mflow[x<<1],mflow[x<<1|1]);
    mcost[x]=minn(mcost[x<<1],mcost[x<<1|1]);
}

void biu(int x,int l,int r)
{
    if(l==r)
    {
        int pos=seq[l];
        mflow[x]=wa[pos];
        if(siz[pos]>1)
            mcost[x]=Inf;
        return;
    }

    int mid=l+r>>1;
    biu(x<<1,l,mid);
    biu(x<<1|1,mid+1,r);
    update(x);
}

inline void push_flow(int x,int val)
{
    mflow[x]-=val;
    tflow[x]+=val;
}

inline void push_cost(int x,int val)
{
    if(mcost[x]<Inf)
        mcost[x]+=val;
    tcost[x]+=val;
}

inline void push_d(int x)
{
    mcost[x]=Inf;
    tcost[x]=0;
    td[x]=1;
}

inline void push(int x)
{
    if(tflow[x])
    {
        push_flow(x<<1,tflow[x]);
        push_flow(x<<1|1,tflow[x]);
        tflow[x]=0;
    }
    if(tcost[x])
    {
        push_cost(x<<1,tcost[x]);
        push_cost(x<<1|1,tcost[x]);
        tcost[x]=0;
    }
    if(td[x])
    {
        push_d(x<<1);
        push_d(x<<1|1);
        td[x]=0;
    }
}

inline int qmflow(int x,int l,int r,int dl,int dr)
{
    if(l==dl && r==dr)
        return mflow[x];

    push(x);
    int mid=l+r>>1,ret=Inf;
    if(dr<=mid)
        ret=qmflow(x<<1,l,mid,dl,dr);
    else if(mid<dl)
        ret=qmflow(x<<1|1,mid+1,r,dl,dr);
    else
        ret=minn(qmflow(x<<1,l,mid,dl,mid),qmflow(x<<1|1,mid+1,r,mid+1,dr));

    update(x);
    return ret;
}

inline int getmcost()
{
    int x=1,l=2,r=dfn,mid;

    while(l<r)
    {
        mid=l+r>>1;
        if(mcost[x<<1]<mcost[x<<1|1])
            x<<=1,r=mid;
        else
            x=x<<1|1,l=mid+1;
    }

    return seq[l];
}

inline int getmflow(int x)
{
    int mf=Inf;

    while(top[x])
    {
        mf=minn(mf,qmflow(1,2,dfn,id[top[x]],id[x]));
        x=fa[top[x]];
    }
    if(id[x]>=2)
        mf=minn(mf,qmflow(1,2,dfn,2,id[x]));

    return mf;
}

inline void decflow(int x,int l,int r,int dl,int dr,int val)
{
    if(dl==l && r==dr && mflow[x]>val)
    {
         push_flow(x,val);
        return;
    }

    if(l==r)
    {
        stk[++stop]=seq[l];
        mflow[x]=0;
        return;
    }

    push(x);
    int mid=l+r>>1;
    if(dr<=mid)
        decflow(x<<1,l,mid,dl,dr,val);
    else if(mid<dl)
        decflow(x<<1|1,mid+1,r,dl,dr,val);
    else
    {
        decflow(x<<1,l,mid,dl,mid,val);
        decflow(x<<1|1,mid+1,r,mid+1,dr,val);
    }

    update(x);
}

inline void incflow(int x,int l,int r,int pos,int val)
{
    if(l==r)
    {
        mflow[x]=val;
        return;
    }

    push(x);
    int mid=l+r>>1;
    if(pos<=mid)
        incflow(x<<1,l,mid,pos,val);
    else
        incflow(x<<1|1,mid+1,r,pos,val);

    update(x);
}

inline void changecost(int x,int l,int r,int dl,int dr)
{
    if(dl==l && r==dr)
    {
        push_cost(x,1);
        return;
    }

    push(x);
    int mid=l+r>>1;
    if(dr<=mid)
        changecost(x<<1,l,mid,dl,dr);
    else if(mid<dl)
        changecost(x<<1|1,mid+1,r,dl,dr);
    else
    {
        changecost(x<<1,l,mid,dl,mid);
        changecost(x<<1|1,mid+1,r,mid+1,dr);
    }

    update(x);
}

inline void changed(int x,int l,int r,int dl,int dr)
{
    if(dl==l && r==dr)
    {
        push_d(x);
        return;
    }

    push(x);
    int mid=l+r>>1;
    if(dr<=mid)
        changed(x<<1,l,mid,dl,dr);
    else if(mid<dl)
        changed(x<<1|1,mid+1,r,dl,dr);
    else
    {
        changed(x<<1,l,mid,dl,mid);
        changed(x<<1|1,mid+1,r,mid+1,dr);
    }

    update(x);
}

inline void update_chain(int x,int val)
{
    stop=0;
    while(top[x])
    {
        decflow(1,2,dfn,id[top[x]],id[x],val);
        x=fa[top[x]];
    }
    if(id[x]>=2)
        decflow(1,2,dfn,2,id[x],val);

    for(int i=1,u;i<=stop;i++)
    {
        u=stk[i];
        if(!clear[u] && wb[u]>wa[u])
        {
            incflow(1,2,dfn,id[u],wb[u]-wa[u]);
            changecost(1,2,dfn,id[u],eid[u]);
        }
        else
            changed(1,2,dfn,id[u],eid[u]);

        clear[u]++;
    }
}

int main()
{
    n=read();
    m=read();
    for(int i=1,u,v,a,b;i<=n;i++)
    {
        u=read();
        v=read();
        add(u,v);
        fa[v]=u;
        wa[v]=read();
        wb[v]=read();
    }

    dfs1(0);
    top[0]=0;
    dfs2(0);

    biu(1,2,dfn);

    int x,y;
    while(mcost[1]<Inf)
    {
        x=getmcost();
        y=getmflow(x);
        if(mcost[1]*y>m)
            y=m/mcost[1];

        if(!y)
            break;

        m-=mcost[1]*y;
        ans+=y;
        update_chain(x,y);
    }

    printf("%d\n",ans);
    return 0;
}