Codevs_P1237 餐巾问题(线性规划与网络流24题+最小费用最大流)

Codevs传送门

时间限制: 1 s
空间限制: 128000 KB
题目等级 : 钻石 Diamond
题目描述 Description
一个餐厅在相继的 N 天里，每天需用的餐巾数不尽相同。假设第 i 天需要 ri块餐巾(i=1，2，…，N)。餐厅可以购买新的餐巾，每块餐巾的费用为 p 分；或者把旧餐巾送到快洗部，洗一块需 m 天，其费用为 f 分；或者送到慢洗部，洗一块需 n 天(n>m)，其费用为 s< f 分。
每天结束时，餐厅必须决定将多少块脏的餐巾送到快洗部，多少块餐巾送到慢洗部，以及多少块保存起来延期送洗。但是每天洗好的餐巾和购买的新餐巾数之和，要满足当天的需求量。
试设计一个算法为餐厅合理地安排好 N 天中餐巾使用计划，使总的花费最小。
编程找出一个最佳餐巾使用计划.

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

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

样例输入 Sample Input
3 10 2 3 3 2
5
6
7

样例输出 Sample Output
145

数据范围及提示 Data Size & Hint

将餐巾拆点，拆成没用过的和用过的两个点，加源加汇。
1.将源点连接没用过的餐巾，容量为INF，费用为购买餐巾的费用，来满足购进餐巾的条件；
2.将没用过的餐巾与汇点连接，容量为ri，费用为0，满足每天的需求；
4.将每天用过的与第二天用过的相连，容量为INF，费用为0，满足延迟清洗；
5.将每天用过的与n(或m)天后没用的店相连，容量位INF，费用为清洗费用，满足清洗餐巾再使用；

ps:最近OI圈好乱…

#include<cstdio>
#include<climits>
#include<cstring>
#include<queue>
#include<vector>
#include<iostream>
using namespace std;
#define INF INT_MAX/3*2
#define N 1005*2
struct NetWork{
    struct Edge{int fr,to,cap,flow,cost;};
    vector<Edge> edge;vector<int> g[N];
    int fl[N],p[N],d[N];
    int n,a,b,f,fa,fb,x,m,s,t,cost,flow;

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

    int MaxFlowMinCost(){
        bool b[N];memset(fl,0,sizeof(fl));memset(b,0,sizeof(b));
        for(int i=1;i<N;i++) d[i]=INF;
        queue<int> q;q.push(s);fl[s]=INF,d[s]=0,b[s]=true;
        while(!q.empty()){
            int x=q.front();q.pop();b[x]=false;
            for(int i=0;i<g[x].size();i++){
                Edge &e=edge[g[x][i]];
                if(e.cap>e.flow&&d[e.to]>d[x]+e.cost){
                    d[e.to]=d[x]+e.cost,p[e.to]=g[x][i];
                    fl[e.to]=min(fl[x],e.cap-e.flow);
                    if(!b[e.to]){b[e.to]=true;q.push(e.to);}
                }
            }
        }
        if(d[t]==INF) return 0;
        flow+=fl[t];cost+=d[t]*fl[t];
        for(int x=t;x!=s;x=edge[p[x]].fr) edge[p[x]].flow+=fl[t],edge[p[x]^1].flow-=fl[t];
        return 1;
    }

    void solve(){
//      scanf("%d%d%d%d%d%d",&n,&a,&b,&f,&fa,&fb);s=N-3,t=N-2;
        scanf("%d%d%d%d%d%d",&n,&f,&a,&fa,&b,&fb);s=2001,t=2002;
        for(int i=1;i<=n;i++){
            scanf("%d",&x);
            Add_Edge(i,t,x,0);Add_Edge(s,i+1000,x,0);Add_Edge(s,i,INF,f);
            if(i<n) Add_Edge(i,i+1,INF,0);
            if(i+a<=n) Add_Edge(i+1000,i+a,INF,fa);
            if(i+b<=n) Add_Edge(i+1000,i+b,INF,fb);
        }
        while(MaxFlowMinCost());
        printf("%d",cost);
    }
}s;
int main(){
    s.solve();return 0;
}