【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=+;
     const int maxm=+;
     const int INF=;

     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=-;
             memset(head,-,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]=,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=;i<=n;i++)d[i]=INF;
             memset(inq,,sizeof(inq));
             d[s]=;inq[s]=;p[s]=-;a[s]=INF;
             queue<int>Q;
             Q.push(s);
             while(!Q.empty()){
                 int u=Q.front();Q.pop();
                 inq[u]=;
                 for(int i=head[u];i!=-;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]=;
                         }
                     }
                 }
             }
             if(d[t]==INF||d[t]>)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]^]-=a[t];
                 u=from[p[u]];
             }
             return true;
         }

         LL Mincost(int s,int t){
             int Flow=;LL Cost=;
             while(BellmanFord(s,t,Flow,Cost));
             return Cost;
         }
     }mcmf;
     const int maxM=;
     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=;
         for(int t=;t<=T;t++){
             ++kase;
             scanf("%d%d",&M,&I);
             mcmf.init(*M+);
             mcmf.s=;mcmf.t=*M+;
             for(int i=;i<=M;i++){
                 scanf("%d%d%d%d%d",&m[i],&n[i],&p[i],&s[i],&E[i]);
                 mcmf.AddEdge(,i,n[i],m[i]);
                 mcmf.AddEdge(i+M,*M+,s[i],-p[i]);
                 for(int j=;j+i<=M&&j<=E[i];j++){
                     mcmf.AddEdge(i,i+j+M,INF,j*I);
                 }
             }
             LL ans=mcmf.Mincost(,*M+);
             printf("Case %d: %lld\n",kase,-ans);
         }
     return ;
     }