「网络流 24 题」餐巾计划

题目描述

一个餐厅在相继的 n n n 天里，每天需用的餐巾数不尽相同。假设第 i i i 天需要 ri r_i r​i​​ 块餐巾。餐厅可以购买新的餐巾，每块餐巾的费用为 P P P 分；或者把旧餐巾送到快洗部，洗一块需 M M M 天，其费用为 F F F 分；或者送到慢洗部，洗一块需 N N N 天，其费用为 S S S 分（S<F S < F S<F）。

每天结束时，餐厅必须决定将多少块脏的餐巾送到快洗部，多少块餐巾送到慢洗部，以及多少块保存起来延期送洗。但是每天洗好的餐巾和购买的新餐巾数之和，要满足当天的需求量。

试设计一个算法为餐厅合理地安排好 n n n 天中餐巾使用计划,使总的花费最小。
输入格式

第 1 1 1 行有 6 6 6 个正整数 n n n、P P P、M M M、F F F、N N N、S S S。

n n n 是要安排餐巾使用计划的天数，P P P 是每块新餐巾的费用，M M M 是快洗部洗一块餐巾需用天数，F F F 是快洗部洗一块餐巾需要的费用，N N N 是慢洗部洗一块餐巾需用天数，S S S 是慢洗部洗一块餐巾需要的费用。

接下来的 n n n 行是餐厅在相继的 n n n 天里，每天需用的餐巾数。
输出格式

输出餐厅在相继的 n n n 天里使用餐巾的最小总花费。
样例
样例输入

3 10 2 3 3 2
5
6
7

样例输出

145

数据范围与提示

1≤n≤1000 

来自大佬的神分析：http://www.cnblogs.com/candy99/p/6127287.html

#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
const int maxn = 2000;
const int inf = 1e9;
typedef long long ll;
using namespace std;
struct Edge
{
    int fr,to,cap,flow,cost;
};
struct MCMF
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[maxn+5];
    int inq[maxn+5],d[maxn+5],p[maxn+5],a[maxn+5];

    void Init(int n)
    {
        this->n = n;
        for(int i=0; i<=n; i++) G[i].clear();
        edges.clear();
    }

    void Addedge(int fr,int to,int cap,int cost)
    {
        edges.push_back((Edge)
        {
            fr,to,cap,0,cost
        });
        edges.push_back((Edge)
        {
            to,fr,0,0,-cost
        });
        m = edges.size();
        G[fr].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool Bell(int s,int t,int &flow,int &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,l=G[u].size(); i<l; 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];
        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]].fr;
        }
        return true;
    }

    int Mincost(int s,int t)
    {
        int flow = 0, cost = 0;
        while(Bell(s,t,flow,cost));
        return cost;
    }
} my;
int n,P,M,F,N,S,w[maxn+5],e[maxn+5];
int main()
{
    int s,t;
    while(~scanf("%d %d %d %d %d %d",&n,&P,&M,&F,&N,&S))
    {
        my.Init(n*2+1);
        s = 0, t = n*2+1;
        for(int i=1; i<=n; i++) scanf("%d",&w[i]);
        for(int i=1;i<=n;i++) my.Addedge(s,i,w[i],0), my.Addedge(i+n,t,w[i],0),my.Addedge(s,i+n,inf,P);
        for(int i=1;i<n;i++) my.Addedge(i,i+1,inf,0);
        for(int i=1;i+M<=n;i++) my.Addedge(i,i+M+n,inf,F);
        for(int i=1;i+N<=n;i++) my.Addedge(i,i+N+n,inf,S);
        int cost = my.Mincost(s,t);
        printf("%d\n",cost);
    }
    return 0;
}