网络流24题之餐巾计划问题

题意

简单来说：
每天对餐巾数量有一定的要求，用完的变成脏的。脏的可以拿去两个店洗，分别花费$a$天、$b$钱；$c$天、$d$钱。可以留到之后洗，或者买新的花费$p$
求最小花费

题解

显然费用流，如何转换呢？
首先最大流必须是合法情况，那么一定餐巾数量够。
那么如何体现回收利用呢？就是流量共用。
每天设置两个点晚上和早上。
早上需要收到$x$个餐巾,连向汇点，最大流就是符合情况的。
晚上得到$x$个脏餐巾。
对于滞后洗的操作，第$i$个晚上连向$i+1$个晚上即可。
流量共用的操作体现在洗餐巾，你花费$b$或者$d$给出一定流量到$a$或$c$天之后那天。
除此之外买餐巾的操作等价于源点连向早上。即可。

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 2e4+200;

int A[maxn];

struct Edge{
    int from,to;
    ll cap,flow,cost;
};

struct MCMF{
    int n,tmp,s,t;
    vector<Edge>edges;
    vector<int>G[maxn];
    int inq[maxn];
    ll d[maxn];//spfa
    int p[maxn];//上一条弧便于回溯
    ll a[maxn];//最小改进量

    void init(int n,int s,int t){
        this->n=n,this->s=s,this->t=t;
        edges.clear();
        for(int i=1;i<=n;i++)G[i].clear();
    }

    void AddEdge(int from,int to,ll cap,ll cost){
        edges.push_back((Edge){from,to,cap,0,cost});
        edges.push_back((Edge){to,from,0,0,-cost});
        tmp=edges.size();
        G[from].push_back(tmp-2);
        G[to].push_back(tmp-1);
    }

    bool spfa(int s,int t,ll& flow,ll& cost){
        for(int i=0;i<=n;i++)d[i]=inf;
        memset(inq,0,sizeof(inq));
        d[s]=0,inq[s]=1,p[s]=0,a[s]=inf;
        queue<int>Q;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            inq[u]=0;
            for(int i=0;i<G[u].size();i++){
                Edge& e=edges[G[u][i]];
                if(e.cap>e.flow&&d[e.to]>d[u]+e.cost){
                    d[e.to]=d[u]+e.cost;//松弛
                    p[e.to]=G[u][i];//记录上一条弧
                    a[e.to]=min(a[u],e.cap-e.flow);//最小可改进量
                    if(!inq[e.to]){Q.push(e.to);inq[e.to]=1;}//入队
                }
            }
        }
        if(d[t]==inf)return false;//说明不连通了。
        flow+=a[t];//如果固定流量的话，可以在flow+a>=k的时候只增广到k，然后终止程序
        cost+=d[t]*a[t];
        int u=t;
        while(u!=s){
            edges[p[u]].flow+=a[t];
            edges[p[u]^1].flow-=a[t];
            u=edges[p[u]].from;
        }
        return true;
    }

    ll Mincost(){//绝对不能有负权圈，否则连续最短路的数学证明失效
        ll flow=0,cost=0;
        while(spfa(s,t,flow,cost));
        return cost;
    }
}mf;

int main(){
    int n;cin>>n;
    mf.init(2*n+2,2*n+1,2*n+2);
    FOR(i,1,n)scanf("%d",&A[i]);
    int p,a,b,c,d;
    scanf("%d%d%d%d%d",&p,&a,&b,&c,&d);
    FOR(i,1,n){
        mf.AddEdge(2*n+1,i,A[i],0);
        mf.AddEdge(n+i,2*n+2,A[i],0);
        if(i<n)mf.AddEdge(i,i+1,inf,0);
        mf.AddEdge(2*n+1,n+i,inf,p);
        if(i+a<=n)mf.AddEdge(i,n+i+a,inf,b);
        if(i+c<=n)mf.AddEdge(i,n+i+c,inf,d);
    }
    cout<<mf.Mincost()<<endl;
}