swust oj 1075: 求最小生成树(Prim算法）

#include <iostream> 
using namespace std;

typedef struct
{
	int n;
	int e;
	char data[500];
	int edge[500][500];
}Graph;

typedef struct
{
	int index;
	int cost;
}mincost;

typedef struct
{
	int x;//起点
	int y;//终点
	int weight;//权重
}EDGE;


typedef struct
{
	int index;
	int flag;
}F;

void create(Graph& G, int n, int e)
{
	int i, j, k, w;
	char a, b;
	for (i = 0; i < n; i++)
		cin >> G.data[i];
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
		{
			if (i == j)
				G.edge[i][j] = 0;
			else
				G.edge[i][j] = 100;
		}

	for (k = 0; k < e; k++)
	{
		cin >> a;
		cin >> b;
		cin >> w;
		for (i = 0; i < n; i++)
			if (G.data[i] == a) break;
		for (j = 0; j < n; j++)
			if (G.data[j] == b) break;

		G.edge[i][j] = w;
		G.edge[j][i] = w;
	}
	G.n = n;
	G.e = e;
}

EDGE* initedge(Graph* G, int index)//边集
{
	EDGE* Edge = new EDGE[G->n];
	for (int i = 0; i < G->n; i++)
	{
		Edge[i].x = index;
		Edge[i].y = i;
		Edge[i].weight = G->edge[index][i];
	}
	return Edge;
}

int getmin(EDGE* Edge, Graph* G)
{
	int min = 100;
	int index;
	for (int i = 0; i < G->n; i++)
	{
		if (Edge[i].weight && Edge[i].weight < min)
		{
			min = Edge[i].weight;
			index = i;
		}
	}
	return index;
}
void Prim(Graph& G, int k)
{
	EDGE* Edge = initedge(&G, k);
	for (int i = 0; i < G.n-1; i++)
	{
		int min = getmin(Edge, &G);
		cout << '(' << G.data[Edge[min].x] << ',' << G.data[Edge[min].y] << ')';
		Edge[min].weight = 0;
		for (int j = 0; j < G.n; j++)
		{
			if (G.edge[min][j] < Edge[j].weight)
			{
				Edge[j].weight = G.edge[min][j];
				Edge[j].x = min;
			}
		}
	}
}

int main()
{
	Graph my;
	int n, e;
	cin >> n >> e;
	create(my, n, e);
	Prim(my, 0);
	return 0;
}