计算长度为K的DAG中的路径数

Question

I have a DAG with 2^N nodes, with values from 0 to 2^N-1. There is edge from x to y if x < y and x (xor) y = 2^p, x and y being the node values and pa non-negative integer. Since N can be as large as 100000, generating the graph and than proceeding with the counting would take much computational time. Is there any way to count the paths with certain length K (K being the number of edges between two nodes), differently stated, is there an equation of some sort for this kind of counting? Thanks in advance

Answer 1

Michael's got some good insights, but I'm not sure I follow his entire argument. Here's my solution.

Let's say N=4, K=2. So the nodes range from 0 (0000 ₂ ) to 15 (1111 ₂ ).

Now let's consider node 2 (0010 ₂ ). There's an edge from 2 to 3 (0011 ₂ ) because 2 < 3 and xor(2,3) = 1 = 2 ⁰ . There's also an edge from 2 to 6 because 2 < 6 and xor(2,6) = 4 = 2 ² . And there's an edge from 2 to 10 because 2 < 10 and xor(2,10) = 8 = 2 ³ .

To generalize: for any x, consider all of the 0 bits in x. By flipping any of the 0 bits to 1, you get a number y that's larger than x and differs from x by one bit. So there's an edge from x to that y.

The number of 1 bits in x is typically called the population count of x. I'll use pop(x) to mean the population count of x.

We're dealing with N-bit numbers (when we include leading zeroes), so the number of 0 bits in x is N - pop(x).

Let's use the term “ j -path” to mean a path of length j . We want to count the number of K-paths.

Every node x has N - pop(x) outgoing edges. Each of these edges is a 1-path.

Let's consider node 5 (0101 ₂ ). Node 5 has an edge to 7 (0111 ₂ ), and node 7 has an edge to 15 (1111 ₂ ). Node 5 also has an edge to 13 (1101 ₂ ), and node 13 has an edge to 15 (1111 ₂ ). So there are two 2-paths out of node 5: 5-7-15 and 5-13-15.

Next let's look at node 2 (0010 ₂ ) again. Node 2 has an edge to 3 (0011 ₂ ), which has edges to 7 (0111 ₂ ) and 11 (1011 ₂ ). Node 2 also has an edge to node 6 (0110 ₂ ), which has edges to 7 (0111 ₂ ) and 14 (1110 ₂ ). Finally, node 2 has an edge to node 10 (1010 ₂ ), which has edges to 11 (1011 ₂ ) and 14 (1110 ₂ ). In all, there are six 2-paths out of node 2: 2-3-7, 2-3-11, 2-6-7, 2-6-14, 2-10-11, and 2-10-14.

The pattern is that, for any node x with z bits set to zero, where z ≥ K, there are some K-paths out of x. To find a K-path out of x, you pick any K of the zero bits. Flipping those bits to 1, one by one, gives you the path. You can flip the bits in any order you want; each order gives a different path.

When you want to pick k items, in a specific order , from a set of n items, that's called an ordered sample without replacement, and there are n! / (nk)! ways to do it. This is often written _n P _k , but it's easier to type P(n,k) here.

So, the nodes that have exactly 2 zero bits have P(2,2) = 2! / (2-2)! = 2 2-paths out of them. (Note that 0! = 1.) The nodes that have exactly 3 zero bits have P(3,2) = 3! / 1! = 6 2-paths out of them. The node that has exactly 4 zero bits has P(4,2)= 4! / 2! = 12 2-paths out of it. (Since I'm using N=4 for the example, there is only one node with exactly 4 zero bits, which is node 0.)

But then we need to know, how many nodes have exactly 2 zero bits? Well, when there are n items to choose from, and we want to choose k of them, and we don't care about the order of the chosen items, that's called an unordered sample without replacement, and there are n! / (k! (nk)!) ways to do it. This is called “n choose k”, and it's usually written in a way that I can't reproduce on stack overflow, so I'll write it as C(n,k).

For our example with N=4, there are C(4,2) = 6 nodes with exactly 2 bits set to zero. These nodes are 3 (0011 ₂ ), 5 (0101 ₂ ), 6 (0110 ₂ ), 9 (1001 ₂ ), 10 (1010 ₂ ), and 12 (1100 ₂ ). Each of these nodes has P(2,2) 2-paths out of it, so that means there are C(4,2) * P(2,2) = 6 * 2 = 12 2-paths out of nodes with exactly two 0 bits.

Then there are C(4,3) = 4 nodes with exactly 3 bits set to zero. These nodes are 1 (0001 ₂ ), 2 (0010 ₂ ), 4 (0100 ₂ ), and 8 (1000 ₂ ). Each of these nodes has P(3,2) 2-paths out of it, so there are C(4,3) * P(3,2) = 4 * 6 = 24 2-paths out of nodes with exactly three 0 bits.

Finally, there is C(4,4) = 1 node with exactly 4 bits set to zero. This node has P(4,2) = 12 2-paths out of it.

So the total number of 2-paths when N=4 is C(4,2)*P(2,2) + C(4,3)*P(3,2) + C(4,4)*P(4,2) = 12 + 24 + 12 = 48.

For general N and K (where K ≤ N), the number of K-paths is the sum of C(N,z) * P(z,K) for K ≤ z ≤ N.

I can type that into Wolfram Alpha (or Mathematica) like this:

Sum[n!/(z! (n - z)!) z!/(z - k)!, {z, k, n}]

And it simplifies it to this :

2^(n-k) n! / (n-k)!

Answer 2

The stated problem seems to be equivalent to this one:

Consider the set of all possible binary strings of length N. Consider operation Fi that flips i-th bit from 0 to 1. For strings x & y denote |x| the number of set bits, x

It's easy to see that one can obtain y from x by a series of exactly K operations Fi if and only if (x,y) is K-admissible. Moreover, if we fix x and sum up over all y such that (x,y) is K-admissible we get (N-|x|)!

Finally, we need to sum up over all x with |x|<=(NK). For a given choice of |x| we have N!/(N-|x|)!|x|! possible choices of x. Combine with the above and you get that for the given |x| there are N!/|x|! possible paths.

Denote |x|=M, with M from 0 to NK, and your answer is the sum over all M of N!/M!