HDU 4756 次小生成树

题意：给你n(n = 1000)个二维点，第一个点是power plant，还有n - 1个点是dormitories。然后现在知道有一条寝室到寝室的边是不能连的，但是我们不知道是哪条边，问这种情况下，最小生成树的最大值。

思路：有一种很朴素的算法就是枚举每一条被删除的边，然后做最小生成树，复杂度高的突破天际，显然不可以。

但是既然想到了上面的那种做法，再想一下就可以得到，我们还是枚举每一条被删除的边，只是这些边都是树边，所以关键就在于，删除这条边之后的图的最小生成树和原来的最小生成树的关系。

我们可以先预处理出来MINE[i][j]， 表示点i 到点j 的最短的一条边。然后再预处理出来NMIN[i][j]， 表示去掉边i -> j 之后，i -> j的最短边。

那么去掉一条边的增量就是NMIN[i][j] - MINE[i][j] 。然后取最大值即可。

#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <string>
#include <vector>
#include <iomanip>
#include <cstring>
#include <iostream>
#include <algorithm>
#define Max 2505
#define FI first
#define SE second
#define ll long long
#define PI acos(-1.0)
#define inf 0x3fffffff
#define LL(x) ( x << 1 )
#define bug puts("here")
#define PII pair<int,int>
#define RR(x) ( x << 1 | 1 )
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )

using namespace std;

inline void RD(int &ret) {
    char c;
    int flag = 1 ;
    do {
        c = getchar();
        if(c == '-')flag = -1 ;
    } while(c < '0' || c > '9') ;
    ret = c - '0';
    while((c=getchar()) >= '0' && c <= '9')
        ret = ret * 10 + ( c - '0' );
    ret *= flag ;
}

#define N 1111
#define M 111111
int st[M] ;
int top ;
double NMIN[N][N] ;
int x[N] , y[N] , cost , n ;
double Map[N][N] ;
double dis[N]  ;
bool vis[N] ;
vector<int>G[N] ;
priority_queue<kdq>qe ;
double mst = 0 ;
bool ismst[N][N] ;
double MINE[N][N] ;
double getdis(int i , int j){
    return sqrt(1.0 * (x[i] - x[j]) * (x[i] - x[j]) + 1.0 * (y[i] - y[j]) * (y[i] - y[j])) ;
}

struct kdq{
    int s , e  ;
    double l ;
    bool operator <  (const kdq & fk)const {
        return l > fk.l ;
    }
} ;

void Prim(){
    mst = 0 ;
    mem(ismst, 0) ;
    while(!qe.empty())qe.pop() ;
    for (int i = 0 ; i < n ; i ++ )dis[i] = Map[0][i] , vis[i] = 0 ,G[i].clear() ,qe.push((kdq){0 , i , dis[i]}) ;
    dis[0] = 0 , vis[0] = 1 ;
    while(!qe.empty()){
        kdq tp = qe.top() ; qe.pop() ;
        if(vis[tp.e])continue ;
        mst += Map[tp.s][tp.e] ;
        vis[tp.e] = 1 ;
        G[tp.s].push_back(tp.e) ; G[tp.e].push_back(tp.s) ;
        ismst[tp.e][tp.s] = ismst[tp.s][tp.e] = 1 ;
        MINE[tp.s][tp.e] = MINE[tp.e][tp.s] = inf ;//删除树边
        for (int i = 0 ; i < n ; i ++ )if(!vis[i] && dis[i] > Map[tp.e][i])dis[i] = Map[tp.e][i] , qe.push((kdq){tp.e , i , dis[i]}) ;
    }
}

void dfs(int root , int fa , int now){
    int sz = G[now].size() ;
    for (int i = 0 ; i < sz ; i ++ ){
        int e = G[now][i] ;
        if(e != fa)dfs(root , now , e) , MINE[root][now] = min(MINE[root][now] , MINE[root][e]) ;
    }
}

void dfs(int fa, int now){
    int fk = top ;
    st[ ++ top] = now ;int sz = G[now].size() ;
    for (int i = 0 ; i < sz ; i ++ ){
        int e = G[now][i] ; if(e != fa)dfs(now , e) ;
    }
    if(fa != -1){
        NMIN[now][fa] = NMIN[fa][now] = inf ;
        for (int i = fk + 1 ; i <= top ; i ++ )NMIN[now][fa] = NMIN[fa][now] = min(NMIN[fa][now] , MINE[st[i]][fa]) ;
    }
}
void solve(){
    cin >> n >> cost ;
    for (int i = 0 ; i < n ; i ++ )RD(x[i]) , RD(y[i]) ;
    for (int i = 0 ; i < n ; i ++ )
        for (int j = 0 ; j < n ; j ++ )
            MINE[i][j] = Map[i][j] = (i == j) ? 0 : getdis(i , j) ;
    Prim() ;
    for (int i = 0 ; i < n ; i ++ )dfs(i , -1 , i ) ;
    top = 0 ;
    dfs(-1 , 0) ;
    double ans = 0 ;
    for (int i = 0 ; i < n ; i ++ ){
        for (int j = 0 ; j < n ; j ++ ){
            if(i == 0 || j == 0)continue ;
            if(!ismst[i][j])continue ;
            ans = max(ans , NMIN[i][j] - Map[i][j]) ;
        }
    }
    printf("%.2f\n",(ans + mst) * cost) ;
}
int main() {
    int _ ; cin >> _ ; while(_ --)solve() ;
    return 0 ;
}