P1364 医院设置 题解

题目传送门

一、二叉树+bfs解法

#include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> PII;

const int N = 210;
bool st[N];               //是不是走过了
int n, ans = 0x3f3f3f3f;
struct Node {
    int left;        //左儿子
    int right;       //右儿子
    int value;       //此结点的人数
    int parent;      //父亲是哪结点
} nodes[N];

//广度优先搜索
int bfs(int u) {
    //既然是bfs,当然需要把根结点先入队列
    queue<PII> q;
    q.push({u, 0});
    //以u为源点的路径权值和
    int sum = 0;
    //开始广度优先搜索
    while (!q.empty()) {
        PII c = q.front();
        q.pop();
        //自己产生的权值
        sum += c.second * nodes[c.first].value;
        //标识已使用
        st[c.first] = true;
        //左子树
        if (nodes[c.first].left && !st[nodes[c.first].left]) q.push({nodes[c.first].left, c.second + 1});
        //右子树
        if (nodes[c.first].right && !st[nodes[c.first].right]) q.push({nodes[c.first].right, c.second + 1});
        //父子树
        if (nodes[c.first].parent && !st[nodes[c.first].parent]) q.push({nodes[c.first].parent, c.second + 1});
    }
    return sum;
}

int main() {
    //读入数据
    cin >> n;
    for (int i = 1; i <= n; i++) {
        //读入权值，左儿子，右儿子
        cin >> nodes[i].value >> nodes[i].left >> nodes[i].right;
        //记录左右儿子的父亲节点
        nodes[nodes[i].left].parent = i; //为了找到父亲
        nodes[nodes[i].right].parent = i;//为了找到父亲
    }
    //遍历每个结点作为医院部署地
    for (int i = 1; i <= n; i++) {
        //每次出发前，注意要清空状态数组，防止状态记录错误
        memset(st, 0, sizeof st);
        //每个结点作为医院部署地，都会产生一个距离和，取最小值
        ans = min(ans, bfs(i));
    }
    cout << ans << endl;
    return 0;
}

二、二叉树+dfs解法

#include <bits/stdc++.h>

using namespace std;
const int N = 210;
bool st[N];               //是不是走过了
int n, ans = 0x3f3f3f3f;
struct Node {
    int num;         //几号结点
    int left;        //左儿子
    int right;       //右儿子
    int value;       //此结点的人数
    int parent;      //父亲是哪结点
} nodes[N];


/**
 * 功能：计算以u为起点，step步数下的权值
 * @param u
 * @param step
 * @return
 */
int dfs(int u, int step) {
    //不加st数组的话，会Memory Limit Exceed 超出内存限制
    //如果不加st数组的话，就会发生：它调了它的父亲，它的父亲又调了它，来来回回，不死不休~,这样看来，状态数组是多么的重要啊~

    //问题1：什么时间退出递归？nodes[u].num==0表示找到了一个终端结点，就是叶子
    if (nodes[u].num == 0 || st[u] == true) return 0;
    //标识为已使用过
    st[u] = true;
    //问题2：如何计算整体的权值
    //这里就是个深度优先搜索，三个侦察兵，左子树，右子树，父子树的距离和.
    //分别对三个方向的侦查兵说：以你为根的子树，距离我step+1这么远，你负责统计一下你子树的距离和！
    //[u,step]的权值=dfs(左儿子)+dfs(右儿子)+自己的权值+dfs(父亲)
    return dfs(nodes[u].left, step + 1) + dfs(nodes[u].right, step + 1) +
           dfs(nodes[u].parent, step + 1) + nodes[u].value * step;
}

int main() {
    //读入数据
    cin >> n;
    for (int i = 1; i <= n; i++) {
        //读入权值，左儿子，右儿子
        cin >> nodes[i].value >> nodes[i].left >> nodes[i].right;
        //记录结点号
        nodes[i].num = i;
        //记录左右儿子的父亲节点
        nodes[nodes[i].left].parent = i; //为了找到父亲
        nodes[nodes[i].right].parent = i;//为了找到父亲
    }
    //遍历每个结点作为医院部署地
    for (int i = 1; i <= n; i++) {
        //每次出发前，注意要清空状态数组，防止状态记录错误
        memset(st, 0, sizeof st);
        //每个结点作为医院部署地，都会产生一个距离和，取最小值
        ans = min(ans, dfs(i, 0));
    }
    cout << ans << endl;
    return 0;
}

三、邻接矩阵+bfs解法

#include <bits/stdc++.h>

using namespace std;
const int N = 210;
bool d[N][N];            //这里n小我就直接邻接矩阵了，如果用邻接表还能快点
bool st[N];               //是不是使用过了,这个是必须要有了，否则不就死循环了吗
int p[N];                //权值数组
int n;                   //n个医院
int ans = 0x3f3f3f3f;    //答案

struct Node {
    int num; //几号结点
    int step;//到这个结点走了多少步了
};

//bfs找当前点x为医院设置点时的总距离
int bfs(int x) {
    //每次计算前需要清空一下使用过的标识数组
    memset(st, 0, sizeof(st));

    //队列
    queue<Node> q;
    st[x] = true; //使用过了
    q.push({x, 0});//放入队列

    int sum = 0;//本次运算的权值和

    while (!q.empty()) {
        Node node = q.front();
        q.pop();
        for (int i = 1; i <= n; i++)
            //如果两个结点之间是联通的，并且没有走过
            if (d[node.num][i] && !st[i]) {
                //准备继续探索
                Node next = {i, node.step + 1};
                sum += p[i] * next.step;    //权值在增加
                st[i] = true;               //标识使用过了
                q.push(next);               //放入队列
            }
    }
    return sum;
}

int main() {
    //读入数据到邻接矩阵
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int l, r;
        cin >> p[i] >> l >> r;
        if (l) d[i][l] = d[l][i] = true;//为0表示无链接,双向建图
        if (r) d[i][r] = d[r][i] = true;//为0表示无链接,双向建图
    }
    //遍历每个结点作为医院部署地
    for (int i = 1; i <= n; i++) ans = min(ans, bfs(i));
    cout << ans << endl;
    return 0;
}

四、邻接矩阵+floyd解法

#include <bits/stdc++.h>

using namespace std;

const int N = 210;
const int INF = 0x3f3f3f3f;
int minn = INF;
int n, m, k;
int d[N][N]; //邻接矩阵存储
int p[N];

// 算法结束后，d[a][b]表示a到b的最短距离,k->i->j
void floyd() {
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}


int main() {
    cin >> n;
    //floyd初始化
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

    //读入数据
    for (int i = 1; i <= n; i++) {
        int a, b;
        cin >> p[i] >> a >> b;
        if (a) d[a][i] = d[i][a] = 1;
        if (b) d[b][i] = d[i][b] = 1;
    }
    //弗洛依德算法
    floyd();

    //模拟
    for (int i = 1; i <= n; i++) {//模拟1-n的每一个结点，尝试将医院放在这里
        int s = 0; //看看取得的”所有居民所走的路程之和“是多少，取最小值
        for (int j = 1; j <= n; j++) s += d[i][j] * p[j];
        //取最小值
        minn = min(minn, s);
    }
    cout << minn << endl;
    return 0;
}