[网络流24题] 10 餐巾 （线性规划网络优化 ，最小费用最大流）

题目大意：

一家餐厅在相继的N天里，每天要用ri块餐巾。餐厅可以选择购买新的餐巾，每块的费用为p分；也可以把旧餐巾送到快洗部，洗一块需m天，花费f分；或者送到慢洗部，洗一块需要n（n>m）天，费用为s（s<f）分。求合理餐巾使用计划下可能的最小总花费。

输入：

输入文件共 3 行，第 1 行为总天教；第 2 行为每天所需的餐巾块数；第 3 行为每块餐巾的新购费用 p ，快洗所需天数 m ，快洗所需费用 f ，慢洗所需天数 n ，慢洗所需费用 s。

思路分析：

将每一天分成二分图两个集合中的顶点X，Y（其中X集表示每天用完的餐巾，Y集表示每天要用的餐巾），建立源点s，汇点t；

①：从s向每个Xi连一条容量为ri， 费用为0的有向边， 表示每天用完ri块餐巾；

②：从每个Yi向t连一条容量为ri， 费用为0的有向边 ，表示每天要用ri块餐巾；

③：从s向每个Yi连一条容量为INF，费用为p的有向边，表示每天买新的餐巾，每块花费p分；

④：从每个Xi向Xi+1（i+1<=N）连一条容量为INF，费用为0的有向边，表示第i天剩下的餐巾留在第i+1天处理；

⑤：从每个Xi向Yi+m（i+m<=N）连一条容量为INF，费用为f的有向边，表示第i天剩下的餐巾送到快洗部，m天之后可以重新使用，花费为f；

⑥：从每个Xi向Yi+n（i+n<=N）连一条容量为INF，费用为s的有向边，表示第i天剩下的餐巾送到慢洗部，n天之后可以重新使用，花费为s；

代码实现：

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
using namespace std;
const int N=410, M=2410, INF=0x3f3f3f3f;
int n, m, s, t, top, sum_cost;
int head[N], vis[N], path[N], minflow[N], num[210], dis[N], pre[N];

struct Edge{
    int to, next, flow, cost;
    Edge(int _to = 0, int _next = 0, int _flow = 0, int _cost = 0):to(_to), next(_next), flow(_flow), cost(_cost){}
}edge[M];

void Addedge(int from, int to, int flow, int cost){
    edge[top] = Edge(to, head[from], flow, cost);
    head[from] = top++;
    edge[top] = Edge(from, head[to], 0, -cost);
    head[to] = top++;
}

int Spfa(){
    queue<int> q;
    memset(dis, 0x3f, sizeof(dis));
    memset(minflow, 0x3f, sizeof(minflow));
    memset(path, -1, sizeof(path));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0, q.push(s);
    while(!q.empty()){
        int u = q.front(); q.pop();
        vis[u] = 0;
        for(int i = head[u]; i + 1; i = edge[i].next){
            if(edge[i].flow && dis[edge[i].to] > dis[u] + edge[i].cost){
                dis[edge[i].to] = dis[u] + edge[i].cost;
                pre[edge[i].to] = u;
                path[edge[i].to] = i;
                minflow[edge[i].to] = Min(minflow[u], edge[i].flow);
                if(!vis[edge[i].to]){
                    vis[edge[i].to] = 1;
                    q.push(edge[i].to);
                }
            }
        }
    }
    if(dis[t] == INF) return 0;
    sum_cost += minflow[t] * dis[t];
    int u = t;
    while(u != s){
        edge[path[u]].flow -= minflow[t];
        edge[path[u]^1].flow += minflow[t];
        u = pre[u];
    }
    return 1;
}

int main(){
    freopen("napkin.in", "r", stdin);
    freopen("napkin.out", "w", stdout);
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) scanf("%d", &num[i]);
    int p_n, t_q, p_q, t_s, p_s;
    scanf("%d%d%d%d%d", &p_n, &t_q, &p_q, &t_s, &p_s);
    memset(head, -1, sizeof(head));
    top = s = sum_cost = 0;
    t = n * 2 + 1;
    for(int i = 1; i <=n; ++i){
        Addedge(s, i, num[i], 0);
        Addedge(i+n, t, num[i], 0);
        Addedge(s, i+n, INF, p_n);
        if(i < n) Addedge(i, i+1, INF, 0);
        if(i+t_q <= n) Addedge(i, i+n+t_q, INF, p_q);
        if(i+t_s <= n) Addedge(i, i+n+t_s, INF, p_s);
    }
    while(Spfa());
    printf("%d\n", sum_cost);
}