「网络流 24 题」最小路径覆盖

最新推荐文章于 2021-12-04 17:03:49 发布

让我改变你的心智

最新推荐文章于 2021-12-04 17:03:49 发布

阅读量527

点赞数

分类专栏：网络流

本文链接：https://blog.csdn.net/zy704599894/article/details/77102827

版权

网络流专栏收录该内容

42 篇文章 0 订阅

订阅专栏

内存限制：256 MiB 时间限制：1000 ms 标准输入输出

题目类型：传统评测方式：Special Judge

上传者：匿名

提交提交记录统计讨论测试数据

给定有向图 $G = (V, E)$ 。设 $P$ 是 $G$ 的一个简单路（顶点不相交）的集合。如果 $V$ 中每个顶点恰好在 $P$ 的一条路上，则称

$P$ 是 $G$ 的一个路径覆盖。 $P$ 中路径可以从 $V$ 的任何一个顶点开始，长度也是任意的，特别地，可以为 $0$ 。 $G$ 的最小路径覆盖是 $G$ 的所含路径条数最少的路径覆盖。

设计一个有效算法求一个有向无环图 $G$ 的最小路径覆盖。

第 $1$ 行有 $2$ 个正整数 $n$ 和 $m$ 。 $n$ 是给定有向无环图 $G$ 的顶点数， $m$ 是 $G$ 的边数。
接下来的 $m$ 行，每行有 $2$ 个正整数 $u$ 和 $v$ ，表示一条有向边 $(i, j)$ 。

从第 $1$ 行开始，每行输出一条路径。
文件的最后一行是最少路径数。

样例输入

样例输出

1 4 7 10 11
2 5 8
3 6 9
3

将所有点拆成功入点和出点，源点连所有入点，汇点连所有出点，所有边容量都为1，而对于每个边u-v来说，只连

u的入点和v的出点，这样保证了每个点至少会走一次。最后还原路径，对于每个起点，每次走与他相连且残留量为0

的点并标记。

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
const int maxm = 60006;
const int maxn = 2050;
const int INF = 1e9 + 7;
struct node
{
	int v, flow, next;
}edge[maxm];
int head[maxm], dis[maxm], cur[maxm], vis[maxm];
int n, m, s, t, cnt;
void init()
{
	cnt = 0, s = 0, t = n * 2 + 1;
	memset(head, -1, sizeof(head));
}
void add(int u, int v, int w)
{
	edge[cnt].v = v, edge[cnt].flow = w, edge[cnt].next = head[u], head[u] = cnt++;
	edge[cnt].v = u, edge[cnt].flow = 0, edge[cnt].next = head[v], head[v] = cnt++;
}
int bfs()
{
	queue<int>q;
	memset(dis, -1, sizeof(dis));
	q.push(s);
	dis[s] = 0;
	while (!q.empty())
	{
		int u = q.front();q.pop();
		for (int i = head[u];i != -1;i = edge[i].next)
		{
			int v = edge[i].v;
			if (dis[v] == -1 && edge[i].flow)
			{
				dis[v] = dis[u] + 1;
				q.push(v);
			}
		}
	}
	if (dis[t] == -1) return 0;
	return 1;
}
int dfs(int u, int flow)
{
	if (u == t) return flow;
	for (int i = cur[u];i != -1;i = edge[i].next)
	{
		int v = edge[i].v;
		if (dis[v] == dis[u] + 1 && edge[i].flow)
		{
			int d = dfs(v, min(edge[i].flow, flow));
			if (d > 0)
			{
				edge[i].flow -= d, edge[i ^ 1].flow += d;
				return d;
			}
		}
	}
	return 0;
}
void dinic()
{
	int d;
	while (bfs())
	{
		for (int i = 0;i <= t;i++) cur[i] = head[i];
		while (d = dfs(s, INF));
	}
}
int main()
{
	int i, j, k, a, b, ans = 0;
	scanf("%d%d", &n, &m);
	init();
	for (i = 1;i <= n;i++)
		add(s, i, 1), add(i + n, t, 1);
	for (i = 1;i <= m;i++)
	{
		scanf("%d%d", &a, &b);
		add(a, b + n, 1);
	}
	dinic();
	memset(vis, 0, sizeof(vis));
	for (i = 1;i <= n;i++)
	{
		if (vis[i] == 1) continue;
		int flag = 0, now = i;
		while (1)
		{
			flag = 0;
			printf("%d ", now);
			vis[now] = 1;
			for (j = head[now];j != -1;j = edge[j].next)
			{
				int v = edge[j].v;
				if (edge[j].flow == 0 && v > n&&v <= 2 * n)
				{
					now = v - n, flag = 1;
					break;
				}
			}
			if (!flag) break;
		}
		printf("\n");
		ans++;
	}
	printf("%d\n", ans);
	return 0;
}