图6

六、给定一个无向图，图中边的权重都是1，利用BFS求图中两个顶点之间的最短距离。

1.用邻接矩阵表示一个图，定义一个邻接矩阵的结构graph.

2.定义一个函数int dis(graph g,int x,int y),函数的返回值为图g中两个顶点x和y之间的最短距离。

#include <iostream>
#define maxValue max
#define E 50
#define V 20
using namespace std;
typedef struct{
	char vexlist[V];//顶点集
	int edge[E][E];//矩阵表
	int n,e;//矩阵的顶点数目，边数
}MTGraph;


/**
 * @param graph 传进来的图
 * @param x
 * @param y
 * @return 返回顶点x和顶点y之间的最短距离
 */
int dis(MTGraph *G,int x,int y) {
	
	//初始化距离矩阵 distance
	int distance[G->n][G->n];
	for (int i = 0; i <G->n; i++) {
		for (int j = 0; j <G->n; j++) {
		    distance[i][j] = G->edge[i][j];
		}
	}
	
	//初始化路径
	int path[G->n][G->n];
	for (int i = 0; i <G->n; i++) {
		for (int j = 0; j < G->n; j++) {
		    path[i][j] = j;
		}
	}
	
	//开始 Floyd 算法
	//每个点为中转
	for (int i = 0; i < G->n; i++) {
		//所有入度
		for (int j = 0; j < G->n; j++) {
		    //所有出度
		    for (int k = 0; k < G->n; k++) {
		        //以每个点为「中转」，刷新所有出度和入度之间的距离
		        //例如 AB + BC < AC 就刷新距离
		        if ( G->edge[j][i]!= 0 && G->edge[i][k] != 0) {
		            int newDistance =  G->edge[j][i] +  G->edge[i][k];
		            if (newDistance < G->edge[j][k] || G->edge[j][k] == 0) {
		                //刷新距离
		                 G->edge[j][k]  = newDistance;
		                //刷新路径
		                path[j][k] = i;
		            }
		        }
		    }
		}
	}
	return  G->edge[x][y];
}

void CreateMGraph(MTGraph *G){
	int i,j;
	//输入图的点数和边数
	cout<<"please cin the mount of point and edge:";
	cin>>G->n;
	cin>>G->e;
	//输入顶点信息
	cout<<"please cin the information of each point:";
	for(i=0;i<G->n;i++){
		cin>>G->vexlist[i];
	}

	//邻接矩阵初始化
	for(i=0;i<G->n;i++){
		for(j=0;j<G->n;j++){
			G->edge[i][j]=0;
		}
	}
	//输入图中边的节点（i，j),此处权值为1
	cout<<"输入图中每条边的节点（i，j),i和j不等:";   //应判断i和j不等，并重新输入 
	for(int k=0;k<G->e;k++) {
		cin>>i;
		cin>>j;
		while(i==j){
		    cout<<"i not equal to j! cin again!"; 
		    cin>>i;
		    cin>>j;
		}
		G->edge[i-1][j-1] =1;
		G->edge[j-1][i-1] =1;
	}
}
  
MTGraph NewNode(MTGraph *G,char x){  //添加顶点 
    G->vexlist[G->n] =x;
	for(int i=0;i<=G->n;i++){
		G->edge[G->n][i]=0;
		G->edge[i][G->n]=0;
	}
    ++G->n;
	return *G;
}

void delNode(MTGraph *G,char x){ //删除字符为特定值的顶点 
	//遍历点的数据，如有有执行删除操作
	for(int i=0;i<G->n;i++){
		if(G->vexlist[i] == x){
			cout<<"find "<<x<<endl;
			//删除顶点集
			for(int j=i;j<G->n-1;j++){
				G->vexlist[j] =G->vexlist[j+1]; //数组，把x后面的顶点向前挪一位 
			}
			G->vexlist[G->n-1] =0;
			cout<<"already del point! "<<x<<endl;
			//删除边集
			for(int ins=i;ins<G->n;ins++){
				if(ins==G->n-1){              //如果删除的顶点是最后一个顶点，"删除"边表中最后一行和最后一列 
					for(int k=0;k<G->n;k++){
						G->edge[ins][k] =0;
						G->edge[k][ins] =0;
					}
				}
				for(int k=0;k<G->n;k++){            
					G->edge[ins][k] =G->edge[ins+1][k];
					G->edge[k][ins] =G->edge[k][ins+1];
				}
				G->edge[ins][ins]=G->edge[ins+1][ins+1];//矩阵对角线上的元素都为0
			}
			//点的数量减一
			--G->n;
			break;
		}
		if(i=G->n)
			cout<<"not find "<<x<<endl;
	}

}

void setSucc(MTGraph *G,char x1,char x2){  //未判断顶点x1和x2之间是否有边的存在，参数是顶点的字符，不用自己找顶点的编号 
	int i,j;
	for(int k=0;k<G->n;k++){
		if(G->vexlist[k] ==x1){
			i=k;
		}
		if(G->vexlist[k] ==x2){
			j=k;
		}
	}
	G->edge[i][j] =1;
	G->edge[j][i] =1;
}

void delSucc(MTGraph *G,char x1,char x2){
	int i,j;
	for(int k=0;k<G->n;k++){
		if(G->vexlist[k] ==x1){
			i=k;
		}
		if(G->vexlist[k] ==x2){
			j=k;
		}
	}
	G->edge[i][j] =0;
	G->edge[j][i] =0;
}

void print(MTGraph *G){
	cout<<"all information of the graph:\n  ";
	int i,j;

	for(i=0;i<G->n;i++){
		cout<<G->vexlist[i]<<" ";
	}
	cout<<endl;
	cout<<"the data of the matrix:\n";
	for(i=0;i<G->n;i++){
		for(j=0;j<G->n;j++){
			cout<<G->edge[i][j]<<" ";
		}
		cout<<endl;
	}
}
int main(){
	MTGraph *G1 =new MTGraph();
	CreateMGraph(G1);
	print(G1);

    int distance = dis(G1,0,3);
	cout<<distance<<endl; 
	
	return 0;
}