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+7;
const int MAXM = 1e5+10;
const int MAXN = 2e2+10;

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 = 0;
    memset(head, -1, 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 = 0;   edge[tot].next = head[u];   head[u] = tot++;
    edge[tot].to = u;   edge[tot].cap = 0;  edge[tot].cost = -cost;
    edge[tot].flow = 0; edge[tot].next = head[v];   head[v] = tot++;
}

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

    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while(!q.empty())
    {
        int u  = q.front();
        q.pop();
        vis[u] = false;
        for(int i = head[u]; i!=-1; 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]==-1) return false;
    if(dis[t]>=0) return false; //当单位费用和大于等于0时，即停止增广
    return true;
}

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

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

        for(int i = 1; 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
", kase, -min_cost);
    }
}