【UVA11613 训练指南】生产销售规划 【费用流】

题意：

  Acme公司生产一种X元素，给出该元素在未来M个月中每个月的单位售价、最大产量、最大销售量，以及最大储存时间（过期报废不过可以储存任意多的量）。你的任务是计算出公司能够赚到的最大利润。

分析：

 把第i个月拆成i1和i2两个点，连一条s到i1的弧，容量为i月最大产量，费用为单位成本。连一条i2到t的弧，容量为最大销量，费用为单位售价的相反数。然后i1向i2连一条容量为INF费用为0的弧，代表当月销售。i1向其他j2连弧，容量为INF，费用为储藏代价。

 

另外，这个题属于流量不固定的最小费用流。也就是说，并不是一定要跑到最大流。用spfa寻找增广路的时候，当d[t]>0的时候就要停止增广。

    #include <cstdio>
    #include <algorithm>
    #include <cstring>
    #include <iostream>
    #include <queue>
    #include <vector>

    using namespace std;
    typedef long long LL;
    const int maxn=300+10;
    const int maxm=40000+10;
    const int INF=2147000000;

    struct MCMF{
        int head[maxn],to[maxm],Next[maxm],from[maxm],cost[maxm],flow[maxm],cap[maxm];
        int n,m,s,t,sz;
        int inq[maxn];
        int d[maxn];
        int p[maxn];
        int a[maxn];

        void init(int n){
            this->n=n;
            sz=-1;
            memset(head,-1,sizeof(head));
        }
        void AddEdge(int a,int b,int ca,int co){
            ++sz;
            to[sz]=b,from[sz]=a,Next[sz]=head[a],head[a]=sz;
            flow[sz]=0,cap[sz]=ca,cost[sz]=co;
            ++sz;
            to[sz]=a,from[sz]=b,Next[sz]=head[b],head[b]=sz;
            flow[sz]=ca,cap[sz]=ca,cost[sz]=-co;
        }
        bool BellmanFord(int s,int t,int &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]=-1;a[s]=INF;
            queue<int>Q;
            Q.push(s);
            while(!Q.empty()){
                int u=Q.front();Q.pop();
                inq[u]=0;
                for(int i=head[u];i!=-1;i=Next[i]){
                    int v=to[i];
                    if(cap[i]>flow[i]&&d[v]>d[u]+cost[i]){
                        d[v]=d[u]+cost[i];
                        p[v]=i;
                        a[v]=min(a[u],cap[i]-flow[i]);
                        if(!inq[v]){
                            Q.push(v);
                            inq[v]=1;
                        }
                    }
                }
            }
            if(d[t]==INF||d[t]>0)return false;
            Flow+=a[t];
            Cost+=(LL)d[t]*(LL)a[t];
            int u=t;

            while(u!=s){
                flow[p[u]]+=a[t];
                flow[p[u]^1]-=a[t];
                u=from[p[u]];
            }
            return true;
        }

        LL Mincost(int s,int t){
            int Flow=0;LL Cost=0;
            while(BellmanFord(s,t,Flow,Cost));
            return Cost;
        }
    }mcmf;
    const int maxM=150;
    int T,M,I,kase;
    int m[maxM],n[maxM],p[maxM],s[maxM],E[maxM];

    int main(){
        scanf("%d",&T);
       // freopen("out.txt","w",stdout);
        kase=0;
        for(int t=1;t<=T;t++){
            ++kase;
            scanf("%d%d",&M,&I);
            mcmf.init(2*M+2);
            mcmf.s=0;mcmf.t=2*M+1;
            for(int i=1;i<=M;i++){
                scanf("%d%d%d%d%d",&m[i],&n[i],&p[i],&s[i],&E[i]);
                mcmf.AddEdge(0,i,n[i],m[i]);
                mcmf.AddEdge(i+M,2*M+1,s[i],-p[i]);
                for(int j=0;j+i<=M&&j<=E[i];j++){
                    mcmf.AddEdge(i,i+j+M,INF,j*I);
                }
            }
            LL ans=mcmf.Mincost(0,2*M+1);
            printf("Case %d: %lld\n",kase,-ans);
        }
    return 0;
    }