数据结构基础 — 公路村村通

最新推荐文章于 2022-11-05 19:36:19 发布

酱油瓶被人注册了

最新推荐文章于 2022-11-05 19:36:19 发布

阅读量990

点赞数 1

分类专栏：数据结构基础

本文链接：https://blog.csdn.net/qq_25175067/article/details/80098111

版权

数据结构基础专栏收录该内容

30 篇文章 2 订阅

订阅专栏

我直接在老师给的样例代码上改，因为我觉得老师给的代码真的很好啊，不是么；手把手教你写代码系列 ……(^-^)，顺便让自己多看看优秀代码。

08-图7 公路村村通（30 分）

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数 $N$ （ $\leq 1000$ ）和候选道路数目 $M$ （ $\leq 3 N$ ）；随后的 $M$ 行对应 $M$ 条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到 $N$ 编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出 $-1$ ，表示需要建设更多公路。

输入样例:

输出样例:

//
//  main.cpp
//  MST01
//  Copyright © 2018年 air. All rights reserved.
//
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <algorithm>
typedef int WeightType;
typedef int ElementType;
typedef int SetName;
/*-------------------- 顶点并查集定义 --------------------*/
typedef int Vertex; /* 默认元素可以用非负整数表示 */
typedef int* SetType ; /* 假设集合元素下标从0开始 */
using namespace std;

typedef struct AdjVNode * PtrToAdjVNode;
struct AdjVNode{
    Vertex AdjV;
    WeightType Weight;
    PtrToAdjVNode Next;
};

typedef struct Vnode{
    PtrToAdjVNode FirstEdge;
}AdjList;

typedef struct GNode * ptrToGNode;
struct GNode{
    int Nv;
    int Ne;
    AdjList * G;
};
typedef ptrToGNode LGraph;

struct ENode{
    Vertex V1;
    Vertex V2;
    WeightType Weight;
};
typedef ENode* Edge;

/*-----------------------------定义结束---------------------------------------*/
void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
    ElementType X;
    for ( X=0; X<N; X++ )
        S[X] = -1;
}

void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}

SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}

bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;
    
    Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
    Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */
    
    if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union( VSet, Root1, Root2 );
        return true;
    }
}
/*-------------------- 并查集定义结束 --------------------*/

/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
    /* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
    int Parent, Child;
    struct ENode X;
    
    X = ESet[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
            Child++;  /* Child指向左右子结点的较小者 */
        if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}

void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;
    
    /* 将图的边存入数组ESet */
    ECount = 0;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;
            }
    /* 初始化为最小堆 */
    for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
        PercDown( ESet, ECount, Graph->Ne );
}

void Swap( Edge a, Edge b){
    Edge temp = (Edge)malloc(sizeof(struct ENode));
    *temp = *a;
    *a = *b;
    *b = *temp;
    free(temp);
}

int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */
    
    /* 将最小边与当前堆的最后一个位置的边交换 */
    Swap( &ESet[0], &ESet[CurrentSize-1]);
    /* 将剩下的边继续调整成最小堆 */
    PercDown( ESet, 0, CurrentSize-1 );
    
    return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/

/*-------------------- 邻接表的图定义 --------------------*/
LGraph CreateGraph(Vertex MaxNumber){
    LGraph graph =  (LGraph)malloc(sizeof(struct GNode));
    graph->Nv = MaxNumber;
    graph->Ne = 0;
    graph->G = (AdjList*)malloc(sizeof(AdjVNode)*MaxNumber); /* 有头节点 */
    
    for(Vertex i = 0; i < graph->Nv; i++){
        graph->G[i].FirstEdge = NULL;
    }
    return graph;
}


void InsertEdge(LGraph MST, Edge edge){
    PtrToAdjVNode NewNode;
    /* 为V2建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = edge->V2;
    NewNode->Weight = edge->Weight;
    /* 将V2插入V1的表头 */
    NewNode->Next = MST->G[edge->V1].FirstEdge;
    MST->G[edge->V1].FirstEdge = NewNode;
    
    /* 为V1建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = edge->V1;
    NewNode->Weight = edge->Weight;
    /* 将V1插入V2的表头 */
    NewNode->Next = MST->G[edge->V2].FirstEdge;
    MST->G[edge->V2].FirstEdge = NewNode;
}
/*-------------------图定义结束---------------------------*/
/*-------------------定义test---------------------------*/
void test1(SetType VSet, int N){
    for(Vertex i = 0; i < N; i++)
        cout << VSet[i] << " ";
    cout << endl;
}

void test2(Edge ESet, int N){
    for(int i = 0; i < N; i++)
        cout << ESet[i].V1 << " " << ESet[i].V2 << " " << ESet[i].Weight << endl;
}
/*-------------------test定义结束---------------------------*/
/*--------------------Krustal算法定义 --------------------*/
int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */
    
    VSet = (SetType)malloc(sizeof(ElementType)*(Graph->Nv));
    InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
//    test1(VSet, Graph->Nv);
    
    ESet = (Edge)malloc( sizeof(struct ENode)*(Graph->Ne) );
    InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
//    test2(ESet, Graph->Ne);
    
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 初始化权重和     */
    ECount = 0;      /* 初始化收录的边数 */
    
    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while ( ECount < Graph->Nv-1 ) {  /* 当收集的边不足以构成树时 */
        NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        /* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
        if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
            /* 将该边插入MST */
            InsertEdge( MST, ESet+NextEdge );
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++; /* 生成树中边数加1 */
        }
    }
    if ( ECount < Graph->Nv-1 )
        TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */
    
    return TotalWeight;
}
/*--------------------Krutal算法结束------------------------------------*/

int main(int argc, const char * argv[]) {
    Vertex Nv,Ne;
    Vertex V1,V2;
    WeightType Weight;
    cin >> Nv >> Ne;
    LGraph graph = CreateGraph(Nv);
    LGraph MST;

    for(Vertex i = 0; i < Ne; i++){
        Edge edge = (Edge)malloc(sizeof(ENode));
        cin >> V1 >> V2 >> Weight;
        V1--; V2--;
        edge->V1 = V1;
        edge->V2 = V2;
        edge->Weight = Weight;
        InsertEdge(graph, edge);
        ++graph->Ne;     /* 不要忘了这个 */
    }
    
    int total;
    total = Kruskal(graph, MST);
    cout << total;
    return 0;
}

酱油瓶被人注册了

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
数据结构基础 — 公路村村通

我直接在老师给的样例代码上改，因为我觉得老师给的代码真的很好啊，不是么；手把手教你写代码系列 ……(^-^)，顺便让自己多看看优秀代码。08-图7 公路村村通（30 分）现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。输入格式:输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出...
复制链接

扫一扫