#1394 : 网络流四·最小路径覆盖

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

原创最新推荐文章于 2021-12-04 17:03:49 发布 · 266 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#网络流 #图论

图论同时被 3 个专栏收录

46 篇文章

订阅专栏

hihocode

43 篇文章

订阅专栏

网络流

14 篇文章

订阅专栏

本文介绍了一种使用最大流算法解决最小路径覆盖问题的方法，通过拆点技巧将问题转化为求最大流的问题，并给出了具体的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

国庆期间正是旅游和游玩的高峰期。

小Hi和小Ho的学习小组为了研究课题，决定趁此机会派出若干个调查团去沿途查看一下H市内各个景点的游客情况。

H市一共有N个旅游景点(编号1..N)，由M条单向游览路线连接。在一个景点游览完后，可以顺着游览线路前往下一个景点。

为了避免游客重复游览同一个景点，游览线路保证是没有环路的。

每一个调查团可以从任意一个景点出发，沿着计划好的游览线路依次调查，到达终点后再返回。每个景点只会有一个调查团经过，不会重复调查。

举个例子：

上图中一共派出了3个调查团：

1. 蓝色：调查景点；2

2. 橙色：调查景点；1->3->4->6

3. 绿色：调查景点；5->7

当然对于这个图还有其他的规划方式，但是最少也需要3个调查团。

由于小组内的人数有限，所以大家希望调查团的数量尽可能少，同时也要将所有的景点都进行调查。

当然，如何规划调查团线路的任务落到了小Hi和小Ho的头上。

提示：最小路径覆盖

输入

第1行：2个整数N,M。1≤N≤500,0≤M≤20,000。

第2..M+1行：2个数字u,v，表示一条有向边(u,v)。保证不会出现重复的边，且不存在环。

输出

第1行：1个整数，表示最少需要的调查团数量。

样例输入

样例输出

虽然是模板题，但考察也比较多，按照最大流解决最小路径覆盖问题的套路建模法。

这种模型的套路就是拆点，把一个点拆成两个。结果为n-最大流，，这个很好理解，最大流是有流量流出的点，那没有流量流出的点当然就是要派出人的多少了。

建模：把点拆成两个，一个i 一个n+i，把s与所有i连 w为1，把t与所有n+i连，w为1. 根据条件连边u，v+n，w为1.

其实这种问题也可以用二分图的最大匹配做，额，以后写上，现在代码是最大流的。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>

#define REP(I, X) for(int I = 0; I < X; ++I)
#define FF(I, A, B) for(int I = A; I <= B; ++I)
#define clear(A, B) memset(A, B, sizeof A)
#define copy(A, B) memcpy(A, B, sizeof A)
#define min(A, B) ((A) < (B) ? (A) : (B))
#define max(A, B) ((A) > (B) ? (A) : (B))
using namespace std;
typedef long long ll;
typedef long long LL;
const int oo = 0x3f3f3f3f;
const int maxE = 1100050;
const int maxN = 10005;
const int maxQ = 1100050;
struct Edge{
    int v, n;
    long long c;

};


Edge edge[maxE];
int adj[maxN], cntE;
int Q[maxQ], head, tail, inq[maxN];
int d[maxN], num[maxN], cur[maxN], pre[maxN];
int s, t, nv;
int n, m, nm;
int path[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void addedge(int u, int v, long long c){
    edge[cntE].v = v;edge[cntE].c = c; edge[cntE].n = adj[u]; adj[u] = cntE++;
    edge[cntE].v = u;edge[cntE].c = 0; edge[cntE].n = adj[v]; adj[v] = cntE++;
}
void REV_BFS(){
    clear(d, -1);
    clear(num, 0);
    head = tail = 0;
    d[t] = 0;
    num[0] = 1;
    Q[tail++] = t;
    while(head != tail){
        int u = Q[head++];
        for(int i = adj[u]; ~i; i = edge[i].n){
            int v = edge[i].v;
            if(~d[v]) continue;
            d[v] = d[u] + 1;
            num[d[v]]++;
            Q[tail++] = v;
        }
    }
}

long long ISAP(){
    copy(cur, adj);
    REV_BFS();
    int  u = pre[s] = s, i;
    long long flow=0;
    while(d[s] < nv){
        if(u == t){
            long long f = oo, neck;
            for(i = s; i != t; i = edge[cur[i]].v){
                if(f > edge[cur[i]].c){
                    f = edge[cur[i]].c;
                    neck = i;
                }
            }
            for(i = s; i != t; i = edge[cur[i]].v){
                edge[cur[i]].c -= f;
                edge[cur[i] ^ 1].c += f;
            }
            flow += f;
            u = neck;
        }
        for(i = cur[u]; ~i; i = edge[i].n) if(edge[i].c && d[u] == d[edge[i].v] + 1) break;
        if(~i){
            cur[u] = i;
            pre[edge[i].v] = u;
            u = edge[i].v;
        }
        else{
            if(0 == (--num[d[u]])) break;
            int mind = nv;
            for(i = adj[u]; ~i; i = edge[i].n){
                if(edge[i].c && mind > d[edge[i].v]){
                    mind = d[edge[i].v];
                    cur[u] = i;
                }
            }
            d[u] = mind + 1;
            num[d[u]]++;
            u = pre[u];
        }
    }
    return flow;
}

int read () {
	char c = ' ' ;
	int x = 0 ;
	while ( c < '0' || c > '9' )
		c = getchar () ;
	while ( c >= '0' && c <= '9' ) {
		x = x * 10 + c - '0' ;
		c = getchar () ;
	}
	return x ;
}


void work()
{
    cntE=0;
    clear(adj, -1);
	int u,v,w;
	int sum=0;
	s = 0 , t = n+1, nv = t + 1 ;
	for(int i=1;i<=m;i++){
		u = read () ;v = read () ;
		sum+=u;
        addedge ( u , nv+v , 1 ) ;

	}
	for(int i=1;i<=n;i++)
	{
	    addedge ( s , i , 1 ) ;
	    addedge ( nv+i , t , 1 ) ;
	}
	LL flow =ISAP();

	printf ( "%lld\n",n-flow) ;


}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        work();
    }
    return 0;
}