The Densest k Subgraph Problem in b-Outerplanar Graphs

07/08/2019
by   Sean Gonzales, et al.
0

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.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

04/19/2018

Exact Algorithms for the Maximum Planar Subgraph Problem: New Models and Experiments

Given a graph G, the NP-hard Maximum Planar Subgraph problem asks for a ...
08/20/2020

On Fine-Grained Exact Computation in Regular Graphs

We show that there is no subexponential time algorithm for computing the...
02/19/2019

Dominator Colorings of Digraphs

This paper serves as the first extension of the topic of dominator color...
09/10/2017

Defining Recursive Predicates in Graph Orders

We study the first order theory of structures over graphs i.e. structure...
07/09/2018

Jointly learning relevant subgraph patterns and nonlinear models of their indicators

Classification and regression in which the inputs are graphs of arbitrar...
03/20/2014

Sparse Learning over Infinite Subgraph Features

We present a supervised-learning algorithm from graph data (a set of gra...
12/25/2019

Neural Subgraph Isomorphism Counting

In this paper, we study a new graph learning problem: learning to count ...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 has vertices and edges, the density of is .

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 is . Goldberg gave an algorithm to find the subgraph of maximum density using network flow techniques [18].

Given an undirected graph and an integer , the densest subgraph problem is defined as follows: find a subgraph such that and the density of is maximized. This problem can be shown to be NP-Hard by a reduction from Clique [13]. Since (if ) 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 and in polynomial time produces a solution that is within of the optimal solution. Unfortunately there is no PTAS (unless NPBPTIME) for the densest -subgraph problem. This is shown by a reduction from the Minimum Distance of Code Problem [20]. The best approximation known is a recent -approximation algorithm that runs in time [4], which is an improvement on the long standing 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 subgraph problem on planar graphs is unknown [9], the connected planar densest 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 subgraph problem in outerplanar graphs inspired by Baker [2] in Section 2. We extend this algorithm to -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 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, , 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, . If has any bridges (an edge whose removal disconnects the graph), , add an additional edge . 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, : First we suppose that 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.

Figure 1: The left figure is an example outerplanar graph, . The middle figure shows the construction of (with square vertices and dashed edges) from . The right figure shows the labeling of after making the choice to have vertex as the root with as ’s leftmost child.

We may choose any interior tree vertex to be the root of . 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 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, , in (with label ). The table will hold the maximum number of edges for a subgraph on vertices ( ranging from 0 to the size of the subgraph for the subtree rooted at ) depending on whether or not and are in the set. For example, consider the leaf vertex, , in representing edge in :

0 0 0 0 1 0 1 0 0 1 1 1

This table is undefined for many entries, for example, the entry where , , and 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 , , and , we obtain a value of because there is an edge between and . The table will be identical for each leaf in .

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 with label :

0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 3

We now give pseudocode for how to merge two sibling tables, and (creating ). For the table of a vertex with label , will be the minimum of (the input for the densest subgraph problem) and the number of vertices in the subtree represented by label .

for Each in  do
     
     for Each from 0 to  do
         for Each in  do
              for Each from to  do
                  
                  if  AND AND  then
                                          
                  
                  if  AND AND AND is an edge then
                                          
                  if  then
                       Add to                                               
     if  is not empty then
         
     else
               
Algorithm 1 Merge()

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

0 0 0 0 1 3 4 6 7 0 1 1 0 1 1 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, (with label ), in the tree, correctly gives the maximum number of edges in the subgraph corresponding to with the constrained number of vertices (each value).

Proof: Each leaf vertex, , in the tree corresponds to a single edge, , in the original graph. There are only three possible values of 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 or 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 for zero edges or only 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 and and since there is an edge between and , we get one edge.

Lemma 2

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

Proof: If is a leaf vertex, then Lemma 1 gives us that is correct. So, we may suppose that is not a leaf vertex and that the tables for the children of are correct. Let denote the children of , and let the child have label . This means that has label . The table for is then calculated by merging the tables for each ; that is, we first merge and to get a table , then we merge with to get and so on, ultimately obtaining the table . We claim that a call to merge on the tables for two consecutive tree vertices and with labels and , respectively, results in a correct table for the union of the subgraphs corresponding to and , as well as the edge (if it is an edge). If the claim is true, then the result of merging the tables of each child must result in the correct table for .

The table should have a row for each pair of values and , and each entry in the row corresponds to a particular value of . So, fix , , and . The entry should contain the maximum number of edges possible over all subgraphs of vertices that may contain and (depending on the values of and ), where this subgraph is contained in the union described above. The merge procedure checks for the cases when we include or do not include in the subgraph by setting the bit . So, fix . The procedure then checks the egde count in every possible subgraph by varying the values of and , which are the values we use to lookup edge counts in the tables and , respectively. The idea is that we can check all possible subgraphs of size containing the included vertices by checking subgraphs corresponding to and such that the number of vertices in both subgraphs sums to . In order to ensure that the values of and do in fact result in a correctly sized subgraph union, the procedure first sets to be some value between and (the lower bound is due to the fact that is a vertex count, and and effectively count whether and are included). The procedure then sets to be ; adding in avoids double counting the inclusion of (if it is included). However, if and (i.e. and are both included in the subgraph), we have double counted the vertex , hence the procedure increments the value of to allow another vertex to be included in the union. The procedure then saves the value and increments it if 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 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 must also be correct.

Note that the running time for this dynamic program on outerplanar graphs is, : 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 time to fill in each table.

3 An Algorithm to Find the Densest Subgraph Problem in -Outerplanar Graphs

We now lay out the dynamic programming solution for the densest subgraph problem in -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 -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 vertices contained in a level face form a connected subgraph called a level 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 and in parallel for each . A triangulation for the graph in Figure 3 is given in Figure 3.

Figure 2: figure

3-outerplanar example

Figure 3: figure

Triangulation of example

3.0.1 Tree Construction

Since a level component is an outerplanar graph, we can construct a tree for each level 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 components, where .

Suppose we want to construct the tree for the level component that is enclosed by a level face . Furthermore, suppose we have already constructed the tree for the level component that contains , hence is represented by some vertex in that tree. The root of the tree for will be of the form for some vertex in . If , we pick so that is adjacent to in the triangulation of the graph. If , we pick to be the third vertex in the triangle containing and in the triangulation.

The leftmost child for (assuming contains more than one vertex) is of the form , where is the vertex in such that is an exterior edge in and is the first edge counterclockwise around after the edge 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.

Figure 4: figure

Trees for example graph

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 be a level component enclosed by the level face , and let be the tree vertex corresponding to . For a particular slice of , we want the left and right boundaries to each contain one vertex from each level of the graph, starting at level and extending outward to level 1. We will choose these vertices to be dividing points. Given two successive leaf vertices of the tree with root corresponding to , we say a vertex in is a dividing point for and if the edges occur in counterclockwise order around in the triangulation of the graph. For example, in Figure 3, is a dividing point for and , and , , and are dividing points for and .

We now define a pair of functions and , 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 components for . This is because we will use boundary numbers to recursively define the boundaries themselves, where level 1 boundaries are the base case and level boundaries are obtained from level boundaries. Using the same setup for and as given above, we define these functions as follows:

  1. Let the leaves of the tree corresponding to be from left to right, where has label for . Let the children of the tree vertex corresponding to be from left to right, where has label for . Set and . For , define , where is the least such that is a dividing point for and . For , define .

  2. Let be a non-leaf vertex in the tree corresponding to , and suppose has leftmost child and rightmost child . Define and .

For example, let be the level 2 component in Figure 3 represented by the tree with root . The enclosing face is represented by the tree vertex . We first assign and since has 4 children. As mentioned above, is the only dividing point for and , so we set (and hence ). We know that , , and are dividing points for and , with indices 2, 3, and 4, respectively, out of the list of vertices in the children of . Since 2 is the least , we set (and hence ).

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 for every pair of consecutive tree vertices and .

Figure 5: figure

Trees with boundary numbers

We are now ready to formally define left and right boundaries. Let be a tree vertex with label . Then,

  1. If is a vertex in a level 1 tree, the left boundary of the slice of is and the right boundary is .

  2. Otherwise, is a vertex in a level tree that corresponds to some level component enclosed by a level face . Suppose the tree vertex corresponding to , denoted , has children. Let and let . Then the left boundary of the slice of is plus the left boundary of the slice of the th child of , where we can let the left boundary of the nonexistent child of equal the right boundary of the child of . Similarly, the right boundary of the slice of is plus the right boundary of the child of , where we can let the right boundary of the nonexistent 0th child of equal the left boundary of the 1st child of .

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 must equal the left boundary of the next consecutive tree vertex .

Figure 6: figure

Trees with slice boundaries

With the definition for boundaries in place, we can now formally define slices. Let be a level tree vertex for with label . We denote the slice of as , which is defined as follows:

  1. If represents a level face that does not enclose any level components, then is the union of the slices of the children of , together with if is an edge.

  2. If represents a level face that encloses a level component , then is the slice of the root of the tree that represents , together with if is an edge.

  3. If is a level 1 leaf, then is simply the edge .

  4. Suppose is a level leaf for . Let be the level face that encloses , and let for be the children of (the tree vertex representing ). Let each have label .

    1. If , then is the union of each for , along with any edges from or to for and the edge .

    2. If , then is the left boundary of (including edges between consecutive boundary vertices), along with any edges from or to and the edge .

The slices for , , and are given in Figure 7, where boundary vertices are connected by dashed lines if they are not connected already. Since is a level 2 leaf enclosed by the face with tree vertex , and , we see that is equal to along with the edges connecting to and , where is the edge . Similarly, is equal to along with the edges connected and to and . Since is a level 2 tree vertex representing a face that encloses the level 3 component represented by , its slice is equal to along with the edge . The slice for is obtained by taking the union of and and adding the edges connecting 1 to and .

Figure 7: figure

Slices for , , and .

3.0.3 Dynamic Program

In this section, we detail the dynamic program that solves the densest subgraph problem for -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 slice consists of entries: one entry for each subset of the boundary vertices (recall that the left and right boundaries for a level slice contain exactly vertices each, for a total of boundary vertices). An entry contains a number for each value of , where this number is the maximum number of edges over all subgraphs of the slice of exactly 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 . This procedure contains a conditional branch corresponding to each of the rules S1 – S4. The branch corresponding to S1 handles the case when represents a face that does not enclose a level component. In this case, the procedure makes a recursive call to table on each child of and merges the resulting tables together. Note that this is analogous to how rule S1 creates by taking the union of the slices for the children of .

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

The third conditional branch (corresponding to rule S3) handles the case when 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 is a level leaf vertex. The idea is to break up the slice of 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 , 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 (this is explained in more detail below).

In the case that , we can create tables for subslices. Since we are dealing with a planar graph, there exists a level vertex such that all level vertices other than that are adjacent to are clockwise from , and all level vertices other than that are adjacent to are counterclockwise from . Here, is the only level vertex in that can be adjacent to both and (although it might not be adjacent to either). So, we construct an initial level table for the subslice corresponding to 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 , and on the other side with subslices constructed from the vertices adjacent to .

Figure 8: figure

The slice for is split into subslices for computing tables.

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

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

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

The contract procedure, given in Figure 12, changes a level table into a level table . Here, represents the slice for , where is the root of a tree corresponding to a level component contained in a level face , and is the table for the slice of . Let and let . Let the left and right boundaries of be and , respectively. Then the left and right boundaries of are of the form and respectively. For each subset of and for each value of , contains two numbers: one that includes and one that does not include . So, for each subset of and each value of , we set equal to the larger of these two numbers.

The create procedure takes as input a leaf vertex in a tree that corresponds to a level component enclosed by a face , and a number , where the children of are . This procedure simply applies brute force to create the table for the subgraph containing the edge , the subgraph induced by the left boundary of if or the right boundary of if , and any edges from or to the level 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 vertex and a table representing a level slice, and produces a table for a level slice. Let and be the boundaries for the level slice represented by . The boundaries for the new slice will be and . For each subset of and each value of , the new table contains two values: one that includes and one that does not include . The entries which do not include can simply be set to their original values in . For the entries that do include , we first check that is not undefined. If this is the case, we set as plus the number of edges between and every vertex in .

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 , its left and right boundaries are both equal to . 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 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 for . Taking the maximum between the two numbers corresponding to when gives us the size of the densest 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 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 results in a correctly adjusted table ; that is, accounts for when the top level boundary vertices of the corresponding slice are equal or not. Let and be the left and right boundaries, respectively, for the sice that represents, and let and be the highest level vertices in and , respectively. Since the case when is already handled in the merge procedure, the adjust procedure only needs to check when , and in particular when is an edge in the graph. In this case, any entry in that includes both and 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 and representing slices and , respectively, results in a correct table representing the slice . Let and be the left and right boundaries of and let and be the left and right boundaries of , where we know the right boundary of is the same as the left boundary of by assumption. Recall that a table has an entry for each subset of the boundaries of the slice it represents. This means has an entry for each subset of , has an entry for each subset of , and we want to have an entry for each subset of . So, for a subset of , we show that the merge procedure calculates the maximum number of edges over all subgraphs of with exactly vertices containing , where ranges from 0 to . This upper bound is obtained by adding the number of vertices in and (which are given by the largest values of in and ) and subtracting the number of vertices shared by the two slices, which by definition are the vertices in . Now, fix . In order to loop over every subgraph of containing with exactly vertices, the merge procedure essentially loops over every pair of subgraphs of and such that the number of vertices in the union of these two subgraphs is exactly . This is accomplished by looping over every subset of , and referring to the table entries in and corresponding to the subsets and . Fix the subset of . Extra care needs to be taken in determining which values of and can be used in and , respectively, so that the union of the corresponding subgraphs of and contains exactly vertices. The number of vertices in this union should be since the two subgraphs only share the vertices in . However, we need to account for when the top level vertices in and are equal; the procedure handles this by subtracting 1 from the above vertex count if this is the case. Then for particular values of and , the procedure keeps track of the number of edges in the described union, which is obtained by adding the table values and , and then subtracting the number of double counted edges, which are edges between vertices in . After calculating all of these values, the procedure sets to be the maximum such value, which must be the maximum number of edges in a subgraph containing with exactly vertices. If all of the values were undefined, the procedure sets to be undefined. Thus, the merge procedure is correct.

Next, we show that a call to the contract procedure on a level table results in a correct level table . Here, represents the slice for a level component contained in the level face , and we want to represent the slice for . Let and be the left and right boundaries, respectively, for , and let be the label for the root of the tree corresponding to . Note that the left and right boundaries for are by definition and , respectively. So, we want to show that contract has a correct entry for each subset of . For each subset of and for each value of , the contract procedure sets to be the maximum value between and . Note that is by definition the maximum number of edges over all subgraphs of containing with exactly vertices, and is the maximum number of edges over all subgraphs of containing as well as with exactly vertices. The maximum between these two values must then be the maximum number of edges over all subgraphs of containing with exactly vertices. Thus, the contract procedure is correct.

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

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 , where is the label of the input tree vertex , whereas our implementation for densest subgraph deals with this case in the merge procedure. Since this case is handled regardless, the proof still follows.

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 tree, a leaf vertex corresponds to an exterior edge of a level face, and a tree vertex which is neither a leaf nor the root corresponds to a level face, which must have at least one interior edge. The root of a level tree corresponds to a level component, which for must be associated with at least one edge connecting the level component to the level 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 -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 for a -outerplanar graph; that is, vertices in each of the left and right boundaries. So, there are at most rows in a table. In each row, there are at most entries for the given input . Since each call to adjust, extend, or contract requires iterating over a table, the time complexity for each is . The merge procedure has four nested loops, where the first (outermost) iterates at most times, the second at most times, the third at most times, and the fourth (innermost) at most times. Thus, the time complexity of merge is . Lastly, the time complexity of create must be 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 .

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 -outerplanar case. This technique works as follows: Given a planar graph and a positive number , let . Perform a breadth-first search on to obtain a BFS tree , and number the levels of starting from the root, which is level 0. For each , let be the subgraph of induced by the vertices on the levels of that are congruent to modulo . Note that is likely disconnected. Let the connected components of be . Since each is -outerplanar by construction, we may run the given dynamic program on each and combine the solutions over all to obtain a solution for the graph . We then take the maximum , denoted , as our approximate solution.

We hypothesize that this technique will not work for the densest 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 . Suppose we have an approximate solution for the densest subgraph problem on some planar graph . Note that is the exact solution for the graph for some , meaning does not account for any vertices on the levels of which are congruent to modulo . While could still be very dense, it is possible that most (if not all) of the edges in are between vertices in different levels of . This allows for the possibility that no matter which is chosen as the maximum, each graph 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 subgraph problem.

References

  • [1] Albert Angel, Nikos Sarkas, Nick Koudas, and Divesh Srivastava. Dense subgraph maintenance under streaming edge weight updates for real-time story identification. Proc. VLDB Endow., 5(6):574–585, February 2012.
  • [2] Brenda S. Baker. Approximation algorithms for NP-complete problems on planar graphs. Journal of The ACM, 41:153–180, 1994.
  • [3] MohammadHossein Bateni, MohammadTaghi Hajiaghayi, and Dániel Marx. Approximation schemes for steiner forest on planar graphs and graphs of bounded treewidth. CoRR, 2009.
  • [4] Aditya Bhaskara, Moses Charikar, Eden Chlamtac, Uriel Feige, and Aravindan Vijayaraghavan. Detecting high log-densities – an approximation for densest k-subgraph. CoRR, abs/1001.2891, 2010.
  • [5] Glencora Borradaile, Philip Klein, and Claire Mathieu. An o(n log n) approximation scheme for steiner tree in planar graphs. ACM Trans. Algorithms, 5:31:1–31:31, July 2009.
  • [6] Gregory Buehrer and Kumar Chellapilla. A scalable pattern mining approach to web graph compression with communities. In Proceedings of the 2008 International Conference on Web Search and Data Mining, WSDM ’08, pages 95–106, New York, NY, USA, 2008. ACM.
  • [7] J. Chen and Y. Saad. Dense subgraph extraction with application to community detection. Knowledge and Data Engineering, IEEE Transactions on, PP(99):1, 2010.
  • [8] Edith Cohen, Eran Halperin, Haim Kaplan, and Uri Zwick. Reachability and distance queries via 2-hop labels. In Proceedings of the Thirteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’02, pages 937–946, Philadelphia, PA, USA, 2002. Society for Industrial and Applied Mathematics.
  • [9] D.G. Corneil and Y. Perl. Clustering and domination in perfect graphs. Discrete Applied Mathematics, 9(1):27 – 39, 1984.
  • [10] Xiaoxi Du, Ruoming Jin, Liang Ding, Victor E. Lee, and John H. Thornton, Jr. Migration motif: A spatial - temporal pattern mining approach for financial markets. In Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’09, pages 1135–1144, New York, NY, USA, 2009. ACM.
  • [11] David Eppstein and Michael T. Goodrich. Studying (non-planar) road networks through an algorithmic lens. In Proceedings of the 16th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, GIS ’08, pages 16:1–16:10, New York, NY, USA, 2008. ACM.
  • [12] David Eppstein and Siddharth Gupta. Crossing patterns in nonplanar road networks. In Proceedings of the 25th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, SIGSPATIAL ’17, pages 40:1–40:9, New York, NY, USA, 2017. ACM.
  • [13] Uriel Feige, Guy Kortsarz, and David Peleg. The dense k-subgraph problem. Algorithmica, 29:2001, 1999.
  • [14] E. Fratkin, B. T. Naughton, D. L. Brutlag, and S. Batzoglou. Motifcut: regulatory motifs finding with maximum density subgraphs. In Bioinformatics, pages 150–157, 2006.
  • [15] David Gibson, Jon Kleinberg, and Prabhakar Raghavan. Inferring web communities from link topology. In Proceedings of the ninth ACM conference on Hypertext and hypermedia : links, objects, time and space—structure in hypermedia systems: links, objects, time and space—structure in hypermedia systems, HYPERTEXT ’98, pages 225–234, New York, NY, USA, 1998. ACM.
  • [16] David Gibson, Ravi Kumar, and Andrew Tomkins. Discovering large dense subgraphs in massive graphs. In Proceedings of the 31st international conference on Very large data bases, VLDB ’05, pages 721–732. VLDB Endowment, 2005.
  • [17] Aristides Gionis and Charalampos Tsourakakis. Dense subgraph recovery. In KDD, 2015.
  • [18] A. V. Goldberg. Finding a maximum density subgraph. Technical report, University of California at Berkeley, Berkeley, CA, USA, 1984.
  • [19] J. Mark Keil and Timothy B. Brecht. The complexity of clustering in planar graphs. The Journal of Combinatorial Mathematics and Combinatorial Computing, 9:155–159, 1991.
  • [20] Subhash Khot. Ruling out PTAS for graph min-bisection, dense k-subgraph, and bipartite clique. SIAM J. Comput., 36:1025–1071, December 2006.
  • [21] Philip N. Klein. A linear-time approximation scheme for tsp in undirected planar graphs with edge-weights. SIAM J. Comput., 37:1926–1952, 2008.
  • [22] Michael A. Langston, Lan Lin, Xinxia Peng, Nicole E. Baldwin, Christopher T. Symons, Bing Zhang, and Jay R. Snoddy. A combinatorial approach to the analysis of differential gene expression data: The use of graph algorithms for disease prediction and screening. In Methods of Microarray Data Analysis IV, pages 223–238. Springer Verlag, 2005.
  • [23] M. E. J. Newman. Fast algorithm for detecting community structure in networks. Phys. Rev. E, 69:066133, Jun 2004.
  • [24] Polina Rozenshtein, Aris Anagnostopoulos, Aristides Gionis, and Nikolaj Tatti. Event detection in activity networks. In Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’14, pages 1176–1185, New York, NY, USA, 2014. ACM.

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.

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0 1 0 1 0 0 1 1 1

0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 3

0 0 0 0 1
0 1 0 1 2
1 0 0 1 3
1 1 0 2 4

0 0 0 0 1 2
0 1 0 1 2 3
1 0 0 1 3 4
1 1 1 2 4 6

0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 3

0 0 0 0 1 3 4
0 1 0 1 2 3 6
1 0 0 1 2 4 5
1 1 1 3 4 6 8

0 0 0 0 1 3 4 6 7
0 1
1 0