管道铺设施工的最佳方案-----------完整程序代码

1）内容：
需要在某个城市n个居民小区之间铺设煤气管道，则在这n个居民小区之间只需要铺设n-1条管道即可。

假设任意两个小区之间都可以铺设管道，但由于地理环境不同，所需要的费用也不尽相同。

选择最优的方案能使总投资尽可能小，这个问题即为求无向网的最小生成树。

2）要求：
在可能假设的m条管道中，选取n-1条管道，使得既能连通n个小区，又能使总投资最小。

每条管道的费用以网中该边的权值形式给出，网的存储采用邻接表的结构。

3) 测试数据:
使用下图给出的无线网数据作为程序的输入，求出最佳铺设方案。

右侧是给出的参考解。

4）输入输出:
参考
完整代码：
#include "iostream"
#include "stdlib.h"
#define MAX_VERTEX_NUM 20
typedef float WeightType;
typedef struct ArcNode{
i nt adjvex;
W eightType weight;
s truct ArcNode *nextarc;
}ArcNode;
typedef struct VertexNode{
c har data;
A rcNode *firstarc;
}VertexNode,AdjList[MAX_VERTEX_NUM];
typedef struct {
A djList vertices;
i nt vexnum, arcnum;
i nt kind;
}ALGraph;
int LocateVex(ALGraph G, char v)
{
i nt i;
f or (i = 0; i < G.vexnum; i++)
{
if (G.vertices[i].data == v)
return i;
}
r eturn -1;
}
void CreateGraph(ALGraph &G)
{
i nt i, j, k;
c har vi, vj;
W eightType weight;
A rcNode *p,*q;
s td::cout << "请输入顶点个数，边数和图的类型：\n"; s td::cin >> G.vexnum >> G.arcnum >> G.kind;
f or ( i = 0; i < G.vexnum; i++)
{
std::cout << "请输入各个顶点：\n";
std::cin >> G.vertices[i].data;
G.vertices[i].firstarc = NULL;
}
f or ( k = 0; k < G.arcnum; k++)
{
std::cout << "请输入两顶点和其边的权值：\n";
std::cin >> vi >> vj>> weight;
i = LocateVex(G, vi);
j = LocateVex(G, vj);
p = (ArcNode *)malloc(sizeof(ArcNode));
p->adjvex = j;
p->weight = weight;
p->nextarc = G.vertices[i].firstarc;
G.vertices[i].firstarc = p;
if (G.kind == 2)
{
q = (ArcNode*)malloc(sizeof(ArcNode));
q->adjvex = i;
q->weight = p->weight;
q->nextarc = G.vertices[j].firstarc;
G.vertices[j].firstarc = q;
}
}
}
int MinEdge(WeightType lowcost[], int vexmun)
{
i nt i, k;
W eightType j;
k = 0;
w hile (lowcost[k]==0)
{
k++;
}
j = lowcost[k];
f or ( i = k+1; i < vexmun; i++)
{
if (lowcost[i]!=0&&lowcost[i] < j)
{
j=lowcost[i];
k = i;
}
}
r eturn k;
}
void Prim(ALGraph G, int v0, int adjvex[])
{
W eightType lowcost[MAX_VERTEX_NUM];
i nt i, k;
A rcNode *p;
f or ( i = 0; i < G.vexnum; i++)
{
if (i!=v0)
{
lowcost[i] = 999;
adjvex[i] = v0;
}
}
p = G.vertices[v0].firstarc;
w hile (p)
{
lowcost[G, p->adjvex] = p->weight;
p = p->nextarc;
}
l owcost[v0] = 0;
f or ( i = 0; i < G.vexnum; i++)
{
k = MinEdge(lowcost, G.vexnum);
if (k >= G.vexnum)
return;
std::cout << "(" << k << "," << adjvex[k] << ")," << lowcost[k]<<'\n';
lowcost[k] = 0;
p = G.vertices[k].firstarc;
while (p)
{
if (p->weight<lowcost[p->adjvex])
{
adjvex[p->adjvex] = k;
lowcost[p->adjvex] = p->weight;
}
p = p->nextarc;
}
}
}
int main()
{
i nt adjvex[MAX_VERTEX_NUM];
A LGraph G;
G.kind = 2;
C reateGraph(G);
P rim(G, 0, adjvex);
r eturn 0;
}
/*测试数据
9 15 2
A
B
C
D
E
F
G
H
I
A B 32.8
A I 18.2
A H 12.1
A C 44.6
B C 5.9
C D 21.3
C E 41.1
C G 56.4
D E 67.3
D F 98.7
E F 85.6
E G 10.5
H G 52.5
I H 8.7
I F 79.2 */。