Minimum Cuts and Shortest Cycles in Directed Planar Graphs via Noncrossing Shortest Paths

TL;DR

This paper presents faster algorithms for finding minimum cuts and shortest cycles in directed planar graphs by leveraging duality and noncrossing shortest paths, improving previous time bounds to nearly linearithmic.

Contribution

It introduces an $O(n ext{log}n ext{log} ext{log}n)$-time algorithm for both problems using a divide-and-conquer approach based on noncrossing shortest paths.

Findings

Achieved $O(n ext{log}n ext{log} ext{log}n)$ time complexity for minimum cut and shortest cycle problems.

Extended noncrossing shortest path algorithms from undirected to directed planar graphs.

Provided a unified approach exploiting duality in planar graphs to improve algorithmic efficiency.

Abstract

Let $G$ be an $n$-node simple directed planar graph with nonnegative edge weights. We study the fundamental problems of computing (1) a global cut of $G$ with minimum weight and (2) a~cycle of $G$ with minimum weight. The best previously known algorithm for the former problem, running in $O(n\log^3 n)$ time, can be obtained from the algorithm of \Lacki, Nussbaum, Sankowski, and Wulff-Nilsen for single-source all-sinks maximum flows. The best previously known result for the latter problem is the $O(n\log^3 n)$-time algorithm of Wulff-Nilsen. By exploiting duality between the two problems in planar graphs, we solve both problems in $O(n\log n\log\log n)$ time via a divide-and-conquer algorithm that finds a shortest non-degenerate cycle. The kernel of our result is an $O(n\log\log n)$-time algorithm for computing noncrossing shortest paths among nodes well ordered on a common face of a directed plane graph, which is extended from the algorithm of Italiano, Nussbaum, Sankowski, and Wulff-Nilsen for an undirected plane graph.

Equations

$$w(u_1{v}_1)+w(u_2{v}_2)\le w(u_1{v}_2)+w(u_2{v}_1)$$

$$r=\max (1,\lceil {\log }_2^{6}n\rceil ).$$

$$O\left(\log n\cdot \frac{n}{\sqrt{r}}{\log }^{2}n\right)=O(n).$$

Full text

1 Introduction

Let $G$ be an $n$-node $m$-edge simple graph with nonnegative edge weights. $G$ is unweighted if the weights of all edges of $G$ are identical. Let $C$ be a subgraph of $G$. The weight $w(C)$ of $C$ is the sum of edge weights of $C$. Let $G\setminus C$ denote the graph obtained from $G$ by deleting the edges of $C$. Paths are allowed to repeat nodes throughout the paper. For nodes $s$ and $t$, an $st$-path of $G$ is a path of $G$ from $s$ to $t$ and an $st$-cut of $G$ is a subgraph $C$ of $G$ such that there are no $st$-paths in $G\setminus C$. A (global) cut of $G$ is an $st$-cut of $G$ for some nodes $s$ and $t$ of $G$. A cycle of $G$ is an $ss$-path of $G$ for some node $s$ of $G$.

• •

The minimum-cut problem on $G$ seeks a cut of $G$ with minimum weight. For instance, the $v_{1}v_{3}$-cut consisting of edge $v_{2}v_{3}$ is the minimum cut of the graph in Figure 1(a). The best known algorithm on directed $G$, due to Hao and Orlin [30], runs in $O(mn\log\frac{n^{2}}{m})$ time. On undirected $G$, Nagamochi and Ibaraki [54] and Stoer and Wagner [61] solved the problem in $O(mn+n^{2}\log n)$ time and Karger [37] solved the problem in expected $O(m\log^{3}n)$ time. Kawarabayashi and Thorup [38] recently announced the first known $o(mn)$-time algorithm on undirected unweighted $G$, improving upon the algorithm of Gabow [24] designed twenty years ago.

• •

The shortest-cycle problem on $G$ seeks a cycle of $G$ with minimum weight. For instance, cycle $v_{2}v_{3}v_{2}$ with weight $6$ is the shortest cycle of the graph in Figure 1(a). Since a shortest directed cycle containing edge $ts$ is obtainable from a shortest $st$-path, the problem on directed graphs can be reduced to computing all-pairs shortest paths in, e.g., $O(mn+n^{2}\log n)$ time [10]. Vassilevska Williams and Williams [65] argued that finding a truly subcubic algorithm for the problem might be hard. For directed (respectively, undirected) unweighted $G$, Itai and Rodeh [32] solved the problem in $O(\mu(n)\log n)$ (respectively, $O(\min(mn,\mu(n)))$) time, where $\mu(n)=O(n^{2.373})$ [64] is the time for multiplying two $n\times n$ matrices.

If $G$ is undirected and planar, Chalermsook, Fakcharoenphol, and Nanongkai [8] showed that the time complexity of both aforementioned problems on $G$ is $O(\log n)$ times that of finding an $st$-cut of $G$ with minimum weight for any given nodes $s$ and $t$. Plugging in the $O(n\log n)$-time algorithms, e.g., of Frederickson [23], Borradaile and Klein [1], and Erickson [14], the reduction of Chalermsook et al. solved both problems in $O(n\log^{2}n)$ time. Plugging in the $O(n\log\log n)$-time algorithm of Italiano, Nussbaum, Sankowski, and Wulff-Nilsen [33], the reduction of Chalermsook et al. solved both problems in $O(n\log n\log\log n)$ time. The best known result for both problems on $G$ is the $O(n\log\log n)$-time algorithm of Łącki and Sankowski [44], relying upon the $st$-cut oracle of Italiano et al. [33].

This paper addresses both problems for the case that $G$ is directed and planar. While the minimum-cut problem has been thoroughly studied for undirected planar graphs, surprisingly no prior work is specifically for directed planar graphs. Djidjev [12] claimed that his technique for unweighted undirected planar graphs solves the shortest-cycle problem on unweighted directed planar $G$ in $O(n^{3/2})$ time and left open the problem of finding a shortest cycle in unweighted directed planar $G$ in $o(n^{3/2})$ time. Weimann and Yuster [67] gave an $O(n^{3/2})$-time algorithm for the shortest-cycle problem, which should be adjustable to solve the minimum-cut problem also in $O(n^{3/2})$ time (via similar techniques to our proof for Lemma 4.2 in §4 to handle degeneracy in shortest cycles). Wulff-Nilsen [68] reduced the time for the shortest-cycle problem on $G$ to $O(n\log^{3}n)$, but it is unclear how to adjust his algorithm to solve the minimum-cut problem without increasing the required time by too much. The algorithm of Łącki, Nussbaum, Sankowski, and Wulff-Nilsen [43] for single-source all-sinks maximum flows solves the minimum-cut problem on directed planar $G$ in $O(n\log^{3}n)$ time. Below is our result:

Theorem 1.1**.**

It takes $O(n\log n\log\log n)$ time to solve the minimum-cut and shortest-cycle problems on an $n$-node simple directed planar graph with nonnegative edge weights.

As pointed out by anonymous reviewers, Mozes, Nikolaev, Nussbaum, and Weimann [51] recently announced an $O(n\log\log n)$-time algorithms for the minimum-cut problem. However, unlike our Theorem 1.1, their algorithm requires the condition that there is a unique shortest path between any two nodes. For general directed planar graphs with nonnegative edge weights, they apply an isolation lemma [50, 53] to perturb the edge weights to meet the condition with high probability. Thus, their results are Monte Carlo randomized algorithms.

Related work

The only known nontrivial linear-time algorithm for the shortest-cycle problem, due to Chang and Lu [9], works on undirected unweighted planar graphs. For undirected $G$, if $G$ is embedded on an orientable surface of genus $g$, Erickson, Fox, and Nayyeri [15] solved the problem in $g^{O(g)}n\log{\log{n}}$ time, based on the algorithm of Łącki and Sankowski [44] for undirected planar graphs. If $G$ is undirected and unweighted and is $2$-cell embedded on an orientable surface of genus $g=O(n^{\alpha})$ with $0<\alpha<1$, Djidjev [12] solved the problem in $O(g^{3/4}n^{5/4}\log{n})$ time. On undirected unweighted $O(1)$-genus $G$, Weimann and Yuster [67] solved the problem in $O(n\log n)$ time. For directed planar $G$, even if $G$ is unweighted, our Theorem 1.1 remains the best known algorithm. If $G$ is unweighted and embedded on a genus-$g$ surface, the technique of Djidjev [12] solved the problem in $O(g^{1/2}n^{3/2})$ time. The shortest-cycle problem on $G$ with negative edge weights can be reduced to one with nonnegative edge weights using the standard reweighting technique via a shortest-path tree in $G$ (e.g., [20, 25, 27, 42, 52]). Cygan, Gabow, and Sankowski [11] studied the problem on graphs whose edge weights are bounded integers. Yuster [69] studied the version on undirected $G$ asking for each node a shortest cycle containing the node. See e.g., [5, 6, 7, 16, 19, 21, 22] for algorithms that compute shortest cycles with prescribed topological properties. See, e.g., [32, 47, 49, 59, 60, 70] for approximation algorithms of the shortest-cycle problem.

The closely related problem that seeks a minimum $st$-cut for given nodes $s$ and $t$ and its dual problem that seeks a maximum $st$-flow have been extensively studied even for only planar graphs (see, e.g., [1, 14, 39, 66]). A minimum $st$-cut of $G$ can be obtained in $O(m+n)$ time from a maximum $st$-flow $f$ of $G$ by identifying the edges from the nodes of $G$ reachable from $s$ to the nodes of $G$ not reachable from $s$ in the residual graph of $G$ with respect to $f$. No efficient reductions for the other direction are known. Orlin [55] gave the only known $O(mn)$-time algorithms for the maximum $st$-flow problem on general graphs with integral edge weights. For undirected planar $G$, Reif [58] gave an $O(n\log^{2}n)$-time algorithm for the minimum $st$-cut problem. Frederickson [23] improved the time complexity of Reif’s algorithm to $O(n\log n)$. The best known algorithms for both problems, due to Italiano et al. [33], run in $O(n\log\log n)$ time. The attempt of Janiga and Koubek [34] to generalize Reif’s algorithm to directed planar $G$ turned out to be flawed [17, 36, 51]. Borradaile and Klein [1] and Erickson [14] gave $O(n\log n)$-time algorithms for both problems on directed planar graphs. On directed planar unweighted $G$, Brandes and Wagner [4] and Eisenstat and Klein [13] solved both problems in $O(n)$ time. The algorithm of Kaplan and Nussbaum [36] is capable of exploiting the condition that nodes $s$ and $t$ are close. For directed planar $G$, the $O(n\log^{3}n)$-time algorithm of Łącki et al. [43] obtains the minimum weights of $st$-cuts for any given $s$ and all nodes $t$ of $G$. For any given node subsets $S$ and $T$ of directed planar $G$, the $O(n\log^{3}n)$-time algorithm of Borradaile, Klein, Mozes, Nussbaum, and Wulff-Nilsen [2] computes a subgraph $C$ of $G$ with minimum weight such that there is no $st$-path in $G\setminus C$ for any $s\in S$ and $t\in T$. On undirected planar $G$, Borradaile, Sankowski, and Wulff-Nilsen [3] gave an $O(n\log^{4}n)$-time algorithm to compute a Gomory-Hu cut-equivalent tree [28], a compact representation of $st$-cuts with minimum weights for all nodes $s$ and $t$.

The kernel of our result is an $O(n\log\log n)$-time algorithm for computing noncrossing shortest paths among nodes well ordered on a common face of a directed plane graph, which is extended from the algorithm of Italiano et al. [33] for an undirected plane graph. A closely related NP-hard shortest-noncrossing-paths problem seeks noncrossing paths between $k$ given terminal pairs on $h$ faces with minimum total weight in a plane graph. Takahashi, Suzuki, and Nishizeki [63] solved the problem for undirected plane graphs with $h\leq 2$ in $O(n\log k)$ time. Papadopoulou [56] addressed the geometric version of the problem, where the terminal pairs are on the boundaries of $h$ polygonal obstacles in the plane with complexity $n$ and gave an $O(n)$-time algorithm for the case $h\leq 2$. Erickson and Nayyeri [18] generalized the result of Takahashi et al., solving the problem for undirected planar graphs in $2^{O(h^{2})}n\log k$ time. They also generalized the result of Papadopoulou to solve the geometric version in $2^{O(h^{2})}n$ time. Each of these algorithms computes an implicit representation of the answers, which may have total size $\Omega(kn)$. Polishchuk and Mitchell [57] addressed the problem of finding noncrossing thick paths with minimum total weight. Takahashi, Suzuki, and Nishizeki [62] also considered the rectilinear version of the problem.

Technical overview and outline

Our proof for Theorem 1.1 consists of a series of reductions. Based upon the duality between simple cycles and minimal cuts in plane graphs, Section 2 gives an $O(n)$-time reduction from the minimum-cut and shortest-cycle problems in an $n$-node planar graph to the problem of finding a shortest non-degenerate cycle in an $n$-node $O(1)$-degree plane graph $G$ (Lemma 2.1). Let $C$ be a balanced separator of $G$ that corresponds to a fundamental cycle with respect to a shortest-path tree of $G$. A shortest non-degenerate cycle that does not cross $C$ can be recursively computed from the subgraphs of $G$ separated by $C$. Although we cannot afford to compute a shortest non-degenerate cycle that crosses $C$, Section 3 reduces the problem of finding a shortest non-degenerate cycle to finding a $C$-short cycle, i.e., a non-degenerate cycle that crosses $C$ with the property that if it is not shortest, then a shortest non-degenerate cycle that does not cross $C$ has to be a shortest non-degenerate cycle of $G$ (Lemma 3.1). This reduction is a divide-and-conquer recursive algorithm using the balanced separator $C$ and thus introduces an $O(\log n)$-factor overhead in the running time. A cycle of $G$ that crosses a shortest path $P$ of $G$ can be shortcutted into a non-degenerate cycle that crosses $P$ at most once. Section 4 reduces the problem of finding a $C$-short cycle to that of finding a $(C,P)$-short cycle, i.e., a non-degenerate cycle whose weight is no more than that of any non-degenerate cycle that crosses a shortest path $P$ of $G$ in $C$ exactly once (Lemma 4.2). By the technique of Reif [58] that incises $G$ along $P$, Section 4 further reduces the problem of finding a $(C,P)$-short cycle to that of finding shortest noncrossing paths among nodes well ordered on the boundary of external face (Lemma 4.1). As a matter of fact, this shortest-noncrossing-paths problem can be solved by the $O(n\log n)$-time algorithm of Klein [40], already yielding improved $O(n\log^{2}n)$-time algorithms for the minimum-cut and shortest-cycle problems. (Mozes et al. [51] also mentioned that $O(n\log^{2}n)$-time algorithms can be obtained by plugging in the $O(n\log n)$-time minimum $st$-cut algorithm of Borradaile and Klein [1] into a directed version of the reduction algorithm of Chalermsook et al. [8].) To achieve the time complexity of Theorem 1.1, Section 5 solves the problem in $O(n\log\log n)$ time by extending the algorithm of Italiano et al. [33] for an undirected plane graph. Section 6 concludes the paper.

2 Reduction to finding shortest non-degenerate cycles

Directed graph $G$ is bidirected if, for any two nodes $s$ and $t$ of $G$, $st$ is an edge of $G$ if and only if $ts$ is an edge of $G$. The graph in Figure 1(a) is not bidirected. The degree of node $v$ in bidirected $G$ is the number of neighbors of $v$ in $G$. The degree of bidirected $G$ is the maximum degree of the nodes in $G$. A bidirected plane graph is a bidirected planar graph equipped with a plane embedding in which edges between two adjacent nodes are bundled together. Figures 1(b) and 1(c) show two bidirected plane graphs $G_{\vartriangle}$ and $G_{\vartriangle}^{*}$. A cycle passing each node at most once is simple. A cycle is degenerate if it is a node or passes both edges $st$ and $ts$ for two nodes $s$ and $t$. A cycle not simple (respectively, degenerate) is non-simple (respectively, non-degenerate). Cycle $C_{1}$ in Figure 2(a) is non-degenerate and non-simple. In the graph $G$ of Figure 1(a), cycle $v_{2}v_{3}v_{2}$ is degenerate and simple, cycle $v_{2}v_{3}v_{4}v_{2}$ is non-degenerate and simple, and cycle $v_{1}v_{2}v_{4}v_{2}v_{3}v_{1}$ is degenerate and non-simple. The shortest degenerate cycle of $G$ is $v_{2}v_{3}v_{2}$ with weight $6$. The shortest non-degenerate cycle of $G$ is $v_{2}v_{3}v_{4}v_{2}$ with weight $16$. Theorem 1.1 can be proved by the following lemma:

Lemma 2.1**.**

It takes $O(n\log n\log\log n)$ time to compute a shortest non-degenerate cycle in an $n$-node $O(1)$-degree simple bidirected plane graph with nonnegative edge weights.

Proof of Theorem 1.1.

Adding edges with weights [math] (respectively, $\infty$) to the input graph does not affect the weight of minimum cuts (respectively, shortest cycles). Hence, we may assume without loss of generality that the input graph $G_{\vartriangle}$ has at least four nodes and is a simple bidirected plane graph such that each face of $G_{\vartriangle}$ is a triangle. See Figures 1(a) and 1(b) for examples. Let the dual $G_{\vartriangle}^{*}$ of $G_{\vartriangle}$ be the simple bidirected plane graph on the $2n-4$ faces of $G_{\vartriangle}$ sharing the same set of $6n-12$ edges with $G_{\vartriangle}$ that is obtainable in $O(n)$ time from $G_{\vartriangle}$ as follows: For any two adjacent nodes $s$ and $t$ of $G_{\vartriangle}$, there are directed edges $fg=st$ and $gf=ts$ in $G_{\vartriangle}^{*}$, where $f$ and $g$ are the two faces of $G_{\vartriangle}$ incident with the bundled edges between $s$ and $t$ such that face $g$ immediately succeeds face $f$ in clockwise order around node $s$ of $G_{\vartriangle}$. See Figure 1(c) for an example. Observe that $C$ is a minimal cut of $G_{\vartriangle}$ if and only if $C$ is a simple non-degenerate cycle of $G_{\vartriangle}^{*}$. By nonnegativity of edge weights, a shortest non-degenerate cycle of $G_{\vartriangle}^{*}$ is a minimum cut of $G_{\vartriangle}$. For instance, the shortest non-degenerate cycle of the graph $G_{\vartriangle}^{*}$ in Figure 1(c) is $f_{1}f_{4}f_{3}f_{1}$ with weight $5$. It corresponds to the $v_{1}v_{3}$-cut $\{v_{1}v_{3},v_{2}v_{3},v_{4}v_{3}\}$ of $G_{\vartriangle}$, which in turn corresponds to the minimum cut $\{v_{2}v_{3}\}$ of $G$. Although the degenerate cycle $f_{1}f_{4}f_{1}$ is a shortest cycle of $G_{\vartriangle}^{*}$, it does not correspond to a cut of $G$ in the above manner. Since each node of $G_{\vartriangle}^{*}$ has exactly three neighbors, the statement of the theorem for the minimum-cut problem follows from applying Lemma 2.1 on $G_{\vartriangle}^{*}$.

By nonnegativity of edge weights, it takes $O(n)$ time to obtain a shortest degenerate cycle of $G_{\vartriangle}$ by examining the $O(n)$ degenerate cycles of $G_{\vartriangle}$ on exactly two nodes. By Lemma 2.1, the statement of the theorem for the shortest-cycle problem is immediate from the following claim:

It takes $O(n)$ time to obtain from $G_{\vartriangle}$ an $O(n)$-node $O(1)$-degree simple bidirected plane graph $G$ such that a shortest non-degenerate cycle of $G_{\vartriangle}$ can be computed from a shortest non-degenerate cycle of $G$ in $O(n)$ time.

Let $G_{1}$ and $G_{2}$ be simple bidirected plane graphs with nonnegative edge weights such that $G_{2}$ is obtained from $G_{1}$ by the following $O(d)$-time operation on a degree-$d$ node $v$ of $G_{1}$ with $d\geq 4$: If $u_{1},\ldots,u_{d}$ are the neighbors of $v$ in $G_{1}$ in clockwise order around $v$, then $\mbox{\sc Split}(v)$

• •

adds zero-weight path $v_{1}v_{2}\cdots v_{d-1}v_{d}v_{d-1}\cdots v_{2}v_{1}$ with new nodes $v_{1},\ldots,v_{d}$,

• •

replaces edge $u_{i}v$ by edge $u_{i}v_{i}$ with the same weight for each $i=1,\ldots,d$,

• •

replaces edge $vu_{i}$ by edge $v_{i}u_{i}$ with the same weight for each $i=1,\ldots,d$, and

• •

deletes $v$.

See Figure 2 for an example of $G_{1}$ and $G_{2}$. An $O(n)$-node $O(1)$-degree simple bidirected plane graph $G$ can be obtained in $O(n)$ time from $G_{\vartriangle}$ by iteratively applying Split on each node $v$ of $G_{\vartriangle}$ with degree $d\geq 4$. To prove the claim, it suffices to ensure the following statement:

*A shortest non-degenerate cycle $C_{1}$ of $G_{1}$ is obtainable in $O(d)$ time from a shortest non-degenerate cycle $C^{*}_{2}$ of $G_{2}$. *

For each $u_{i}u_{j}$-path $P$ of $C^{*}_{2}$ with $1\leq i\neq j\leq d$ such that $P$ has at least two edges and all internal nodes of $P$ are in $\{v_{1},\ldots,v_{d}\}$, we replace $P$ by path $u_{i}vu_{j}$. By $w(P)=w(u_{i}vu_{j})$, we have $w(C_{1})=w(C^{*}_{2})$. Since $C^{*}_{2}$ is non-degenerate, so is the resulting $O(d)$-time obtainable cycle $C_{1}$ of $G_{1}$. Since $C_{1}$ may pass $v$ more than once, $C_{1}$ could be non-simple. See Figure 2 for an example of $C^{*}_{2}$ and $C_{1}$. It remains to show $w(C_{1})=w(C^{*}_{1})$ for any shortest simple non-degenerate cycle $C^{*}_{1}$ of $G_{1}$. By nonnegativity of edge weights, we have $w(C_{1})\geq w(C^{*}_{1})$ even if $C_{1}$ is non-simple. Let $C_{2}$ be the cycle of $G_{2}$ that is obtained from $C^{*}_{1}$ as follows: If there is a path $u_{i}vu_{j}$ with $1\leq i\neq j\leq d$ in $C^{*}_{1}$, then replace it by path $u_{i}v_{i}\cdots v_{j}u_{j}$. By $w(u_{i}vu_{j})=w(u_{i}v_{i}\cdots v_{j}u_{j})$, we have $w(C_{2})=w(C^{*}_{1})$. Otherwise, let $C_{2}=C^{*}_{1}$. Since $C^{*}_{1}$ is simple, there is at most one path $u_{i}vu_{j}$ in $C^{*}_{1}$. Since $C^{*}_{1}$ is non-degenerate, so is $C_{2}$. See Figure 2 for an example of $C^{*}_{1}$ and $C_{2}$. By $w(C_{1})=w(C^{*}_{2})\leq w(C_{2})=w(C^{*}_{1})$, $C_{1}$ is a shortest non-degenerate cycle of $G_{1}$. ∎

The rest of the paper proves Lemma 2.1.

3 Divide-and-conquer via balanced separating cycles

Let $C$ be a simple non-degenerate cycle of a bidirected plane graph $G$ with nonnegative edge weights. Let $\textit{int}_{G}(C)$ (respectively, $\textit{ext}_{G}(C)$) denote the subgraph of $G$ consisting of the nodes and edges on the boundary of the faces of $G$ inside (respectively, outside) of $C$. A non-degenerate cycle $C_{3}$ of $G$ is $C$-short if one of $C_{1}$, $C_{2}$, and $C_{3}$ is a shortest non-degenerate cycle of $G$, where $C_{1}$ (respectively, $C_{2}$) is a shortest non-degenerate cycle of $\textit{int}_{G}(C)$ (respectively, $\textit{ext}_{G}(C)$). We say that $C$ is segmented if it consists of the following three paths in order: (1) a shortest path $P_{1}$, (2) an edge, and (3) the reverse of a shortest path $P_{2}$, where one of $P_{1}$ and $P_{2}$ is allowed to be a node. Let shortest paths $P_{1}$ and $P_{2}$ be the segments of $C$. See Figure 3(a) for an example. This section proves Lemma 2.1 using Lemmas 3.1, 3.2, and 3.3. Section 4 proves Lemma 3.1.

Lemma 3.1**.**

Let $G$ be an $n$-node $O(1)$-degree simple bidirected plane graph with nonnegative edge weights. Given a segmented simple non-degenerate cycle $C$ of $G$ together with its segments, it takes $O(n\log\log n)$ time to compute a $C$-short non-degenerate cycle of $G$.

Lemma 3.2** (Henzinger, Klein, Rao, and Subramanian [31]).**

It takes $O(n)$ time to compute a shortest-path tree rooted at any given node of an $n$-node connected simple directed planar graph with nonnegative edge weights.

Lemma 3.3** (Lipton and Tarjan [48], Goodrich [29], Klein, Mozes, and Sommer [41, Lemma 1]).**

Let $G_{\vartriangle}$ be an $n$-node simple undirected plane triangulation with nonnegative face weights summing to $1$ such that the weight of each face of $G_{\vartriangle}$ is at most $\frac{1}{4}$. Given any spanning tree $T$ of $G_{\vartriangle}$, it takes $O(n)$ time to obtain an edge $e$ of $G_{\vartriangle}\setminus T$ such that the total weight of the faces of $G_{\vartriangle}$ inside (respectively, outside) of the simple cycle in $T\cup\{e\}$ is no more than $\frac{3}{4}$.

Proof of Lemma 2.1.

We give a divide-and-conquer recursive algorithm on the input graph $H$, which can be assumed to be connected without loss of generality. For each degree-$2$ node $y$ whose neighbors $x$ and $z$ are non-adjacent, we replace $y$ and its incident edges by edges $xz$ and $zx$ with weights $w(xy)+w(yz)$ and $w(zy)+w(yx)$, respectively. The resulting graph $G$ obtainable in $O(n)$ time from $H$ remains an $O(1)$-degree simple connected bidirected plane graph. See Figure 3 for an example of $H$ and $G$. Let $\ell$ be the number of faces in $G$. Since each maximal simple path on the degree-$2$ nodes of $G$ has $O(1)$ edges, $G$ has $O(\ell)$ nodes. A shortest non-degenerate cycle of $H$ can be obtained in $O(n)$ time from a shortest non-degenerate cycle of $G$, which can be found in $O(1)$ time for the case with $\ell\leq 4$.

To obtain a shortest non-degenerate cycle of $G$ for the case with $\ell\geq 5$, let $T$ be an $O(n)$-time obtainable shortest-path tree of $G$ rooted at an arbitrary node as ensured by Lemma 3.2. For each face $f$ of the simple undirected unweighted version $G_{0}$ of $G$ having size $k\geq 3$, (1) let $f$ be triangulated into $k-2$ faces via adding $k-3$ edges without introducing multiple edges, (2) let an arbitrary one of the $k-2$ faces be assigned weight $\frac{1}{\ell}$, and (3) let the remaining $k-3$ faces be assigned weights [math]. Let $G_{\vartriangle}$ be the resulting simple plane triangulation. The undirected version $T_{0}$ of $T$ is a spanning tree of $G_{0}$ and $G_{\vartriangle}$. See Figure 4 for an example. Lemma 3.3 ensures an edge $xy$ of $G_{\vartriangle}\setminus T_{0}$ obtainable in $O(n)$ time such that the face weights of $G_{\vartriangle}$ inside (respectively, outside) of the simple cycle of $T_{0}\cup\{xy\}$ sum to at most $\frac{3}{4}$. For instance, such an edge $xy$ in the example in Figure 4 is $v_{3}v_{4}$. If $x$ and $y$ are adjacent in $G$, then let $E=\varnothing$; otherwise, let $E$ consist of edges $xy$ and $yx$ with weights $\infty$. We union $G$ and $E$ to obtain a simple bidirected plane graph $G^{*}$. Let $s$ be the least common ancestor of $x$ and $y$ in $T$. Let $C$ be the segmented simple non-degenerate cycle of $G^{*}$ consisting of (1) the $sx$-path of $T$, (2) edge $xy$, and (3) the reverse of the $sy$-path of $T$. By Lemma 3.1, it takes $O(n\log\log n)$ time to compute a $C$-short cycle $C_{3}$ of $G^{*}$. Let $H_{1}=\textit{int}_{G^{*}}(C)\setminus E$ and $H_{2}=\textit{ext}_{G^{*}}(C)\setminus E$. No matter $E=\varnothing$ or not, $H_{1}$ and $H_{2}$ are subgraphs of $G$ . We recursively compute a shortest non-degenerate cycle $C_{1}$ (respectively, $C_{2}$) in $H_{1}$ (respectively, $H_{2}$), which is also a shortest non-degenerate cycle of $\textit{int}_{G^{*}}(C)$ (respectively, $\textit{ext}_{G^{*}}(C)$). By definition of $C_{3}$, a cycle $C^{*}$ in $\{C_{1},C_{2},C_{3}\}$ with minimum weight is a shortest non-degenerate cycle of $G^{*}$. If $C^{*}$ passes an edge in $E\neq\varnothing$, then the weight of each non-degenerate cycle of $G^{*}$ and $G$ is $\infty$. Otherwise, we return $C^{*}$ as a shortest non-degenerate cycle of $G$. The algorithm runs in $O(n\log\log n)$ time without accounting for the time for its subsequent recursive calls. By $\ell\geq 5$, the number $\ell_{1}$ (respectively, $\ell_{2}$) of faces in $H_{1}$ (respectively, $H_{2}$) is at most $\frac{3}{4}\ell+1\leq\frac{19}{20}\ell$, implying that there are $O(\log n)$ levels of recursion. By $\ell_{1}+\ell_{2}\leq\ell+2$, the overall number of faces in each recursion level is $O(n)$, implying that the overall number of nodes in each recursion level is $O(n)$. The algorithm runs in $O(n\log n\log\log n)$ time. ∎

4 Non-degenerate cycles that cross the separating cycle

This section proves Lemma 3.1 by Lemma 4.2, which is proved by Lemmas 3.2 and 4.1. Section 5 proves Lemma 4.1. If graph $G$ has $uv$-paths, then let $d_{G}(u,v)$ denote the weight of a shortest $uv$-path of $G$. If $G$ has no $uv$-paths, then let $d_{G}(u,v)=\infty$.

Lemma 4.1**.**

Let $G$ be an $n$-node simple connected bidirected plane graph with nonnegative edge weights. Let $u_{1},\ldots,u_{\ell},v_{\ell},\ldots,v_{1}$ be $O(n)$ nodes on the boundary of the external face of $G$ in order. It takes overall $O(n\log\log n)$ time to compute $d_{G}(u_{i},v_{i})$ for each $i=1,\ldots,\ell$.

Let $G$ be a simple bidirected plane graph. A simple path $Q$ of $G$ aligns with subgraph $H$ of $G$ if $Q$ or the reverse of $Q$ is a path of $H$. A simple path $Q$ of $G$ passing at least one edge deviates from subgraph $H$ of $G$ if the edges and the internal nodes of $Q$ are not in $H$. For any simple path $P$ of $G$, a non-degenerate cycle of $G$ is a $P$-cycle if it consists of a path aligning with $P$ and a path deviating from $P$. For any simple non-degenerate cycle of $G$ and any path $P$ of $G$ aligning with $C$, a $P$-cycle is a $(C,P)$-cycle if the first edge of its path deviating from $P$ is in $\textit{int}_{G}(C)$ if and only if the last edge of its path deviating from $P$ is in $\textit{ext}_{G}(C)$. For instance, the $C^{*}$ in Figure 3(a) is a $P_{1}$-cycle of $G$ whose path aligning with $P_{1}$ is node $v_{2}$. The first edge $v_{2}v_{6}$ (respectively, last edge $v_{5}v_{2}$) of its path deviating from $P_{1}$ is in $\textit{ext}_{G}(C)$ (respectively, $\textit{int}_{G}(C)$), so $C^{*}$ is a $(C,P_{1})$-cycle of $G$. $C^{*}$ is also a $(C,P_{2})$-cycle. A non-degenerate cycle of $G$ is $(C,P)$-short if its weight is no more than that of any $(C,P)$-cycle of $G$.

Lemma 4.2**.**

Let $G$ be an $n$-node $O(1)$-degree simple bidirected plane graph with nonnegative edge weights. Let $C$ be a simple non-degenerate cycle of $G$. Given a path $P$ of $G$ aligning with $C$, it takes $O(n\log\log n)$ time to compute a $(C,P)$-short cycle of $G$.

Proof.

Let $C^{*}$ be a $(C,P)$-cycle of $G$ with minimum weight. For instance, the red and blue cycles in Figure 5(a) are two $(C,P)$-cycles with minimum weight $2$. Let $C_{0}$ be a shortest non-degenerate cycle of $G$ passing at least one endpoint of $P$, which can be obtained in $O(n)$ time via examining shortest $uv$-paths in $G\setminus\{uv,vu\}$ by Lemma 3.2 for all $O(1)$ edges $uv$ of $G$ incident to at least one endpoint of $P$. If $C^{*}$ passes some endpoint of $P$, then $w(C_{0})\leq w(C^{*})$, implying that $C_{0}$ is a cycle ensured by the lemma. The rest of the proof assumes that $C^{*}$ does not pass any endpoint of $P$. Thus, $P$ has internal nodes. Let $H$ be an $O(n)$-node $O(1)$-degree simple bidirected plane graph obtainable in $O(n)$ time as follows: Suppose that $u_{0},\ldots,u_{\ell+1}$ with $\ell\geq 1$ are the nodes of $P$ in order. Let $s=v_{0}=u_{0}$ and $t=v_{\ell+1}=u_{\ell+1}$. We incise $G$ along $P$ by

• •

adding new nodes $v_{1},\ldots,v_{\ell}$, a new path $P^{\prime}=sv_{1}\cdots v_{\ell}t$ and the reverse of $P^{\prime}$,

• •

for each $i=1,\ldots,\ell$, letting each edge $vu_{i}$ (respectively, $u_{i}v$) incident to $u_{i}$ in $\textit{int}_{G}(C)\setminus P$ be replaced by $vv_{i}$ (respectively, $v_{i}v$) with the same weight,

• •

letting the weight of each edge in $P^{\prime}$ and the reverse of $P^{\prime}$ be $\infty$, and

• •

embedding the resulting graph $H$ such that $P$ and $P^{\prime}$ are on the external face.

See Figure 5 for an example. By Lemma 4.1, it takes overall $O(n\log\log n)$ time to compute $d_{H}(u_{i},v_{i})$ and $d_{H}(v_{i},u_{i})$ for each $i\in\{1,\ldots,\ell\}$. Let $i_{1}$ (respectively, $i_{2}$) be an $i\in\{1,\ldots,\ell\}$ that minimizes $d_{H}(u_{i},v_{i})$ (respectively, $d_{H}(v_{i},u_{i})$). By Lemma 3.2, it takes $O(n)$ time to obtain a simple shortest $u_{i_{1}}v_{i_{1}}$-path $P_{1}$ of $H$ and a simple shortest $v_{i_{2}}u_{i_{2}}$-path $P_{2}$ of $H$. The weight of $P_{1}$ (respectively, $P_{2}$) is minimum over all $u_{i}v_{i}$-paths (respectively, $v_{i}u_{i}$-paths) of $H$ with $1\leq i\leq\ell$. Let $C_{1}$ (respectively, $C_{2}$) be the non-degenerate cycle of $G$ corresponding to $P_{1}$ (respectively, $P_{2}$). Let $Q$ be the path of $C^{*}$ that deviates from $P$. Let $u_{i}$ and $u_{j}$ with $1\leq i,j\leq\ell$ be the first and last nodes of $Q$, respectively. If the first edge of $Q$ is in $\textit{int}_{G}(C)$, then $C^{*}$ corresponds to a $v_{i}u_{i}$-path of $H$, implying $w(C_{2})\leq w(C^{*})$. If the last edge of $Q$ is in $\textit{int}_{G}(C)$, then $C^{*}$ corresponds to a $u_{j}v_{j}$-path of $H$, implying $w(C_{1})\leq w(C^{*})$. For instance, the red (respectively, blue) cycle of $G$ in Figure 5(a) corresponds to the red $u_{1}v_{1}$-path (respectively, blue $v_{1}u_{1}$-path) of $H$ in Figure 5(b). Thus, one of $C_{0}$, $C_{1}$, and $C_{2}$ with minimum weight is a cycle ensured by the lemma. ∎

Proof of Lemma 3.1.

Let $G_{1}=\textit{int}_{G}(C)$ and $G_{2}=\textit{ext}_{G}(C)$. Let $P_{1}$ and $P_{2}$ be the given segments of $C$. Let $C^{*}$ be a shortest non-degenerate cycle of $G$ whose number of edges not in $P_{1}\cup P_{2}$ is minimized over all shortest non-degenerate cycles of $G$. If $C^{*}$ is a cycle of $G_{1}$ or $G_{2}$, then any cycle of $G$ is $C$-short, including the one ensured by Lemma 4.2. The rest of the proof assumes that neither $G_{1}$ nor $G_{2}$ contains $C^{*}$. By Lemma 4.2, it suffices to ensure that $C^{*}$ is a $(C,P_{1})$-cycle. We need the following claim:

For each $i\in\{1,2\}$, if $C^{*}\cap P_{i}\neq\varnothing$, then $C^{*}$ is a $P_{i}$-cycle of $G$.

By the claim, $C^{*}$ intersects both $P_{1}$ and $P_{2}$ or else $C^{*}$ would be a cycle of $G_{1}$ or $G_{2}$, as illustrated by Figure 6(a), contradicting the assumption. Since $C^{*}$ is a $P_{1}$-cycle and a $P_{2}$-cycle, $C^{*}$ consists of four paths $Q_{1}$, $R_{1}$, $Q_{2}$, and $R_{2}$ in order such that $Q_{i}$ aligns with $P_{i}$ and $R_{i}$ deviates from $P_{1}\cup P_{2}$ for each $i\in\{1,2\}$. By the assumption, if $R_{1}\subseteq G_{i}$ and $R_{2}\subseteq G_{j}$, then $\{i,j\}=\{1,2\}$. Thus, $C^{*}$ is a $(C,P_{1})$-cycle. See Figure 6(b) for an illustration. It remains to prove the claim. Assume for contradiction that $C^{*}$ intersects $P_{i}$ but is not a $P_{i}$-cycle for an index $i\in\{1,2\}$. There are nodes $u_{1},v_{1},u_{2},v_{2}$ of $P_{i}$ with $u_{1}\neq v_{1}$ and $u_{2}\neq v_{2}$ such that

• •

$u_{1}$ precedes $v_{1}$ in $P_{i}$,

• •

$u_{2}$ succeeds $v_{2}$ in $P_{i}$,

• •

the $u_{1}v_{1}$-path and the $u_{2}v_{2}$-path of $C^{*}$ deviate from $P_{i}$, and

• •

the $u_{1}v_{1}$-path of $C^{*}$ deviates from the $u_{2}v_{2}$-path of $C^{*}$.

Let $C^{\prime}$ be the cycle of $G$ obtained from $C^{*}$ by replacing the $u_{1}v_{1}$-path of $C^{*}$ with the $u_{1}v_{1}$-path of $P_{i}$. Since $P_{i}$ is a shortest path of $G$, $w(C^{\prime})\leq w(C^{*})$. Since $C^{*}$ is non-degenerate, the reverse of each of the $u_{2}v_{2}$-path of $C^{\prime}$ is not in $C^{\prime}$. Thus, even if $C^{\prime}$ is degenerate, there is a non-degenerate cycle $C^{\prime\prime}$ in $C^{\prime}$. See Figure 6(c) for an illustration. By nonnegativity of edge weights, $w(C^{\prime\prime})\leq w(C^{\prime})$. By $w(C^{\prime\prime})\leq w(C^{*})$, $C^{\prime\prime}$ is a shortest non-degenerate cycle of $G$ whose number of edges not in $P_{1}\cup P_{2}$ is fewer than the number of edges of $C^{*}$ not in $P_{1}\cup P_{2}$, contradicting the definition of $C^{*}$. ∎

5 Noncrossing shortest paths among nodes on external face

This section proves Lemma 4.1 via extending techniques of Reif [58] and Italiano et al. [33] for undirected planar graphs. Algorithms for $r$-divisions (Lemma 5.1) and dense-distance graphs (Lemma 5.2) are reviewed in §5.1. Data structures for fast-Dijkstra algorithm (Lemma 5.5) are given in §5.2. Data structures that enables efficient partition of boundary nodes via noncrossing paths (Lemma 5.6) are given in §5.3. Tools involving noncrossing shortest paths (Lemma 5.8) are given in §5.4. Lemma 4.1 is proved by Lemmas 3.2, 5.1, 5.2, 5.5, 5.6, and 5.8 in §5.5.

5.1 Dense-distance graph

Let $G$ be a simple bidirected plane graph. A division $D$ of $G$ is an edge-disjoint partition of $G$ into bidirected plane subgraphs, each of which is a piece of $D$. The multiplicity of node $v$ of $G$ in $D$ is the number of pieces of $D$ containing $v$. A node of $G$ with multiplicity two or more in $D$ is a boundary node of $D$. A face of a piece of $D$ is a hole of the piece if it is not a face of $G$. For any $r>0$, an $r$-division (see, e.g., [23, 31, 33, 41, 44]) of $G$ is a division of $G$ with $O(n/r)$ pieces, each having $O(r)$ nodes, $O(\sqrt{r})$ boundary nodes, and $O(1)$ holes.

Lemma 5.1** (Klein, Mozes, and Sommer [41]).**

For any $r>0$, it takes $O(n)$ time to compute an $r$-division for an $n$-node simple bidirected plane graph each of whose faces contains at most three nodes.

Let $D$ be an $r$-division of $G$. For any connected component $H$ of any piece of $D$, let $K(H)$ denote the complete directed graph on the boundary nodes of $D$ in $H$ in which $w(uv)=d_{H}(u,v)$. See Figure 7 for an example. The dense distance graph (see, e.g., [33]) $K(D)$ of $D$ is the $O(n)$-edge simple directed graph on the $O(n/\sqrt{r})$ boundary nodes of $D$ simplified from the union of $K(H)$ over all connected components $H$ of all pieces of $D$ by keeping exactly one copy of parallel edges with minimum weight. For any edge $uv$ of $K(D)$, an underlying $uv$-path is a $uv$-path in some connected component $H$ of some piece of $D$ with weight equal to $w(uv)$ in $K(D)$. For any path $\Pi$ of $K(D)$, an underlying path of $\Pi$ consists of an underlying $uv$-path for each edge $uv$ of $\Pi$.

Lemma 5.2** (Klein [40]).**

For any given $r$-division $D$ of an $n$-node simple bidirected plane graph with nonnegative edge weights, it takes $O(n\log r)$ time to compute $K(D)$ and a data structure from which, for any path $\Pi$ of $K(D)$, the first $c$ edges of an underlying path of $\Pi$ can be obtained in $O(c\log\log r)$ time.

5.2 Fast-Dijkstra algorithm

Consider the following equation

[TABLE]

for distinct nodes $u_{1},u_{2},v_{1},v_{2}$ of a simple directed graph $H$ with edge weights. A type-$1$ Monge unit is a complete $H$ equipped with a cyclic ordering for the nodes of $H$ such that Equation (1) holds for any distinct nodes $u_{1},u_{2},v_{2},v_{1}$ of $H$ in order. A type-$2$ Monge unit is a complete bipartite $H$ equipped with an ordering for each of the two maximal independent sets of $H$ such that Equation (1) holds for any distinct nodes $u_{1}$ and $u_{2}$ of one independent set in order and any distinct nodes $v_{1}$ and $v_{2}$ of the other independent set in order.

A Monge decomposition of a simple directed graph $K$ with edge weights is a set $M$ of Monge units on node subsets of $K$ such that $K$ is the graph simplified from the union of the Monge units in $M$. The multiplicity of a node $v$ of $K$ in $M$ is the number of Monge units in $M$ that contain $v$. The size of $M$ is the sum of the multiplicities of all nodes of $K$ in $M$. An equivalent form of the following lemma is proved by Mozes and Wulff-Nilsen [52, §4.4] using the algorithm of Klein [40] and used by Kaplan, Mozes, Nussbaum, and Sharir [35, §5.2]. Specifically, for any hole $C$ of a piece $H$ of $D$, the complete graph on the nodes of $C$ with $w(uv)=d_{H}(u,v)$ for any nodes $u$ and $v$ in $C$ equipped with the cyclic ordering of $C$ is a type-$1$ Monge unit. For instance, the subgraphs of $K(H)$ in Figure 7(b) induced by $\{x_{1},x_{2},x_{3}\}$ and $\{y_{1},y_{2}\}$ equipped with their cyclic orders on the holes are two type-$1$ Monge units. For any two holes $C_{1}$ and $C_{2}$ of a piece $H$ of $D$, Mozes et al. showed that the complete bipartite graph on the nodes of $C_{1}$ and $C_{2}$ with $w(uv)=d_{H}(u,v)$ for nodes $u$ and $v$ such that each of $C_{1}$ and $C_{2}$ contains exactly one of $u$ and $v$ can be simplified from the union of $O(1)$ type-$2$ Monge units. For instance, the subgraph of $K(H)$ in Figure 7 consisting of edges between $\{x_{1},x_{2},x_{3}\}$ and $\{y_{1},y_{2}\}$ can be simplified from the union of the graphs in Figures 8(a) and 8(b). The edges of the graph in Figure 8(a) from $\langle x_{1},x_{2},x_{3}\rangle$ (respectively, $\langle y_{2},y_{1}\rangle$) to $\langle y_{1},y_{2}\rangle$ (respectively, $\langle x_{3},x_{1},x_{2}\rangle$) form a type-$2$ Monge unit. The edges of the graph in Figure 8(b) from $\langle x_{3},x_{1},x_{2}\rangle$ (respectively, $\langle y_{1},y_{2}\rangle$) to $\langle y_{1},y_{2}\rangle$ (respectively, $\langle x_{3},x_{1},x_{2}\rangle$) form a type-$2$ Monge unit.

Lemma 5.3**.**

For any given $r$-division $D$ of an $n$-node simple bidirected plane graph with nonnegative edge weights, it takes $O(n\log r)$ time to obtain a Monge decomposition $M(D)$ of $K(D)$ such that the multiplicity of a node of $K(D)$ in $M(D)$ is $O(1)$ times its multiplicity in $D$.

As summarized in the following lemma, given a size-$m$ Monge decomposition of graph $K$, there are $O(m\log^{2}m)$-time obtainable data structures for range minimum queries (see, e.g., Kaplan et al. [35] and Gawrychowski, Mozes, and Weimann [26]) with which the fast-Dijkstra algorithm of Fakcharoenphol and Rao [20] outputs a shortest-path tree of $K$ in $O(m\log^{2}m)$ time.

Lemma 5.4**.**

Given a size-$m$ Monge decomposition of a simple strongly connected directed graph $K$ with nonnegative edge weights, it takes $O(m\log^{2}m)$ time to compute a shortest-path tree of $K$ rooted at any given node.

Lemma 5.5**.**

Let $D$ be a given $r$-division of an $n$-node simple plane graph with nonnegative edge weights. It takes $O(n\log r)$ time to compute a data structure from which, for any subset $X$ of the boundary nodes of $D$ such that the subgraph $K$ of $K(D)$ induced by $X$ is strongly connected, it takes $O(m\log^{2}m)$ time to compute a shortest-path tree of $K$ rooted at any given node, where $m$ is the sum of the multiplicities of the nodes of $X$ in $D$.

Proof.

Let $M(D)$ be a Monge decomposition of $K(D)$ as ensured by Lemma 5.3. Let $M$ consist of the subgraph $H[X]$ of $H$ induced by $X$ for each Monge unit $H$ in $M(D)$. Each $H[X]$ remains a Monge unit with the induced cyclic ordering (respectively, orderings) of the nodes in $H[X]$ for the first (respectively, second) type. Thus, $M$ is a Monge decomposition of $K$ preserving the property that the multiplicity of a node of $K$ in $M$ is $O(1)$ times its multiplicity in $D$, implying that the size of $M$ is $O(m)$. It takes overall $O(m)$ time to obtain the induced cyclic ordering or the two induced orderings of the nodes of $H[X]$ from $H$ for each Monge unit $H$ in $M(D)$. Since the weight of each edge of $H[X]$ can be obtained in $O(1)$ time from its weight in $H$, we have an implicit representation of $M$ in $O(m)$ time. The lemma follows from Lemma 5.4. ∎

5.3 Noncrossing paths

Let $G$ be a simple connected bidirected plane graph. Let $u_{1},u_{2},v_{2},v_{1}$ be distinct nodes on the boundary of the external face of connected plane graph $G$ in order. A simple $u_{1}v_{1}$-path $P_{1}$ and a simple $u_{2}v_{2}$-path $P_{2}$ of $G$ are noncrossing if $P_{1}\cap P_{2}$ is empty or is a path. For instance, in Figure 9, $P_{1}$ in red and $P_{2}$ in blue are noncrossing. For noncrossing $P_{1}$ and $P_{2}$, let $G[P_{1},P_{2}]$ denote the connected bidirected plane subgraph of $G$ enclosed by $P_{1}$, $P_{2}$, and the $u_{1}u_{2}$-path and $v_{2}v_{1}$-path on the boundary of the external face of $G$ following the order of $u_{1},u_{2},v_{2},v_{1}$. See Figure 9 for an example.

Let $D$ be an $r$-division of $G$. Our proof of Lemma 4.1 needs a data structure $B(D)$ with the following property: For distinct nodes $u_{1},u_{2},u_{3},v_{3},v_{2},v_{1}$ on the external face of $G$ in order, any disjoint simple $u_{1}v_{1}$-path $P_{1}$ and $u_{3}v_{3}$-path $P_{3}$ of $G$, and any simple $u_{2}v_{2}$-path $P_{2}$ of $G[P_{1},P_{3}]$ such that $P_{1}$ and $P_{2}$ are noncrossing, given $X(1,3)$ and $P_{2}\setminus P_{1}$, it takes $O((m_{1}+m_{2})\log r)$ time to obtain $X(1,2)$ and $X(2,3)$, where $X(i,j)$ with $1\leq i<j\leq 3$ consists of the boundary nodes of $D$ in $G[P_{i},P_{j}]$, $m_{1}$ is the sum of multiplicities of the nodes of $X(1,3)$ in $D$, and $m_{2}$ is the number of edges in $P_{2}\setminus P_{1}$. See Figure 10 for an illustration.

Lemma 5.6**.**

It takes $O(n)$ time to compute a data structure $B(D)$ for any given $r$-division $D$ of any $n$-node simple connected bidirected plane graph.

Proof.

Given $X(1,3)$ and the edge set $E$ of $P_{2}\setminus P_{1}$, it takes $O(m_{1}+m_{2})$ time to obtain the nodes of $X(1,3)$ in $E$, which belongs to $X(1,2)\cap X(2,3)$. Let $X$ consist of the nodes of $X(1,3)$ not in $E$. If $X=\varnothing$, then $X(1,2)=X(2,3)=X(1,3)$. The rest of the proof assumes $X\neq\varnothing$. Let $\mathbbmsl{H}_{0}$ (respectively, $\mathbbmsl{H}_{1}$) consist of the pieces $H$ of $D$ such that $H$ contains nodes of $X$ and no (respectively, some) edges of $E$. We have $\mathbbmsl{H}_{1}\neq\varnothing$, since $G[P_{1},P_{3}]$ is connected and $E\neq\varnothing$. Let $A$ be the $O(m_{1}+m_{2})$-time obtainable undirected bipartite graph on the nodes $x$ in $X$ and the pieces $H$ of $D$ in $\mathbbmsl{H}_{0}$ such that $H$ and $x$ are adjacent in $A$ if and only if $H$ contains $x$ in $G$. The nodes of $X$ in the same connected component of $A$ either all belong to $X(1,2)$ or all belong to $X(2,3)$. Since $G[P_{1},P_{3}]$ is connected, each connected component of $A$ contains a node of $X$ that belongs to a piece of $H\in\mathbbmsl{H}_{1}$ in $G$. It takes overall $O(m_{1}+m_{2})$ time to obtain $H\cap E$, $C\cap E$, and $C\cap X$ for each hole $C$ of each piece $H$ of $D$ in $\mathbbmsl{H}_{1}$. Since each piece of $D$ has $O(1)$ holes, it remains to show that with the $B(D)$ defined below, for each hole $C$ of each piece $H$ of $D$ in $\mathbbmsl{H}_{1}$, it takes $O(m\log r)$ time to determine the nodes of $C\cap X$ in $X(1,2)$, where $m$ is the number of nodes in $H\cap X$ plus the number of edges in $H\cap E$.

Assume without loss of generality that the external face of each piece $H$ of $D$ is a hole of $H$. The $O(n)$-time obtainable data structure $B(D)$ consists of (1) the cyclic ordering of the incident edges around each node of $G$ and (2) the following items for each hole $C$ of each piece $H$ of $D$:

• •

An arbitrary simple path $Q$ of $H$ from a node of $C$ to a node $q$ on the external face of $H$.

• •

The ordering indices of the nodes on $Q$.

• •

The cyclic ordering indices of the nodes on $C$.

It takes overall $O(m_{1}+m_{2})$ time to obtain $Q\cap E$ for each hole $C$ of each piece $H$ of $D$ in $\mathbbmsl{H}_{1}$. With the first part of $B(D)$, if $uv$ is an edge of $G[P_{1},P_{3}]$ with $u\in P_{2}$ and $v\notin P_{2}$, then it takes $O(1)$ time to determine whether $v\in G[P_{1},P_{2}]$. With the second part of $B(D)$, for any $k$-node subset $U$ of any piece $H$ of $D$ and any hole $C$ of $H$, it takes $O(k)$ time to determine the ordering indices of the nodes of $U\cap Q$ in $Q$ and the cyclic ordering indices of the nodes of $U\cap C$ in $C$.

Case 1: $C\cap E\neq\varnothing$. As illustrated by Figure 11(a), it takes overall $O(m\log r)$ time via sorting their ordering indices to compute, for each node $x$ of $C\cap X$, the first node $u\in E$ in the traversal of $C$ starting from $x$ following the order of $u_{1},u_{3},v_{3},v_{1}$ and the node $v$ of $C$ preceding $u$ in the traversal. We have $x\in X(1,2)$ if and only if $v\in G[P_{1},P_{2}]$, which can be determined in $O(1)$ time.

Case 2: $C\cap E=\varnothing$. As illustrated by Figure 11(b), if $Q\cap E\neq\varnothing$, then let $v$ be the node preceding the first node $u$ of $Q$ in $E$. Let $C^{\prime}$ be the boundary of the external face of $H$. As illustrated by Figure 11(c), if $Q\cap E=\varnothing$, then let $v$ be the node of $C^{\prime}$ preceding the first node $u$ of $C^{\prime}$ in $E$ on the traversal of $C^{\prime}$ starting from $q$ following the order of $u_{1},u_{3},v_{3},v_{1}$. Either way, it takes $O(m)$ time to obtain $v$ and determine whether $v\in G[P_{1},P_{2}]$. If $v\in G[P_{1},P_{2}]$, then $C\cap X\subseteq X(1,2)$. Otherwise, $C\cap X\subseteq X(2,3)$. ∎

5.4 Noncrossing shortest paths

Lemma 5.7**.**

Let $G$ be a simple connected bidirected plane graph with nonnegative edge weights. If nodes $u_{1},u_{2},v_{2},v_{1}$ are on the boundary of the external face of $G$ in order, then for any shortest $u_{1}v_{1}$-path $P_{1}$ of $G$, there is a shortest $u_{2}v_{2}$-path $P_{2}$ of $G$ such that $P_{1}$ and $P_{2}$ are noncrossing.

Proof.

As illustrated by Figure 12, suppose that $P^{\prime}_{2}$ is a shortest $u_{2}v_{2}$-path of $G$ with $P_{1}\cap P^{\prime}_{2}\neq\varnothing$. Let $u$ (respectively, $v$) be the first (respectively, last) node of $P^{\prime}_{2}$ in $P_{1}$. Let $P_{2}$ be obtained from $P^{\prime}_{2}$ by replacing its $uv$-path with the $uv$-path of $P_{1}$. By the order of $u_{1},u_{2},v_{2},v_{1}$ on the boundary of the external face of $G$, $P_{2}$ is well defined and is a shortest $u_{2}v_{2}$-path of $G$ such that $P_{1}$ and $P_{2}$ are noncrossing. ∎

Lemma 5.8**.**

Let $G$ be an $n$-node simple connected bidirected plane graph with nonnegative edge weights. Let $u_{1},\ldots,u_{k},v_{k},\ldots,v_{1}$ be $2k$ distinct nodes on the boundary of the external face of $G$ in order. For each $i\in\{1,k\}$, let $P_{i}$ be a simple shortest $u_{i}v_{i}$-path of $G$ such that $P_{1}$ and $P_{k}$ are noncrossing. Let $h$ be the number of nodes of $G[P_{1},P_{k}]$ not in $P_{1}\cap P_{k}$. Given $P_{1}\setminus P_{k}$ and $P_{k}\setminus P_{1}$, consider the problem of computing $d_{G}(u_{i},v_{i})$ for all $i=1,\ldots,k$.

If $P_{1}\cap P_{k}=\varnothing$, then the problem can be solved in $O(h\log k)$ time. 2. 2.

If $P_{1}\cap P_{k}=\varnothing$ and we are given a set $Z$ of $O(1)$ nodes such that for each $i=1,\ldots,k$ at least one shortest $u_{i}v_{i}$-path passes at least one node of $Z$, then the problem can be solved in $O(h)$ time. 3. 3.

If $P_{1}\cap P_{k}\neq\varnothing$ and we are given $w(P_{1}\cap P_{k})$, then the problem can be solved in $O(h)$ time.

Proof.

Since $P_{1}\setminus P_{k}$ and $P_{k}\setminus P_{1}$ are given, it takes $O(h)$ time to obtain $G[P_{1},P_{k}]$ excluding the edges and internal nodes of $P_{1}\cap P_{k}$. Statements 2 and 3 follow from Lemmas 3.2 and 5.7. As for Statement 1, under the assumption that a simple shortest $u_{a}v_{a}$-path $P_{a}$ and a simple shortest $u_{b}v_{b}$-path $P_{b}$ of $G$ are given and disjoint, below is the recursive algorithm $\textsc{Measure}(a,b)$ with $1\leq a<b\leq k$ for solving the $(a,b)$-subproblem of computing $d_{G}(u_{i},v_{i})$ for all indices $i$ with $a<i<b$:

Let $i=\lfloor(a+b)/2\rfloor$. By Lemma 3.2, it takes time linear in the number of nodes in $G[P_{a},P_{b}]$ to obtain $d_{G}(u_{i},v_{i})$ and a simple shortest $u_{i}v_{i}$-path $P_{i}$ of $G[P_{a},P_{b}]$ that is noncrossing with both $P_{a}$ and $P_{b}$. For the $(a,i)$-subproblem, if $P_{a}\cap P_{i}=\varnothing$, then call $\textsc{Measure}(a,i)$; otherwise, apply Statement 2 with $Z$ consisting of an arbitrary node in $P_{a}\cap P_{i}$. For the $(i,b)$-subproblem, if $P_{i}\cap P_{b}=\varnothing$, then call $\textsc{Measure}(i,b)$; otherwise, apply Statement 2 with $Z$ consisting of an arbitrary node in $P_{i}\cap P_{b}$.

The algorithm for the statement obtains $d_{G}(u_{1},v_{1})$ and $d_{G}(u_{k},v_{k})$ from $P_{1}$ and $P_{k}$ and calls $\textsc{Measure}(1,k)$. Since each $d_{G}(u_{i},v_{i})$ with $1<i<k$ is computed by Lemma 3.2 or Statement 2, the correctness holds trivially. By the choice of $i$, $\textsc{Measure}(1,k)$ runs in $O(\log k)$ levels of recursion. Since $P_{a}\cap P_{b}=\varnothing$ holds for each call to $\textsc{Measure}(a,b)$, each node of $G[P_{1},P_{k}]$ appears in at most two subgraphs $G[P_{a},P_{b}]$ in the same level of recursion. Thus, the overall running time for each level of recursion is $O(h)$. The algorithm runs in $O(h\log k)$ time. ∎

5.5 Proving Lemma 4.1

Proof of Lemma 4.1.

For each $i=1,\ldots,\ell$, let $d_{i}=d_{G}(u_{i},v_{i})$. With the modification below, each $d_{i}$ with $1\leq i\leq\ell$ equals the weight of a shortest $u^{\prime}_{i}v^{\prime}_{i}$-path in the resulting $G$, which remains an $O(n)$-node simple connected bidirected plane graph: (1) for each $i=1,\ldots,\ell$, add new nodes $u^{\prime}_{i}$ and $v^{\prime}_{i}$ in the external face, zero-weighted edges $u^{\prime}_{i}u_{i}$ and $v_{i}v^{\prime}_{i}$, and $\infty$-weighted edges $u_{i}u^{\prime}_{i}$ and $v^{\prime}_{i}v_{i}$, (2) contract each zero-weighted strongly connected subgraph into a single node, (3) delete all self-loops, and (4) delete all except one copy of each set of multiple edges with minimum weight. Thus, the rest of the proof assumes that $u_{1},\ldots,u_{\ell},v_{\ell},\ldots,v_{1}$ are distinct and $G$ does not have any zero-weighted cycles, implying that all shortest paths of $G$ are simple.

Let $G_{\vartriangle}$ be an $O(n)$-node bidirected plane graph obtainable in $O(n)$ time from $G$ by identifying nodes $u_{i}$ and $v_{i}$ into a new node $z_{i}$ for each $i=1,\ldots,\ell$ and then triangulating each face of size larger than $3$. Let

[TABLE]

By Lemma 5.1, an $r$-division $D_{0}$ for $G_{\vartriangle}$ can be computed in $O(n)$ time. Let $D_{1}$ be the division of $G$ induced by $D_{0}$: Each piece of $D_{1}$ is obtained from a piece of $D_{0}$ by deleting the edges added to triangulate faces of size larger than $3$. Each piece of $D_{0}$ has $O(r)$ nodes, $O(\sqrt{r})$ boundary nodes, and $O(1)$ holes, so does each piece of $D_{1}$. Let $I$ consist of indices $1$ and $\ell$ and the indices $i$ such that at least one of $u_{i}$ and $v_{i}$ is a boundary node of $D_{1}$. Since each $z_{i}$ with $i\in I\setminus\{1,\ell\}$ is a boundary node in $D_{0}$, the cardinality of $I$ is $O(n/\sqrt{r})$. To turn both of $u_{i}$ and $v_{i}$ with $i\in I$ into boundary nodes, we introduce $O(n/r)$ new $O(\sqrt{r})$-node pieces, which form a partition of the nodes $u_{i}$ and $v_{i}$ with $i\in I$. Let $D$ be the resulting division of $G$. Each new piece of $D$ has $O(\sqrt{r})$ nodes and no edges, so it has $O(\sqrt{r})$ boundary nodes and $O(1)$ holes. Thus, $D$ is an $r$-division of $G$ such that each $u_{i}$ with $1\leq i\leq\ell$ is a boundary node in $D$ if and only if so is $v_{i}$. Let $G^{\prime}$ be the simple bidirected plane graph with edge weights obtained from $G$ by reversing the direction of each edge. Let $D^{\prime}$ be the $r$-division of $G^{\prime}$ corresponding to $D$. By Equation (2), it takes $O(n\log\log n)$ time to compute $K(D)$ and $K(D^{\prime})$ and the data structures ensured by Lemmas 5.2 and 5.5.

For any nodes $x$ and $y$ in a shortest path $P$ of $G$, let $P[x,y]$ denote the $xy$-path of $P$. We need a subroutine $\textsc{Label}(P)$ to compute label $\phi(z)$ for each node $z$ of a shortest path $P$ of $G$ under the assumption that $\phi(z)$ for at most one node of $P$ is pre-computed:

Let $z^{*}$ be the node with pre-computed $\phi(z^{*})$. If there is no such a node, then let $z^{*}$ be an arbitrary node of $P$ and let $\phi(z^{*})=0$. For each node $z$ that precedes $z^{*}$ in $P$, let $\phi(z)=\phi(z^{*})-w(P[z,z^{*}])$. For each node $z$ that succeeds $z^{*}$ in $P$, let $\phi(z)=\phi(z^{*})+w(P[z,z^{*}])$.

Subroutine $\textsc{Label}(P)$ runs in $O(1)$ time per node of $P$ and does not overwrite $\phi(z)$ for any $z$ with pre-computed $\phi(z)$. After running $\textsc{Label}(P)$, for any nodes $x$ and $y$ of $P$, $w(P[x,y])$ can be obtained from $\phi(y)-\phi(x)$ in $O(1)$ time.

For any indices $a$ and $b$, let set $I(a,b)$ consist of the indices $i\in I$ with $a<i<b$. For each $i\in\{1,\ell\}$, let $P_{i}$ be a shortest $u_{i}v_{i}$-path of $G$ obtainable in $O(n)$ time by Lemma 3.2. If $P_{1}\cap P_{\ell}\neq\varnothing$, then the lemma follows from Lemma 5.8(2) with $Z=\{x\}$ for an arbitrary node $x\in P_{1}\cap P_{\ell}$. The rest of the proof assumes $P_{1}\cap P_{\ell}=\varnothing$. The algorithm proving the lemma calls $\textsc{Label}(P_{1})$, $\textsc{Label}(P_{k})$, and $\textsc{Solve}(1,\ell)$, where the main subroutine $\textsc{Solve}(a,b)$, as defined in Figure 13 and elaborated below, solves the $(a,b)$-subproblem of computing $d_{i}$ for all indices $i$ with $a\leq i\leq b$ under the condition that

• •

shortest $u_{a}v_{a}$-path $P_{a}$ of $G$ and shortest $u_{b}v_{b}$-path $P_{b}$ of $G$ are disjoint,

• •

$\phi(z)$ is pre-computed for each node $z\in P_{a}\cup P_{b}$, and

• •

the set $X(a,b)$ of boundary nodes of $D$ in $G[P_{a},P_{b}]$ is given.

By Equation (2), it remains to prove that $\textsc{Solve}(1,\ell)$ correctly solves the $(1,\ell)$-subproblem in $O(n\log r)$ time. If $I(a,b)=\varnothing$, then all $u_{i}$ with $a<i<b$ are not boundary nodes in $D$. Since these $u_{i}$ induce a connected subgraph of $G$, they belong to a common piece of $D$, implying $b-a=O(r)$. The $(a,b)$-subproblem can be solved by Lemma 5.8(1) in $O(h(a,b)\log r)$ time, where $h(a,b)$ is the number of nodes in $G[P_{a},P_{b}]$ that are not in $P_{a}\cap P_{b}$.

For the case with $I(a,b)\neq\varnothing$, we cannot afford to directly compute a shortest $u_{i}v_{i}$-path $P_{i}$ of $G$ for a median $i$ of $I(a,b)$ by Lemma 3.2. Instead, in the subgraph of $K(D)$ induced by the given set $X(a,b)$ of boundary nodes of $D$ in $G[P_{a},P_{b}]$, we compute a shortest $u_{i}v_{i}$-path $\Pi$ (respectively, $\Pi^{\prime}$) of $K(D)$ (respectively, $K(D^{\prime})$), the first (respectively, last) $c$ edges of whose underlying path $P$ (respectively, $P^{\prime}$) can be obtained in $O(c\log\log r)$ time by Lemma 5.2. By Lemma 5.7, $G[P_{a},P_{b}]$ contains at least one shortest $u_{i}v_{i}$-path of $G$, implying that the subgraph of $K(D)$ induced by $X(a,b)$ contains at least one shortest $u_{i}v_{i}$-path of $K(D)$. Therefore, $P$ and $P^{\prime}$ are shortest $u_{i}v_{i}$-paths of $G$ in $G[P_{a},P_{b}]$. If $P$ does not intersect $P_{a}\cup P_{b}$, then it takes $O(\log\log r)$ time per node to obtain $P$. As in Case 1 of Figure 13, the subroutine lets $P_{i}=P$ and calls $\textsc{Label}(P_{i})$, $\textsc{Solve}(a,i)$, and $\textsc{Solve}(i,b)$. If $P$ intersects $P_{a}\cup P_{b}$, it takes $O(\log\log r)$ time per node to obtain $P[u_{i},x]$ and $P^{\prime}[y,v_{i}]$, where $x$ is the first node of $P$ in $P_{a}\cup P_{b}$ and $y$ is the last node of $P^{\prime}$ in $P[u_{i},x]\cup P_{a}\cup P_{b}$, as stated by the first two bullets in Case 2 of Figure 13. The subroutine calls $\textsc{Label}(P[u_{i},x])$ and $\textsc{Label}(P^{\prime}[y,v_{i}])$.

• •

As illustrated by Figure 14(a), if each of $P_{a}$ and $P_{b}$ contains exactly one of $x$ and $y$, then the $(a,b)$-subproblem is solved in $O(h(a,b))$ time by Lemma 5.8(2) with $Z=\{x,y\}$, as stated by the first bullet in Case 2(1) of Figure 13.

• •

As illustrated by Figure 14(b), if $x,y\in P_{a}$, then let $P_{i}=P[u_{i},x]P_{a}[x,y]P^{\prime}[y,v_{i}]$. The $(i,b)$-subproblem is solved by calling $\textsc{Solve}(i,b)$. The $(a,i)$-subproblem is solved by Lemma 5.8(3) with $w(P_{a}\cap P_{i})=\phi(y)-\phi(x)$ in $O(h(a,b))$ time. The case with $x,y\in P_{b}$ is similar. The second bullet of Case 2(1) in Figure 13 states these two cases.

• •

As illustrated by Figure 14(c), if $x\in P_{a}$ and $y\notin P_{a}\cup P_{b}$, then the shortest $u_{i}v_{i}$-path $P_{i}=P[u_{i},y]P^{\prime}[y,v_{i}]$ is disjoint with $P_{a}\cup P_{b}$. The $(i,b)$-subproblem is solved by calling $\textsc{Solve}(i,b)$. Since at least one shortest $u_{i}v_{i}$-path of $G[P_{a},P_{i}]$ passes $x$, the $(a,i)$-subproblem can be solved in $O(h(a,b))$ time by Lemma 5.8(2) with $Z=\{x\}$. The case with $x\in P_{b}$ and $y\notin P_{a}\cup P_{b}$ is similar. Case 2(2) in Figure 13 states these two cases.

The correctness holds trivially, since each $d_{i}$ with $1\leq i\leq\ell$ is computed somewhere during the execution of $\textsc{Solve}(1,\ell)$ by Lemma 5.8. Since $i$ is chosen to be a median of $I(a,b)$ in each subroutine call to $\textsc{Solve}(a,b)$, there are $O(\log n)$ levels of recursion in executing $\textsc{Solve}(1,\ell)$. Let $m(a,b)$ be the sum of the multiplicities of the nodes of $X(a,b)$ in $D$. By Lemma 5.5, the time for computing $\Pi$ and $\Pi^{\prime}$ is $O(m(a,b)\log^{2}m(a,b))$. In order to maintain the condition that $X(a,b)$ is given whenever $\textsc{Solve}(a,b)$ is called, we apply Lemma 5.6 to obtain $X(a,i)$ and $X(i,b)$ in $O((m(a,b)+m_{i})\log r)$ time before calling $\textsc{Solve}(a,i)$ or $\textsc{Solve}(i,b)$, where $m_{i}$ is the number of edges in $P_{i}\setminus(P_{a}\cup P_{b})$. Since $P_{a}$ and $P_{b}$ are disjoint, each boundary node of $D$ is contained by one or two subgraphs $G[P_{a},P_{b}]$ of the same recursion level. Since there are $O(n/r)$ pieces of $D$ and each piece of $D$ has $O(\sqrt{r})$ boundary nodes, the sum of $m(a,b)$ over all subgraphs $G[P_{a},P_{b}]$ at the same recursion level is $O(n/\sqrt{r})$. Since each edge of $G$ appears in at most one $P_{i}\setminus(P_{a}\cup P_{b})$ for all subroutine calls to $\textsc{Solve}(a,b)$, the sum of all $m_{i}$ throughout the execution of $\textsc{Solve}(1,\ell)$ is $O(n)$. By Equation (2), the overall time for computing $\Pi$ and $\Pi^{\prime}$ is

[TABLE]

The overall time of finding all paths $P$, $P[u_{i},x]$, and $P^{\prime}[y,v_{i}]$ is $O(n\log\log r)$, since their edges are disjoint and all of them are obtainable in $O(\log\log r)$ time per node. Therefore, the running time of $\textsc{Solve}(1,\ell)$ is dominated by the sum of the $O(h(a,b)\log r)$ time for solving the $(a,b)$-subproblems by Lemmas 5.8(1), 5.8(2), and 5.8(3) at the bottom of recursion. Since the sum of $h(a,b)$ over all these $(a,b)$-subproblems is $O(n)$, the running time of $\textsc{Solve}(1,\ell)$ is $O(n\log r)$. The lemma is proved. ∎

6 Concluding remarks

We give the first known $O(n\log n\log\log n)$-time algorithms for finding a minimum cut and a shortest cycle in an $n$-node simple directed planar graph $G$ with nonnegative edge weights. For the case that $G$ is restricted to be unweighted, our shortest-cycle algorithm remains the best known result for the shortest-cycle problem. The best algorithm for the minimum-cut problem, running in $O(n\log n)$ time, is obtained by plugging in the $O(n)$-time minimum $st$-cut algorithm of, e.g., Brandes and Wagner [4] and Eisenstat and Klein [13] to a directed version of the reduction algorithm of Chalermsook et al. [8]. Thus, an interesting future direction is to further reduce the running time of our algorithms on both problems for this special case. Extending our results to bounded-genus graphs is also of interest.

Acknowledgment

We thank the anonymous reviewers for helpful comments.