BZOJ1927 [Sdoi2010]星际竞速

题目大意：自己看中文。

。

。

思路：不难发现，题目等价于让我们求出一些标号上升的子序列精确覆盖全集。每个子序列的起点一定是利用“能力爆发”   得到的。

那么我们仅仅需对于每一个星球，确定一个前驱就能够了。

若是0作为前驱。则转移代价为定位时间；否则转移代价为路径长度。

此外一个点的前驱的标号严格小于自己的标号。

注意0能够作为多个星球的前驱，剩下的星球仅仅能作为一个星球的前驱。

于是转化为类二分图最优匹配问题，利用最小费用流求解就可以。

Code:

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

queue<int> q;

#define N 810
struct Solver {
	int head[N<<1], next[N*N], end[N*N], flow[N*N], cost[N*N], ind;
	int d[N<<1], ld[N<<1], lb[N<<1];
	bool inq[N<<1];
	void reset() {
		ind = 0;
		memset(head, -1, sizeof head);
	}
	void addedge(int a, int b, int _flow, int _cost) {
		int q = ind++;
		end[q] = b;
		next[q] = head[a];
		head[a] = q;
		flow[q] = _flow;
		cost[q] = _cost;
	}
	void make(int a, int b, int _flow, int _cost) {
		addedge(a, b, _flow, _cost);
		addedge(b, a, 0, -_cost);
	}
	bool spfa(int S, int T) {
		memset(d, 0x3f, sizeof d);
		d[S] = 0;
		inq[S] = 1;
		q.push(S);
		int i, j;
		while(!q.empty()) {
			i = q.front();
			q.pop();
			inq[i] = 0;
			for(j = head[i]; j != -1; j = next[j]) {
				if (flow[j] && d[end[j]] > d[i] + cost[j]) {
					d[end[j]] = d[i] + cost[j];
					ld[end[j]] = i;
					lb[end[j]] = j;
					if (!inq[end[j]])
						inq[end[j]] = 1, q.push(end[j]);
				}
			}
		}
		return d[T] != 0x3f3f3f3f;
	}
	int Mincost(int S, int T) {
		int res = 0, Min, i;
		while(spfa(S, T)) {
			Min = 0x3f3f3f3f;
			for(i = T; i != S; i = ld[i])
				Min = Min > flow[lb[i]] ? flow[lb[i]] : Min;
			for(i = T; i != S; i = ld[i])
				flow[lb[i]] -= Min, flow[lb[i] ^ 1] += Min;
			res += Min * d[T];
		}
		return res;
	}
}G;

int main() {
	
	int n, m;
	scanf("%d%d", &n, &m);
	
	register int i;
	int x;
	G.reset();
	for(i = 1; i <= n; ++i) {
		scanf("%d", &x);
		G.make(1, i<<1^1, 1, x);
	}
	
	int a, b;
	for(i = 1; i <= m; ++i) {
		scanf("%d%d%d", &a, &b, &x);
		if (a > b)
			swap(a, b);
		G.make(a<<1, b<<1^1, 1, x);
	}
	
	G.make(0, 1, 0x3f3f3f3f, 0);
	for(i = 1; i <= n; ++i)
		G.make(0, i<<1, 1, 0), G.make(i<<1^1, 2*n+2, 1, 0);
	
	printf("%d\n", G.Mincost(0, 2*n+2));
	
	return 0;
}