# The high-degree low-degree technique and arboricity

In this piece we demonstrate the high-degree low-degree technique in graphs. Often, we obtain running times that depends on the individual degrees of the vertices. If the graph has only low degree vertices, then a faster algorithm exists. For graph with only large degrees, then it is dense, and can often be handled in another way.

We will also use the information of arboricity. Mainly, there are a few useful statements.

For a graph $G=(V,E)$ with arboricity $α$, we have $uv∈E∑ min(g(u),g(v))≤2αm$

Often, using the arboricity, we can obtain the same complexity algorithm without high-degree low-degree technique. Note the arboricity is $O(m )$. The application of arboricity are from [1].

Some of the algorithms described can be speedup by using matrix multiplication, or faster combinatorial boolean matrix multiplication. We avoid them for simplicity of exposition.

# 1 Dominating set with few edges

The set cover problem, given $S={S_{1},…,S_{n}}$ are $n$ set contains a total of $m$ elements. $U=⋃_{S∈S}S$ is the universe, with size $u$.

There is a probability distribution $D$ over $S$, such that for each $u$, the probability a random set $S$ covers $u$ is at least $ε$. There exists a set cover of $⌈εlogu ⌉$.

There exists a set that covers at least $ε∣U_{′}∣$ for any $U_{′}⊂U$. Therefore each greedy iteration decrease the size of uncovered universe by an $ε$ fraction. So there can be at most $t$ iterations, where $(1−ε)_{t}<1$. One can show $⌈εlogu ⌉$ suffices.

There is a dominating set incident to $O(nngn )$ edges.

Fix a $δ$. We repeatedly removing vertices with degree no more than $δ$ from the graph, and add it into a set $D$. The total degree of $D$ is at most $nδ$. Now the remaining vertices has degree at least $δ$. Using the set cover theorem, and let the distribution to be the uniform distribution. If all elements are covered at least by $ε$ fraction of the set, then we obtain a set cover of size $O(εlogu )$. Indeed, just let the sets $N(v)$ for each $v$, and we pick them uniformly. We set $ε=δ/n$. Since the degree of each vertex is at least $δ$, then there is a dominating set of size $O(δnlogn )$, and incident to $O(δn_{2}logn )$ edges. Add the dominating set to $D$. $D$ is a dominating set, and the number of edges incident to it is $O(nδ+δn_{2}logn )$, set $δ=ngn $ and we obtain the desired result.

One can show the above result is almost optimal, as there exists graphs where every dominating set incidents $Ω(n_{3/2})$ edges. The same bound holds for weakly connected dominating set, that is a dominating set $D$ such that the edges incident to $D$ forms a connected graph. The stronger modification of this result was used in deciding the $4$-connectivity of a matroid [2].

# 2 Finding small subgraphs

## 2.1 Finding a triangle

A *triangle* is $3$ vertices
pairwise adjacent to each other, another name for $K_{3}$.

There is a $O(mΔ)$ time algorithm to decide if the graph has a triangle, where $Δ$ is the maximum degree.

Indeed, for each vertex $v$, we consider its neighbors, see if any is adjacent to each other. We then delete $v$. The algorithm takes $O(∑_{v}g_{2}(v))=O(mΔ)$ time.

There is a $O(n_{3})$ time algorithm to decide if the graph has a triangle.

The naive algorithm, for each $3$ vertices, we decide if it forms a triangle.

There is a $O(m_{3/2})$ time algorithm to decide if the graph has a triangle.

Let $t$ be a parameter we will find later. Apply the above algorithm by picking the vertex with the smallest degree, until the next vertex has degree at least $t$. It will use at most $O(mt)$ time. Now, for the remaining graph, it is clear the maximum degree is at least $t$. Note, there can be at most $tm $ vertices. We use the $O(n_{3})$ time algorithm. The final running time is $O(mt+(m/t)_{3})$. Set $t=m $ and we are done.

We modify the algorithm a little. For each vertex $v$, we consider its neighbor $u$, and check if $u$ has a neighbor that is in $v$. Then we delete $v$, and move on to next vertex. The running
time become $∑_{v∈V}(g(v)+∑_{u∈N(v)}g(u))$. Now, assume we pick vertices by the
*largest* to *smallest* in term of degrees. We rearrange
the sum and obtain $∑_{v∈V}(g(v)+∑_{u∈N(v)}g(u))=∑_{v∈V}g(v)+2∑_{uv∈E}min(g(u),g(v))=O(αm)$. Because $α≤m $, we have the running time
$O(m_{3/2})$.

## 2.2 A motivating problem

Let $S_{1},…,S_{n}$ be sets with total of $m$ elements. How quickly can we find two distinct $i$ and $j$ such that $∣S_{i}∩S_{j}∣≥ℓ$? This problem can be shown to be equivalent to finding a colored $K_{2,ℓ}$ in a bipartite graph. That is, for input bipartite graph $G=(A,B,E)$. Find a $K_{2,ℓ}$ where the side of two vertices has to be in $A$.

## 2.3 Finding a $C_{4}$ in bipartite graphs

This section we use technique that follows from [3]. Although we are into finding $C_{4}$, but some theorems are more general for $K_{2,ℓ}$, so we will state them too. Note finding a colored $K_{2,2}$ and finding a $K_{2,2}$ is the same problem due to symmetry.

Let $v_{1},…,v_{n}$ be an ordering such that $g(v_{i})≥g(v_{i+1})$. There exists an algorithm that finds an ordering of vertices $v_{1},…,v_{n}$, and returns $N_{i}(v_{i})∩N_{i}(v_{j})$ for each $i$ and $j>i$. Here $N_{i}(v)$ is the set of neighbors of $v$ in $G[{v_{i},…,v_{n}}]$. Here we show an algorithm solves the above problem when the arboricity is small.

The algorithm is as follows [1]. Take $v$, we consider each neighbor $u$. Maintain a set $S_{w}$ for each vertex $w$ distance $2$ from $v$. Add $u$ into each of $u$’s neighbor in $w$. $S_{w}$ would give us information of $N(v)∩N(w)$. We delete $v$ and keep going. It is known the algorithm takes $O(α(G)m)$ time. This allows us to compute $C_{4}$ in the same time. Hence we directly obtain $O(m_{3/2})$ running time. However, we show something better is possible if we are not interested in finding all $C_{4}$, but find any $C_{4}$. We also need the following theorem.

One can check if there exists a $K_{2,ℓ}$ in the bipartite graph $G=(A,B,E)$ in $O(ℓn_{2})$ time.

Now, we combine the two algorithms. It requires a theorem in extremal graph theory can be found in [4].

There exists a constant $c$, such that each $n$ vertex graph with $cn_{3/2}ℓ_{1/2}$ edges contains a $K_{2,ℓ}$.

There is a $O(m_{4/3})$ time algorithm to find a $C_{4}$ in the graph.

If the arboricity is $t$. We use the first algorithm and we get running time $O(tm)$. Otherwise, we know there is a subgraph with minimum degree at least $t$. The subgraph can be found by repeatedly deleting vertices of minimum degree. The subgraph $G_{′}$ with the previous property has $n_{′}≤n$ vertices and $m_{′}≤n_{′}t$ edges. One can see $n_{′}≤m_{′}/t≤m/t$. If $cn_{′3/2}≤m_{′}≤n_{′}t$, then we know there exists a $C_{4}$ in $G_{′}$ by the previous theorem, and we can apply the $O(n_{2})$ time algorithm in the subgraph to find the $C_{4}$. The total running time is therefore $O(tm+n_{′2})=O(tm+(m/t)_{2})$. We set $t=c_{3/2}m_{1/3}$. One can check after lot of algebra, it make sure the condition $cn_{′3/2}≤n_{′}t$ is satisfied. The algorithm takes $O(m_{4/3})$ time.

## 2.4 Finding a colored $K_{2,3}$ in bipartite graphs

For finding $K_{2,ℓ}$, the low arboricity algorithm for $C_{4}$ works here. The $O(α(G)m)$ algorithm is still fine. It’s not hard to generalize and show a $O(ℓ_{1/3}m_{4/3})$ running time algorithm.

However, in order to solve the motivating problem. We need a colored $K_{2,ℓ}$.

Let’s consider a $K_{2,ℓ}$ in $G$, and consider the first indexed vertex $v$. If $v∈A$, then we are done, as the algorithm will find it. If $v∈B$, then we will solve the problem in another way, which gives us some time improvement when $ℓ=3$.

For each $v_{i}$ in $B$, we consider $v_{j}∈B$ that has distance $2$ from $v_{i}$ and $j>i$. We consider the set of vertices $S_{i,j}=N_{i}(v_{i})∩N_{i}(v_{j})$. If there are two sets $S_{i,j}$ and $S_{a,b}$ has intersection size at least $2$, then we claim there exists a $K_{2,3}$ in $G$. Now, this becomes finding a $C_{4}$ in the input sets. The total size of the input sets are $O(α(G)m)$. Hence we can use $O((α(G)m)_{4/3})$ time to find a $C_{4}$. Hence this implies a $O((α(G)m)_{4/3})$ time algorithm to find a $K_{2,3}$.

Using the idea for finding $C_{4}$, we can mix the $((α(G)m)_{4/3})$ time algorithm and the $O(n_{2})$ time algorithm. Working out the algebra shows the following theorem.

There is a $O(m_{28/15})$ time algorithm for finding a colored $K_{2,3}$.

# References

**Arboricity and Subgraph Listing Algorithms**, SIAM Journal on Computing. 14 (1985) 210–223 10.1137/0214017.

**Finding and counting given length cycles**, Algorithmica. 17 (1997) 209–223 10.1007/BF02523189.

**New asymptotics for bipartite turán numbers**, Journal of Combinatorial Theory, Series A. 75 (1996) 141–144 10.1006/jcta.1996.0067.