邻接表存储最小生成树:
关于定义无穷为0x3f3f3f3f的原因,点击这里!
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 1010
using namespace std;
int dist[MAX];
int parent[MAX];
typedef struct ENode
{
int V1, V2;
int Weight;
}*Edge;
typedef struct GNode
{
int Vertex_num;
int EdgeNum;
int G[MAX][MAX];
}*Graph;
struct AdjNode
{
int Adj;
AdjNode *Next;
int Weight;
};
typedef struct VNode
{
AdjNode *First;
int Data;
}*AdjList[MAX];
typedef struct LGNode
{
int Vertex_num;
int EdgeNum;
AdjList G;
}*LGraph;
Graph InitGraph(int VertexNum)
{
Graph G =(Graph)malloc(sizeof(GNode));
G->Vertex_num = VertexNum;
G->EdgeNum = 0;
memset(G->G, 0x3f, sizeof(G->G));
return G;
}
LGraph InitLGraph(int VertexNum)
{
LGraph G;
G = (LGraph)malloc(sizeof(LGNode));
G->Vertex_num = VertexNum;
G->EdgeNum = 0;
for(int i = 0; i < G->Vertex_num; i++)
G->G[i]->First = NULL;
return G;
}
void InsertLGEdge(LGraph G, Edge E)
{
AdjNode *NewNode;
NewNode = (AdjNode*)malloc(sizeof(AdjNode));
NewNode->Adj = E->V2;
NewNode->Weight = E->Weight;
NewNode->Next = G->G[E->V1]->First;
G->G[E->V1]->First = NewNode;
}
void InsertGEdge(Graph G, Edge E)
{
G->G[E->V1][E->V2] = E->Weight;
G->G[E->V2][E->V1] = E->Weight;
}
Graph BuildGraph()
{
Graph G;
Edge E;
int VertexNum;
cin >> VertexNum;
G = InitGraph(VertexNum);
cin >> G->EdgeNum;
if(G->EdgeNum == 0) return G;
E = (Edge)malloc(sizeof(ENode));
for(int i = 0; i < G->EdgeNum; i++)
{
cin >> E->V1 >> E->V2 >> E->Weight;
InsertGEdge(G, E);
}
return G;
}
LGraph BuildLGraph(int VertexNum)
{
LGraph G;
Edge E;
G = InitLGraph(VertexNum);
cin >> G->EdgeNum;
if(G->EdgeNum == 0) return G;
E = (Edge)malloc(sizeof(ENode));
for(int i = 0; i < G->EdgeNum; i++)
{
cin >> E->V1 >> E->V2 >> E->Weight;
InsertLGEdge(G, E);
}
return G;
}
int FindMinDist(Graph G)
{
int MinDist = INF, MinV = -1;
for(int V = 0; V < G->Vertex_num; V++)
{
if(dist[V] != 0 && dist[V] < MinDist)
{
MinDist = dist[V];
MinV = V;
}
}
return MinV;
}
int Prim(Graph G, LGraph MST, int S)
{
int V;
int VNum = 0;
int TotalWeight = 0;
Edge E;
for(int i = 0; i < G->Vertex_num; i++)
{
dist[i] = G->G[S][i];
parent[i] = S;
}
E = (Edge)malloc(sizeof(ENode));
MST = (LGraph)malloc(sizeof(LGNode));
MST = BuildLGraph(G->Vertex_num);
dist[S] = 0;
VNum++;
parent[S] = -1;
while(1)
{
V = FindMinDist(G);
if(V == -1) break;
E->V1 = parent[V];
E->V2 = V;
E->Weight = dist[V];
InsertLGEdge(MST, E);
TotalWeight += dist[V];
dist[V] = 0;
VNum++;
for(int W = 0; W < G->Vertex_num; W++)
{
if(dist[W] != 0 && G->G[V][W] < INF)
{
if(G->G[V][W] < dist[W])
{
dist[W] = G->G[V][W];
parent[W] = V;
}
}
}
}
if(VNum < G->Vertex_num) TotalWeight = -1;
return TotalWeight;
}
int main()
{
return 0;
}