#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

// 边的结构体
struct Edge {
    int src, dest, weight;

    // 按照权重进行排序
    bool operator<(const Edge& other) const {
        return weight < other.weight;
    }
};

class Graph {
public:
    int V; // 顶点数
    vector<Edge> edges; // 边的集合

    // 构造函数
    Graph(int v) : V(v) {}

    // 添加边
    void addEdge(int src, int dest, int weight) {
        Edge edge = {src, dest, weight};
        edges.push_back(edge);
    }

    // Prim算法实现
    void primMST() {
        vector<int> key(V, INT_MAX); // 用于存储顶点的键值
        vector<int> parent(V, -1);   // 用于存储MST中的父节点
        vector<bool> inMST(V, false); // 用于标记顶点是否在MST中

        // 从第一个顶点开始
        key[0] = 0;

        // 创建最小优先队列
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

        pq.push({0, 0}); // {键值, 顶点}

        while (!pq.empty()) {
            int u = pq.top().second;
            pq.pop();

            inMST[u] = true;

            // 遍历u的邻居
            for (const Edge& edge : edges) {
                int v = (edge.src == u) ? edge.dest : edge.src;
                int weight = edge.weight;

                if (!inMST[v] && weight < key[v]) {
                    key[v] = weight;
                    parent[v] = u;
                    pq.push({key[v], v});
                }
            }
        }

        // 输出MST
        cout << "Prim MST:" << endl;
        for (int i = 1; i < V; ++i)
            cout << parent[i] << " - " << i << endl;
    }

    // Kruskal算法实现
    void kruskalMST() {
        // 对边按照权重进行排序
        sort(edges.begin(), edges.end());

        vector<int> parent(V, -1); // 用于存储每个集合的父节点

        // 查找根节点
        function<int(int)> find = [&](int i) {
            while (parent[i] != -1)
                i = parent[i];
            return i;
        };

        // 合并两个集合
        function<void(int, int)> unionSets = [&](int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            parent[rootX] = rootY;
        };

        // 输出MST
        cout << "Kruskal MST:" << endl;
        for (const Edge& edge : edges) {
            int rootSrc = find(edge.src);
            int rootDest = find(edge.dest);

            // 如果加入这条边不会形成环，则加入MST
            if (rootSrc != rootDest) {
                cout << edge.src << " - " << edge.dest << endl;
                unionSets(rootSrc, rootDest);
            }
        }
    }

    // Dijkstra算法实现
    void dijkstra(int src) {
        // 创建最小优先队列
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

        vector<int> dist(V, INT_MAX); // 用于存储最短路径
        dist[src] = 0;
        pq.push({0, src});

        while (!pq.empty()) {
            int u = pq.top().second;
            pq.pop();

            for (const Edge& edge : edges) {
                if (edge.src == u) {
                    int v = edge.dest;
                    int weight = edge.weight;

                    // 更新最短路径
                    if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
                        dist[v] = dist[u] + weight;
                        pq.push({dist[v], v});
                    }
                }
            }
        }

        // 输出最短路径
        cout << "Dijkstra Shortest Paths from vertex " << src << ":" << endl;
        for (int i = 0; i < V; ++i)
            cout << "To " << i << ": " << dist[i] << endl;
    }

    // Bellman-Ford算法实现
    void bellmanFord(int src) {
        vector<int> dist(V, INT_MAX); // 用于存储最短路径
        dist[src] = 0;

        // 松弛操作
        for (int i = 1; i < V; ++i) {
            for (const Edge& edge : edges) {
                int u = edge.src;
                int v = edge.dest;
                int weight = edge.weight;

                if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                }
            }
        }

        // 检测负权环
        for (const Edge& edge : edges) {
            int u = edge.src;
            int v = edge.dest;
            int weight = edge.weight;

            if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
                cout << "Graph contains negative weight cycle!" << endl;
                return;
            }
        }

        // 输出最短路径
        cout << "Bellman-Ford Shortest Paths from vertex " << src << ":" << endl;
        for (int i = 0; i < V; ++i)
            cout << "To " << i << ": " << dist[i] << endl;
    }

    // Floyd算法实现
    void floydWarshall() {
        vector<vector<int>> dist(V, vector<int>(V, INT_MAX));

        // 初始化邻接矩阵
        for (int i = 0; i < V; ++i)
            dist[i][i] = 0;

        for (const Edge& edge : edges)
            dist[edge.src][edge.dest] = edge.weight;

        // Floyd算法核心
        for (int k = 0; k < V; ++k) {
            for (int i = 0; i < V; ++i) {
                for (int j = 0; j < V; ++j) {
                    if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX &&
                        dist[i][k] + dist[k][j] < dist[i][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                    }
                }
            }
        }

        // 输出最短路径
        cout << "Floyd Shortest Paths:" << endl;
        for (int i = 0; i < V; ++i) {
            for (int j = 0; j < V; ++j) {
                cout << dist[i][j] << "\t";
            }
            cout << endl;
        }
    }
};

int main() {
    Graph g(6);

    // 添加边
    g.addEdge(0, 1, 4);
    g.addEdge(0, 2, 3);
    g.addEdge(1, 2, 1);
    g.addEdge(1, 3, 2);
    g.addEdge(2, 3, 4);
    g.addEdge(3, 4, 2);
    g.addEdge(4, 5, 6);

    // 执行算法
    g.primMST();
    g.kruskalMST();
    g.dijkstra(0);
    g.bellmanFord(0);
    g.floydWarshall();

    return 0;
}