【洛谷2469/BZOJ1927】[SDOI2010]星际竞速（费用流/最小路径覆盖）

题目：

洛谷2469

分析：

把题目翻译成人话：给一个带边权的DAG，求一个路径覆盖方案使路径边权总和最小。从点\(i\)开始的路径需要额外加上\(A_i\)的权值。

回xian忆chang一xue下xi不带权DAG的最小路径覆盖用网络流是怎么做的：把点\(u\)拆成\(u\)和\(u'\)两个点，如果原图存在边\((u,v)\)就在网络中连边\((u,v')\)，然后源点\(s\)向所有\(u\)连边，所有\(v\)向汇点\(t\)连边，所有边容量均为\(1\)，跑最大流。原图中点数\(n\)减去最大流就是最小路径覆盖。

考虑这样做的原理：最小路径覆盖中每个点属于且仅属于一条路径。对于任意包含多于\(1\)个点的路径，有且只有一个点入度为\(0\)，一个点出度为\(0\)，其余所有点入度、出度皆为\(1\)。网络中若\((s,u)\)有流量说明\(u\)出度为\(1\)（\(s\)流到\(u\)后必然要流向某个点\(v'\)），若\((u',t)\)有流量说明\(u\)入度为\(1\)（必须有某个点流到\(u'\)，\((u',t)\)才有流量）。那么最大流就是所有点入度之和，\(n\)减去入度之和就是入度为\(0\)的点数，即路径起点的数量，即路径数。如果边\((u,v')\)有流量说明原图中\((u,v)\)这条边在最小路径覆盖中。

那么给每条边加上权以后呢？自然能想到把原图中边\((u,v)\)的权作为网络中\((u,v')\)的费用然后跑费用流

然后你就gg了

费用流全名叫“最小费用最大流”，是在保证流量最大的情况下的最小费用。在这道题中，就相当于首先要保证路径的条数最少（即流量最大），然后再使费用最小。此时要感谢某神犇T兔z崽z子给我说的我自己想出来的方法……先打个广告

戳我进入兔崽子的博客

\(s\)向每个\(u'\)连边，这条边有流量说明\(u\)入度为\(0\)（因为\((u',t)\)容量为\(1\)，\((s,u‘)\)有流量就说明肯定没有别的点会流到\(u'\)）。这样无论如何路径覆盖最大流都是\(n\)，就消除了路径条数的影响，求出最小费用即为答案。

这种方案顺便解决了下一个问题：路径起点有额外权值。把\(A_u\)作为\((s,u')\)的费用即可。

代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
namespace zyt
{
	typedef long long ll;
	const ll INF = 0x3f3f3f3f3f3f3f3fLL;
	const int N = 810, P = N * 2, M = (N * 3 + 15010) * 2;
	int head[P], cnt, n, m, s, t;
	struct edge
	{
		int to, w, c, next;
	}e[M];
	inline void add(const int a, const int b, const int c, const int d)
	{
		e[cnt] = (edge){b, c, d, head[a]};
		head[a] = cnt++;
	}
	inline void addtw(const int a, const int b, const int c, const int d)
	{
		add(a, b, c, d);
		add(b, a, 0, -d);
	}
	namespace EK
	{
		bool vis[P];
		ll dis[P];
		int pre[P];
		bool SPFA()
		{
			queue<int>q;
			memset(pre, -1, sizeof(pre));
			memset(vis, 0, sizeof(vis));
			memset(dis, INF, sizeof(dis));
			q.push(s);
			vis[s] = true;
			dis[s] = 0;
			while (!q.empty())
			{
				int u = q.front();
				q.pop();
				vis[u] = false;
				for (int i = head[u]; ~i; i = e[i].next)
				{
					int v = e[i].to;
					if (e[i].w && dis[v] > dis[u] + e[i].c)
					{
						dis[v] = dis[u] + e[i].c, pre[v] = i;
						if (!vis[v])
							vis[v] = true, q.push(v);
					}
				}
			}
			return dis[t] != INF;
		}
		ll EK()
		{
			ll ans = 0;
			while (SPFA())
			{
				int i = pre[t];
				int minn = n + 1;
				while (~i)
					minn = min(minn, e[i].w), i = pre[e[i ^ 1].to];
				i = pre[t];
				while (~i)
					e[i].w -= minn, e[i ^ 1].w += minn, i = pre[e[i ^ 1].to];
				ans += minn * dis[t];
			}
			return ans;
		}
	}
	int work()
	{
		ios::sync_with_stdio(false);
		memset(head, -1, sizeof(head));
		cin >> n >> m;
		s = n * 2 + 1, t = n * 2 + 2;
		for (int i = 1; i <= n; i++)
		{
			int a;
			cin >> a;
			addtw(s, i, 1, 0);
			addtw(s, i + n, 1, a);
			addtw(i + n, t, 1, 0);
		}
		for (int i = 0; i < m; i++)
		{
			int a, b, c;
			cin >> a >> b >> c;
			if (a > b)
				swap(a, b);
			addtw(a, b + n, 1, c);
		}
		cout << EK::EK();
		return 0;
	}
}
int main()
{
	return zyt::work();
}