图

//Prim
void Prim(int v){
	int adjvex[maxsize],lowcoast[maxsize];
	for(int i=0;i<vertexnum;i++){
		lowcoast[i]=edge[v][i];
		adjvex[i]=v;
	}
	lowcoast[v]=0;
	for(int j=1;j<vertexnum;i++){
		int k=MIN(lowcoast,vertexnum);
		cout<<k<<adjvvex[k]<<lowcoast[k]<<endl;
		for(int i=0;i<vertexnum;i++){
			if(lowcoast[i]>edge[k][i]){
				lowcoast[i]=edge[k][i];
				adjvex[i]=k;
			}
		}
	}
}
int MIN(int a[],int n){
	int temp=100,sign=0;
	for(int i=0;i<n;i++){
		if(lowcoast[i]<temp){
			temp=lowcoast[i];
			sign=i;
		}
	}
	return i;
}
//Kruskal
struct edge{
	int from,to,weight;
};
void Kruskal(){
	int vex1,vex2;
	int parent[maxsize];
	for(int i=0;i<vertexnum;i++){
		parent[i]=-1;
	}
	for(int num=0,i=0;num<vertexnum-1;i++){
		vex1=FindRoot(parent,edge[i].from);
		vex2=FindRoot(parent,edge[i].to);
		if(vex1!=vex2){
			cout<<"("<<edge[i].from<<","<<edge[i].to<<")"<<edge[i].weight;
			parent[vex2]=vex1;
			num++;
		}
	}
}
int FindRoot(int parent[],int v){
	int t=v;
	while(parent[t]>-1){
		t=parnet[t];
	}
	return t;
}
//Dijkstra  最短路径
void Dijkstra(int v){
	int dist[maxsize];
	string path[maxsize];
	for(int i=0;i<vertexnum;i++){
		dist[i]=edge[v][i];
		if(dist[i]!=100){
			path[i]=vertex[v]+vertex[i];
		}else{
			path[i]="";
		}
	}
	
	for(int num=1;num<vertexnum;num++){
		k=MIN(dist,vertexnum);
		cout<<path[k]<<dist[k];
		for(int i=0;i<vertexnum;i++){
			if(dist[i]>dist[k]+edge[k][i]){
				dist[i]>dist[k]+edge[k][i];
				path[i]=path[k]+vertex[i];
			}
		}
		dist[k]=0;
	}
}
int MIN(int a[],int n){
	int a=0,b=100;
	for(int i=0;i<n;i++){
		if(a[i]!=0&&a[i]<b){
			b=a[i];
			a=i;
		}
	}
	return a;
}
//Floyd
void Floyd{
	int dist[maxsize][maxsize];
	string path[maxsize][maxsize];
	for(int i=0;i<vertexnum;i++){
		for(int j=0;j<vertexnum;j++){
			dist[i][j]=edge[i][j];
			if(dist[i][j]!=100){
				path[i][j]=vertex[i]+vertex[j];
			}else{
				path[i][j]="";
			}
		}
	}
	for(int k=0;k<vertexnum;k++){
		for(int i=0;i<vertexnum;i++){
			for(int j=0;j<vertexnum;j++){
				if(dist[i][j]>dist[i][k]+dist[k][j]){
					dist[i][j]=dist[i][k]+dist[k][j];
					path[i][j]=path[i][k]+path[k][j];
				}
			}
		}
	}

}
//拓扑排序
srtuct EdgeNode{
	int adjvex;
	EdgeNode*next;
}
template<typename T>
struct VertexNode{
	T vertex;
	int in;
	EdgeNode*firstEdge;
}
void TopSort(){
	EdgeNode*p=nullptr;
	int S[maxsize],num=0,top=-1;
	for(int i=0;i<vertexnum;i++){
		if(adjlist[i].in==0){
			top[++p]=i;
		}
	}
	while(top!=-1){
		j=S[top--];
		cout<<adjlist[j].vertex;count++;
		p=adjlist[j].firstedge;
		while(p!=nullptr){
			k=p->adjvex;
			adjlist[k].in--;
			if(adjlist[k].in==0){
				S[++top]=k;
			}
			p=p->next;
		}

	}
	if(count<vertexnum)
		cout<<"youhuilu";
}