具有N个标记顶点和K个未标记边的简单连接图的数量

Question

tl;dr My recurrence relation is accounting for a smaller number of graphs than should be.

I need to find the number of simple connected graphs with N labeled vertices and K unlabeled edges. Link to full source with complete question

[I have seen this post and it didn't solve my question]

Constraints: 2 <= N <= 20. It follows that, N-1 <= K <= N(N-1)/2.

I approached this problem with two different (not quite, I later realized) ideas.

The first idea: Connect N nodes with K edges such that there is 1 path between 2 nodes Ideation: Consider N-1 nodes and K-1 edges. How many ways to add Nth node?

• distribute 1 edge between node N and any of the other N-1 nodes; this is trivial, \\binom {N-1}1, ie, given N-1 choose 1.
• distribute 2 edges between ....
• ....
• ....
• distribute N-1 edges between ....

The 'formula' I came up with looked something like this:

We only look at values of K ∈ [N-1, N(N-1)/2] (other values don't make sense). When K = N-1, it's essentially falls under Cayley's formula . The recurrence relation is the part I came up with. The issue is that I am accounting for a smaller number of graphs than should be . The code:

static Map<List<Integer>, String> resultMap = new HashMap<List<Integer>, String>();
// N -> number of nodes
// K -> number of edges
// N will be at least 2 and at most 20.
// K will be at least one less than n and at most (n * (n - 1)) / 2
public static String answer(int N, int K) {
    /* for the case where K < N-1 */
    if(K < N-1)
        return BigInteger.ZERO.toString();

    /* for the case where K = N-1 */
    // Cayley's formula applies [https://en.wikipedia.org/wiki/Cayley's_formula].
    // number of trees on n labeled vertices is n^{n-2}.
    if(K == N-1)
        return BigInteger.valueOf((long)Math.pow(N, N-2)).toString();

    /* for the case where K > N-1 */
    // check if key is present in the map
    List<Integer> tuple = Arrays.asList(N, K);
    if( resultMap.containsKey(tuple) )
        return resultMap.get(tuple);

    // maximum number of edges in a simply 
    // connected undirected unweighted graph 
    // with n nodes = |N| * |N-1| / 2
    int maxEdges = N * (N-1) / 2;

    /* for the case where K = N(N-1)/2 */
    // if K is the maximum possible 
    // number of edges for the number of 
    // nodes, then there is only one way is 
    // to make a graph (connect each node
    // to all other nodes)
    if(K == maxEdges)
        return BigInteger.ONE.toString();

    /* for the case where K > N(N-1)/2 */
    if(K > maxEdges)
        return BigInteger.ZERO.toString();

    BigInteger count = BigInteger.ZERO;

    for(int k = 1; k <= N-1 ; k++) {
        BigInteger combinations = nChooseR(N-1, k);
        combinations = combinations.multiply(new BigInteger(answer(N-1, K-k)));
        count = count.add(combinations);
    }

    // unmodifiable so key cannot change hash code
    resultMap.put(Collections.unmodifiableList(Arrays.asList(N, K)), count.toString());

    return count.toString();
}

I found this post on MSE that addresses the same problem. Using that as reference, the 'formula' looked somewhat like this: This works exactly as expected. The code for this section is below.

static Map<List<Integer>, String> resultMap2 = new HashMap<List<Integer>, String>();
// reference: https://math.stackexchange.com/questions/689526/how-many-connected-graphs-over-v-vertices-and-e-edges
public static String answer2(int N, int K) {
    /* for the case where K < N-1 */
    if(K < N-1)
        return BigInteger.ZERO.toString();

    /* for the case where K = N-1 */
    // Cayley's formula applies [https://en.wikipedia.org/wiki/Cayley's_formula].
    // number of trees on n labeled vertices is n^{n-2}.
    if(K == N-1)
        return BigInteger.valueOf((long)Math.pow(N, N-2)).toString();

    /* for the case where K > N-1 */
    // check if key is present in the map
    List<Integer> tuple = Arrays.asList(N, K);
    if( resultMap2.containsKey(tuple) )
        return resultMap2.get(tuple);

    // maximum number of edges in a simply 
    // connected undirected unweighted graph 
    // with n nodes = |N| * |N-1| / 2
    int maxEdges = N * (N-1) / 2;

    /* for the case where K = N(N-1)/2 */
    // if K is the maximum possible 
    // number of edges for the number of 
    // nodes, then there is only one way is 
    // to make a graph (connect each node
    // to all other nodes)
    if(K == maxEdges)
        return BigInteger.ONE.toString();

    /* for the case where K > N(N-1)/2 */
    if(K > maxEdges)
        return BigInteger.ZERO.toString();

    // get the universal set
    BigInteger allPossible = nChooseR(maxEdges, K);

    BigInteger repeats = BigInteger.ZERO;
    // now, to remove duplicates, or incomplete graphs
    // when can these cases occur?
    for(int n = 0 ; n <= N-2 ; n++) {

        BigInteger choose_n_from_rem_nodes = nChooseR(N-1, n);

        int chooseN = (N - 1 - n) * (N - 2 - n) / 2;

        BigInteger repeatedEdges = BigInteger.ZERO;
        for(int k = 0 ; k <= K ; k++) {
            BigInteger combinations = nChooseR(chooseN, k);

            BigInteger recurse = new BigInteger(answer2(n+1, K-k));

            repeatedEdges = repeatedEdges.add(combinations.multiply(recurse));
        }

        repeats = repeats.add(choose_n_from_rem_nodes.multiply(repeatedEdges));
    }

    // remove repeats
    allPossible = allPossible.subtract(repeats);

    // add to cache
    resultMap2.put(Collections.unmodifiableList(Arrays.asList(N, K)), allPossible.toString());
    return resultMap2.get(tuple);
}

I would be grateful if someone could point me in a direction so that I can get the error in my first approach. The second approach works, but it makes O(NK) recursive calls and K is on average quadratic in N. So, clearly not very good, although I have tried to minimize computations using DP. The nChooseR() and factorial() functions are below.

Code for nChooseR:

static Map<List<Integer>, BigInteger> nCrMap = new HashMap<List<Integer>, BigInteger>();
// formula: nCr = n! / [r! * (n-r)!]
private static BigInteger nChooseR(int n, int r) {
    // check if key is present
    List<Integer> tuple = Arrays.asList(n, r);
    if( nCrMap.containsKey(tuple) )
        return nCrMap.get(tuple);

    // covering some basic cases using
    // if statements to prevent unnecessary
    // calculations and memory wastage

    // given 5 objects, there are 0 ways to choose 6
    if(r > n)
        return BigInteger.valueOf(0);

    // given 5 objects, there are 5 ways of choosing 1
    // given 5 objects, there are 5 ways of choosing 4
    if( (r == 1) || ( (n-r) == 1 ) )
        return BigInteger.valueOf(n);

    // given 5 objects, there is 1 way of choosing 5 objects
    // given 5 objects, there is 1 way of choosing 0 objects
    if( (r == 0) || ( (n-r) == 0 ) )
        return BigInteger.valueOf(1);

    BigInteger diff = getFactorial(n-r);

    BigInteger numerator = getFactorial(n);

    BigInteger denominator = getFactorial(r);
    denominator = denominator.multiply(diff);

    // unmodifiable so key cannot change hash code
    nCrMap.put(Collections.unmodifiableList(Arrays.asList(n, r)), numerator.divide(denominator));

    return nCrMap.get(tuple);
}

Code for factorial:

    private static Map<Integer, BigInteger> factorials = new HashMap<Integer, BigInteger>();
    private static BigInteger getFactorial(int n) {
        if(factorials.containsKey(n))
            return factorials.get(n);

        BigInteger fact = BigInteger.ONE;
        for(int i = 2 ; i <= n ; i++)
            fact = fact.multiply(BigInteger.valueOf(i));

        factorials.put(n, fact);

        return fact;
    }

Some test code:

public static void main(String[] args) {
    int fail = 0;
    int total = 0;
    for(int n = 2 ; n <= 20 ; n++) {
        for(int k = n-1 ; k <= n*(n-1)/2 ; k++) {
            total++;
            String ans = answer(n,k);
            String ans2 = answer2(n,k);
            if(ans.compareTo(ans2) != 0) {
                fail++;
                System.out.println("N = " + n + " , K = " + k + " , num = " + ans + " ||| " + ans2);
            }
        }
    }
    System.out.println("Approach 1 fails " + ((100*fail)/total) + "% of the test");
}

PS I got this challenge as a part of the Google Foobar challenges. Just wanted to make that aware to all. answer2() was judged to be working based on the test-cases on Foobar that cannot be seen by the challenge-taker. And just for reading all that, here is a video of a tiny hamster eating a tiny burrito .

Answer 1

An alternate approach...

We know that f(n,n-1) = n^{n-2} is the counting function of the number of labeled rooted trees [Cayley's formula]

Now, let f(n, k) be the total number of connected graphs with n nodes and k edges, we have a characterization of how to add a new edge:

1) Take any graph in F[n,k], and you can add an edge between any of the {n \\choose 2} - k pairs of unmatched nodes.

2) If you have two connected graphs g_1 and g_2, say in F[s, t] and F[ns, kt] respectively (that is, a connected graph with s nodes and t edges and a connected graph with ns nodes and kt edges), then you can surgically construct a new graph by connecting these two subgraphs together.

You have s * (ns) pairs of vertices to choose from, and you can choose the s point in {n \\choose s} ways. You can then sum over the choice of s and t respectively from 1 to n-1 , and in doing so, you will have double-counted each graph twice. Let's call this construction g(n, k) .

Then g(n,k) = (\\sum_s,t {n \\choose s} s (ns) f(s,t) f(ns, kt))/2

Now, there are no other ways to add in an extra edge (without reducing to the two constructions above), so the additive term h(n,k+1) = (N - k)f(n,k) + g(n,k) gives a characterization of the multiset of graphs that we've constructed. Why is this a multiset?

Well, let's look at a case analysis on the two subcases (induction on the construction). Take a random graph g in h(n, k+1) graphs constructed this way. The induction hypothesis is that there are k + 1 copies of g within the multiset h(n, k+1) .

Let's just look at the inductive case If you break an edge within a connected graph, then it either remains a connected graph or it breaks into two connected graphs. Now, fixate on an edge e , if you break any other edges, then e will still be within (k+1) - 1 distinct constructions. If you break e , you will have yet another unique construction. This means that there are k + 1 possible distinct classes of graphs (either single component of two components) from which we can construct the same final graph g .

Therefore, h(n,k+1) counts each graph a total of k+1 times, and so f(n, k+1) = h(n, k+1)/(k+1) = ((Nk)f(n,k) + g(n,k))/(k+1) .

Given a fixed n and k , this recurrence will compute the correct result in O((nk)^2) time, so complexity wise, it's equivalent to the previous algorithm. The nice thing about this construction is that it easily yields an analytic generating function so you can do analysis on it.
In this case, suppose you have a complex-valued function f_k(x,y) , then

2 dy f_{k+1} = (x^2 dx^2 f_k - 2 y dy f_k) + \\sum_s z^2 dz f_s dz f_{ks} .

You'll need a lot of complex analysis machinery to solve this recurrence PDE.

Here's a java implementation [ source ]