图的深度优先,完全搜索...有点脑残....java实现

在图中.深度优先...查找到所有线路,犹豫在网上没有找到实现的源码,自己写了一个.我估计这是所有图的搜素算法中.最脑残的一个.效率最低的一个...

Node.java

================================================================

public class Node extends Object {
public int x;
public int y;

public Node(int x, int y) {
super();
this.x = x;
this.y = y;
}


@Override
public int hashCode() {
return x * 1000 + y;
}


@Override
public String toString() {
return "[" + x + "," + y + "]";
}


@Override
public boolean equals(Object obj) {
return this.hashCode() == obj.hashCode();
}
}

DfsMain.java

===========================

import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

public class DfsMain {


// -1是无法通过的点
static int map[][] = { { 0, 0, 0, 0 }, { 0, -1, -1, 0 }, { 0, 0, -1, 0 }, { -1, -1, -1, 0 }, { 0, 0, -1, 0 },
{ 0, 0, -1, 0 }, { 0, 0, 0, 0 } };
// static int map[][] = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, {
// 0, 0, 0, 0 } };
// 开始点
static Node from = new Node(0, 0);
// 所有的线路
static LinkedList<LinkedList<Node>> allroads = new LinkedList<LinkedList<Node>>();
public static LinkedList<Node> roads = new LinkedList<Node>(); // 当前的路
// 记录每一层的已经走过的点
static Map<Integer, Set<Node>> allClose = new HashMap<Integer, Set<Node>>();


public static void main(String[] args) {
long start = System.currentTimeMillis();
// 深度优先关键在于回溯
// until 彻底无路可走.当前路程为空
roads.add(from);
while (!roads.isEmpty()) {
// {
// 1.选择没有走过的点
Set<Node> canMove = findCanMove(roads.peekLast());
if (allClose.get(roads.size()) != null)
canMove.removeAll(allClose.get(roads.size()));
canMove.removeAll(roads);
// 2.无路可走?回退一步,并把该点标记为已经走过 continue
if (canMove.isEmpty()) {
Node n = roads.pollLast();
// 把回退的节点放在当前层的已经走过的集合里
if (allClose.containsKey(roads.size()))
allClose.get(roads.size()).add(n);
else {
Set<Node> set = new HashSet<Node>();
set.add(n);
allClose.put(roads.size(), set);
}
// 下一层的走过的集合剔除掉
allClose.remove(roads.size() + 1);
continue;
}
// 3.当前的点加入路程中,不在路程中的点都设置为未走过
// }
roads.add(canMove.iterator().next());
allroads.add(new LinkedList<Node>(roads));
}


// 把所有的路径都写进文件里
try {
FileWriter writer = new FileWriter("1.txt", false);
for (LinkedList<Node> r : allroads) {
writer.write(r.toString());
writer.write("\r\n");
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(allroads.size());
System.out.println((System.currentTimeMillis() - start) / 1000.0);
}


public static Set<Node> findCanMove(Node local) {
Set<Node> locals = new HashSet<Node>();
for (int i = -1; i < 2; i++) {
for (int j = -1; j < 2; j++) {
try {
if (map[local.x + i][local.y + j] == 0 || map[local.x + i][local.y + j] == 2) {
locals.add(new Node(local.x + i, local.y + j));
}
} catch (ArrayIndexOutOfBoundsException e) {
continue;
}
}
}
return locals;
}
}