图论算法（5） --- 双向广搜求最短路（Bidirectional Breadth First Search)

我们知道，在图论算法中，求最短路是最基本的问题。在求最短路的问题中，应用双向广度优先搜索算法，又是一个较为高效而又简单的算法。所谓双向广度优先搜索，其实根本的核心还是BFS，只不过它是从起点和终点两头同时搜索，大大提高了搜索效率，又节省了搜索空间。广搜大家知道当然是用队列来实现了，在这里，要注意的问题就是，我们必须按层搜索，正向队列处理一层，接着去处理反向队列的一层，按层交替进行，而不是按节点交替进行，这点需要注意，其他的也就很简单了，代码中附有注释，如有问题请留言。

package similarity;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

public class ShortestStep {
Map<Integer, LinkedList<Integer>> graph;
Map<String, Integer> graphmapping;

public ShortestStep(String path) {//构造函数里初始化，构造无向图
String[] strs;
String str;
int a, b;
try {
BufferedReader br = new BufferedReader(new FileReader(path));
graph = new HashMap<Integer, LinkedList<Integer>>();
while ((str = br.readLine()) != null) {
strs = str.split("\\s");
a = Integer.parseInt(strs[0]);
b = Integer.parseInt(strs[1]);

if (graph.containsKey(a)) {
graph.get(a).add(b);
} else {
LinkedList<Integer> linkedlist = new LinkedList<Integer>();
linkedlist.add(b);
graph.put(a, linkedlist);
}
if (graph.containsKey(b)) {
graph.get(b).add(a);
} else {
LinkedList<Integer> linkedlist = new LinkedList<Integer>();
linkedlist.add(a);
graph.put(b, linkedlist);
}
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}

}

public void initialMapping(String path) {/*此函数为备用，若想查询dbpedia数据集上URI之间的最短路，可用此初始化函数加载映射文件*/
String[] strs;
String str;
graphmapping = new HashMap<String, Integer>();
try {
BufferedReader br = new BufferedReader(new FileReader(path));
while ((str = br.readLine()) != null) {
strs = str.split("\\s");
int t = Integer.parseInt(strs[1]);
graphmapping.put(strs[0], t);
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}

}

public void findShortestStep(int a, int b) {/*双向广度优先搜索*/
Queue<Integer> queue1 = new LinkedList<Integer>();//正向队列
Queue<Integer> queue2 = new LinkedList<Integer>();//反向队列
Queue<Integer> adj1;//记录邻接点
Queue<Integer> adj2;
Set<Integer> visit1 = new HashSet<Integer>();//标记是否访问
Set<Integer> visit2 = new HashSet<Integer>();
Map<Integer, Integer> step1 = new HashMap<Integer, Integer>();//记录步数
Map<Integer, Integer> step2 = new HashMap<Integer, Integer>();
queue1.add(a);
queue2.add(b);
visit1.add(a);
visit2.add(b);
step1.put(a, 0);
step2.put(b, 0);
int cnt1 = 0;//用来记录搜索的层数
int cnt2 = 0;
while (!queue1.isEmpty() || !queue2.isEmpty()) {
while (true) {
Integer nextnode1 = queue1.peek();
adj1 = graph.get(nextnode1);
if(step1.get(nextnode1)!=cnt1){
//按层搜索，正向队列搜一层，反向队列搜一层，交替进行，
//如果当前出队点的层数超过正在搜索的层数，则跳出循环，去反向队列搜索
break;
}
queue1.poll();
if (adj1 != null) {
Iterator<Integer> itadj1 = adj1.iterator();
while (itadj1.hasNext()) {
Integer neighbor1 = itadj1.next();
if (!visit1.contains(neighbor1)) {
if (visit2.contains(neighbor1)) {//如果有共同的节点出现，则说明最短路找到，输出即可
System.out.println(step2.get(neighbor1)
+ step1.get(nextnode1) + 1);
return;

} else {
queue1.add(neighbor1);
visit1.add(neighbor1);
step1.put(neighbor1, step1.get(nextnode1) + 1);

}
}
}
}
}
cnt1++;
while (true) {
Integer nextnode2 = queue2.peek();
adj2 = graph.get(nextnode2);
if(step2.get(nextnode2)!=cnt2){
//按层搜索，正向队列搜一层，反向队列搜一层，交替进行，
//如果当前出队点的层数超过正在搜索的层数，则跳出循环，去正向队列搜索
break;
}
queue2.poll();
if (adj2 != null) {
Iterator<Integer> itadj2 = adj2.iterator();
while (itadj2.hasNext()) {
Integer neighbor2 = itadj2.next();
if (!visit2.contains(neighbor2)) {
if (visit1.contains(neighbor2)) {//如果有共同的节点出现，则说明最短路找到，输出即可
System.out.println(step1.get(neighbor2)
+ step2.get(nextnode2) + 1);
return;

} else {
queue2.add(neighbor2);
visit2.add(neighbor2);
step2.put(neighbor2, step2.get(nextnode2) + 1);

}
}
}
}
}
cnt2++;
}
}

public static void main(String[] args) {
ShortestStep ss = new ShortestStep("c:/datatest.txt");
ss.findShortestStep(6, 7);
}
}