BZOJ1061: [Noi2008]志愿者招募

BZOJ1061: [Noi2008]志愿者招募

Description

 

申奥成功后，布布经过不懈努力，终于成为奥组委下属公司人力资源部门的主管。

布布刚上任就遇到了一个难题：为即将启动的奥运新项目招募一批短期志愿者。

经过估算，这个项目需要N 天才能完成，其中第i 天至少需要Ai 个人。

布布通过了解得知，一共有M 类志愿者可以招募。

其中第i 类可以从第Si 天工作到第Ti 天，招募费用是每人Ci 元。

新官上任三把火，为了出色地完成自己的工作，布布希望用尽量少的费用招募足够的志愿者，但这并不是他的特长！

于是布布找到了你，希望你帮他设计一种最优的招募方案。

Input

第一行包含两个整数N, M，表示完成项目的天数和可以招募的志愿者的种类。

接下来的一行中包含N 个非负整数，表示每天至少需要的志愿者人数。

接下来的M 行中每行包含三个整数Si, Ti, Ci，含义如上文所述。

为了方便起见，我们可以认为每类志愿者的数量都是无限多的。

Output

　　仅包含一个整数，表示你所设计的最优方案的总费用。

Sample Input

3 3
2 3 4
1 2 2
2 3 5
3 3 2

Sample Output

14

HINT

1 ≤ N ≤ 1000，1 ≤ M ≤ 10000，题目中其他所涉及的数据均 不超过2^31-1。

题解Here!

其实我一开始是想源点连志愿者、志愿者连工作的天（区间）、天连汇点，再跑最小费用最大流。

但是想一想就知道会被叉掉——费用就不好算。

然后看完题解，发现了一种建图方法：

用二元组 (w , cost) 表示流量为 w 费用为 cost 的边。

对于每一天向后一天连边 (MAX-ai,0)

对于每一种志愿者选择，si 向 ti+1 连边 (MAX,ci)

从超级源向第一天连边 (MAX,0)

从最后一天+1 向超级汇连边 (MAX,0)

然后从超级源向超级汇跑费用流。

为什么这样跑会正确呢？

可以发现，第一次网络流后所有天数边的容量会被填 max-ai（max为需求最大天的需求量），不会走带权边。

然后因为有带权边存在，所以网络还可以扩容。

因为保证一定存在可行解，所以容量一定可以扩成 MAX。

那么每条天数边都可以视为填满（因为天数边权值为0,一定优于带权边，会优先被填满，出现前面填带权边覆盖本条边情况除外）。

然后对于每天，不通过天数边经过的流量总和一定至少为 ai。

换句话说，缺少的流量会从带权边流过，自动补齐MAX。

并且费用流算法会自动求出费用最小解，因此可以保证方案一定最优。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define MAXN 20010
#define MAX 999999999
using namespace std;
int n,m,s,t,c=2,maxflow=0,mincost=0;
int head[MAXN],deep[MAXN],path[MAXN],flow[MAXN],fa[MAXN];
bool vis[MAXN];
struct node{
    int next,to,w,cost;
}a[MAXN<<1];
inline int read(){
    int date=0,w=1;char c=0;
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
    return date*w;
}
inline int relax(int u,int v,int i,int w,int cost){
    if(path[v]>path[u]+cost){
        path[v]=path[u]+cost;
        fa[v]=u;
        deep[v]=i;
        flow[v]=min(flow[u],w);
        return 1;
    }
    return 0;
}
inline void add(int u,int v,int w,int cost){
    a[c].to=v;a[c].w=w;a[c].cost=cost;a[c].next=head[u];head[u]=c++;
    a[c].to=u;a[c].w=0;a[c].cost=-cost;a[c].next=head[v];head[v]=c++;
}
bool spfa(){
    int u,v;
    queue<int> q;
    for(int i=s;i<=t;i++){path[i]=MAX;vis[i]=false;fa[i]=-1;}
    path[s]=0;
    vis[s]=true;
    fa[s]=0;
    flow[s]=MAX;
    q.push(s);
    while(!q.empty()){
        u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];i;i=a[i].next){
            v=a[i].to;
            if(a[i].w&&relax(u,v,i,a[i].w,a[i].cost)&&!vis[v]){
                vis[v]=true;
                q.push(v);
            }
        }
    }
    if(path[t]==MAX)return false;
    return true;
}
void EK(){
    while(spfa()){
        for(int i=t;i!=s;i=fa[i]){
            a[deep[i]].w-=flow[t];
            a[deep[i]^1].w+=flow[t];
        }
        maxflow+=flow[t];
        mincost+=flow[t]*path[t];
    }
}
void work(){
    EK();
    printf("%d\n",mincost);
}
void init(){
    int u,v,w;
    n=read();m=read();
    s=0;t=n+2;
    for(int i=1;i<=n;i++){
        u=read();
        add(i,i+1,MAX-u,0);
    }
    add(s,1,MAX,0);add(n+1,t,MAX,0);
    for(int i=1;i<=m;i++){
        u=read();v=read();w=read();
        add(u,v+1,MAX,w);
    }
}
int main(){
    init();
    work();
    return 0;
}

 

转载于:https://www.cnblogs.com/Yangrui-Blog/p/9409329.html