【BZOJ】1061 [Noi2008]志愿者招募 最小费用最大流——预流&填坑

传送门：【BZOJ】1061 [Noi2008]志愿者招募

题目分析：

设每个时间i都需要有至少Ai个志愿者，设每种志愿者i使用了xi个，那么我们对于每个时间点都可以列出一个不等式：x1+x2+x3+...+xn>=Ai（其中如果第i类志愿者不能在该区间工作则xi固定为0）。

最后要求最小化w1*x1+w2*x2+x3*x3+...+wn*xn（其中wi是第i种志愿者的单位价格）。

这正是一个线性规划的问题。

那么我们是否可以转化为网络流来求解呢？

当然是可以哒~

现在我们将每个点的Ai取反，变成-Ai，这样他就成了一个“坑”了（相对于y=0而言），我们从源点S给最左边的时间点引流，流的大小为U（U为大整数），然后每个时间点i向时间点i+1建边（i，i+1，U-Ai，0），最后设汇点为最右端的时间点。

现在，如果所有时间点的Ai都为0，那么显然，汇点的流量恰好等于U。

问题来了，现在我们有的Ai不等于0了，那么显然源点到汇点的流量被这些“坑”所截断了，怎么解决这一个问题？

假设志愿者工作的时间为【Li，Ri】，且该种志愿者单位花费为Ci，则我们建边（Li，Ri+1，INF，Ci），表示我们雇佣了一些志愿者“填坑”来了，如果雇佣了xi个志愿者，则说明将该区间内的所有“坑”的深度填掉了xi（当然可能有的坑在“填坑”行动后高于y=0，那也无所谓了嘛，多多益善~）。

那么现在是不是看起来思路有一点清晰了？

于是志愿者的作用就是一个人可以填一个区间的“坑”（好厉害！），然后需要每种志愿者选择一些使得花费最小的情况下填掉所有的“坑”，就是这样~

最后就是让费用流帮我们选择志愿者的时候了~

于是我们按照上面的方法跑完一遍最小费用最大流，如果流量等于U，则说明满流（志愿者们成功填掉了所有的坑，同志们辛苦了~），此时的记录的cost就是最小值（cost为算法记录的最小费用）。如果流量不等于U则无解。

这时我们又收获了一种费用流的模型：初始给一道大流，然后将有至少覆盖次数限制的点（边）的权值取反变成“坑”，最后区间覆盖就等于“填坑”，只要最后的流量等于大流的流量，就有解。

题外话：这题有说一定有解吗？。。。真是坑，明明可以构造数据让他无解的，题目出的不严谨啊。。

在树上的也有该题的特殊形式，同样可以用该题的思想解决。如：HDU3947

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
//#include <cmath>
#include <queue>
using namespace std ;
  
typedef long long LL ;
  
#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )

const int U = 100000 ;
const int MAXN = 1005 ;
const int MAXM = 10005 ;
const int MAXE = 23333 ;
const int MAXQ = 100000 ;
const int INF = 0x3f3f3f3f ;

struct Edge {
	int v , c , w , n ;
	Edge () {}
	Edge ( int v , int c , int w , int n ) : v ( v ) , c ( c ) , w ( w ) , n ( n ) {}
} E[MAXE] ;

int H[MAXN] , cntE ;
int d[MAXN] , cur[MAXN] , cap[MAXN] ;
int vis[MAXN] , Time ;
int Q[MAXQ] , head , tail ;
int flow , cost ;
int s , t ;
int n , m ;

void clear () {
	cntE = 0 ;
	clr ( H , -1 ) ;
}

void addedge ( int u , int v , int c , int w ) {
	E[cntE] = Edge ( v , c , +w , H[u] ) ;
	H[u] = cntE ++ ;
	E[cntE] = Edge ( u , 0 , -w , H[v] ) ;
	H[v] = cntE ++ ;
}

int spfa () {
	clr ( d , INF ) ;
	head = tail = 0 ;
	++ Time ;
	Q[tail ++] = s ;
	d[s] = 0 ;
	cur[s] = -1 ;
	cap[s] = INF ;
	while ( head != tail ) {
		int u = Q[head ++] ;
		vis[u] = Time - 1 ;
		for ( int i = H[u] ; ~i ; i = E[i].n ) {
			int v = E[i].v , c = E[i].c , w = E[i].w ;
			if ( c && d[v] > d[u] + w ) {
				d[v] = d[u] + w ;
				cap[v] = min ( cap[u] , c ) ;
				cur[v] = i ;
				if ( vis[v] != Time ) {
					vis[v] = Time ;
					Q[tail ++] = v ;
				}
			}
		}
	}
	if ( d[t] == INF ) return 0 ;
	cost += cap[t] * d[t] ;
	flow += cap[t] ;
	for ( int i = cur[t] ; ~i ; i = cur[E[i ^ 1].v] ) {
		E[i].c -= cap[t] ;
		E[i ^ 1].c += cap[t] ;
	}
	return 1 ;
}

int mcmf () {
	flow = cost = 0 ;
	while ( spfa () ) ;
	return cost ;
}

void solve () {
	int u , v , w ;
	clear () ;
	s = 0 ;
	t = n + 1 ;
	addedge ( s , 1 , U , 0 ) ;
	For ( i , 1 , n ) {
		scanf ( "%d" , &w ) ;
		addedge ( i , i + 1 , U - w , 0 ) ;
	}
	while ( m -- ) {
		scanf ( "%d%d%d" , &u , &v , &w ) ;
		addedge ( u , v + 1 , INF , w ) ;
	}
	mcmf () ;
	printf ( "%d\n" , cost ) ;
}
int main () {
	clr ( vis , 0 ) ;
	Time = 0 ;
	while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
	return 0 ;
}