Activating AND nodes and OR nodes - algorithm

Question

Consider a directed graph with AND nodes and OR nodes. The AND nodes are activated only when all the in edges into it are activated. The OR nodes are activated if at least one of the in edges into it is activated. How to design an efficient algorithm to decide if all nodes can be activated? I have thought of some naive algorithm but it takes O(n^3) time. I am also assuming that vertices with no in edges into them are activated initially.I believe n^3 cannot be an efficient algorithm and there's some method that I am missing. Tagging domains where the problem might have a solution.

Answer 1

Maintain a set A of already activated nodes, a queue Q of nodes, and counters C of in-edges for each node.
Start by counting in-edges:
for each n in nodes {
for each n2 adjacent to n {
C[n2] += 1
}
}
Then initialize Q with the nodes with no in-edges:
for each n in nodes {
if C[n] == 0 {
add n to Q
}
}
Now repeat this process, until the queue is empty:
take q from Q
for each n adjacent to q {
if n is in A { continue }
if n is OR {
add n to A
add n to Q
} else { // n must be AND
C[n] -= 1
if C[n] is 0 {
add n to A
add n to Q
}
}
}
[This is a variant of topological sort that copes with the differences between OR and AND nodes].
When this process terminates, the set A contains all activated nodes.
The runtime is O(V+E), where V is the number of nodes in the graph, and E the number of edges.

Answer 2

You could preprocess the graph to compute the in-degree of each node.
Add all nodes with in-degree 0 to a stack, and prepare an array A containing the activation count for each node (initially equal to 0).
Then do the following pseudo-code
visited = set(stack)
while stack:
node = stack.pop()
for dest in node.neighbours():
A[dest] += 1
if ((Type[dest]==AND and A[dest]==indegree[dest]) or
(Type[dest]==OR and A[dest]>0)):
if node not in visited:
visited.add(node)
stack.append(dest)
This will visit each edge and each node at most once, so will have linear complexity.
When you finish the process, visited contains the set of activated nodes.

Answer 3

It is possible in O(n). Here is a possible algorithm.
n the total number of nodes
s the sum of the nodes that have been activated
a array to indicate if node n has been activated
c array to count the number of incoming edges for node n
Iterate through the nodes, if they have no incoming edges call your propagation function with it, e.g. propagate(i);.
If s == n all nodes have been activated.
Pseudo code for the propagate function:
function propagate(idx) {
if (a[idx]) // is node activated already
return; // return because node was already propagated
a[idx] = true; // activate
s++; // increase the number of activated nodes
for (var j = 0; j < outEdges[idx].length; j++) { // iterate through the outgoing edges
var idx2 = outEdges[idx][j]; // the node the edge is pointing to
if (isOrNode[idx2]) {
propagate(idx2);
} else { // AND node
c[idx2]++; // increase the count of incoming activated edges
if (inEdges[idx2].length == c[idx2]) // all incoming edges have been activated
propagate(idx2);
}
}
}