Question

I need to calculate something whose value is given by the following inneficient pseudo python code:

def foo(a,b):
   tmp = 0
   for i in graph.nodes():
       for j in graph.nodes():
          tmp += c
          if (i and j are neighbors):
              tmp += a - c
          elif (i and j are next-neighbors):
              tmp += b - c
   return tmp

In other words, given all the pairs of nodes, foo = a * (E = number of edges) + b * (EE = number of pairs who are not neighbors but have a common neighbor) + c * ( N(N-1)/2 – EE – E).

I tried to think on some kind of breadth first search but I couldn’t.

EDIT: more info

• the graph is not static. I constantly add and remove edges, so I can’t calculate this only once. I must constantly update the “list of next neighbors”.
• I store the graph as an adjacency matrix.

Answer 1

Here’s a rough idea. But first, some assumptions: 1. undirected graph 2. constant vertex-count

Your graph changes constantly. So you need to keep the number of neighbours (edges) and second-neighbours updated efficiently. The first is trivial, so let’s look at second neighbours.

Per @Patrick’s suggestion, let’s work with A^2, and let’s see how it can be efficiently updated without recomputing it from scratch every time. A^2_ij is the number of length-two paths from i to j, just keep in mind that it’ll have diagonal entries as well because there’s always a length-two path from a vertex to itself. If you have A^2, you can easily count the number of second-neighbours, so let’s keep all of A^2 updated in memory while the graph changes.

How to update A^2 efficiently:

When you add/remove an edge, you change A by a matrix B that has only two entries. Suppose we’re adding (not removing) an edge. Then (A+B)^2 = A^2 + AB + BA + B^2.

Assume the edge added was (i,j).

• B^2 is trivial: (B^2)_ii = (B^2)_jj = 1, the rest is 0.
• AB = transpose(BA) so we only need to compute one of the two, say BA. It turns out that row i of BA is row j of A and row j of BA is row i of A, the rest is zero. So again, it’s fast to compute.

Removing edges will be similar.

You only need the count of second-neighbours, so instead of counting how many non-zero non-diagonal entries A^2 has at each step, with some extra work you can count by how much the number of non-zero entries changes in A^2 when you add AB + BA.

EDIT

This whole thing explained in a different language:

Let’s keep track of the number of length-two paths between any two vertices in a matrix M. When we add (remove) an edge between i and j, the number of length-two paths will increase (decrease) by one between i and all neighbours of j as well as j and all neighbours of i, so M is easy to update in O(n) time after every change to the graph.