recursive traversal through a graph, counting ways to a point - graph

Question

Got a graph which is looks like this one:
I want to count all possible ways to a specific point p(i,j) from p(0,0) in this graph. I think i can do it with Depth-first search. How i should extend the Depth-first search, so its don't count some ways twice?

Answer 1

The best way is to count the number of ways without actually following all of the paths. Let F(x, y) be the number of ways to get to your destination point. Then, you can see that in your graph, F(x, y) = F (x+1, y) + F (x, y+1) + F(x+1, y+1). You want F(0,0). Your base cases are going to be F(i, j) = 1 (one way to get there if you're already there: don't go anywhere) and F(any number > i, any j) and F(i, any number > j) = 0 because there's no way to get to your destination point once you've passed it.
Update with more detail: Now how to evaluate this formula? You could do it recursively, but a naive implementation will be extremely inefficient. A naive implementation would just be something like this in pseudocode that loosely looks like python:
i = ...
j = ...
def paths (x, y):
if (x > i) or (y > j):
return 0
if (x == i) and (y == j):
return 1
else:
return paths (x+1, y) + paths (x, y+1) + paths (x+1, y+1)
print F(0, 0)
The problem with this is that if you start at (0,0), your first level of recursive calls will be (0, 1), (1, 0), and (1, 1). When these calls in turn evaluate, (0, 1) will compute (0, 2) (1, 1), and (1, 2); then (1, 0) will compute (1, 1), (2, 0), and (2, 1), and then (1, 1) will compute (1, 2), (2, 1), and (2, 2). Notice how many of these calls are redundant in that they compute the same value. The technique to resolve this is to keep a matrix that memorizes the values of F. So then the code might look something like this:
i = ...
j = ...
memorizedValues = ... #make an i by j grid filled with -1
memorizedValues[i][j] = 1 #initial condition
def paths (x, y):
if (x > i) or (y > j):
return 0
if (memorizedValues[x][y] != -1): #check for a memorized value before
return memorizedValues[x][y] # starting more recursion!
else:
memorizedValues[x][y] = paths (x+1, y) + paths (x, y+1) + paths (x+1, y+1)
return memorizedValues[x][y]
print F(0, 0)
This is still not the most efficient implementation, but I think it gets the point across. It's considerably faster than counting each path by following it and backtracking!

Answer 2

You can use BFS and either mark the nodes or use a map to keep track of them. However, if your graph is large, BFS entails keeping it all in memory. DFS is better at it. However, DFS can get lost in a large graph unless you put a depth restriction on it.
Anyhow, to speed up your program you might consider stopping early if:
the graph is disconnected
you reach a bridge
Other heuristics:
visit a neighbour of degree 1 first before going any further.
I wrote a somewhat similar program to see how far I can optimize it:
https://github.com/eamocanu/allPathsFinder