最短路——BFS

BFS

核心思想：

1. 将图先构建成二维数组。初始化一个队列，将起点加入队列。
2. 队头元素出队，依次遍历与它直接相连的节点。每次遍历到一个节点时，判断是否访问过：
           - 如果被访问过：跳过；
           - 如果未访问：
                              将该点加入队列
                              标记已经访问
                              将父节点置为队头元素
3. 直到将与队头元素直接相连的节点遍历完，再执行步骤2，直到队列中无元素为止；

辅助空间：

1. 一个二维数组，用于记录相连的节点【如：a[0]={1,2,5}表示节点0和1，2，5直接相连】
2. 一个队列，用于记录遍历顺序【如队列{1，2}表示先遍历1直接相连的所有节点，再遍历2直接相连的节点】
3. 一个visited一维数组，用于标记该点是否被访问。【如a[2]=0表示节点2未被访问。a[1]=1表示节点1已经被访问】
4. 一个parent一维数组，用于记录元素的上一个元素。【如a[2]=5表示到节点2的最短路径的上一个元素为5】

样例展示

java 源码：

import java.util.ArrayList;
import java.util.LinkedList;
public class Bfs {
	static int []visited;
	static int []parent;
	public static void main(String[] args) {
		visited=new int[6];
		parent=new int[6];
		//构建图
		ArrayList <Integer> al[]=new ArrayList[6];
		for(int i=0;i<al.length ;i++){
			al[i]=new ArrayList<Integer>();
		}
		al[0].add(1);
		al[0].add(2);
		al[1].add(0);
		al[1].add(3);
		al[2].add(0);
		al[2].add(4);
		al[3].add(1);
		al[3].add(4);
		al[3].add(5);
		al[4].add(3);
		al[4].add(2);
		al[5].add(3);
		BFS(al,0);
		//输出到5的最短距离
		int s=5;
		int length=0;
		while(s!=-1){
			length++;
			s=parent[s];
		}
		System.out.println("从0到5的最短路径为"+length);
	}
	static void BFS(ArrayList<Integer> []al,int s){
		//初始化队列，加入起始元素s,并设置其已经被访问，且父节点置为-1（结束标志）
		LinkedList<Integer> l=new LinkedList<Integer>();
		l.add(s);
		visited[s]=1;
		parent[s]=-1;
		//进入循环体
		while(l.size()>0){
			//出队
			int vertex=l.pollFirst();//根节点
			//遍历其叶子节点
			for(int i=0;i<al[vertex].size();i++){
				int node=al[vertex].get(i);
				if(visited[node]==0){//若未被访问，则加入队列，并设置其已经被访问，且父节点置为当前出队元素
					l.add(node);
					parent[node]=vertex;
					visited[node]=1;
				}
			}
		}
	}
}