Question

Let G be a DAG (a graph without loops) and u, v be two designated nodes (there are many other nodes in G). In particular, each node in G is labeled with a color and multiple nodes can share the same color. A good path is one where the number of green nodes is bigger than the number of yellow nodes. Describe an efficient algorithm to count the number of good paths from u to v.

Answer 1

I would use a breadth-first search to check all possible paths between the two nodes. During the calculation of a given edge distance I would include a check to determine if the the edge is red or green or neither and increment a counter variable for the number of red or green edges. (Two variables, one for red edges and one for green edges) These variables would be attached to each node so just like the distance is calculated by totaling the distances from one node to the next, the number of red and green edges can be totaled along any given path.

Below is my algorithm.

Let L be an empty list that possible paths will be added to.
Let Q be a queue to store nodes to be examined

For each node in G
        mark undiscovered, set distance to infinity, set parent to null, and set        counters to 0

starting at v
initialize distance of v to be 0
add v to Q

while Q is not empty
        dequeue Q and call this node u (Current node)
        for each vertex x adjacent to u
                if x undiscovered
                        mark x as discovered
                        set x’s distance = parents u’s distance + 1
                        set x’s parent to u
                        if x is green
                                set x's green count to u's + 1
                        if yellow
                                set x's yellow count to u's + 1
                
                        add x to Q
        mark u as fully explored
        add u to L

for each element In L
        if element == v'
                if v' yellow Count < v' green Count
                        cnt++