最小生成树

最小生成树

原理

将一张连通图转化为最小生成树，我们需要先将原图中所有边按权值从小到大排序，然后我们依次遍历排好序的各边来创建我们的最小生成树，如果遍历该边时其两端在我们的树中任未连通，则我们将这条边加入我们的树中，否则不进行任何操作。

如何判断树中两点是否连通：我们开个一维数组minimum_connect用于存储与各点连通的最小编号结点(例如a[5] = 2表示当前图中与结点5连通的所有点中编号最小的是2)，每个结点初始连通的最小编号都为其本身。如果两点的最小连通编号不一致则说明两点不连通（每次判断前我们需要对最小连通进行更新）。

如何判断已经更新为最小连通: 假设我们需要判断的结点为i，则我们判断minimum_connect[i]是否等于i，如果等于则已更新为最小连通，否则我们将minimum_connect[i]赋值给i重复操作，直到相等为止(不要忘记用最后找到的最小连通去更新途中的所有minimum_connect[i]，不然复杂度会大大上升)。

代码实现

#include<map>
#include<vector>
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;

// 结点字母对应数字
map<char, int> node_to_num;

struct edge {
    char edge_node_a, edge_node_b;
    int edge_node_a_map, edge_node_b_map;
    int distance;

    void updata(const int dis, const char node_b, const char node_a) {
        cout << node_a << " " << node_b << " " << dis << endl;
        distance = dis;
        edge_node_a_map = node_to_num[edge_node_a = node_a];
        edge_node_b_map = node_to_num[edge_node_b = node_b];
    }

    bool operator < (const edge& t) const {
        return distance < t.distance;
    }

};

// 整数读入
inline int scanf_int() {
    char in;
    int ans = 0;
    bool negative = false;
    in = getchar();
    while(in < '0' || in > '9') {
        in = getchar();
        if(in == '-') {
            in = getchar();
            negative = (in >= '0' && in <= '9');
        } else if(in == EOF) return ans;
    }
    while(true) {
        ans += in - '0';
        in = getchar();
        if(in >= '0' && in <= '9') ans *= 10;
        else return ans;
    }
}

// 更新processing_node的最小连通
int get_minimum_connect(int *minimum_connect, const int processing_node) {
    if(minimum_connect[processing_node] == processing_node) return processing_node;
    return minimum_connect[processing_node] = get_minimum_connect(minimum_connect, minimum_connect[processing_node]);
    // minimum_connect[processing_node] = 千万不要忘记
}

void minimum_spanning_tree(edge edges[], const int nodes_num, const int edges_num) {
    int minimum_connect[nodes_num+1];
    for(int i = 0; i <= nodes_num; i++) minimum_connect[i] = i;
    sort(edges, edges+edges_num);
    for(int i = 0, processing_edge_node_a_connect, processing_edge_node_b_connect; i < edges_num; i++) {
        processing_edge_node_a_connect = minimum_connect[edges[i].edge_node_a_map] = get_minimum_connect(minimum_connect, edges[i].edge_node_a_map);
        processing_edge_node_b_connect = minimum_connect[edges[i].edge_node_b_map] = get_minimum_connect(minimum_connect, edges[i].edge_node_b_map);
        if(processing_edge_node_a_connect != processing_edge_node_b_connect) {
            minimum_connect[max(processing_edge_node_a_connect, processing_edge_node_b_connect)] = min(processing_edge_node_a_connect, processing_edge_node_b_connect);
            cout << edges[i].edge_node_a << edges[i].edge_node_b << setw(4) << edges[i].distance << endl;
        }
    }
}

void work() {
    int nodes_num = scanf_int(), edges_num = scanf_int();
    char num_to_node[nodes_num+1]; // 数字对应结点字母
    for(int i = 1; i <= nodes_num; i++) {
        num_to_node[i] = getchar();
        node_to_num[num_to_node[i]] = i;
    }
    getchar(); //换行
    
    {
        edge edges[edges_num+1];
        int **dis = new int*[nodes_num+1];
        for(int i = 0; i <= nodes_num; i++) dis[i] = new int[nodes_num+1]();
        // int dis[nodes_num+1][nodes_num+1] = {0}; 无法全部初始化为零

        // 读入边
        char ch1, ch2;
        for(int i = 0, ins; i < edges_num; i++) {
            edges[i].updata(scanf_int(), getchar(), getchar());
            // edges[i].updata(getchar(), getchar(), scanf_int()); 函数实参操作既然是从后往前，会出错
            dis[edges[i].edge_node_a_map][edges[i].edge_node_b_map] = dis[edges[i].edge_node_b_map][edges[i].edge_node_a_map] = edges[i].distance;
        }

        // 矩阵输出边
        cout << setw(4) << left << "";
        for(int i = 1; i <= nodes_num; i++) cout << setw(4) << num_to_node[i];
        cout << endl;
        for(int i = 1; i <= nodes_num; i++) {
            cout << setw(4) << num_to_node[i];
            for(int j = 1; j <= nodes_num; j++) {
                if(dis[i][j]) cout << setw(4) << dis[i][j];
                else cout << setw(4) << ((i == j)? "0": "inf"); // 非直接连通输出inf
            }
            cout << endl;
        }

        // 最小生成树
        cout << right;
        minimum_spanning_tree(edges, nodes_num, edges_num);

        // dis数组释放
        for(int i = 0; i <= nodes_num; i++) {
            delete[] dis[i];
            dis[i] = nullptr;
        }
        delete[] dis;
        dis = nullptr;
    }

}

int main() {
    work();
    return 0;
}

/*
样例输入:
5 8
ABCDE
AB 8
AC 4
AE 3
BD 8
BE 6
CD 10
CE 13
DE 12
样例输出:
    A   B   C   D   E
A   0   8   4   inf 3
B   8   0   inf 8   6
C   4   inf 0   10  13
D   inf 8   10  0   12
E   3   6   13  12  0
AE   3
AC   4
BE   6
BD   8
*/
```++