11. Matrices

We can model a number of graph problems using matrices. This then allows us to use techniques from linear algebra (Strassen’s, iterative squaring) to speed up computation.

Problems in Matrix version

Existence of Walks

We can first reformulate this as a DP problem. $L_{ij}^{(k)}=1$ iff. there exists a walk of length $k$ from $i$ to $j$. Then we have the following recurrence: $L_{ij}^{(k)}=\{\begin{array}{ll}1& \text{if }\exists v\in V{L}_{iv}^{(k-1)}\wedge L_{vj}^{(1)}\\ 0& \text{otherwise}\end{array}$

Minimal Cost of a Walk

The minimal cost can be formulated in a very similar way, by taking the minimum of the shortest walk with $k-1$ edges and all possible $v\in V$ with an edge to $t$ and the cost to get to them.

Number of Walks

We want to count the number of walks to reach a vertex $j$. We let $N_{ij}^{(k)}:=$ number of walks from $i$ to $j$. Recurrence: $N_{ij}^{(k)}={\sum }_{s=1}^n{N}_{is}^{(k-1)}\cdot N_{sj}^{(1)}$which is exactly a matrix multiplication. Note that if $N_{sj}^{(1)}=0$ the product will be $0$ and as there is no path through $s$, this is exactly what we want.

Let $A$ denote the adjacency matrix for graph $G$. Then $N^{(k)}=N^{(k-1)}A=A^k$.

Counting Triangle Walks

We can use this trick to count the number of triangle walks in a graph (walks from $s$ to $i$ to $t$ to $s$ (not using $s$ in between).

As a triangle walk is just a walk from $s\to s$ with $3$ edges, we can use the matrix $A^3$. We can check the number of triangle walks from vertex $i$ by checking $A_{ii}^3$. Then we sum over all of these $i$‘s.

This is exactly the trace of $A^3$, thus: $\text{Number of triangle walks }=\frac{1}{3}\text{Tr}(A^3)$note we divide by three as otherwise we’d count the same walk $(s,i,t,s)$ thrice for each intermediate vertex.

Reachability (Transitive Closure)

In an undirected graph, it’s easy to check for reachability: we just use BFS or DFS to find the connected component.

In a directed graph the problem is slightly more involved. Instead of counting the number of walks, we now go back to the problem of checking if any exists.

But we don’t want to have to calculate $\forall i{A}^i$ in order to check if there exists a path of length $i$, but only check the final $A^n$. We can do this by adding a self-loop ($A_{ii}=1$) for each vertex. Then any walk can just “wait” on the last vertex.

Then we can use iterative squaring to find the final matrix instead of having to check every single one.

Optimisations

There are a few ways to speed up naive matrix multiplication from $O(n^3)$.

Iterative Squaring

Iterative Squaring relies on the fact that $A^4=A^2{A}^2$ which means we only need to compute $A^2$ once and get $A^4$ using one more multiplication (instead of $AAAA$ for a total of 4).

$$A^k=\{\begin{array}{ll}(A^{k/2}{)}^2,& \text{if }k\text{ is even}\\ A\cdot (A^{(k-1)/2}{)}^2,& \text{if }k\text{ is odd}\end{array}$$

Algorithm:

1. Initialize: result = I (identity matrix), temp = A, k' = k
2. Iterate: While k' > 0:
   • If k' is odd: result = result * temp (using appropriate multiplication - arithmetic or boolean), k' = k' - 1
   • temp = temp * temp
   • k' = k' / 2
3. Return: result

Strassen’s

Strassen’s algorithm is basically Karatsuba’s but for matrices. The runtime is given by: $T(n)=7T(n/2)+O(n^2)$ where the $O(n^2)$ factor is the combining of final results for each entry.

This is slightly faster than $n^3$ at $n^{2.81}$, as we can verify using the Master Theorem.