传送门：【POJ】3164 Command Network

题目大意：平面上n个点，分别编号1~n。有m条有向边(u,v)，边权为两点间的笛卡尔距离，表达为(u,v,cost)。现在问你能否选择一些边使得编号为1的点能到达其他所有点并且花费最小。

题目分析：最小树形图入门题。

什么是最小树形图？其实就是有向最小生成树。

那么算法是怎么实现的呢？

首先，我们从根做一次dfs，判断是否根结点能到达其他所有的节点，如果不行，直接输出无解。

现在我们假设解存在。

1.我们为除根结点以外的每个节点 i 选择一条边权最小的入边，用inEdge[ i ]表示最小入边的边权，如果所选的边不构成环，那么很显然这就是最小树形图了，答案就是边权之和。

2.如果构成了环，那么我们就缩环成点！对于这个环，我们设立一个新的点new来代替，对于所有进入new中节点 i 的边(u,i,cost)，我们构造边(u,new,cost - inEdge[ i ] )，对于所有从new中节点 i 出去的边(i,v,cost)，我们构造边(new,v,cost)。

为什么要这么构造呢？我们可以这么思考：假设环中存在边(1,2,3)、(2,1,4)，那么如果有边(i,1,7)、(j,2,9)，那么如果走边(i,1,7)则只能走i->1->2过，因此我们要删除边(1,2,3)，如果走边(j,2,9)则只能走j->2->1，因此我们要删除边(2,1,4)，正因为这样我们通过建边(i,new,7-3)，(j,new,9-4)表示如果走i->1->2那么我们删边(1,2,3)，同理如果走j->2->1那么我们删边(2,1,4)。

同样可以这么理解：除根以外，每个点有且只能有一条入边，如果选择了一条边从环外的点u到环中的点v，那么必定要替代掉环中到v的边inEdge[ v ]，所以建边(u,new,cost - inEdge[ v ])。

3.回到步骤1继续执行直到不存在环为止。

那么既然我们需要求出构造最小树形图的花费，那么我们该怎么记录呢？

只要在每次求出所有点的最小入边后累加即可。

为什么这样得到的就是答案呢?

因为，如果你一开始选择了一条边，加上了它的边权，而之后你要删除它，那么我们可以知道你一定是要删除它了，因此它必定是环中的边，那么仔细想想我们正不是在缩环的时候已经变相删除了它么~~

主算法流程基本就是这样了~

接下来将一下我对这个算法的实现。

首先假设根是固定的。

1.首先并查集判断是否根结点能到达所有点。怎么判断？如果存在边(x,y)且y不是根结点，那么用并查集将y接到x身上。注意！当y是根结点的时候不进行此操作。只要结束后判断一下是不是有节点编号不是根结点的编号即可。如果有解再执行接下来的操作。无解直接停止。

2.为除根以外的所有点选择最小入边，必须保证不能选自环！同时记录前驱。

3.加上除根以外每个节点的最小入边的权值。

4.对每一个节点通过不断找前驱的方式，边走边将自己染色，一直走直到遇到根结点或者环或者已经染成相同颜色的节点。如果找到的前驱不是根结点，那么说明找到了一个环，如果这个环已经被缩成点，跳过，否则将遇到的这个环缩点。

5.如果染色完所有的节点依旧没有遇到环，那么恭喜！最小树形图已经找到了！直接跳出循环输出解。

6.如果有环，将每条边(u,v)都改为缩点以后的编号(idx[ u ],idx[ v ])（除根结点以外其他点的编号都是不断改变的），并对于idx[ u ] != idx[ v ]的边(u,v)，将其替换成(idx[ u ],idx[ v ] , cost - inEdge[ v ] )。

7.回到第二步重复上述步骤知道没有环存在。

算法的复杂度是O(VE)的。

代码如下：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define REPF( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define REPV( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define clear( a , x ) memset ( a , x , sizeof a )

const int MAXN = 105 ;
const int MAXE = 100000 ;
const double INF = 2e9 ;

struct Edge {
int u , v ;
double c ;
} ;

struct Node {
double x , y ;
void input () {
scanf ( "%lf%lf" , &x , &y ) ;
}
} ;

struct MST {
Node a[MAXN] ;
Edge edge[MAXE] ;
double inEdge[MAXN] ;
int idx[MAXN] ;
int p[MAXN] ;
int color[MAXN] ;
int n , m ;
double res ;

double dist ( double x , double y ) {
return sqrt ( x * x + y * y ) ;
}

void input () {
int x , y ;
REP ( i , n )
a[i].input () ;
REP ( i , m ) {
scanf ( "%d%d" , &edge[i].u , &edge[i].v ) ;
-- edge[i].u , -- edge[i].v ;
int u = edge[i].u , v = edge[i].v ;
edge[i].c = dist ( a[u].x - a[v].x , a[u].y - a[v].y ) ;
if ( u == v )
edge[i].c = INF ;
}
}

int build_tree () {
REP ( i , n )
inEdge[i] = INF ;
REP ( i , m ) {
int u = edge[i].u , v = edge[i].v ;
if ( u != v && inEdge[v] > edge[i].c ) {
inEdge[v] = edge[i].c ;
p[v] = u ;
}
}
int cnt = 1 ;
clear ( idx , -1 ) ;
clear ( color , 0 ) ;
idx[0] = 0 ;
p[0] = 0 ;
inEdge[0] = 0 ;
REP ( i , n ) {
res += inEdge[i] ;
int v = i ;
while ( color[v] != i && idx[v] == -1 && v != 0 )
color[v] = i , v = p[v] ;
if ( v != 0 && idx[v] == -1 ) {
for ( int u = p[v] ; u != v ; u = p[u] )
idx[u] = cnt ;
idx[v] = cnt ++ ;
}
}
if ( cnt == 1 )//no circle
return 1 ;
REP ( i , n )
if ( idx[i] == -1 )
idx[i] = cnt ++ ;
REP ( i , m ) {
int u = edge[i].u , v = edge[i].v ;
edge[i].u = idx[u] ;
edge[i].v = idx[v] ;
if ( idx[u] != idx[v] )
edge[i].c -= inEdge[v] ;
}
n = cnt ;
return 0 ;
}

int find ( int x ) {
return p[x] == x ? x : ( p[x] = find ( p[x] ) ) ;
}

void solve () {
input () ;
REP ( i , n )
p[i] = i ;
REP ( i , m ) {
int x = find ( edge[i].u ) ;
int y = find ( edge[i].v ) ;
if ( x != y && y )
p[y] = x ;
}
REP ( i , n )
if ( p[i] != 0 ) {
printf ( "poor snoopy\n" ) ;
return ;
}
res = 0 ;
while ( !build_tree () ) ;
printf ( "%.2f\n" , res ) ;
}
} ;

MST z ;

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