一、有向线段，存储开始点与结束点
/**
* 有方向的线段
*
* @author Gm
*
*/
public class DirectionLine implements Cloneable {
private String beginNode;
private String endNode;
public DirectionLine(String beginNode, String endNode) {
this.beginNode = beginNode;
this.endNode = endNode;
}
public String toString() {
return beginNode + "->" + endNode;
}
public String getBeginNode() {
return beginNode;
}
public void setBeginNode(String beginNode) {
this.beginNode = beginNode;
}
public String getEndNode() {
return endNode;
}
public void setEndNode(String endNode) {
this.endNode = endNode;
}
public boolean equals(Object obj) {
DirectionLine dl = (DirectionLine) obj;
if (this.getBeginNode().equals(dl.getBeginNode()) && this.getEndNode().equals(dl.getEndNode())) {
return true;
}
return false;
}
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
三、过滤无效节点
public class Graph {
List<DirectionLine> directionLines = null; // 已知的路径（有向线，包含：开始点、结束点）
List<String> visitedList = new ArrayList<String>(); // 存放已经访问过点的节点
Set<String> resultSet = new HashSet<String>(); // 目的访问路径（点的集合）
Set<DirectionLine> loopList = new HashSet<DirectionLine>(); // 已知的回路（有向线，包含：开始点、结束点）
public Graph(List<DirectionLine> directionLines) {
this.directionLines = directionLines;
}
public List<DirectionLine> getDirectionLines() {
return directionLines;
}
public void setDirectionLines(List<DirectionLine> directionLines) {
this.directionLines = directionLines;
}
public List<String> getVisitedList() {
return visitedList;
}
public void setVisitedList(List<String> visitedList) {
this.visitedList = visitedList;
}
public Set<String> getResultSet() {
return resultSet;
}
public void setResultSet(Set<String> resultSet) {
this.resultSet = resultSet;
}
public Set<DirectionLine> getLoopList() {
return loopList;
}
public void setLoopList(Set<DirectionLine> loopList) {
this.loopList = loopList;
}
/**
* 路径遍历的核心算法
*
* @param startNode
* @param endNode
*/
public void getAllPaths(String startNode, String endNode) {
visitedList.add(startNode);
// System.out.println("访问的起点->终点：" + startNode + "->" + endNode);
for (int z = 0; z < directionLines.size(); z++) {
// System.out.println("遍历次数：" + z + "，路径：" + directionLines.get(z).toString());
if (directionLines.get(z).getBeginNode().equals(startNode)) { // 寻找找以startNode开始的路径
if (directionLines.get(z).getEndNode().equals(endNode)) { // 如果以endNode结尾，则为一条有效路径
resultSet.add(visitedList.toString().substring(0, visitedList.toString().lastIndexOf("]")) + "," + endNode + "]");
continue;
}
// System.out.println("已访问过的节点：" + visitedList.toString());
if (!visitedList.contains(directionLines.get(z).getEndNode())) {// 此节点仍未遍历，则继续迭代
getAllPaths(directionLines.get(z).getEndNode(), endNode);
} else {// 证明存在回路
loopList.add(directionLines.get(z));
}
}
}
visitedList.remove(startNode);
}
}
public class MapVisit {
/**
* 构造初始化路径--已知
*
*/
public List<DirectionLine> init() {
List<DirectionLine> directionLines = new ArrayList<DirectionLine>();
String str = CommonUtil.readToString("room_layout2.json");
JSONObject jsonObject = JSONObject.parseObject(str);
for (Entry<String, Object> entry : jsonObject.entrySet()) {
String startNode = "node" + entry.getKey();
JSONObject child_nodes = JSONObject.parseObject(entry.getValue().toString());
for (Entry<String, Object> child_entry : child_nodes.entrySet()) {
String endNode = "node" + child_entry.getKey();
// System.out.println(startNode + ":" + endNode);
directionLines.add(new DirectionLine(startNode, endNode));
}
}
return directionLines;
}
/**
* 判断所有路径中是否有以beginNode节点为起点的基本路径
*
* @param beginNode
* @param directionLines
* @return
*/
public boolean existBeginNode(String beginNode, List<DirectionLine> directionLines) {
boolean result = false;
for (DirectionLine dl : directionLines) {
if (dl.getBeginNode().equals(beginNode)) {
result = true;
break;
}
}
return result;
}
/**
* 判断所有路径中是否有以end节点为终点的基本路径
*
* @param endNode
* @param directionLines
* @return
*/
public boolean existEndNode(String endNode, List<DirectionLine> directionLines) {
boolean result = false;
for (DirectionLine dl : directionLines) {
if (dl.getEndNode().equals(endNode)) {
result = true;
break;
}
}
return result;
}
/**
* 根据路径获取到所有的节点
*
* @param directionLines
* @return
*/
public Set<String> getAllNodes(List<DirectionLine> directionLines) {
Set<String> nodes = new HashSet<String>();
for (DirectionLine r : directionLines) {
nodes.add(r.getBeginNode());
nodes.add(r.getEndNode());
}
return nodes;
}
/**
* 获取到需要删除的路径
*
* @param beginNodes
* 无效起始节点
* @param endNodes
* 无效终结点
* @param directionLines
*/
public Set<DirectionLine> deleteDirectionLines(Set<String> beginNodes, Set<String> endNodes, List<DirectionLine> directionLines) {
Set<DirectionLine> set = new HashSet<DirectionLine>();
for (String str : beginNodes) {
for (DirectionLine dl : directionLines) {
if (dl.getBeginNode().equals(str)) {
set.add(dl);
}
if (dl.getBeginNode().equals(str)) {
set.add(dl);
}
}
}
return set;
}
/**
* 过滤掉无用的节点 获取到无效开始节点和无效结束点
*
* @param all
* @param directionLines
* @param beginNodes
* @param endNodes
* @return
*/
public Set<String> filterInvalidNode(Set<String> allNodes, List<DirectionLine> directionLines, Set<String> beginNodes, Set<String> endNodes) {
Set<String> result = new HashSet<String>();
boolean isBegin = true;
boolean isEnd = true;
for (String node : allNodes) {
if (!existEndNode(node, directionLines)) { // 没有以此节点结尾的路径，则证明此节点为无用节点
isBegin = false;
beginNodes.add(node);
} else if (!existBeginNode(node, directionLines)) {// 没有以此节点开头的路径，则证明此节点为无用节点
isEnd = false;
endNodes.add(node);
} else {
result.add(node); // 有用的节点
}
}
if (isBegin == true && isEnd == true) {
return result;
} else {
return filterInvalidNode(result, directionLines, beginNodes, endNodes);
}
}
/**
* @param args
*/
public static void main(String[] args) {
MapVisit visit = new MapVisit();
List<DirectionLine> directionLines = visit.init();
// 构造基本路径--为已知条件
Set<String> invalidBeginNodes = new HashSet<String>(); // 无效的起始节点
Set<String> invalidEndNodes = new HashSet<String>(); // 无效的结束节点
Set<String> allNodes = visit.getAllNodes(directionLines);
visit.filterInvalidNode(allNodes, directionLines, invalidBeginNodes, invalidEndNodes); // 获取到无效开始节点和无效结束点
Set<DirectionLine> invalidRoads = visit.deleteDirectionLines(invalidBeginNodes, invalidEndNodes, directionLines); // 获取需要删除的路径
directionLines.removeAll(invalidRoads); // 删除无效的路径
// System.out.println(directionLines.toString());
Graph pra = new Graph(directionLines);
String begin = "node12"; // 起始点
String end = "node1"; // 终结点
// 获取所有有效路径
pra.getAllPaths(begin, end);
Iterator<String> it = pra.getResultSet().iterator();
System.out.println("-----------------从" + begin + "至" + end + "的有效路径如下-----------------");
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
四、数据集
{"1":{"2":1},"2":{"1":1,"3":1,"19":1},"3":{"2":1,"4":1,"9":1},"4":{"3":1,"5":1},"5":{"4":1},"6":{"9":1},"7":{"10":1},"8":{"11":1},"9":{"3":1,"6":1,"10":1},"10":{"7":1,"9":1,"11":1,"12":1},"11":{"8":1,"10":1},"12":{"10":1,"13":1,"17":1},"13":{"12":1,"14":1,"15":1},"14":{"13":1,"16":1},"15":{"13":1},"16":{"14":1},"17":{"12":1,"18":1},"18":{"17":1,"19":1,"20":1},"19":{"2":1,"18":1},"20":{"18":1}}
五、效果展示
-----------------从node12至node1的有效路径如下-----------------
[node12, node17, node18, node19, node2,node1]
[node12, node10, node9, node3, node2,node1]
