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

时间限制:10000ms单点时限:1000ms内存限制:256MB

描述

国庆期间正是旅游和游玩的高峰期。小Hi和小Ho的学习小组为了研究课题，决定趁此机会派出若干个调查团去沿途查看一下H市内各个景点的游客情况。H市一共有N个旅游景点(编号1..N)，由M条单向游览路线连接。在一个景点游览完后，可以顺着游览线路前往下一个景点。为了避免游客重复游览同一个景点，游览线路保证是没有环路的。每一个调查团可以从任意一个景点出发，沿着计划好的游览线路依次调查，到达终点后再返回。每个景点只会有一个调查团经过，不会重复调查。举个例子：

上图中一共派出了3个调查团：1. 蓝色：调查景点；22. 橙色：调查景点；1->3->4->63. 绿色：调查景点；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个整数，表示最少需要的调查团数量。样例输入

7 7
1 2
1 3
2 4
3 4
4 5
4 6
5 7

样例输出

3

虽然是模板题，但考察也比较多，按照最大流解决  最小路径覆盖问题的  套路建模法。
这种模型的套路就是拆点，把一个点拆成两个。结果为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;
}