HDU 4756 树形DP + prim

树形DP + prim

题意：

​ 有n个寝室，现在准备安装空调，但是线路比较老化，需要安装新的线路，每米的线路花费为m，给出n个寝的坐标，求出需要的最小花费，但是现在有一个问题，就是求出的最短的路径和其中有一条是不可以用的，但是也不知道是哪一条，但是与第一个寝室相连的路径可以用，为了确保安装进行至少需要多少钱？：

思路：

​ 转化一下问题，求出最小生成树之后，除了与第一个节点相连接的路径，其它都有可能需要替换，所以问题就是求出其余路径被替换之后的最小生成树的最大值，这样才能确保空调可以安全安装。

那么这道题就很好办了：

1. prim求出最小生成树
2. 找出每一条路径的替换路径
3. 遍历找出答案

• 注意树形DP的目的是什么，结合dfs的特性可以获得答案，此题与HDU 4126 基本相同

#include <iostream>
#include <cstdio>
#include <cstring>
#include <math.h>

using namespace std;

const int maxn = 1010;
const int inf = 0x3f3f3f3f;

int n,m;
double mst,ans;
double map[maxn][maxn],dis[maxn],dp[maxn][maxn];
int pre[maxn],vis[maxn];
int flag[maxn][maxn];

struct Coor
{
    int x,y;
}coor[maxn];

struct Node
{
    int e,next;
}edge[maxn*2];
int head[maxn],pos;

double Dis(int x1,int y1,int x2,int y2)
{
    return sqrt(1.0*(x1-x2)*(x1-x2) + 1.0*(y1-y2)*(y1-y2));
}

void inputAndinit()
{
    pos = 0;
    for(int i = 0;i < n; i++) 
        scanf("%d%d",&coor[i].x,&coor[i].y);
    for(int i = 0;i < n; i++) {
        head[i] = -1;
        for(int j = i;j < n; j++) {
            dp[i][j] = dp[j][i] = inf;
            flag[i][j] = flag[j][i] = 0;
            if(i == j) map[i][i] = 0;
            else 
                map[i][j] = map[j][i] = Dis(coor[i].x,coor[i].y,coor[j].x,coor[j].y);
        }
    }
}

void prim()
{
    for(int i = 0;i < n; i++) {
        pre[i] = 0;
        vis[i] = 0;
        dis[i] = map[0][i];
    }
    dis[0] = inf;       //不可缺少
    pre[0] = -1;
    vis[0] = true;
    mst = 0;
    for(int i = 0;i < n-1; i++) {
        int k = 0;
        for(int j = 0;j < n; j++) {
            if(!vis[j] && dis[k] > dis[j])
                k = j;
        }
        mst += dis[k];
        vis[k] = true;
        if(pre[k] != -1) {
            edge[pos].e = k;
            edge[pos].next = head[pre[k]];
            head[pre[k]] = pos++;
            edge[pos].e = pre[k];
            edge[pos].next = head[k];
            head[k] = pos++;

            flag[k][pre[k]] = flag[pre[k]][k] = true;
        }
        for(int j = 0;j < n; j++) {
            if(!vis[j] && dis[j] > map[k][j]) {
                dis[j] = map[k][j];
                pre[j] = k;
            }
        }
    }
}

double dfs(int pos,int u,int fa)
{
    double ans = inf;
    for(int i = head[u];i != -1; i = edge[i].next) {
        int to = edge[i].e;
        if(to == fa) continue;
        double temp = dfs(pos,to,u);
        dp[u][to] = dp[to][u] = min(dp[u][to],temp);
        ans = min(ans,temp);
    }
    if(pos != fa) ans = min(ans,map[pos][u]);
    return ans;
}

void solve()
{
    for(int i = 0;i < n; i++) {
        dfs(i,i,-1);
    }
}

void output()
{
    double ans = mst;
    for(int i = 1;i < n; i++) {
        for(int j = i+1;j < n; j++) {
            if(flag[i][j]) {
                ans = max(ans,mst - map[i][j] + dp[i][j]);
            }
        }
    }
    printf("%.2f\n",ans*m);
}

int main(int argc, char const *argv[])
{
    //freopen("in.txt","r",stdin);

    int tt;
    scanf("%d",&tt);
    while(tt--) {
        scanf("%d%d",&n,&m);
        inputAndinit();
        prim();
        solve();
        output();
    }

    return 0;
}