#include <bits/stdc++.h>
using namespace std;
typedef char VertexType;
typedef struct EdgeNode{
int adjvex;
int weight;
struct EdgeNode *nextedge;
}EdgeNode;
typedef struct VNode{
VertexType data;
int visited;
struct EdgeNode *firstedge;
}VNode;
struct ALGraphStruct;
typedef struct ALGraphStruct *ALGraph;
struct ALGraphStruct{
VNode vexs[1000];
int vertexnum;
int edgenum;
};
//创建邻接表
ALGraph CreateALGraph()
{
ALGraph g=(ALGraph)malloc(sizeof(struct ALGraphStruct));
g->vertexnum=0;
g->edgenum=0;
return g;
}
//查找顶点位置
int Locates(ALGraph g,VertexType v)
{
for(int i=0;i<g->vertexnum;i++)
if(g->vexs[i].data==v)
return i;
return -1;
}
//增加顶点
void AddVertex(ALGraph g,VertexType v)
{
int k=Locates(g,v);
if(k!=-1)
return ;
int n=g->vertexnum;
g->vertexnum++;
g->vexs[n].data=v;
g->vexs[n].visited=0;
g->vexs[n].firstedge=NULL;
}
//查找边
EdgeNode *FindEdge(ALGraph g,int i,int j)
{
for(EdgeNode *p=g->vexs[i].firstedge;p!=NULL;p=p->nextedge)
if(p->adjvex==j)
return p;
return NULL;
}
//插入边
void InsertEdge(ALGraph g,int i,int j,int w)
{
EdgeNode *s=(EdgeNode*)malloc(sizeof(struct EdgeNode));
s->adjvex=i;
s->weight=w;
s->nextedge=g->vexs[j].firstedge;
g->vexs[j].firstedge=s;
}
//增加边
void AddEdge(ALGraph g,VertexType v1,VertexType v2,int w)
{
EdgeNode *s,*t;
int i=Locates(g,v1);
int j=Locates(g,v2);
if(i==-1 || j==-1)
return ;
s=FindEdge(g,i,j);
if(s!=NULL){
t=FindEdge(g,j,i);
if(s->weight>w){
s->weight=w;
t->weight=w;
}
return;
}
InsertEdge(g,i,j,w);
InsertEdge(g,j,i,w);
g->edgenum++;
}
//第一个邻接点
int FirstEdge(ALGraph g,int i)
{
EdgeNode *p=g->vexs[i].firstedge;
if(p!=NULL)
return p->adjvex;
return -1;
}
//下一个邻接点
int NextEdge(ALGraph g,int i,int j)
{
EdgeNode *p=FindEdge(g,i,j);
if(p==NULL)
return -1;
p=p->nextedge;
if(p==NULL)
return -1;
return p->adjvex;
}
//邻接表的初始化
void ALGraphInit(ALGraph g)
{
int n,m,w;
char v,x,y;
scanf("%d%d",&n,&m);
getchar();
for(int i=0;i<n;i++){
v=getchar();
AddVertex(g,v);
}
for(int j=0;j<m;j++){
getchar();
x=getchar();
y=getchar();
w=getchar();
AddEdge(g,x,y,w);
}
for(int k=0;k<n;k++)
g->vexs[k].visited=1;
}
//最小生成树之kruskal算法
typedef struct{
int start;
int end;
int weight;
}Edge;
void SwapEdge(Edge e[],int i,int j)
{
Edge t;
t=e[i];
e[i]=e[j];
e[j]=t;
}
int SortEdge(ALGraph g,Edge e[])
{
int m=0;
for(int i=0;i<g->vertexnum;i++){
for(EdgeNode *p=g->vexs[i].firstedge;p!=NULL;p=p->nextedge){
e[m].start=i;
e[m].end=p->adjvex;
e[m].weight=p->weight;
m++;
}
}
for(int i=0;i<g->vertexnum;i++){
for(int j=i+1;j<g->vertexnum;j++){
if(e[i].weight>e[j].weight)
SwapEdge(e,i,j);
}
}
return m;
}
int Root(int set[],int x)
{
while(set[x]!=x)
x=set[x];
return x;
}
void Union(int set[],int x,int y)
{
x=Root(set,x);
y=Root(set,y);
set[x]=y;
}
int FindMinEdge(Edge e[],int m,int set[],int k)
{
int x,y;
for(int i=k+1;i<m;i++){
x=e[i].start;
y=e[i].end;
if(Root(set,x)!=Root(set,y))
return i;
}
return -1;
}
void InitSet(int set[],int n)
{
for(int i=0;i<n;i++)
set[i]=i;
}
int kruskal(ALGraph g,ALGraph t)
{
int lowcost=0;
Edge e[1000];
int set[1000];
InitSet(set,g->vertexnum);
int m=SortEdge(g,e);
int count=0;
int k=-1;
char v1,v2;
while(1){
k=FindMinEdge(e,m,set,k);
if(k==-1)
return -1;
lowcost+=e[k].weight;
v1=g->vexs[e[k].start].data;
v2=g->vexs[e[k].end].data;
Union(set,e[k].start,e[k].end);
AddVertex(t,v1);
AddVertex(t,v2);
AddEdge(t,v1,v2,e[k].weight);
count++;
if(count==g->vertexnum-1)
return lowcost;
}
return -1;
}
int main()
{
return 0;
}