HDU 4756:Install Air Conditioning (最小生成树最佳替换边，最小生成树+树形dp)

题目翻译：

由于给每个寝室都装了空调，所以要从电站（编号为1）往那些寝室送电。

所以要铺设线路，线路每米的花费为K。给出N个点，的坐标，第一个点

总代表电站的位置，剩余N-1个点是寝室的位置，欲想让费用最小，我们

肯定是求该图的最小生成树，但是由于构成最小生成树的边可能出故障，

（与1相连的边不会出故障，因为1是电站，是唯一供电的地方，）

则该图就被分为S，T两个集合，追条删除构成最小生成树的边，然后在

求最小生成树，求其中最大的一颗。

解题思路：

思路来源：http://blog.csdn.net/triple_wdf/article/details/49678471

最笨的想法是先求原图的MST，然后追条删除构成MST的边，在求一次

最下生成树，这样时间复杂度就是N^3，但是这样会超时。看别人的思路，

是用树形DP写的，维护dp[u][v]，代表的是切断u-v这条边后，S集（u所在

的集合）到T集（v所在的集合）的最短距离。

它是这样做的，分别以图中每一个点为根，加入当前根是root,则在最小

生成树的图中进行深搜，假如一条搜索路径为，

root ->v1->v2->v3->u，到u搜索不下去了。

则我们倒着考虑，切断v3-u，这个边，则u单独成一个集合，其他n-1个点是

一个结合，此时考录root到u的距离,dp[v3][u] = min(dp[v3][u],dis(root,u));

这样我们有了root-u的距离。然后考虑切断v2-v3,则v3,u是一个集合了，其他n-2

个点成了一个结合，我们也可以得到root-v3，则两个集合的最短距离是min(root-v3,root-u，dp[v2][v3]).

然后考虑切断v1-v2，则v2,v3,u成了一个集合，其他n-3个点是一个集合,

两个集合的最短距离是min(root-v2,root-v3,root-u,dp[v1][v2])

如果切断root-v1，则v1,v2,v3,u是一个集合，root自己是一个集合，其最短距离是

min(root-v2,root-v3,root-u,dp[v1][v2])，这时因为root-v1是构成最小生成树的边，我们

不能把它考虑进去。按照这个规则，我们以每个节点为根都进行这样的深搜，得到

断掉最小生成树中的边后，两个集合的最短距离，然后暴力枚举删除最小生成树

的边来求解。

AC代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>

using namespace std;

const double INF = 1e9;
const int maxn = 1e6+10;
int N,K;
struct Point
{
    double x,y;
}p[maxn];
struct Edge
{
    int to;
    int nex;
}edge[1002];
double dist(Point p1,Point p2)
{
    double temp = (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);
    return sqrt(temp);
}
double Map[1002][1002];   ///存放图
bool mark[1002][1002];    ///用来标记构成最小生成树的边
double lowcost[1002];     ///记录每个点到最小生成树集合的最短距离
int closest[1002];        ///记录距离某点最近的点是谁
int vis[1002];            ///用来标记某个顶点有没有加入最小生成树
double dp[1002][1002];    ///dp[u][v]代表删除u-v边后，两个集合的最小距离
int head[1002],cnt;       ///head相当于邻接链表头结点，cnt代表边的数量
void addEdge(int u,int v)  ///加边函数，注意是无向图
{
    edge[cnt].to = v;
    edge[cnt].nex = head[u];
    head[u] = cnt++;

    edge[cnt].to = u;
    edge[cnt].nex = head[v];
    head[v] = cnt++;
}
double MST()  ///求最小生成树
{
    memset(mark,false,sizeof(mark));
    for(int i = 1; i <= N; i++)
    {
        lowcost[i] = Map[1][i];
        closest[i] = 1;
        vis[i] = 0;
    }
    lowcost[1] = 0;
    vis[1] = 1;
    double mst = 0,Min;
    int u;
    for(int i = 1; i < N; i++)
    {
        Min = INF;
        u = 0;
        for(int j = 1; j <= N; j++)
        {
            if(vis[j]==0 && lowcost[j]<Min)
            {
                Min = lowcost[j];
                u = j;
            }
        }
        int pre = closest[u];  ///找u的前驱
        vis[u] = 1;            ///u加入最小生成树
        mst += Min;
        mark[pre][u] = mark[u][pre] = true;
        addEdge(pre,u);
        for(int j = 1; j <= N; j++)
        {
            if(vis[j]==0 && Map[u][j] < lowcost[j])
            {
                lowcost[j] = Map[u][j];
                closest[j] = u;
            }
        }
    }
    return mst;
}
double dfs(int root,int u,int father)
{
    double ans = INF;
    for(int i = head[u]; i != -1; i = edge[i].nex)
    {
        int v = edge[i].to;
        if(v != father)
        {
            double temp = dfs(root,v,u);
            dp[u][v] = dp[v][u] = min(dp[u][v],temp);
            ans = min(ans,temp);
        }
    }
    if(root != father)  ///保证u-root不是构成最小生成树的边
        ans = min(ans,Map[u][root]);
    return ans;
}
int main()
{
    int T;
    scanf("%d",&T);   ///T组测试数据
    while(T--)
    {
        memset(head,-1,sizeof(head));   ///head相当于链表头节点
        cnt = 0;                        ///边的数目为0
        scanf("%d%d",&N,&K);            ///N个点，每米线路费用K元
        for(int i = 1; i <= N; i++)     ///输入N个点的坐标
            scanf("%lf%lf",&p[i].x,&p[i].y);
        for(int i = 1; i <= N; i++)     ///建图
        {
            Map[i][i] = 0;
            dp[i][i] = INF;
            for(int j = i+1; j <= N; j++)
            {
                Map[i][j] = Map[j][i] = dist(p[i],p[j]);
                dp[i][j] = dp[j][i] = INF;
            }
        }
        double ans = MST();
        double mst = ans;
        for(int i = 1; i <= N; i++)
            dfs(i,i,-1);
        for(int i = 2; i <= N; i++)
        {
            for(int j = i+1; j <= N; j++)
            {
                if(mark[i][j] == true)  ///是最小生成树的边
                {
                    ans = max(ans,mst-Map[i][j]+dp[i][j]);
                }
            }
        }
        printf("%.2lf\n",ans*K);
    }
    return 0;
}