Thursday, February 19, 2015

This week in competitive programming

Theorem (Generalized Cayley's formula?).

Given a graph with n labeled vertices, let s be the number of its connected components and m1,m2,...,ms be the numbers of vertices in those components. Then the number of ways to add s-1 edges to this graph so that it becomes connected is ns-2∏mi.

When Mikhail `Endagorion' Tikhomirov told me this theorem, I was very suprised that it looks so simple yet I've never encountered it before. Is it a well-known result? Does it have a name?

This theorem comes in handy when solving a problem from previous week's summary: how many simple undirected graphs are there with n labeleld vertices and k bridges?

Here's how we can solve this problem: in addition to the numbera an,k of graphs with n vertices and k bridges, we'll also count the number bn,k of connected graphs with n vertices and k bridges (including, as k=0 case, the number of biconnected graphs), the value cn,k which is the sum over all graphs with n vertices and k connected components, such that all its connected components are biconnected, of the products of sizes of the components, and finally the number dn of connected graphs with n vertices.

Let's start with bn,k with positive k. Since the graph has at least one bridge, the bridges split it into several biconnected components, and the Generalized Cayley's formula mentioned above helps count the ways to join those biconnected components with bridges into a connected graph, so we get bn,k=nk-1*cn,k+1. Now bn,0 is simply dn-sum(bn,k).

To find cn,k, we first notice that cn,1=n*bn,0. For larger k, we should consider how many vertices are there in the biconnected component the contains the first vertex - let's say it has m vertices, then we have to multiply the number of ways to pick the remaining m-1 vertex in the component by the numbe of ways to pick the remaining components. In other words, cn,k=sum(comb(n-1,m-1)*cm,1*cn-m,k-1).

Finding dn is a standard question that is solved in a similar way: connected graphs are all graphs minus disconnected graphs, and disconnected graphs can be categorized by the size of the connected component containing the first vertex. In other words, dn=2n*(n-1)/2-sum(comb(n-1,m-1)*dm*2(n-m)*(n-m-1)/2).

And finally, we can find the value that we need: an,k. Again, let's look at the connected component containing the first vertex, and suppose it has m vertices and p bridges. Then we get an,k=sum(comb(n-1,m-1)*bm,p*an-m,k-p).

We compute O(n2) values, spending O(n) for each value in b, c and d, but O(n2) for each value of a, so the total running time is O(n4).

Here's the code:
```public class Fragile {
static final long MODULO = (long) (1e9 + 7);

public int countGraphs(int N, int K) {
long[][] a = new long[N + 1][N + 1];
long[][] b = new long[N + 1][N + 1];
long[][] c = new long[N + 1][N + 1];
long[] d = new long[N + 1];
d[0] = 1;
long[][] comb = new long[N + 1][N + 1];
comb[0][0] = 1;
a[0][0] = 1;
long[] p2 = new long[N * (N - 1) / 2 + 1];
p2[0] = 1;
for (int i = 1; i < p2.length; ++i) {
p2[i] = 2 * p2[i - 1] % MODULO;
}

for (int n = 1; n <= N; ++n) {
comb[n][0] = 1;
for (int k = 1; k <= N; ++k) {
comb[n][k] = (comb[n - 1][k - 1] + comb[n - 1][k]) % MODULO;
}
d[n] = p2[n * (n - 1) / 2];
for (int m = 1; m < n; ++m) {
d[n] = (d[n] - comb[n - 1][m - 1] * d[m] % MODULO * p2[(n - m) * (n - m - 1) / 2] % MODULO + MODULO) % MODULO;
}
for (int k = 2; k <= n; ++k) {
for (int m = 1; m < n; ++m) {
c[n][k] = (c[n][k] + comb[n - 1][m - 1] * c[m][1] % MODULO * c[n - m][k - 1]) % MODULO;
}
}
b[n][0] = d[n];
long pw = 1;
for (int k = 1; k < n; ++k) {
b[n][k] = pw * c[n][k + 1] % MODULO;
pw = pw * n % MODULO;
b[n][0] = (b[n][0] - b[n][k] + MODULO) % MODULO;
}
c[n][1] = n * b[n][0] % MODULO;
for (int k = 0; k < n; ++k) {
for (int m = 1; m <= n; ++m) {
for (int p = 0; p <= k; ++p) {
a[n][k] = (a[n][k] + comb[n - 1][m - 1] * b[m][p] % MODULO * a[n - m][k - p]) % MODULO;
}
}
}
}

return (int) a[N][K];
}
}```
Do you know a simpler way to solve this problem? Do you know a faster way to solve this problem?

My solution at the contest was even more complicated with O(n4) states and O(n6) running time, so it didn't complete in 2 seconds and I had to precompute the answers and submit those. I've used the following dynamic programming: how many graphs are there with n vertices, m vertices in the biconnected component containing the first vertex, k bridges, and p bridges going out from the biconnected component containing the first vertex.

Now, let's turn to last week's only regular online competition - TopCoder SRM 649 (problems, results, top 5 on the left). Fourteen people solved all three presented problems, but sdya has managed to create a comfortable 100+ point margin with fast solutions and a challenge - congratulations!

Thanks for reading, and check back next week!