P1364 医院设置【BFS+Floyed算法】

医院设置

题目描述

设有一棵二叉树，如图：

其中，圈中的数字表示结点中居民的人口。圈边上数字表示结点编号，现在要求在某个结点上建立一个医院，使所有居民所走的路程之和为最小，同时约定，相邻接点之间的距离为 $1$。如上图中，若医院建在 $1$ 处，则距离和 $=4+12+2\times 20+2\times 40=136$；若医院建在 $3$ 处，则距离和 $=4\times 2+13+20+40=81$。

输入格式

第一行一个整数 $n$，表示树的结点数。

接下来的 $n$ 行每行描述了一个结点的状况，包含三个整数 $w,u,v$，其中 $w$ 为居民人口数，$u$ 为左链接（为 $0$ 表示无链接），$v$ 为右链接（为 $0$ 表示无链接）。

输出格式

一个整数，表示最小距离和。

样例 #1

样例输入 #1

5						
13 2 3
4 0 0
12 4 5
20 0 0
40 0 0

样例输出 #1

81

提示

数据规模与约定

对于 $100\%$ 的数据，保证 $1\le n\le 100$，$0\le u,v\le n$，$1\le w\le 10^5$。

问题链接： P1364 医院设置
问题分析： 计算图的最短距离，可以用BFS来解决。这个题也可以用Floyd-Warshall算法来解决。
参考链接： （略）
题记： （略）

AC的C++语言程序如下：

/* P1364 医院设置 */

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>

using namespace std;

const int N = 100 + 1;
int g[N][N], w[N];
bool vis[N];
int n;

struct Node {
    int u, step;
};

int bfs(int u)
{
    memset(vis, false, sizeof vis);
    queue<Node> q;
    vis[u] = 1;
    q.push({u, 0});
    int sum = 0;
    while (!q.empty()){
        Node t = q.front();
        q.pop();
        for (int i = 1; i <= n; i++)
            if (g[t.u][i] && vis[i] == false) {
                Node next = {i, t.step + 1};
                sum += w[i] * next.step;
                vis[i] = 1;
                q.push(next);
            }
    }
    return sum;
}

int main()
{
    memset(g, 0, sizeof g);
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int u, v;
        cin >> w[i] >> u >> v;
        if (u) g[i][u] = g[u][i] = 1;
        if (v) g[i][v] = g[v][i] = 1;
    }
    int ans = 1 << 30;
    for (int i = 1; i <= n; i++)
        ans = min(ans, bfs(i));
    cout << ans;
    return 0;
}

AC的C++语言程序如下：

/* P1364 医院设置 */

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

/* Floyd-Warshall算法：计算图中任意2点之间的最短距离
 * 复杂度：O(N×N×N)
 * 输入：n 全局变量，图结点数
 *      g 全局变量，邻接矩阵，g[i][j]表示结点i到j间的边距离
 * 输出：g 全局变量
 */
const int INF = 0x3F3F3F3F;
const int N = 100 + 1;
int n, g[N][N];
void floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            if (i != k)
                for(int j = 1; j <= n; j++)
                    if (j != k && j != i)
                        g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}

int w[N];

int main()
{
    memset(g, INF, sizeof g);
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int u, v;
        cin >> w[i] >> u >> v;
        if (u > 0) g[i][u] = g[u][i] = 1;
        if (v > 0) g[i][v] = g[v][i] = 1;
        g[i][i] = 0;
    }
    floyd();
    int ans = 0x7FFFFFFF;
    for (int i = 1; i <= n; i++) {
        int tot = 0;
        for (int j = 1; j <= n; j++)
            tot += g[i][j] * w[j];
        ans = min(ans, tot);
    }
    cout << ans;
    return 0;
}