Question

I have the following Python code, and it works perfect with the directed graph.
My question is how to modify the code in such way to find all the paths with ignoring the directions of the edges.

For example, if we have the following connections:

1->2

3->2

My code will not return a path between 1 and 3, which is expected as it is directed. But with ignoring the directions of edges the code should find a path from 1 to 3.

I want the code to ignore the direction and finds all the paths between the two given nodes.

I tried the proposed solution and it works really nice, the solution is: “The simplest solution might be to pre-process your graph by adding the arc B->A for every A->B that’s in the graph.“

What I really wanted is to modify the algorithm itself to deal with the graph as is.

Python Code:

# a sample graph
graph = {'A': ['B', 'C','E'],
             'B': ['A','C', 'D'],
             'C': ['D'],
             'D': ['C'],
             'E': ['F','D'],
             'F': ['C']}

class MyQUEUE: # just an implementation of a queue

    def __init__(self):
        self.holder = []

    def enqueue(self,val):
        self.holder.append(val)

    def dequeue(self):
        val = None
        try:
            val = self.holder[0]
            if len(self.holder) == 1:
                self.holder = []
            else:
                self.holder = self.holder[1:]   
        except:
            pass

        return val  

    def IsEmpty(self):
        result = False
        if len(self.holder) == 0:
            result = True
        return result


path_queue = MyQUEUE() # now we make a queue


def BFS(graph,start,end,q):

    temp_path = [start]

    q.enqueue(temp_path)

    while q.IsEmpty() == False:
        tmp_path = q.dequeue()
        last_node = tmp_path[len(tmp_path)-1]
        #print tmp_path
        if last_node == end:
            print "VALID_PATH : ",tmp_path
        for link_node in graph[last_node]:
            if link_node not in tmp_path:
                new_path = []
                new_path = tmp_path + [link_node]
                q.enqueue(new_path)

BFS(graph,"A","D",path_queue)

————-Output of the Code——————-

['A', 'B', 'D'] 
['A', 'C', 'D']
['A', 'E', 'D']
['A', 'B', 'C', 'D']
['A', 'E', 'F', 'C', 'D']

Note: I taged Java, in case someone has a solution to the same problem in Java

Answer 1

The simplest solution might be to pre-process your graph by adding the arc B->A for every A->B that’s in the graph. Then you should be able to use your algorithm as-is.