algorithm - DFS extremely slow when keeping the visisted nodes - algorithm

Question

i might be missing something about DFS/DLS, wikipedia doesn’t say visited nodes should be concatenated with the current depth...
problem: you have this 2x4 map S=start E=exit
____
E |
|
|
S |
if you are using DFS maxDepth=3 and your move generator is:
dir = {right, left, up, down}
DFS won’t solve this at depth 3 (which means an IDDFS will fail too...)
DFS will try this path first:
____
E |
|
3 2 |
0 1 |
if you are marking the visited positions now E is only reachable at depth 5 since dfs will backtrack to depth 0 and find that the first move ‘up’ is not valid anymore because it was taken at depth 3 already!
the only solution i see is to mark the visited position with the current depth (so you can ignore a ‘visited’ position if visited.depth > currentDepth) which means each position will be visited MANY MANY times in each DFS search when depth=X making it impossible to use in large problems!
in my test if you have enough memory to run a breadth-first search in a large problem it will run a lot faster than a DFS at depth=X even when X is the shortest depth to solve.. it sounds i’m wrong but i just don’t see it why or what i'm doig wrong.. someone please enlighten me up!! (yes that's the question... i don't know what's going on)
this is my search functions to solve puzzles:
BFS (works great but not with very large problems.. uses a lot of RAM)
note i'm not using the hasmap's values (always 0)
HashMap<State, Integer> table = new HashMap();
State bfs() {
State state = this.initState;
Queue<State> pending = new LinkedList();
table.put(state, 0);
pending.add(state);
while ( !pending.isEmpty() ) {
state = pending.remove();
for ( State child : state.getChildren() ) {
if ( !table.containsKey(child) ) {
table.put(child, 0);
if ( child.isSolved() )
return child;
pending.add(child);
}
}
}
return null;
}
DFS (very slow, too much nodes, unusable for large problems)
note that hashMap.put also updates the old values
State dls(State state, int depth) {
if ( depth == maxDepth )
return state.isSolved() ? state : null;
for ( State child : state.getChildren() ) {
if ( !table.containsKey(child) ||
table.get(child) > depth ) {
table.put(child, depth);
State solution = dls(child, depth + 1);
if (solution != null)
return solution;
}
}
return null;
}
State solution(int depth) {
this.maxDepth = depth;
table.put(this.initState, 0);
return dls(this.initState, 0);
}

Answer 1

What problem are you trying to solve? DFS traditionally is used to solve mazes because it there is a theory that it will reach the end of the maze first because it searches depth first, but I believe in general a BFS will be just as fast.
In this case it looks like DFS will work just fine, however, you will visit many nodes in the graph before getting there.
Here is one possible DFS traversal:
____
7 6 |
4 5 |
3 2 |
0 1 |
Where you start at 0 and go to 7. The steps for the DFS are as follows:
Start at 0, add it to a stack.
Stack:{0}
Remove 0, add its three children (3,2,1) to the stack. Mark 0 as visited.
Stack:{3,2,1}
Remove 1, add its three children (0,3,2) to the stack. However, 0 is visited, so skip it. Mark 1 as visited.
Stack:{3,2,3,2}
Remove 2, add its three children (3,4,5) to the stack. Mark 2 as visited.
Stack:{3,2,3,2,5,4,3}
...
Eventually you will end up at E, but your stack will have many nodes in it. Every time you pop a node you'll have to check to see if it is visited, and if it is do nothing.
As you can see, this is a very slow algorithm because the graph is connected.
A better way to find E from S would be to use Shortest Paths or A*

Answer 2

Naive DFS is complete but non-optimal.
That means it guarantees a solution if one exists, but does not guarantee that it is optimal. While one choice for finding an optimal solution is the approach you've taken, it now makes DFS a much worse choice than BFS as it now needs to expand every node up to every possible path, while BFS just needs to expand every node.
For this case, you are correct that BFS is better than DFS, as you have a small search space with many possible paths and are trying to find the optimal solution. Different algorithms are better at different problems. A* and Dijkstra's are examples of algorithms that will perform even better than BFS in this case.
When is it practical to use DFS vs BFS? has some more information about relative benefits of each approach.