A simple algorithm for multicuts in planar graphs with outer terminals

On external-memory MST, SSSP and multi-way planar graph separation

The problem of processing shortest pa th queries in graphs arises in application areas such as intelligent t ranspor ta t ion system (ITS), geographic information system (GIS), and robotics. In this paper, we present an efficient algorithmic solution for processing shortest pa th queries in undirected planar graphs with non-negative edge weights. Previous algorithms for this problem on planar graphs all have a tradeoff between the query t ime and the da ta structure space used by the solutions. The previously best known trade-off on an n-vertex planar graph G in the worst case is O(v/-r) t ime for a pa th length query and O(v/-r + L) t ime for report ing an actual shortest path, with a da ta structure of O(n2/x/~) space, where r is an integer parameter with 1 < r _< n and L is the number of edges on the output shortest path. We present a new scheme, called frame search, that exploits the graph planari ty in a novel fashion. Wi th this scheme, we build an improved da ta structure of O(n + pv/-r + p2/r) space (in O(n + p2/v/~ + pr 3/4) time), where p is the minimum cardinality of a face-covering of the planar embedding of G with 1 < p < O(n), and r is an integer parameter with 1 < r < p. This da ta structure enables us to process each length query in O(v/-rlog r + a(n)) t ime and report an actual shortest path in an addit ional O(L) time, where a(n) is the inverse of Ackermann's function. In the worst case, our approach reduces the previously best query t ime by a factor of up to O(n 1/4) if the same amount of space is used. Our technique can also be applied to improve the previous query algorithms for some geometric shortest pa th problems on the plane.

Primal-dual approximation algorithms for Node-Weighted Steiner Forest on planar graphs

We consider the parameterized Feedback Vertex Set problem on unweighted, undirected planar graphs. We present a kernelization algorithm that takes a planar graph G and an integer k as input and either decides that (G,k) is a no instance or produces an equivalent (kernel) instance (G′,k′) such that k′≤k and |V(G′)|<97k. In addition to the improved kernel bound (from 112k to 97k), our algorithm features simple linear-time reduction procedures that can be applied to the general Feedback Vertex Set problem.

In this paper we give a fully dynamic approximation scheme for maintaining all-pairs shortest paths in planar networks. Given an error parameter $\epsilon$ such that $0<\epsilon$ , our algorithm maintains approximate all-pairs shortest paths in an undirected planar graph G with nonnegative edge lengths. The approximate paths are guaranteed to be accurate to within a 1+ $\epsilon$ factor. The time bounds for both query and update for our algorithm is O( \epsilon -1 n 2/3 log 2 n log D) , where n is the number of nodes in G and D is the sum of its edge lengths. The time bound for the queries is worst case, while that for the additions is amortized. Our approximation algorithm is based upon a novel technique for approximately representing all-pairs shortest paths among a selected subset of the nodes by a sparse substitute graph.

In this paper we give a fully dynamic approximation scheme for maintaining all-pairs shortest paths in planar networks. Given an error parameter e such that 0<e≤1, our algorithm maintains approximate allpairs shortest-paths in an undirected planar graph G with nonnegative edge lengths. The approximate paths are guaranteed to be accurate to within a (1+e)-factor. The time bounds for both query and update for our algorithm wis O(e−1n2/3 log2n log D), where n is the number of nodes in G and D is the sum of its edge lengths.

We consider dynamic subgraph connectivity problems for planar undirected graphs. In this model there is a fixed underlying planar graph, where each edge and vertex is either off (failed) or (recovered). We wish to answer connectivity queries with respect to the subgraph. The model has two natural variants, one in which there are d edge/vertex failures that precede all connectivity queries, and one in which failures/recoveries and queries are intermixed. We present a d-failure connectivity oracle for planar graphs that processes any d edge/vertex failures in sort(d,n) time so that connectivity queries can be answered in pred(d,n) time. (Here sort and pred are the time for integer sorting and integer predecessor search over a subset of [n] of size d.) Our algorithm has two discrete parts. The first is an algorithm tailored to triconnected planar graphs. It makes use of Barnette's theorem, which states that every triconnected planar graph contains a degree-3 spanning tree. The second part is a generic reduction from general (planar) graphs to triconnected (planar) graphs. Our algorithm is, moreover, provably optimal. An implication of Pǎtrascu and Thorup's lower bound on predecessor search is that no d-failure connectivity oracle (even on trees) can beat pred(d,n) query time. We extend our algorithms to the subgraph connectivity model where edge/vertex failures (but no recoveries) are intermixed with connectivity queries. In triconnected planar graphs each failure and query is handled in O(logn) time (amortized), whereas in general planar graphs both bounds become O(log2n).

Optimal parallel algorithms for path problems on planar graphs

We consider the following problem. Let G=(V, E) be an undirected planar graph and let s, t∈V, s≠t. The problem is to find a set of pairwise edge-disjoint paths, each connecting s with t, with maximum cardinality. In other words, the problem is to find a maximum unit flow from s to t. The fastest algorithm in the literature has running time O(|V|log|V|)(¦V¦ log ¦V¦). In this paper now, we give a linear time algorithm.KeywordsPlanar GraphLinear TimeUnit FlowOuter FaceSearch PathThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We consider the robot exploration of a planar graph-like world. The robot's goal is to build a complete map of its environment. The environment is modeled as an arbitrary undirected planar graph which is initially unknown to the robot. The robot cannot distinguish vertices and edges that it has explored from the unexplored ones. The robot is assumed to be able to autonomously traverse graph edges, recognize when it has reached a vertex, and enumerate edges incident upon the current vertex. The robot cannot measure distances nor does it have a compass, but it is equipped with a single marker that it can leave at a vertex and sense if the marker is present at a newly visited vertex. The total number of edges traversed while constructing a map of a graph is used as a measure of performance. We present an efficient algorithm for learning an unknown, undirected planar graph by a robot equipped with one marker. Experimental results obtained by running a large collection of example worlds are presented.

In this paper we give a simple algorithm to generate all connected rooted plane graphs with at most m edges. A "rooted" plane graph is a plane graph with one designated (directed) edge on the outer face. The algorithm uses O(m) space and generates such graphs in O(1) time per graph on average without duplications. The algorithm does not output the entire graph but the difference from the previous graph. By modifying the algorithm we can generate all connected (non-rooted) plane graphs with at most m edges in O(m3) time per graph.

Distance oracles are data structures that provide fast (possibly approximate) answers to shortest-path and distance queries in graphs. The tradeoff between the space requirements and the query time of distance oracles is of particular interest and the main focus of this paper. Unless stated otherwise, we assume all graphs to be planar and undirected.In FOCS 2001 (J. ACM 2004), Thorup introduced approximate distance oracles for planar graphs (concurrent with Klein, SODA 2002). Thorup proved that, for any ε > 0 and for any undirected planar graph G = (V, E) on n = |V| nodes, there exists a (1 + ε)-approximate distance oracle using space O(nε−1 log n) such that approximate distance queries can be answered in time O(ε−1).In this paper, we aim at reducing the polynomial dependency on ε−1 and log n, getting the first improvement in the query time-space tradeoff. To simplify the statement of our bounds, we define Ō(·) to hide log log n and log(1/ε) factors.•We provide the first oracle with a time-space product that is subquadratic in ε−1. We obtain an oracle with space Ō(n log n) and query time Ō(ε−1).•For unweighted graphs we show how the logarithmic dependency on n can be removed. We obtain an oracle with space Ō(n) and query time Ō(ε−1). This bound also holds for graphs with polylogarithmic average edge length, which may be a quite reasonable assumption, e.g., for road networks.

Betting Boolean-style: a framework for trading in securities based on logical formulas

We study the following all-or-nothing multicommodity flow problem in planar graphs. Input: A graph G with n vertices and k pairs of vertices (s1, t1), (s2, t2),..., (sk, tk) in G. Find: A largest subset W of {1, ...., k such that for every i in W, we can send one unit of flow between si and ti. This problem is different from the well-known maximum edge-disjoint paths problem in that we do not require integral flows for the pairs. This problem is APX-hard even for trees, and a 2-approximation algorithm is known for trees. For general graphs, Chekuri et al. (STOC'04) give a poly-logarithmic factor approximation algorithm and show that a natural LP-relaxation has a poly-logarithmic integrality gap. This result is in contrast with the integrality gap Ω(√n) for the maximum edge-disjoint paths problem. Our main result considerably strengthens this result when an input graph is planar. Namely, for the all-or-nothing multicommodity flow problem in planar graphs, we give an O(1)-approximation algorithm and show that the integrality gap is O(1). In particular, in polynomial time, we can find an index set W with |W| = Ω(OPT) and eight si-ti paths for each i in W such that each edge is used at most eight times in these paths (with multiplicity), where OPT is the optimal value of the LP-relaxation of the all-or-nothing multicommodity flow problem. Our result can be compared to the recent result by S'eguin-Charbonneau and Shepherd (FOCS'11) who give an O(1)-approximation algorithm for the maximum edge-disjoint paths problem in planar graphs with congestion 2 (but not implied by this result).

Traditional representations of graphs and their duals suggest that the dual vertices should be placed inside their corresponding primal faces, and the edges of the dual graph should only cross their corresponding primal edges. We consider the problem of simultaneously embedding a planar graph and its dual on a small integer grid such that the edges are drawn as straight-line segments and the only crossings are between primal--dual pairs of edges. We provide an O(n) time algorithm that simultaneously embeds a 3-connected planar graph and its dual on a (2n - 2) × (2n - 2) integer grid, where n is the total number of vertices in the graph and its dual. All the edges are drawn as straight-line segments except for one edge on the outer face, which is drawn using two segments.