08-图7 公路村村通 (30分)

第一个代码:邻接表+Prim

第二个代码:邻接表+Kruskal

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct Edge {
    Edge(const int &a, const int &b, const int &w):
        indexA(a), indexB(b), weight(w) {}

    int indexA;
    int indexB;
    int weight;
};

bool operator<(const Edge &x, const Edge &y) {
    return x.weight > y.weight;
}

class Graph {
public:
    Graph(const int &c);
    ~Graph();
    void insertEdge(const int &a, const int &b, const int &w);
    int PrimMST(const int &index);

private:
    struct Vertex {
        bool isVisited;
        vector<Edge> edgeVec;
    };
    int capacity;
    Vertex *pVertex;
};

inline
Graph::Graph(const int &c):
    capacity(c),
    pVertex(new Vertex[c]()) {}

inline
Graph::~Graph() {
    delete[] pVertex;
}

inline
void Graph::insertEdge(const int &a, const int &b, const int &w) {
    pVertex[a].edgeVec.emplace_back(Edge(a, b, w));
    pVertex[b].edgeVec.emplace_back(Edge(b, a, w));
}

int Graph::PrimMST(const int &index) {
    vector<int> vertexVec;
    vertexVec.reserve(capacity);
    priority_queue<Edge> edgeMinHeap;

    vertexVec.push_back(index);
    pVertex[index].isVisited = true;
    int edgeCnt(0);
    int ret(0);

    while(edgeCnt < capacity - 1) {
        int tmp(vertexVec.back());
        auto end(pVertex[tmp].edgeVec.end());
        for(auto iter(pVertex[tmp].edgeVec.begin()); iter != end; ++iter) {
            if(!pVertex[iter->indexB].isVisited)
                edgeMinHeap.emplace(*iter);
        }

        if(edgeMinHeap.empty()) break;      //没有待选边了。

        Edge minEdge(edgeMinHeap.top());
        edgeMinHeap.pop();
        int next(minEdge.indexB);
        if(!pVertex[next].isVisited) {
            vertexVec.push_back(next);
            pVertex[next].isVisited = true;
            ret += minEdge.weight;
            ++edgeCnt;
        }

    }

    if(edgeCnt == capacity - 1) //所有边已收录。
        return ret;
    else                        //不是连通图。
        return -1;
}


int main(void) {
    int n, m;
    cin >> n >> m;
    Graph g(n);
    int a, b, w;
    for(int i(0); i < m; ++i) {
        cin >> a >> b >> w;
        g.insertEdge(a-1, b-1, w);
    }

    cout << g.PrimMST(0) << endl;

    return 0;
}

用vector<unordered_set...来作为点的集合的集合,不知道相对于vector<vector...的性能如何。

用set点集,只需要判断set里是否有这个点,来确定顶点在哪个集合。

用verctor作为点集,则需要遍历一遍vector(内层的)。

在这两个代码中,用邻接表+Kruskal在最大的N和M上,效率不如邻接表+Prim。

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>
using namespace std;

struct Edge {
    Edge(const int &a, const int &b, const int &w):
        indexA(a), indexB(b), weight(w) {}

    int indexA;
    int indexB;
    int weight;
};

bool operator<(const Edge &x, const Edge &y) {
    return x.weight > y.weight;
}

class Graph {
public:
    Graph(const int &c);
    ~Graph();
    void insertEdge(const int &a, const int &b, const int &w);
    int KruskalMST();

private:
    struct Vertex {
        bool isVisited;
        vector<Edge> edgeVec;
    };
    int capacity;
    Vertex *pVertex;
};

inline
Graph::Graph(const int &c):
    capacity(c),
    pVertex(new Vertex[c]()) {}

inline
Graph::~Graph() {
    delete[] pVertex;
}

inline
void Graph::insertEdge(const int &a, const int &b, const int &w) {
    pVertex[a].edgeVec.emplace_back(Edge(a, b, w));
    pVertex[b].edgeVec.emplace_back(Edge(b, a, w));
}

int Graph::KruskalMST() {
    priority_queue<Edge> edgeMinHeap;
    for(int i(0); i < capacity; ++i) {
        auto iter(pVertex[i].edgeVec.begin());
        auto end(pVertex[i].edgeVec.end());
        for(; iter != end; ++iter) {
            //怎样防止重复收边呢?
            if(iter->indexA < iter->indexB)
                edgeMinHeap.emplace(*iter);
        }
    }

    if((int)edgeMinHeap.size() < capacity - 1) return -1;    //不可能有生成树。

    vector<unordered_set<int>> vertexSets;
    int edgeCnt(0);
    int ret(0);

    while(edgeCnt < capacity-1 && !edgeMinHeap.empty()) {
        Edge minEdge(edgeMinHeap.top());
        edgeMinHeap.pop();

        int indexA(minEdge.indexA);
        int indexB(minEdge.indexB);
        //表示顶点所在集合的索引
        int labelA(-1);
        int labelB(-1);
        //找出顶点所在的集合索引。
        for(unsigned i(0); i < vertexSets.size(); ++i) {
            if(labelA == -1 && vertexSets[i].count(indexA) > 0)
                labelA = i;
            if(labelB == -1 && vertexSets[i].count(indexB) > 0)
                labelB = i;
        }

        if(labelA == -1 && labelB == -1) {
            unordered_set<int> newSet;
            newSet.emplace(indexA);
            newSet.emplace(indexB);
            vertexSets.push_back(newSet);
        }
        else if(labelA == -1 && labelB != -1)
            vertexSets[labelB].emplace(indexA);
        else if(labelA != -1 && labelB == -1)
            vertexSets[labelA].emplace(indexB);
        else if(labelA == labelB)                   //相等且不等于-1,意味着在同一个集合中。舍弃边。
            continue;
        else {
            vertexSets[labelA].insert(vertexSets[labelB].begin(), vertexSets[labelB].end());
            vertexSets.erase(vertexSets.begin() + labelB);
        }

        ++edgeCnt;
        ret += minEdge.weight;
    }

    if(edgeCnt == capacity - 1) return ret;
    else return -1;
}


int main(void) {
    int n, m;
    cin >> n >> m;
    Graph g(n);
    int a, b, w;
    for(int i(0); i < m; ++i) {
        cin >> a >> b >> w;
        g.insertEdge(a-1, b-1, w);
    }

    cout << g.KruskalMST() << endl;

    return 0;
}



### 使用Kruskal算法解决公路村村通问题 #### 背景介绍 公路村村通问题是典型的最小生成树(Minimum Spanning Tree, MST)问题之一。假设存在一组村庄以及连接这些村庄的道路成本矩阵,目标是以最低的成本修建道路使得所有村庄之间能够互相连通。 Kruskal算法是一种经典的用于求解MST的方法[^1]。它的核心思想是从全局角度出发,在不形成环的情况下逐步选择权值最小的边加入生成树中,最终得到一棵总权重最小的生成树[^2]。 --- #### Kruskal算法的具体应用过程 以下是利用Kruskal算法解决公路村村通问题的关键步骤: 1. **输入数据建模** 假设共有 \( n \) 个村庄和 \( m \) 条可能的道路,每条道路具有一定的建设费用作为权重。可以将此问题抽象成一个无向加权 \( G(V, E) \),其中顶点集合 \( V \) 表示村庄,边集合 \( E \) 和对应的权重表示各村庄之间的潜在道路及其建设成本。 2. **初始化并查集 (Union-Find)** 并查集被用来高效检测新选入的边是否会构成回路。初始状态下,每个节点都属于独立的一个子集。每次成功添加一条边时,需执行 `union` 操作来合并两个不同的子集[^3]。 3. **按权重排序所有边** 首先把所有的候选路径依据它们各自的造价从小到大排列好顺序以便后续逐一挑选最优选项。 4. **迭代选取合适的边构建MST** 对于排好序后的每一边依次考察: - 如果这条边两端别位于不同集合里,则将其纳入结果集中,并调用一次 union 合并操作; - 若发现两头已经处于同一组内则跳过该边以免造成循环结构。 5. **终止条件** 当所选出的有效边数达到 \(|V|-1\) 即停止运算流程,此时所得即为满足题目需求的最佳解决方案——也就是所需铺设的所有路段组合起来形成的那棵最小代价生成树。 --- #### Python实现代码示例 下面给出一段基于上述原理编写而成的Python程序片段演示如何运用克鲁斯卡尔方法处理此类实际场景中的最优化决策任务: ```python class UnionFind: def __init__(self, num_nodes): self.parent = list(range(num_nodes)) def find(self, u): if self.parent[u]!=u: self.parent[u]=self.find(self.parent[u]) return self.parent[u] def union(self,u,v): root_u=self.find(u) root_v=self.find(v) if root_u !=root_v : self.parent[root_u ]=root_v def kruskal(edges,nodes_count ): edges.sort(key=lambda edge :edge[2]) uf_set=UnionFind(nodes_count ) result_edges=[] for e in edges: node_a ,node_b,cost=e[:3] set_a=uf_set .find(node_a ) set_b=uf_set .find(node_b ) if(set_a!=set_b ): result_edges.append((node_a,node_b )) uf_set.union(set_a,set_b ) if(len(result_edges)==nodes_count-1 ):break total_cost=sum([e[-1]for e in result_edges ]) return {"edges":result_edges,"total_cost":total_cost} # Example usage with sample data representing villages and roads. villages_and_roads=[ ('A','B',7),('A','D',5), ('B','C',8),('B','D',9), ('C','E',5),('C','F',6), ('D','E',15),('D','G',6), ('E','F',8),('E','H',9), ('F','I',11),('G','H',10)] num_of_villages=len(set(sum(([list(pair[:-1])for pair in villages_and_roads]),[]))) solution=kruskal(villages_and_roads,num_of_villages) print(f"Selected Roads:{solution['edges']}\nTotal Cost={solution['total_cost']}") ``` --- #### 结果解释 运行以上脚本后会输出哪些具体线路应该建造才能达成既定目的同时还保持整体花费最少的效果展示出来的同时也会告知总的预算数额是多少。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值