UVA11613 Acme Corporation —— 最小费用流（流量不固定的最小费用流）

题目链接：https://vjudge.net/problem/UVA-11613

题意：

商品X在第i个月内：生产一件需要花费mi元，最多可生产ni件，销售一件（在这个月内销售，而不管它是在那个月生产的）的价格是pi元， 最多能销售si件， 在这个月生产的产品的保质期为Ei。对于所有商品X，每“保质”一个月，就要花费I元。问：在M个月内，最多能获利多少？

题解：

最小费用流问题，建图方式如下（详情在《训练指南》P367）：

1.把每个月拆成两个点，一个点为生产，另一个点为销售。

2.如果月x生产的商品能够放到月y内销售，就在月x的生产点和月y的销售点之间连一条边，容量为月x的最大生产量， 花费为0。

3.建立超级源点，并且连向每个月的生产点，边的容量为该月的最大生产量， 边的花费为该月生产一件商品所需的花费。

4.建立超级汇点，并且连向每个月的销售点，边的容量为该月的最大销售量， 边的花费为该月单间商品的售价的负值。

5.跑最小费用流算法：当增广得到的单位费用和小于0时，表明收入大于敷出（因为收入在图中设置为负值），继续增广；当单位费用和大于等于0时，表明收入小于敷出，再继续增广，利润反而降低，所以在此时就应该停止增广。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXM = 1e5+;
 const int MAXN = 2e2+;

 struct Edge
 {
     int to, next, cap, flow, cost;
 }edge[MAXM];
 int tot, head[MAXN];
 int pre[MAXN], dis[MAXN];
 bool vis[MAXN];
 int N;

 void init(int n)
 {
     N = n;
     tot = ;
     memset(head, -, sizeof(head));
 }

 void add(int u, int v, int cap, int cost)
 {
     edge[tot].to = v;  edge[tot].cap = cap;  edge[tot].cost = cost;
     edge[tot].flow = ;   edge[tot].next = head[u];   head[u] = tot++;
     edge[tot].to = u;   edge[tot].cap = ;  edge[tot].cost = -cost;
     edge[tot].flow = ; edge[tot].next = head[v];   head[v] = tot++;
 }

 bool spfa(int s, int t)
 {
     queue<int>q;
     for(int i = ; i<N; i++)
     {
         dis[i] = INF;
         vis[i] = false;
         pre[i] = -;
     }

     dis[s] = ;
     vis[s] = true;
     q.push(s);
     while(!q.empty())
     {
         int u  = q.front();
         q.pop();
         vis[u] = false;
         for(int i = head[u]; i!=-; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap>edge[i].flow && dis[v]>dis[u]+edge[i].cost)
             {
                 dis[v] = dis[u]+edge[i].cost;
                 pre[v] = i;
                 if(!vis[v])
                 {
                     vis[v] = true;
                     q.push(v);
                 }
             }
         }
     }
     if(pre[t]==-) return false;
     if(dis[t]>=) return false; //当单位费用和大于等于0时，即停止增广
     return true;
 }

 int minCostMaxFlow(int s, int t, LL &cost)
 {
     int flow = ;
     cost = ;
     while(spfa(s,t))
     {
         int Min = INF;
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             if(Min>edge[i].cap-edge[i].flow)
                 Min = edge[i].cap-edge[i].flow;
         }
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             edge[i].flow += Min;
             edge[i^].flow -= Min;
             cost += 1LL*edge[i].cost*Min;
         }
         flow += Min;
     }
     return flow;
 }

 int main()
 {
     int T, M, I;
     scanf("%d", &T);
     for(int kase = ; kase<=T; kase++)
     {
         scanf("%d%d", &M, &I);
         int start = , end = *M+;
         init(*M+);

         for(int i = ; i<=M; i++)
         {
             int m, n, p, s, E;
             scanf("%d%d%d%d%d", &m,&n,&p,&s,&E);
             add(start, i, n, m);
             for(int j = i; j<=min(M, i+E); j++)
                 add(i, M+j, n, (j-i)*I);
             add(M+i, end, s, -p);
         }

         LL min_cost;
         minCostMaxFlow(start, end, min_cost);
         printf("Case %d: %lld\n", kase, -min_cost);
     }
 }