The Densest k Subgraph Problem in b-Outerplanar Graphs

TL;DR

This paper presents efficient algorithms for finding the densest k subgraph in b-outerplanar graphs and discusses the limitations of existing approximation techniques in planar graphs.

Contribution

It introduces exact algorithms with specific time complexities for b-outerplanar graphs and explores the challenges of applying Baker's PTAS to planar graphs.

Findings

Exact $O(nk^2)$ algorithm for outerplanar graphs

Extended $O(nk^2 8^b)$ algorithm for b-outerplanar graphs

Baker's PTAS likely ineffective for planar graphs

Abstract

We give an exact $O(nk^2)$ algorithm for finding the densest k subgraph in outerplanar graphs. We extend this to an exact $O(nk^2 8^b)$ algorithm for finding the densest k subgraph in b-outerplanar graphs. Finally, we hypothesize that Baker's PTAS technique will not work for the densest k subgraph problem in planar graphs.

Figures

Full text

1 Introduction

The density of a graph is defined to be the ratio of edges to vertices in the graph. More precisely, if an undirected graph $G=(V,E)$ has $|V|=n$ vertices and $|E|=m$ edges, the density of $G$ is ${m\over n}$.

In a network that represents academic collaboration, authors within the densest component of the graph tend to be the most prolific [23]. Dense components in a web graph might correspond to sets of web sites dealing with related topics [15] or link farms [16]. A dense subgraph of the dolphin social network might identify the most popular dolphins. Finding dense subgraphs aids in finding price value motifs [10]. Dense subgraphs can identify communities in social networks [7]. In the field of visualization, finding dense subgraphs allows for better graph compression [6]. Dense subgraphs assist in finding stories and events in micro-blogging streams such as Twitter [1]. Dense subgraphs can be used to discover regulatory motifs in genomic DNA [14], and to find correlated genes [22]. It is therefore interesting to find the dense components of graphs, or dense subgraphs. The density of a subgraph induced by a vertex set $S\subseteq V$ is $d(S)={{|E(S)|}\over{|S|}}$. Goldberg gave an $O(nm\log n\log({{n^{2}}\over{m}}))$ algorithm to find the subgraph of maximum density using network flow techniques [18].

Given an undirected graph $G=(V,E)$ and an integer $k$, the densest $k$ subgraph problem is defined as follows: find a subgraph $H\subseteq G$ such that $|V(H)|=k$ and the density of $H$ is maximized. This problem can be shown to be NP-Hard by a reduction from Clique [13]. Since (if $P\neq NP$) there is no polynomial time algorithm for this problem, we search for an approximation algorithm. The best approximation algorithm that one could hope to develop is a PTAS or polynomial time approximation scheme. A PTAS is an algorithm that takes as an input an instance of an optimization (maximization) problem and a parameter $\epsilon$ and in polynomial time produces a solution that is within $1-\epsilon$ of the optimal solution. Unfortunately there is no PTAS (unless NP$\subseteq\cap_{\epsilon>0}$BPTIME$(2^{n^{\epsilon}})$) for the densest $k$-subgraph problem. This is shown by a reduction from the Minimum Distance of Code Problem [20]. The best approximation known is a recent $O(n^{1/4+\epsilon})$-approximation algorithm that runs in time $n^{O(1/\epsilon)}$ [4], which is an improvement on the long standing $O(n^{1/3})$ approximation [13].

Often, when there is no PTAS possible for a problem in a general graph, one will find a PTAS for that same problem restricted to planar graphs, graphs that can be drawn in the plane in such a way that no two edges cross each other. For example, the maximum independent set problem, which is known to be NP-Complete in general graphs, has a PTAS in planar graphs [2]. There are many PTASes for classic problems such as: travelling salesperson [21], Steiner tree [5], and Steiner forest [3], when the domain is restricted to be planar. This leads us to consider planar variants of the densest subgraph problems.

While the complexity of the unconnected densest $k$ subgraph problem on planar graphs is unknown [9], the connected planar densest $k$ subgraph problem is NP-Complete by a reduction from the connected vertex cover problem on planar graphs with maximum degree 4 [19].

In what follows we begin with an exact polynomial time algorithm for the densest $k$ subgraph problem in outerplanar graphs inspired by Baker [2] in Section 2. We extend this algorithm to $b$-outerplanar graphs in Section 3. Finally we hypothesize that a Polynomial Time Approximation Scheme (PTAS) for the densest-k subgraph problem in planar graphs cannot be achieved using Baker’s technique in Section 4.

2 An Algorithm to Find the Densest $k$ Subgraph Problem in

Outerplanar Graphs

We modify the dynamic programming technique of Baker [2] for outerplanar graphs. Suppose we are given an outerplanar graph, a planar graph with an embedding such that all vertices are on the outer face. We will define a rooted labelled tree, $T$, that will correspond to the given outerplanar graph. This tree construction was given by Baker [2]. We repeat it here for completeness.

Suppose we are given an outerplanar graph, $G$. If $G$ has any bridges (an edge whose removal disconnects the graph), $(x,y)$, add an additional edge $(x,y)$. Then the bridge may be treated as a face. We will call edges exterior if they lie on the outer face and interior otherwise.

Now we build the tree, $T$: First we suppose that $G$ has no cutpoints (vertices whose removal disconnects the graph). For a description of the tree construction on an outerplanar graph with cutpoints, see [2]. We place a tree vertex in each interior face (call these interior tree vertices) and on each exterior edge (call these exterior tree vertices). We add a tree edge between each interior tree vertex and the interior tree vertices of adjacent faces. We also add a tree edge between each interior tree vertex and any exterior tree vertices with edges adjacent to the face. For a very simple example, see Figure 1.

We may choose any interior tree vertex to be the root of $T$. We may also choose which child of this root will be the leftmost child. These two choices determine the ordering of all remaining vertices. We label the vertices of $T$ recursively. Label each exterior tree vertex in the tree with the exterior edge that it is on. Label each interior tree vertex with the first and last vertices of its children’s labels.

After constructing Baker’s tree (as described above), we give our original dynamic program. We fill in a table for each vertex, $v$, in $T$ (with label $(x,y)$). The table will hold the maximum number of edges for a subgraph on $k$ vertices ($k$ ranging from 0 to the size of the subgraph for the subtree rooted at $v$) depending on whether or not $x$ and $y$ are in the set. For example, consider the leaf vertex, $L$, in $T$ representing edge $(b,a)$ in $G$:

$Table(L)=T_{(b,a)}=$

$b$ $a$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

This table is undefined for many entries, for example, the entry where $b=0$, $a=1$, and $k=2$ is undefined because there is no way to have a subgraph on 2 vertices when there is only one vertex to select from. For the entry where $b=1$, $a=1$, and $k=2$, we obtain a value of $1$ because there is an edge between $b$ and $a$. The table will be identical for each leaf in $T$.

Now we will fill out a table for a tree vertex with exactly two children. This table is calculated by merging the tables for its two children, as described below. Consider $H$ with label $(b,e)$:

$Table(H)=T_{(b,e)}=$

$b$ $e$ $k=0$ $k=1$ $k=2$ $k=3$

0 0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 1 $\emptyset$

1 0 $\emptyset$ 0 1 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1 3

We now give pseudocode for how to merge two sibling tables, $T_{(x,y)}$ and $T_{(y,z)}$ (creating $T_{(x,z)}$). For the table of a vertex with label $\mathcal{L}$, $\mathcal{K}$ will be the minimum of $k$ (the input $k$ for the densest $k$ subgraph problem) and the number of vertices in the subtree represented by label $\mathcal{L}$.

To find the solution for the densest $k$ subgraph problem, we look to the table for the root, in the case of our example, the table for $J$. We take the maximum value in the table for the column corresponding to $k$.

$Table(J)=T_{(c,c)}=$

$c$ $c$ $k=0$ $k=1$ $k=2$ $k=3$ $k=4$ $k=5$ $k=6$ $k=7$

0 0 0 0 1 3 4 6 7 $\emptyset$

0 1 $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$

1 0 $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$ $\emptyset$

1 1 $\emptyset$ 0 1 3 4 6 8 10

To find all intermediate tables, please see Appendix A.

The following two lemmas will give the proof of correctness of the dynamic programming algorithm.

Lemma 1

For each leaf vertex, $X$ (with label $(a,b)$), in the tree, $Table(X)=T_{(a,b)}$ correctly gives the maximum number of edges in the subgraph corresponding to $X$ with the constrained number of vertices (each $k$ value).

Proof: Each leaf vertex, $X$, in the tree corresponds to a single edge, $(a,b)$, in the original graph. There are only three possible values of $k$ in this case, zero, one, or two.

If there are zero vertices included, the maximum number of edges is zero. However if we try to include either vertex $a$ or $b$ or both this would be absurd (because we are including zero vertices), so these entries should be undefined.

If one vertex is to be included, again it would be absurd to try to include zero or two vertices, so these entries are undefined. The only feasible possibilities are including only $a$ for zero edges or only $b$ for zero edges.

If two vertices are to be included, it would be absurd to include zero or only one vertex, so these entries are undefined. The only feasible possibility is to include both $a$ and $b$ and since there is an edge between $a$ and $b$, we get one edge.

$\Box$

Lemma 2

For each vertex, $V$, in the tree $Table(V)$ correctly gives the maximum number of edges in the subgraph corresponding to $V$ with the constrained number of vertices (each $k$ value).

Proof: If $V$ is a leaf vertex, then Lemma 1 gives us that $Table(V)$ is correct. So, we may suppose that $V$ is not a leaf vertex and that the tables for the children of $V$ are correct. Let $X_{1},X_{2},\dots,X_{m-1}$ denote the children of $V$, and let the child $X_{i}$ have label $(x_{i},x_{i+1})$. This means that $V$ has label $(x_{1},x_{m})$. The table for $V$ is then calculated by merging the tables for each $X_{i}$; that is, we first merge $Table(X_{1})=T_{(x_{1},x_{2})}$ and $Table(X_{2})=T_{(x_{2},x_{3})}$ to get a table $T_{(x_{1},x_{3})}$, then we merge $T_{(x_{1},x_{3})}$ with $Table(X_{3})=T_{(x_{3},x_{4})}$ to get $T_{(x_{1},x_{4})}$ and so on, ultimately obtaining the table $T_{(x_{1},x_{m})}$. We claim that a call to merge on the tables for two consecutive tree vertices $X$ and $Y$ with labels $(x,y)$ and $(y,z)$, respectively, results in a correct table for the union of the subgraphs corresponding to $X$ and $Y$, as well as the edge $(x,z)$ (if it is an edge). If the claim is true, then the result of merging the tables of each child $X_{i}$ must result in the correct table for $V$.

The table $T_{(x,z)}$ should have a row for each pair of values $b_{x}$ and $b_{z}$, and each entry in the row corresponds to a particular value of $k$. So, fix $b_{x}$, $b_{z}$, and $k$. The entry $T_{(x,z)}(b_{x},b_{z},k)$ should contain the maximum number of edges possible over all subgraphs of $k$ vertices that may contain $x$ and $z$ (depending on the values of $b_{x}$ and $b_{z}$), where this subgraph is contained in the union described above. The merge procedure checks for the cases when we include $y$ or do not include $y$ in the subgraph by setting the bit $b_{y}$. So, fix $b_{y}$. The procedure then checks the egde count in every possible subgraph by varying the values of $k_{x}$ and $k_{z}$, which are the $k$ values we use to lookup edge counts in the tables $T_{(x,y)}$ and $T_{(y,z)}$, respectively. The idea is that we can check all possible subgraphs of size $k$ containing the included vertices by checking subgraphs corresponding to $X$ and $Y$ such that the number of vertices in both subgraphs sums to $k$. In order to ensure that the values of $k_{x}$ and $k_{z}$ do in fact result in a correctly sized subgraph union, the procedure first sets $k_{x}$ to be some value between $b_{x}+b_{y}$ and $k$ (the lower bound is due to the fact that $k_{x}$ is a vertex count, and $b_{x}$ and $b_{y}$ effectively count whether $x$ and $y$ are included). The procedure then sets $k_{z}$ to be $k-k_{x}+b+y$; adding in $b_{y}$ avoids double counting the inclusion of $y$ (if it is included). However, if $x=z$ and $b_{x}=b_{z}=1$ (i.e. $x$ and $z$ are both included in the subgraph), we have double counted the vertex $x$, hence the procedure increments the value of $k_{z}$ to allow another vertex to be included in the union. The procedure then saves the value $T_{(x,y)}(b_{x},b_{y},k_{x})+T_{(y,z)}(b_{y},b_{z},k_{z})$ and increments it if $(x,z)$ is an edge and both vertices are included (this is because each individual table does not account for the edge). Once all such values are computed, the procedure sets $T_{(x,z)}(b_{x},b_{z},k)$ to be the maximum value (if all values were undefined, the table entry is set to be undefined as well). Since each value corresponds to an edge count of the corresponding subgraph and all subgraphs were checked, the table entry is thus the maximum number of edges. Therefore, the merge procedure results in a correct table for the corresponding subgraph, whence the table for $V$ must also be correct.

$\Box$

Note that the running time for this dynamic program on outerplanar graphs is, $O(nk^{2})$: There is a table for each tree vertex and the number of tree vertices is the number of edges in the graph (plus 1 for the root which doesn’t correspond to an edge). Also, since our graph is planar the number of edges is linear in the number of vertices. It takes $O(k^{2})$ time to fill in each table.

3 An Algorithm to Find the Densest $k$ Subgraph Problem in

$b$-Outerplanar Graphs

We now lay out the dynamic programming solution for the densest $k$ subgraph problem in $b$-outerplanar graphs. We define trees, labels, and slices as given by Baker [2]. We assume that the given graph is connected. We define levels. Level 1 vertices form the outer face of the $b$-outerplanar graph. Level 2 vertices form the outer face if all level 1 vertices are removed, and so on. Additionally, we assume that the level $i$ vertices contained in a level $i-1$ face form a connected subgraph called a level $i$ component. If this is not the case, we may add fake edges that will simply be ignored when we calculate table values. Throughout this section, we will use the 3-outerplanar graph in Figure 3 as a running example.

Furthermore, we need to construct a triangulation of our graph. We will use the triangulation to construct trees in Section 3.0.1 and slices in Section 3.0.2. Any triangulation will do, and one can be constructed in linear time by scanning the vertices in levels $i$ and $i+1$ in parallel for each $i=1,2,\dots,k-1$. A triangulation for the graph in Figure 3 is given in Figure 3.

3.0.1 Tree Construction

Since a level $i$ component is an outerplanar graph, we can construct a tree for each level $i$ component where the vertices of the tree represent interior faces and exterior edges of the component, just as in the previous section. However, we need to restrict how the roots and leftmost children are chosen for trees of level $i$ components, where $i>1$.

Suppose we want to construct the tree for the level $i$ component $C$ that is enclosed by a level $i-1$ face $f$. Furthermore, suppose we have already constructed the tree for the level $i-1$ component that contains $f$, hence $f$ is represented by some vertex $(x,y)$ in that tree. The root of the tree for $C$ will be of the form $(z,z)$ for some vertex $z$ in $C$. If $x=y$, we pick $z$ so that $z$ is adjacent to $x$ in the triangulation of the graph. If $x\neq y$, we pick $z$ to be the third vertex in the triangle containing $x$ and $y$ in the triangulation.

The leftmost child for $(z,z)$ (assuming $C$ contains more than one vertex) is of the form $(z,u)$, where $u$ is the vertex in $C$ such that $(z,u)$ is an exterior edge in $C$ and is the first edge counterclockwise around $z$ after the edge $(z,x)$ in the triangulation. With these two restrictions, the rest of the tree is constructed exactly as in the previous section. The trees for the components of the graph in Figure 3 are given in Figure 4.

3.0.2 Slice Construction

The dynamic programming solution follows a divide and conquer paradigm, where we divide the graph into so-called slices and calculate the tables for each slice before merging them together. Each vertex in each tree (and hence each interior face and exterior edge in each component of the graph) corresponds to a particular slice. We lay out the construction of these slices below. The idea is to first define left and right boundaries for each tree vertex, and then define their slices by taking the induced subgraph of all vertices and edges that exist between the boundaries. The analogy here is that you can obtain a slice of pie by first deciding where your two cut lines will be (the left and right boundaries), and then your slice will be the pie that exists between your cuts.

Let $C$ be a level $i$ component enclosed by the level $i-1$ face $f$, and let $(x,y)$ be the tree vertex corresponding to $f$. For a particular slice of $C$, we want the left and right boundaries to each contain one vertex from each level of the graph, starting at level $i$ and extending outward to level 1. We will choose these vertices to be dividing points. Given two successive leaf vertices $(x_{1},x_{2}),(x_{2},x_{3})$ of the tree with root corresponding to $C$, we say a vertex $y$ in $f$ is a dividing point for $(x_{1},x_{2})$ and $(x_{2},x_{3})$ if the edges $(x_{2},x_{1}),(x_{2},y),(x_{2},x_{3})$ occur in counterclockwise order around $x_{2}$ in the triangulation of the graph. For example, in Figure 3, $B$ is a dividing point for $(a,b)$ and $(b,c)$, and $B$, $C$, and $E$ are dividing points for $(b,c)$ and $(c,d)$.

We now define a pair of functions $\mathrm{lbn}$ and $\mathrm{rbn}$, which assign to each tree vertex a left boundary number and a right boundary number, respectively. Note that these boundary numbers will only be assigned to trees corresponding to level $i$ components for $i>1$. This is because we will use boundary numbers to recursively define the boundaries themselves, where level 1 boundaries are the base case and level $i>1$ boundaries are obtained from level $i-1$ boundaries. Using the same setup for $C$ and $f$ as given above, we define these functions as follows:

1. (F1)

Let the leaves of the tree corresponding to $C$ be $v_{1},v_{2},\dots,v_{t}$ from left to right, where $v_{i}$ has label $(x_{i},x_{i+1})$ for $1\leq i\leq t$. Let the children of the tree vertex corresponding to $f$ be $z_{1},z_{2},\dots,z_{r}$ from left to right, where $z_{j}$ has label $(y_{j},y_{j+1})$ for $1\leq j\leq r$. Set $\mathrm{lbn}(v_{1})=1$ and $\mathrm{rbn}(v_{t})=r+1$. For $1<i\leq t$, define $\mathrm{lbn}(v_{i})=q$, where $q$ is the least $p\geq\mathrm{lbn}(v_{i-1})$ such that $y_{p}$ is a dividing point for $(x_{i-1},x_{i})$ and $(x_{i},x_{i+1})$. For $1\leq i<t$, define $\mathrm{rbn}(v_{i})=\mathrm{lbn}(v_{i+1})$. 2. (F2)

Let $v$ be a non-leaf vertex in the tree corresponding to $C$, and suppose $v$ has leftmost child $c_{L}$ and rightmost child $c_{R}$. Define $\mathrm{lbn}(v)=\mathrm{lbn}(c_{L})$ and $\mathrm{rbn}(v)=\mathrm{rbn}(c_{R})$.

For example, let $C$ be the level 2 component in Figure 3 represented by the tree with root $(a,a)$. The enclosing face $f$ is represented by the tree vertex $(A,A)$. We first assign $\mathrm{lbn}((a,b))=1$ and $\mathrm{rbn}((d,a))=5$ since $(A,A)$ has 4 children. As mentioned above, $B$ is the only dividing point for $(a,b)$ and $(b,c)$, so we set $\mathrm{lbn}((b,c))=2$ (and hence $\mathrm{rbn}((a,b))=2$). We know that $B$, $C$, and $E$ are dividing points for $(b,c)$ and $(c,d)$, with indices 2, 3, and 4, respectively, out of the list of vertices in the children of $(A,A)$. Since 2 is the least $p\geq\mathrm{lbn}((b,c))=2$, we set $\mathrm{lbn}((c,d))=2$ (and hence $\mathrm{rbn}((b,c))=2$).

A complete list of boundary numbers can be seen in Figure 5, where we write the left and right boundary numbers on the left and right side of each tree vertex, respectively. Note that $\mathrm{lbn}((x_{i-1},x_{i}))=\mathrm{rbn}((x_{i},x_{i+1}))$ for every pair of consecutive tree vertices $(x_{i-1},x_{i})$ and $(x_{i},x_{i+1})$.

We are now ready to formally define left and right boundaries. Let $v$ be a tree vertex with label $(x,y)$. Then,

1. (B1)

If $v$ is a vertex in a level 1 tree, the left boundary of the slice of $v$ is $x$ and the right boundary is $y$. 2. (B2)

Otherwise, $v$ is a vertex in a level $i$ tree that corresponds to some level $i$ component enclosed by a level $i-1$ face $f$. Suppose the tree vertex corresponding to $f$, denoted $\mathrm{vertex}(f)$, has $s$ children. Let $\ell=\mathrm{lbn}(v)$ and let $r=\mathrm{rbn}(v)$. Then the left boundary of the slice of $v$ is $x$ plus the left boundary of the slice of the $\ell$th child of $\mathrm{vertex}(f)$, where we can let the left boundary of the nonexistent $(s+1)$ child of $\mathrm{vertex}(f)$ equal the right boundary of the $s$ child of $\mathrm{vertex}(f)$. Similarly, the right boundary of the slice of $v$ is $y$ plus the right boundary of the $(r-1)$ child of $\mathrm{vertex}(f)$, where we can let the right boundary of the nonexistent 0th child of $\mathrm{vertex}(f)$ equal the left boundary of the 1st child of $\mathrm{vertex}(f)$.

A complete list of boundaries for every tree vertex is given in Figure 6. As with boundary numbers, the left and right boundaries have been written on the left and right side of each corresponding tree vertex. By construction, the right boundary of the tree vertex $(x_{i-1},x_{i})$ must equal the left boundary of the next consecutive tree vertex $(x_{i},x_{i+1})$.

With the definition for boundaries in place, we can now formally define slices. Let $v$ be a level $i$ tree vertex for $i\geq 1$ with label $(x,y)$. We denote the slice of $v$ as $\mathrm{slice}(v)$, which is defined as follows:

1. (S1)

If $v$ represents a level $i$ face $f$ that does not enclose any level $i+1$ components, then $\mathrm{slice}(v)$ is the union of the slices of the children of $v$, together with $(x,y)$ if $(x,y)$ is an edge. 2. (S2)

If $v$ represents a level $i$ face $f$ that encloses a level $i+1$ component $C$, then $\mathrm{slice}(v)$ is the slice of the root of the tree that represents $C$, together with $(x,y)$ if $(x,y)$ is an edge. 3. (S3)

If $v$ is a level 1 leaf, then $\mathrm{slice}(v)$ is simply the edge $(x,y)$. 4. (S4)

Suppose $v$ is a level $i$ leaf for $i>1$. Let $f$ be the level $i-1$ face that encloses $(x,y)$, and let $u_{j}$ for $1\leq j\leq t$ be the children of $\mathrm{vertex}(f)$ (the tree vertex representing $f$). Let each $u_{j}$ have label $(z_{j},z_{j+1})$.

1. (i)

If $\mathrm{lbn}(v)\neq\mathrm{rbn}(v)$, then $\mathrm{slice}(v)$ is the union of each $\mathrm{slice}(u_{j})$ for $\mathrm{lbn}(v)\leq j<\mathrm{rbn}(v)$, along with any edges from $x$ or $y$ to $z_{j}$ for $\mathrm{lbn}(v)\leq j\leq\mathrm{rbn}(v)$ and the edge $(x,y)$. 2. (ii)

If $\mathrm{lbn}(v)=\mathrm{rbn}(v)=b$, then $\mathrm{slice}(v)$ is the left boundary of $\mathrm{slice}(u_{b})$ (including edges between consecutive boundary vertices), along with any edges from $x$ or $y$ to $z_{b}$ and the edge $(x,y)$.

The slices for $(a,b)$, $(b,d)$, and $(d,a)$ are given in Figure 7, where boundary vertices are connected by dashed lines if they are not connected already. Since $(a,b)$ is a level 2 leaf enclosed by the face with tree vertex $(A,A)$, and $\mathrm{lbn}((a,b))=1\neq 2=\mathrm{rbn}((a,b))$, we see that $\mathrm{slice}((a,b))$ is equal to $\mathrm{slice}((A,B))$ along with the edges connecting $a$ to $A$ and $B$, where $\mathrm{slice}((A,B))$ is the edge $(A,B)$. Similarly, $\mathrm{slice}((d,a))$ is equal to $\mathrm{slice}((E,A))$ along with the edges connected $d$ and $a$ to $E$ and $A$. Since $(b,d)$ is a level 2 tree vertex representing a face that encloses the level 3 component represented by $(1,1)$, its slice is equal to $\mathrm{slice}((1,1))$ along with the edge $(b,d)$. The slice for $(1,1)$ is obtained by taking the union of $\mathrm{slice}((b,c))$ and $\mathrm{slice}((c,d))$ and adding the edges connecting 1 to $b$ and $d$.

3.0.3 Dynamic Program

In this section, we detail the dynamic program that solves the densest $k$ subgraph problem for $b$-outerplanar graphs. Note that adjust, merge, extend and contract are original whereas the table procedure is given by Baker [2]. The pseudocode for these procedures can be found in Appendix B. The program essentially follows the same recursive structure that we used to build the slices since it creates a table for each slice. The table for a level $i$ slice consists of $2^{2i}$ entries: one entry for each subset of the boundary vertices (recall that the left and right boundaries for a level $i$ slice contain exactly $i$ vertices each, for a total of $2i$ boundary vertices). An entry contains a number for each value of $k^{\prime}=0\dots k$, where this number is the maximum number of edges over all subgraphs of the slice of exactly $k^{\prime}$ vertices that contain the corresponding subset of the boundary vertices.

The main procedure of the program is table (shown in Figure 9), which takes as input a tree vertex $v=(x,y)$. This procedure contains a conditional branch corresponding to each of the rules S1 – S4. The branch corresponding to S1 handles the case when $v$ represents a face $f$ that does not enclose a level $i+1$ component. In this case, the procedure makes a recursive call to table on each child of $v$ and merges the resulting tables together. Note that this is analogous to how rule S1 creates $\mathrm{slice}(v)$ by taking the union of the slices for the children of $v$.

The second conditional branch (corresponding to rule S2) handles the case when $v$ represents a face $f$ that encloses a level $i+1$ component $C$. In this case, the procedure makes a recursive call to table on the tree vertex that represents $C$. The resulting table is then passed to the contract function, which turns a level $i+1$ table into a level $i$ table by removing the level $i+1$ boundary vertices from the table, and the contracted table is then returned.

The third conditional branch (corresponding to rule S3) handles the case when $v$ is a level 1 leaf. In this case, the procedure returns a template table that works for all level 1 leaf vertices, since any level 1 leaf represents a level 1 exterior edge of the graph.

The fourth conditional branch, which corresponds to rule S4, is slightly more complicated. This branch handles the case when $v$ is a level $i>1$ leaf vertex. The idea is to break up the slice of $v$ into subslices, compute the table for an initial subslice, and extend this table by merging the tables for the subslices clockwise and counterclockwise from the initial subslice. These subslices have their own respective subboundaries. In the second case of rule S4, where $\mathrm{lbn}(v)=\mathrm{rbn}(v)$, no subslices can be created, so the procedure will return the table for the whole slice by passing the vertex to the create procedure, which effectively applies brute force to create the table for the subslice determined by the second parameter $p$ (this is explained in more detail below).

In the case that $\mathrm{lbn}(v)\neq\mathrm{rbn}(v)$, we can create tables for subslices. Since we are dealing with a planar graph, there exists a level $i-1$ vertex $z_{p}$ such that all level $i-1$ vertices other than $z_{p}$ that are adjacent to $x$ are clockwise from $z_{p}$, and all level $i-1$ vertices other than $z_{p}$ that are adjacent to $y$ are counterclockwise from $z_{p}$. Here, $z_{p}$ is the only level $i-1$ vertex in $\mathrm{slice}(v)$ that can be adjacent to both $x$ and $y$ (although it might not be adjacent to either). So, we construct an initial level $i$ table for the subslice corresponding to $z_{p}$ using create, and then we make as many calls as necessary to the merge and extend procedures (described below) to extend the table on one side with subslices constructed from the vertices adjacent to $x$, and on the other side with subslices constructed from the vertices adjacent to $y$.

For example, Figure 8 shows how we split $\mathrm{slice}((c,d))$ into subslices. The algorithm finds that $E$ is a level 1 vertex such that the level 1 vertices adjacent to $c$ are clockwise from $E$ and the level 1 vertices adjacent to $d$ are counterclockwise to $E$ (of which there are none). A call to create constructs the table for the initial subslice with subboundaries $c,E$ and $d,E$. We then merge the other subslices in a clockwise fashion, first merging the table for the subslice with subboundaries $c,C$ and $c,E$, and then merging the table for the subslice with subboundaries $c,C$ and $c,B$.

The adjust procedure, given in Figure 10, takes as input a table $T$, which represents a slice with left boundary $L$ and right boundary $R$. Let $x$ and $y$ be the highest level boundary vertices in $L$ and $R$, respectively. This procedure checks if $x\neq y$, and if so, adds 1 to the table entry where $x$ and $y$ are both included. Unlike in Baker’s original procedure, the case when $x=y$ is not handled in this procedure and is instead handled in merge.

The merge procedure, given in Figure 11, takes as input two tables $T_{1}$ and $T_{2}$ such that the right boundary of the slice that $T_{1}$ represents is the same as the left boundary of the slice that $T_{2}$ represents. Let the left and right boundaries of the slice that $T_{1}$ represents be $L$ and $M$, and let the left and right boundaries of the slice that $T_{2}$ represents be $M$ and $R$. The resulting table $T$ returned by merge has left and right boundaries $L$ and $R$. This procedure constructs $T$ by creating an entry for each subset $A$ of $L\cup R$. As stated earlier, each entry contains a number for each value of $k^{\prime}$, where $k^{\prime}$ ranges from 0 to the number of vertices in the union of the two slices represented by $T_{1}$ and $T_{2}$, and where the number is the maximum number of edges over all subgraphs of exactly $k^{\prime}$ vertices containing $A$. Each of these individual subgraphs contains a different subset $B$ of $M$.

The contract procedure, given in Figure 12, changes a level $i+1$ table $T$ into a level $i$ table $T^{\prime}$. Here, $T$ represents the slice for $(z,z)$, where $(z,z)$ is the root of a tree corresponding to a level $i+1$ component $C$ contained in a level $i$ face $f$, and $T^{\prime}$ is the table for the slice of $\mathrm{vertex}(f)$. Let $S=\mathrm{slice}((z,z))$ and let $S^{\prime}=\mathrm{slice}(\mathrm{vertex}(f))$. Let the left and right boundaries of $S^{\prime}$ be $L$ and $R$, respectively. Then the left and right boundaries of $S$ are of the form $z,L$ and $z,R$ respectively. For each subset of $L\cup R$ and for each value of $k^{\prime}$, $T$ contains two numbers: one that includes $z$ and one that does not include $z$. So, for each subset $A$ of $L\cup R$ and each value of $k^{\prime}$, we set $T(A,k^{\prime})$ equal to the larger of these two numbers.

The create procedure takes as input a leaf vertex $v=(x,y)$ in a tree that corresponds to a level $i+1$ component enclosed by a face $f$, and a number $p\leq t+1$, where the children of $\mathrm{vertex}(f)$ are $u_{1},u_{2},\dots,u_{t}$. This procedure simply applies brute force to create the table for the subgraph containing the edge $(x,y)$, the subgraph induced by the left boundary of $u_{p}$ if $p\leq t$ or the right boundary of $u_{p-1}$ if $p=t+1$, and any edges from $x$ or $y$ to the level $i$ vertex of this boundary (this construction is similar to the construction of slices, hence the term subslice is appropriate). Due to the simplicity of this function, it will not be explicitly written here.

Lastly, the extend procedure, given in Figure 13, takes as input a level $i+1$ vertex $z$ and a table $T$ representing a level $i$ slice, and produces a table $T^{\prime}$ for a level $i+1$ slice. Let $L$ and $R$ be the boundaries for the level $i$ slice represented by $T$. The boundaries for the new slice will be $L\cup\{z\}$ and $R\cup\{z\}$. For each subset $A$ of $L\cup R$ and each value of $k^{\prime}$, the new table $T^{\prime}$ contains two values: one that includes $z$ and one that does not include $z$. The entries $T^{\prime}(A,k^{\prime})$ which do not include $z$ can simply be set to their original values in $T$. For the entries $T^{\prime}(A\cup\{z\},k^{\prime})$ that do include $z$, we first check that $T(A,k^{\prime}-1)$ is not undefined. If this is the case, we set $T^{\prime}(A\cup\{z\},k^{\prime})$ as $T(A,k^{\prime}-1)$ plus the number of edges between $z$ and every vertex in $A$.

We claim that calling the above algorithm on the root of the level 1 tree results in a correct table for the slice of the root and that this slice is actually the entire graph. Since the level 1 root is of the form $(x,x)$, its left and right boundaries are both equal to $x$. Thus, the table for this root has exactly 4 rows, and two of these rows are invalid since they attempt to include one copy of $x$ and not the other (which is nonsensical). The two remaining rows have numbers corresponding to the maxmimum number of edges in subgraphs of size exactly $k^{\prime}$ for $k^{\prime}=0,\dots,k$. Taking the maximum between the two numbers corresponding to when $k^{\prime}=k$ gives us the size of the densest $k$ subgraph.

3.0.4 Proof of Correctness

Baker’s original paper provides us with a proof that the procedure table is correct under the assumption that the procedures adjust, merge, contract, create, and extend are implemented correctly. While we have to slightly modify this proof so that it works for our implementation, the bulk of the work is in proving that the above five procedures are in fact correct for the densest $k$ subgraph problem. Since create is just a brute-force algorithm, its implementation is trivial and is omitted from the proof.

Lemma 3

The procedures adjust, merge, contract, and extend defined above are implemented correctly.

Proof: First, we show that a call to the adjust procedure on a table $T$ results in a correctly adjusted table $T^{\prime}$; that is, $T^{\prime}$ accounts for when the top level boundary vertices of the corresponding slice are equal or not. Let $L$ and $R$ be the left and right boundaries, respectively, for the sice that $T$ represents, and let $x$ and $y$ be the highest level vertices in $L$ and $R$, respectively. Since the case when $x=y$ is already handled in the merge procedure, the adjust procedure only needs to check when $x\neq y$, and in particular when $(x,y)$ is an edge in the graph. In this case, any entry in $T$ that includes both $x$ and $y$ should be incremented by one in order to count this edge. Thus, adjust is correct.

Now, we show that a call to the merge procedure on two tables $T_{1}$ and $T_{2}$ representing slices $S_{1}$ and $S_{2}$, respectively, results in a correct table $T$ representing the slice $S=S_{1}\cup S_{2}$. Let $L$ and $M$ be the left and right boundaries of $S_{1}$ and let $M$ and $R$ be the left and right boundaries of $S_{2}$, where we know the right boundary of $S_{1}$ is the same as the left boundary of $S_{2}$ by assumption. Recall that a table has an entry for each subset of the boundaries of the slice it represents. This means $T_{1}$ has an entry for each subset of $L\cup M$, $T_{2}$ has an entry for each subset of $M\cup R$, and we want $T$ to have an entry for each subset of $L\cup R$. So, for a subset $A$ of $L\cup R$, we show that the merge procedure calculates the maximum number of edges over all subgraphs of $S$ with exactly $k^{\prime}$ vertices containing $A$, where $k^{\prime}$ ranges from 0 to $\max_{T_{1}}k^{\prime}+\max_{T_{2}}k^{\prime}-|M|$. This upper bound is obtained by adding the number of vertices in $S_{1}$ and $S_{2}$ (which are given by the largest values of $k^{\prime}$ in $T_{1}$ and $T_{2}$) and subtracting the number of vertices shared by the two slices, which by definition are the vertices in $M$. Now, fix $k^{\prime}$. In order to loop over every subgraph of $S$ containing $A$ with exactly $k^{\prime}$ vertices, the merge procedure essentially loops over every pair of subgraphs of $S_{1}$ and $S_{2}$ such that the number of vertices in the union of these two subgraphs is exactly $k^{\prime}$. This is accomplished by looping over every subset $B$ of $M$, and referring to the table entries in $T_{1}$ and $T_{2}$ corresponding to the subsets $(A\cap L)\cup B$ and $(A\cap R)\cup B$. Fix the subset $B$ of $M$. Extra care needs to be taken in determining which values of $k_{1}$ and $k_{2}$ can be used in $T_{1}$ and $T_{2}$, respectively, so that the union of the corresponding subgraphs of $S_{1}$ and $S_{2}$ contains exactly $k^{\prime}$ vertices. The number of vertices in this union should be $k_{1}+k_{2}-|B|$ since the two subgraphs only share the vertices in $B$. However, we need to account for when the top level vertices in $L$ and $R$ are equal; the procedure handles this by subtracting 1 from the above vertex count if this is the case. Then for particular values of $k_{1}$ and $k_{2}$, the procedure keeps track of the number of edges in the described union, which is obtained by adding the table values $T_{1}((A\cap L)\cup B,k_{1})$ and $T_{2}((A\cap R)\cup B,k_{2})$, and then subtracting the number of double counted edges, which are edges between vertices in $B$. After calculating all of these values, the procedure sets $T(A,k^{\prime})$ to be the maximum such value, which must be the maximum number of edges in a subgraph containing $A$ with exactly $k^{\prime}$ vertices. If all of the values were undefined, the procedure sets $T(A,k^{\prime})$ to be undefined. Thus, the merge procedure is correct.

Next, we show that a call to the contract procedure on a level $i+1$ table $T$ results in a correct level $i$ table $T^{\prime}$. Here, $T$ represents the slice $S$ for a level $i+1$ component $C$ contained in the level $i$ face $f$, and we want $T^{\prime}$ to represent the slice $S^{\prime}$ for $f$. Let $L$ and $R$ be the left and right boundaries, respectively, for $S^{\prime}$, and let $(z,z)$ be the label for the root of the tree corresponding to $C$. Note that the left and right boundaries for $S$ are by definition $L\cup\{z\}$ and $R\cup\{z\}$, respectively. So, we want to show that contract has a correct entry for each subset of $L\cup R$. For each subset $A$ of $L\cup R$ and for each value of $k^{\prime}$, the contract procedure sets $T^{\prime}(A,k^{\prime})$ to be the maximum value between $T(A,k^{\prime})$ and $T(A\cup\{z\},k^{\prime})$. Note that $T(A,k^{\prime})$ is by definition the maximum number of edges over all subgraphs of $S$ containing $A$ with exactly $k^{\prime}$ vertices, and $T(A\cup\{z\},k^{\prime})$ is the maximum number of edges over all subgraphs of $S$ containing $A$ as well as $z$ with exactly $k^{\prime}$ vertices. The maximum between these two values must then be the maximum number of edges over all subgraphs of $S^{\prime}$ containing $A$ with exactly $k^{\prime}$ vertices. Thus, the contract procedure is correct.

Lastly, we show that a call to the extend procedure on a table $T$ representing a level $i$ slice $S$ and a level $i+1$ vertex $z$ results in a correct table $T^{\prime}$ representing the slice $S\cup\{z\}$. Let $L$ and $R$ be the left and right boundaries for $S$, respectively. We will show that extend produces correct entries for each subset of $L\cup R\cup\{z\}$. Clearly, the entry in $T^{\prime}$ for a subset that does not include $z$ should equal the entry in $T$ for the same subset, which is precisely how extend initializes $T^{\prime}$. So, we only need to focus on the entries that include $z$. Let $A$ be a subset of $L\cup R$, and fix $k^{\prime}$. The procedure first checks that $T(A,k^{\prime}-1)$ is not undefined, for if it were undefined, this would mean that there is no value for a subgraph of $S$ containing $A$ with exactly $k^{\prime}-1$ vertices, and hence there cannot be a value for the same subgraph after adding in $z$ with exactly $k^{\prime}$ vertices. We then let $m$ be the number of edges between $z$ and every vertex in $A$. The maximum number of edges over all subgraphs of $S^{\prime}$ containing $A\cup\{z\}$ with exactly $k^{\prime}$ vertices should then be the maximum number of edges over all subgraphs of $S$ containing $A$ with exactly $k^{\prime}-1$ vertices, plus $m$. This is exactly what extend sets as the value for $T^{\prime}(A\cup\{z\},k^{\prime})$, hence the procedure must be correct.

$\Box$

Theorem 4

A call of table on the root of the level 1 tree results in a correct table for the corresponding slice, which is in fact the entire graph.

Proof: The argument is essentially the same as Lemma 2 in [2], which focuses on the maximum independent set problem. The only difference is that the adjust procedure in the maximum independent set scenario deals with the case $x=y$, where $(x,y)$ is the label of the input tree vertex $v$, whereas our implementation for densest $k$ subgraph deals with this case in the merge procedure. Since this case is handled regardless, the proof still follows.

$\Box$

3.0.5 Performance Bounds

Constructing the trees and computing the boundaries of slices requires linear time. By Lemma 1 in [2], the table procedure is called once for each tree vertex. Recall that for a level $i$ tree, a leaf vertex corresponds to an exterior edge of a level $i$ face, and a tree vertex which is neither a leaf nor the root corresponds to a level $i$ face, which must have at least one interior edge. The root of a level $i$ tree corresponds to a level $i$ component, which for $i>1$ must be associated with at least one edge connecting the level $i$ component to the level $i-1$ component (for the level 1 root, there may be no associated edge). Thus, the number of tree vertices over all trees is at most the number of edges in the $b$-outerplanar graph (plus one to account for the level 1 root). Since the number of edges in a planar graph is linear in the number of vertices, the number of calls on table is linear in the number of vertices as well.

Each table constructed in the dynamic program has one row for each subset of the left and right boundary vertices, of which there can be at most $2b$ for a $b$-outerplanar graph; that is, $b$ vertices in each of the left and right boundaries. So, there are at most $4^{b}$ rows in a table. In each row, there are at most $k$ entries for the given input $k$. Since each call to adjust, extend, or contract requires iterating over a table, the time complexity for each is $O(k4^{b})$. The merge procedure has four nested loops, where the first (outermost) iterates at most $4^{b}$ times, the second at most $k$ times, the third at most $2^{b}$ times, and the fourth (innermost) at most $k$ times. Thus, the time complexity of merge is $O(k^{2}8^{b})$. Lastly, the time complexity of create must be $O(kb4^{b})$ since it constructs an entire table by brute force. Each of these procedures is called at most once for each recursive call of table. Therefore, the time complexity must be bounded by merge, hence the time complexity of table is $O(k^{2}8^{b}n)$.

4 Polynomial Time Approximation Scheme and Future Work

When searching for a polynomial time approximatin scheme (PTAS) for planar graph problems, one often attempts to use Baker’s technique. For this technique, we assume that we have a dynamic programming solution to the given problem in the $b$-outerplanar case. This technique works as follows: Given a planar graph $G$ and a positive number $\epsilon$, let $b=\frac{1}{\epsilon}$. Perform a breadth-first search on $G$ to obtain a BFS tree $T$, and number the levels of $T$ starting from the root, which is level 0. For each $i=0,1,\dots,b-1$, let $G_{i}$ be the subgraph of $G$ induced by the vertices on the levels of $T$ that are congruent to $i$ modulo $b$. Note that $G_{i}$ is likely disconnected. Let the connected components of $G_{i}$ be $G_{i,0},G_{i,1},\dots$. Since each $G_{i,j}$ is $(b-1)$-outerplanar by construction, we may run the given dynamic program on each $G_{i,j}$ and combine the solutions over all $j$ to obtain a solution $S_{i}$ for the graph $G_{i}$. We then take the maximum $S_{i}$, denoted $S$, as our approximate solution.

We hypothesize that this technique will not work for the densest $k$ subgraph problem on planar graphs. The reason is that by having a potentially large number of disconnected components, the approximate solution cannot be guaranteed to be within the bound given by $\epsilon$. Suppose we have an approximate solution $S$ for the densest $k$ subgraph problem on some planar graph $G$. Note that $S$ is the exact solution for the graph $G_{i}$ for some $i$, meaning $S$ does not account for any vertices on the levels of $T$ which are congruent to $i$ modulo $b$. While $S$ could still be very dense, it is possible that most (if not all) of the edges in $G$ are between vertices in different levels of $T$. This allows for the possibility that no matter which $S_{i}$ is chosen as the maximum, each graph $G_{i}$ is missing too many edges to closely approximate the optimal solution. For future work, it would be of great interest for one to prove that such a construction is impossible using Baker’s technique.

5 Acknowledgements

We would like to express our sincere thanks to Samuel Chase for his collaboration on our initial explorations of finding a PTAS for the densest $k$ subgraph problem.

Appendix A A Complete Set of Tables for the Example in Figure 1

As mentioned in Section 2, the tables for each leaf in the tree are the same. We list them here for completeness.

$Table(P)=T_{(c,b)}=$

$c$ $b$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(L)=T_{(b,a)}=$

$b$ $a$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(M)=T_{(a,e)}=$

$a$ $e$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(N)=T_{(e,f)}=$

$e$ $f$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(O)=T_{(f,g)}=$

$f$ $g$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(R)=T_{(g,d)}=$

$g$ $d$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(Q)=T_{(d,c)}=$

$d$ $c$ $k=0$ $k=1$ $k=2$

0 0 0 $\emptyset$ $\emptyset$

0 1 $\emptyset$ 0 $\emptyset$

1 0 $\emptyset$ 0 $\emptyset$

1 1 $\emptyset$ $\emptyset$ 1

$Table(H)=Merge(T_{(b,a)},T_{(a,e)},3)=T_{(b,e)}=$

[TABLE]

$Merge(H,N)=Merge(T_{(b,e)},T_{(e,f)},4)=T_{(b,f)}=$

[TABLE]

$Table(I)=Merge(T_{(b,f)},T_{(f,g)},5)=T_{(b,g)}=$

[TABLE]

$Table(K)=Merge(T_{(g,d)},T_{(d,c)},3)=T_{(g,c)}=$

[TABLE]

$Merge(P,I)=Merge(T_{(c,b)},T_{(b,g)},6)=T_{(c,g)}=$

[TABLE]

$Table(J)=Merge(T_{(c,g)},T_{(g,c)},7)=T_{(c,c)}=$

[TABLE]

Appendix B Procedures for the Exact $b$-outerplanar Algorithm