用C++，使用贪心算法，给出两种解决TSP问题的代码

在C++中，使用贪心算法解决旅行商问题(TSP)的一种常见方法是通过克鲁斯卡尔(Kruskal's)算法或弗洛伊德(Floyd-Warshall)算法找到最小生成树，然后取树上的环作为旅行路线。这里以克鲁斯卡尔算法为例，因为它更适合用于近似求解TSP，而不是精确解决方案。

**1. 克鲁斯卡尔算法示例**

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

// 边的数据结构
struct Edge {
    int src, dest, weight;
};

// 使用优先队列存储边
class PriorityQueue {
public:
    // ... (实现插入、删除和查找操作)
};

// 贪心选择最小权重边
void kruskal(int n, std::vector<Edge>& edges) {
    PriorityQueue pq;
    std::vector<int> graph(n, 0);

    for (Edge edge : edges) {
        if (edge.weight < graph[edge.src]) {
            pq.push(edge);
            graph[edge.src] = edge.weight;
        }
    }

    int total_weight = 0;
    int current_city = 0;

    while (pq.size()) {
        Edge next_edge = pq.top();
        pq.pop();

        if (next_edge.dest != current_city) {
            total_weight += next_edge.weight;
            graph[next_edge.dest] = graph[current_city];
            current_city = next_edge.dest;
        }
    }

    std::cout << "Total weight: " << total_weight << std::endl;
}

// 示例调用
int main() {
    // 假设有n个城市，edges存储城市间的距离
    int n = 5;
    std::vector<Edge> edges = { /* 填充城市的边 */ };
    kruskal(n, edges);
    return 0;
}

**2. 弗洛伊德算法示例**
弗洛伊德算法通常用于寻找图中任意两点之间的最短路径，但可以通过构建一个从每个节点到其他所有节点的最短路径矩阵来间接解决TSP问题。该算法会填充一个二维数组，表示两个节点之间的最短路径。

#include <iostream>
#include <vector>

std::vector<std::vector<int>> floydWarshall(std::vector<std::vector<int>>& distances) {
    int n = distances.size();
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (distances[i][j] > distances[i][k] + distances[k][j]) {
                    distances[i][j] = distances[i][k] + distances[k][j];
                }
            }
        }
    }
    return distances;
}

int main() {
    // 假设distances是一个n*n的矩阵，存储城市间距离
    std::vector<std::vector<int>> distances = { /* 初始化矩阵 */ };
    auto shortest_paths = floydWarshall(distances);
    // ... (后续处理最短路径)
    return 0;
}

注意：上述代码仅为基本框架，实际应用时需要根据具体问题调整输入数据和算法细节。在TSP问题中，这些算法可能不直接返回最优解，但可以提供一个好的初始近似方案。