HDU 5723 Abandoned country（最小生成树+DFS）

未已优

于 2020-03-17 16:58:20 发布

阅读量211

点赞数 1

分类专栏：个人题解文章标签： ACM 最小生成树 DFS

本文链接：https://blog.csdn.net/qq_41765114/article/details/104925622

版权

个人题解专栏收录该内容

32 篇文章 0 订阅

订阅专栏

HDU 5723 Abandoned country（最小生成树+DFS）

题面

题意：有 $N$ 个村庄以及 $M$ 条长度为 $W_i$ 的待修道路，保证这些道路可以让所有村庄连通，现在问最少需要修多少长度的道路使得所有村庄连通，在此基础上计算新的图中所有路径长度的期望值。

范围： $\le 100000~,~M \le 1000000~,~W_i \le 1000000$

分析：一共有 $2$ 个问题需要解决，一个是求最小生成树，二是求所有路径长度的期望。

最小生成树就不用说了，这里我使用的是 $K r u s k a l$ 。

那么如何求新图中的路径长度期望值呢？

首先路径长度期望值 = 所有路径长度之和 / 所有路径数量。

那么问题又分成了两个子问题：求所有路径长度之和以及路径数量。

路径数量比较好解决，只需要确定起始点就可以确定一条路径，在 $N$ 个点中选择 $2$ 个点的不重复方案数为 $\frac{N*(N-1)}{2}$ 。

现在需要求所有路径长度之和，直接遍历所有的路径肯定是不可取的，考虑每条边对答案的贡献。

对于 $M S T$ 中的每一条边，都是对所有路径长度之和是有贡献的，假设当前的边为 $E\{u, v\}$ ，长度为 $l e n$ ，那么经过这条边的路径数为两侧子树大小的乘积 $s z 1 * s z 2 * l e n$ ，如图所示。

在这里插入图片描述

那么我们只要计算每条边的贡献，就可以计算出所有路径长度之和了，对于计算子树大小的部分比较简单就不多说了，详见代码。

Code：

#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;

const int MAXN = 1e5 + 10;
const int MAXM = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double PI = acos(-1.0);

int n, m;

inline int read()
{
    int s = 0, w = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            w = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        s = s * 10 + ch - '0', ch = getchar();
    return s * w;
}

vector<int> E[MAXN];

int sz[MAXN];  // sz[i]保存以i为根的子树大小

// 计算u的子树大小
void dfs(int u, int fa)
{
    if (sz[u])  
        return;
    sz[u] = 1;
    for (auto v : E[u])
    {
        if (v == fa)
            continue;
        dfs(v, u);
        sz[u] += sz[v];
    }
}

int F[MAXN]; //并查集使用
struct Edge
{
    int u; //起点
    int v; //终点
    int w; //权值
    int flag;
} edge[MAXM]; //存储边的信息

int tol; //边数，加边前赋值为0

void addEdge(int u, int v, int w)
{
    edge[tol].flag = 0;
    edge[tol].u = u;
    edge[tol].v = v;
    edge[tol++].w = w;
    return;
}

bool cmp(Edge a, Edge b)
{
    //排序函数，将边按照权值从小到大排序
    return a.w < b.w;
}

int find(int x)
{
    if (F[x] == -1)
    {
        return x;
    }
    else
    {
        return F[x] = find(F[x]);
    }
}

int Kruskal(int n) //传入点数，返回最小生成树的权值，如果不连通则返回-1
{
    memset(F, -1, sizeof(F));
    sort(edge, edge + tol, cmp);
    int cnt = 0; //计算加入的边数
    int ans = 0;
    for (int i = 0; i < tol; i++)
    {
        int u = edge[i].u;
        int v = edge[i].v;
        int w = edge[i].w;
        int tOne = find(u);
        int tTwo = find(v);
        if (tOne != tTwo)
        {
            // 标记这条边属于MST
            edge[i].flag = 1;
            E[u].push_back(v);
            E[v].push_back(u);
            ans += w;
            F[tOne] = tTwo;
            cnt++;
        }
        if (cnt == n - 1)
        {
            break;
        }
    }
    if (cnt < n - 1)
    {
        return -1; //不连通
    }
    else
    {
        return ans;
    }
}

signed main()
{
    int T = read();
    while (T--)
    {
        // 清空数组
        memset(sz, 0, sizeof(sz));
        n = read(), m = read();
        if (n == 1 && m == 0)
        {
            cout << "0 0.00" << endl;
            continue;
        }
        for (int i = 0; i <= n; i++)
            E[i].clear();
        tol = 0;
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            u = read(), v = read(), w = read();
            addEdge(u, v, w);
        }
        // 计算最小生成树
        int minCost = Kruskal(n);
        // 处理子树大小
        dfs(1, -1);
        double ans = 0;
        for (int i = 0; i < m; i++)
        {
            // 不在MST中的边跳过
            if (!edge[i].flag)
                continue;
            int sz1 = sz[edge[i].u], sz2 = sz[edge[i].v], len = edge[i].w;
            // 处理出两侧子树大小
            if (sz1 > sz2)
            {
                sz1 = n - sz2;
            }
            else
            {
                sz2 = n - sz1;
            }
            // 统计对答案的贡献
            ans += sz1 * sz2 * len;
        }
        // 求出期望
        ans = ans / (n * (n - 1) / 2.0);
        cout << minCost << " ";
        cout << fixed << setprecision(2) << ans << endl;
    }
    return 0;
}