图的深度优先,完全搜索...有点脑残....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;

}

}