网络流24题10. 餐巾计划问题

餐巾计划问题

Description

一个餐厅在相继的 N 天里，每天需用的餐巾数不尽相同。假设第 i 天需要 r i 块餐巾(i=1，2，…，N)。餐厅可以购买新的餐巾，每块餐巾的费用为 p 分；或者把旧餐巾送到快洗部，洗一块需 m 天，其费用为 f 分；或者送到慢洗部，洗一块需 n 天(n>m)，其费用为 s(

Input

第 1 行有 6 个正整数 N,p,m,f,n,s。N 是要安排餐巾使用计划的天数；p 是每块新餐巾的费用；m 是快洗部洗一块餐巾需用天数；f 是快洗部洗一块餐巾需要的费用；n 是慢洗部洗一块餐巾需用天数；s 是慢洗部洗一块餐巾需要的费用。
接下来的 N 行是餐厅在相继的 N 天里，每天需用的餐巾数。

Output

将餐厅在相继的 N 天里使用餐巾的最小总花费输出。

Sample Input

3 10 2 3 3 2
5
6
7

Sample Output

145

题解

【问题分析】

网络优化问题，用最小费用最大流解决。

【建模方法】

把每天分为二分图两个集合中的顶点Xi,Yi，建立附加源S汇T。

1、从S向每个Xi连一条容量为ri，费用为0的有向边。
2、从每个Yi向T连一条容量为ri，费用为0的有向边。
3、从S向每个Yi连一条容量为无穷大，费用为p的有向边。
4、从每个Xi向Xi+1(i+1<=N)连一条容量为无穷大，费用为0的有向边。
5、从每个Xi向Yi+m(i+m<=N)连一条容量为无穷大，费用为f的有向边。
6、从每个Xi向Yi+n(i+n<=N)连一条容量为无穷大，费用为s的有向边。

求网络最小费用最大流，费用流值就是要求的最小总花费。

【建模分析】

这个问题的主要约束条件是每天的餐巾够用，而餐巾的来源可能是最新购买，也可能是前几天送洗，今天刚刚洗好的餐巾。每天用完的餐巾可以选择送到快洗部或慢洗部，或者留到下一天再处理。

经过分析可以把每天要用的和用完的分离开处理，建模后就是二分图。二分图X集合中顶点Xi表示第i天用完的餐巾，其数量为ri，所以从S向Xi连接容量为ri的边作为限制。Y集合中每个点Yi则是第i天需要的餐巾，数量为ri，与T连接的边容量作为限制。每天用完的餐巾可以选择留到下一天（Xi->Xi+1），不需要花费，送到快洗部(Xi->Yi+m)，费用为f，送到慢洗部(Xi->Yi+n)，费用为s。每天需要的餐巾除了刚刚洗好的餐巾，还可能是新购买的(S->Yi)，费用为p。

在网络上求出的最小费用最大流，满足了问题的约束条件（因为在这个图上最大流一定可以使与T连接的边全部满流，其他边只要有可行流就满足条件），而且还可以保证总费用最小，就是我们的优化目标。

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int N = 2000 + 10, M = 25000 + 10, inf = 0x3f3f3f3f;
struct Edge{
    int fr, to, cap, flow, cost;
}edg[M];
struct IN{
    int p, f, m, n, s;
}in;
int n, s, t, tot;
int hd[N], nxt[M];
int q[N], inq[N], d[N], p[N], a[N];

void insert(int u, int v, int w, int x){
    edg[tot].fr = u, edg[tot].to = v, edg[tot].cap = w, edg[tot].cost = x;
    nxt[tot] = hd[u]; hd[u] = tot;
    tot++;
    edg[tot].fr = v, edg[tot].to = u, edg[tot].cost = -x;
    nxt[tot] = hd[v]; hd[v] = tot;
    tot++;
}

bool spfa(int &fl, int &cst){
    for(int i = 0; i <= t; i++) d[i] = inf;
    memset(inq, 0, sizeof(inq));
    d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = inf;

    int head = 0, tail = 1;
    q[0] = s;
    while(head != tail){
        int u = q[head++]; if(head == 2001) head = 0;
        inq[u] = 0;
        for(int i = hd[u]; i >= 0; i = nxt[i]){
            Edge &e = edg[i];
            if(e.cap > e.flow && d[e.to] > d[u] + e.cost){
                d[e.to] = d[u] + e.cost;
                p[e.to] = i;
                a[e.to] = min(a[u], e.cap - e.flow);
                if(!inq[e.to]){
                    q[tail++] = e.to;
                    if(tail == 2001) tail = 0;
                    inq[e.to] = 1;
                }
            }
        }
    }
    if(d[t] == inf) return false;
    fl += a[t];
    cst += d[t] * a[t];
    int u = t;
    while(u != s){
        edg[p[u]].flow += a[t];
        edg[p[u]^1].flow -= a[t];
        u = edg[p[u]].fr;
    }
    return true;
}

void init(){
    scanf("%d%d%d%d%d%d", &n, &in.p, &in.m, &in.f, &in.n, &in.s);
    memset(hd, -1, sizeof(hd));
    s = 0, t = n * 2 + 1;
    int r;
    for(int i = 1; i <= n; i++){
        scanf("%d", &r);
        insert(s, i, r, 0);
        insert(n+i, t, r, 0);
        insert(s, n+i, inf, in.p);
        if(i + 1 <= n) insert(i, i+1, inf, 0);
        if(i + in.m <= n) insert(i, n+i+in.m, inf, in.f);
        if(i + in.n <= n) insert(i, n+i+in.n, inf, in.s);
    }
}

void work(){
    int flow = 0, cost = 0;
    while(spfa(flow, cost));
    printf("%d\n", cost);
}

int main(){
    freopen("prog810.in", "r", stdin);
    freopen("prog810.out", "w", stdout);
    init();
    work();
    return 0;
}