Fixed-Parameter Algorithms for the Weighted Max-Cut Problem on Embedded 1-Planar Graphs

TL;DR

This paper introduces fixed-parameter algorithms for solving the weighted Max-Cut problem on embedded 1-planar graphs, leveraging graph reduction techniques based on the crossing number to efficiently find maximum cuts.

Contribution

The paper presents novel fixed-parameter algorithms that reduce 1-planar graphs to planar graphs for Max-Cut, with a new recursive reduction method based on crossing number.

Findings

Algorithms run in time O(3^k * n^{3/2} log n) for graphs with crossing number k.

Reduction from 1-planar to planar graphs enables use of existing Max-Cut algorithms.

Effective for graphs with small crossing number, providing practical solutions.

Abstract

We propose two fixed-parameter tractable algorithms for the weighted Max-Cut problem on embedded 1-planar graphs parameterized by the crossing number $k$ of the given embedding. A graph is called 1-planar if it can be drawn in the plane with at most one crossing per edge. Our algorithms recursively reduce a 1-planar graph to at most $3^k$ planar graphs, using edge removal and node contraction. Our main algorithm then solves the Max-Cut problem for the planar graphs using the FCE-MaxCut introduced by Liers and Pardella [23]. In the case of non-negative edge weights, we suggest a variant that allows to solve the planar instances with any planar Max-Cut algorithm. We show that a maximum cut in the given 1-planar graph can be derived from the solutions for the planar graphs. Our algorithms compute a maximum cut in an embedded weighted 1-planar graph with $n$ nodes and $k$ edge crossings in time $O(3^k \cdot n^{3/2} \log n)$.

Equations

$$S/xy=$$

$$\text{Split}(S,v_{xy})=$$

$$c(\delta (S{}^{\ast },G))\stackrel{L\text{ref}lem:cut-transfer-from-G}{=}c(\delta (S{}_i^{\ast },G_i))\stackrel{IH}{\le }c(\delta (S{}_i,G_i))\stackrel{\stackrel{A\text{ref}algo:MaxCut1pl}{L\text{ref}lem:cut-transfer-to-G}}{\le }c(\delta (S,G))$$

$$T(k,n)=3^k\cdot \left[T(0,n)+\sum _{i=1}^k{3}^{-i}\cdot \mathcal{O}(n)\right]$$

Full text

Keywords:

weighted maximum cut; fixed-parameter tractable; 1-planar graphs

1 Introduction

Partitioning problems on graphs get increasing attention in the literature. Here the task is to partition the node set of a given (weighted) undirected graph, so that the number (or weighted sum) of connections between the parts is minimised. A special case is the Max-Cut problem, which asks for a node partition into two sets, so that the sum of the edge weights in the cut is maximised. The problem is getting increasing attention in the literature, since it is directly related to solving Ising spin glass models (see, e.g., Barahona [3]), which are of high interest in physics. Besides the theoretical merits, Ising spin glass models need to be solved in adiabatic quantum computation [25]. Other applications occur in the layout of electronic circuits [6, 11].

The Max-Cut problem has been shown to be NP-hard for general graphs [20]. Papadimitriou and Yannakakis [30] have shown that the Max-Cut problem is even APX-hard, i.e., there does not exist a polynomial-time approximation scheme, unless P=NP. Goemans and Williamson suggested a randomized constant factor approximation algorithm [14], which has been derandomized by Mahajan and Ramesh [24] and has performance guarantee 0.87856.

In the unweighted case, i.e., all weights are one, the problem is also called the simple max-cut problem or the maximum bipartite subgraph problem. It is well known that in this setting always a cut of size at least $|E|/2+(|V|-1)/4$ exists that can be computed in linear time (see, e.g., [32]). This bound is called the Edwards-Erdős bound and is tight for odd cliques. Recently, Etscheid and Mnich [12] have suggested an algorithm for the Max-Cut parameterized above Edwards–Erdős bound problem thus improving a result by Crowston et al. [8]. This problem asks if $G$ has a cut exceeding the above bound by an amount of parameter $k$.

There are a number of special cases, for which the weighted max-cut problem can be solved in polynomial time. The most prominent case arises if the weights of all edges are negative, since then the problem can be solved, e.g., via network flow. Other special cases are, e.g., graphs without long odd cycles [15] or weakly bipartite graphs [16]. Another prominent case appears for planar input graphs. Orlova and Dorfman [28] and Hadlock [17] have shown that the Max-Cut problem can be solved in polynomial time for unweighted planar graphs. Their algorithms can be extended to work on weighted planar graphs (e.g., Mutzel [27]). The currently fastest algorithms have been suggested by Shih et al. [31] and by Liers and Pardella [23]. These results have been extended to the classes of graphs not contractible to $K_{5}$ [5] and to toroidal graphs [4, 13], i.e., graphs that can be embedded on the torus.

A graph is 1-planar if it can be drawn on the plane, so that every edge is crossed at most once. While planarity testing can be done in linear time [18], the recognition problem for 1-planar graphs is much harder. Korzhik and Mohar showed that 1-planarity testing is NP-hard [22]. However, there are fixed-parameter tractable (FPT) algorithms parameterized by the cyclomatic number (the minimum number of edges that must be removed from the graph to make a forest), the tree-depth or the node cover number [2]. For 1-planar graphs these algorithms construct a 1-planar embedding.

Our contribution

Given an embedded weighted 1-planar graph with $k$ crossings, we introduce two fixed-parameter tractable algorithms for the Max-Cut problem with parameter $k$. The first algorithm calculates a weighted Max-Cut on graphs with non-negative edge weights555This algorithm has been presented at IWOCA 2018 [9]. However, the claim that the algorithm works for general edge-weights is not correct, as shown in this paper. and the second on graphs with arbitrary edge weights. The main idea of our algorithms is to recursively reduce the input graph into a set of at most $3^{k}$ planar graphs using a series of edge removals and node contractions. The planar instances can then be solved using the polynomial time algorithm suggested in [23] with running time $O(n^{3/2}\log n)$ for a planar graph with $n$ nodes.

The paper is organized as follows. Section 2 contains the basic definitions concerning cuts and 1-planarity. We also introduce the class of $k$-almost-planar graphs, which admit a 1-planar drawing not exceeding $k$ crossings. In Section 3 we present our weighted Max-Cut algorithm for embedded 1-planar graphs with non-negative edge weights and prove its correctness. In Section 4 we give a counter example to show the first algorithm might fail on graphs with negative edge weights. Therefore a variant of our algorithm is introduced in Section 5. The second algorithm is proven to solve the weighted Max-Cut problem on embedded graphs with arbitrary edge weights. Our analysis of the running times shows that both algorithms are fixed-parameter tractable with parameter $k$. We end with a conclusion and open problems in Section 6.

Follow-up work

In follow-up works Chimani et al. [7] and Kobayashi et al. [21] extended our algorithm to solve the weighted Max-Cut problem on arbitrary graphs. Using different techniques, both results improve the running time of the algorithm to $\mathcal{O}(2^{k}(n+k)^{3/2}\log(n+k))$, where $n$ is the number of nodes and $k$ is the number of crossings in a given embedded graph. Furthermore Chimani et al. [7] show that Max-Cut is fixed-parameter tractable with respect to the crossing number, even without a given embedding.

2 Preliminaries

Throughout our paper we consider undirected weighted graphs $G=(V,E,c)$ with non-negative edge weights in Section 3 and arbitrary edge weights in Sections 4 and 5. A partition of the nodes of $G$ into two sets $S\subseteq V$ and $\overline{S}=V\backslash S$ defines the cut $F=\delta(S,G)=\{uv\in E\mid(u\in S\hbox{ and }v\in\overline{S})\hbox{ or }(v\in S\hbox{ and }u\in\overline{S})\}$. The value of a cut $F$ in the graph $G$ is the sum of weights of all edges in the cut: $c(F)=\sum_{e\in F}c_{e}$. Choosing $S=\emptyset$ gives a valid cut of value [math]. The weighted Max-Cut problem searches for a cut in a given weighted graph with highest value. For the graph class of planar graphs, the Max-Cut problem can be solved in polynomial time [17, 28].

A graph is planar if it admits a planar drawing, i.e., a drawing on the plane without any edge crossing. A drawing admits a rotation system $\Pi$, which is a clockwise-ordering of the incident edges for every node. In a planar drawing, a rotation system defines the faces, i.e., the topologically connected regions of the plane. One of the faces, the outer face, is unbounded. A face is uniquely described by its boundary edges. Such a description for each face is an equivalent definition of a (planar) embedding. A (planar) embedding represents the set of all planar drawings with the same faces. It can be represented by the description of the faces or by the rotation system. It is well known that planarity testing can be solved in linear time [19]. The same is true for computing a planar embedding [26]. In order to generate crossing free drawings of planar graphs, a number of various algorithms exist, e.g., the straight-line drawing algorithm by de Fraysseix et al. [10].

Planar graphs are contained in the class of 1-planar graphs. A graph is 1-planar if it admits a 1-planar drawing, i.e., a drawing on the plane with at most one crossing per edge. Testing 1-planarity is NP-hard [22] even in the case of bounded treewidth or bandwith [2]. A 1-planar embedding defines the faces of a given 1-planar drawing, i.e., the topologically connected regions of the plane, and can be represented by the set of crossings $X\subset 2^{E}$ and a rotation system $\Pi$ for the nodes of the graph. A face of a 1-planar drawing is uniquely described by its boundary edges and half edges, i.e., an edge between a node and a crossing. Note that a 1-planar embedding uniquely defines a rotation system for the nodes. However, the opposite is not true. In general, a rotation system does not allow for computing the crossings or a 1-planar embedding efficiently. Auer et al. [1] have shown that testing 1-planarity of a graph with a fixed rotation system is NP-hard even if the graph is 3-connected.

We call a 1-planar graph $k$-almost-planar if it admits a 1-planar drawing with at most $k$ edge crossings. For edge removal and node contraction we use the following notation: $G-e=(V,E\setminus\{e\})$ denotes the graph obtained from $G=(V,E)$ by deleting the edge $e\in E$. $G/xy$ denotes the graph obtained by contracting the two nodes $x$ and $y$ into a new node $v_{xy}\notin V$. In doing so the edges leading to $x$ or $y$ are replaced by a new edge to $v_{xy}$. Multi-edges to $v_{xy}$ are contracted to one edge and their edge weights are added, self-loops are deleted. We denote the inverse operation of contraction by Split. The contraction and Split operation can be applied to a subset of nodes $S\subseteq V$ as well:

[TABLE]

3 Max-Cut for embedded 1-planar graphs with non-negative edge weights

Our main idea for computing the maximum cut in an embedded weighted 1-planar graph with non-negative edge weights is to eliminate its $k$ crossings and then use a Max-Cut algorithm for planar graphs on the resulting planar graphs. In order to remove a crossing we need to know its two crossing edges. We introduce two methods to remove a crossing: Either by deleting one of the crossing edges, or by contracting two nodes that do not belong to the same crossing edge.

3.1 Removing a crossing

In this section let $G=(V,E,c)$ be a $k$-almost-planar graph with a 1-planar embedding $(X,\Pi)$ and a set of crossing edges $X$ with $|X|=k$. A crossing is defined by a pair of crossing edges, e.g., let $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing. The following lemma shows that specific node contractions (and edge deletions) remove at least one crossing and do not introduce new crossings.

Lemma 1**.**

Let $G$ be a $k$-almost-planar graph with a 1-planar embedding $(X,\Pi)$ and let $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing. The graphs $G/ab$, $G-e_{vy}$ and $G-e_{wz}$ are $(k-1)$-almost-planar for $ab\in\{vw,vz,wy,yz\}$. The set of crossings in each resulting 1-planar embedding is a proper subset of $X$.

Proof.

Since the contracted nodes $a$ and $b$ are each an endpoint of one of the crossing edges, the contracted node is an endpoint to both edges. Since $e_{vy}$ and $e_{wz}$ now have a common endpoint, they can be drawn in the plane without crossing. Therefore the crossing $\chi$ is removed. The contraction does not create new crossings because the two nodes $a$ and $b$ can be moved along their half edges towards the crossing. This is possible because in every a 1-planar embedding every crossing is incident to four half edges connecting it with its four endpoints. The new node $v_{ab}$ is then placed where the crossing used to be. All other edges can be extended to the new node along the way of the same half edges without creating new crossings. Multi-edges are merged into one of the two edges and self-loops are deleted. In $G-e_{vy}$ and $G-e_{wz}$ the crossing $\chi$ is removed by deleting one of its crossing edges. Obviously this does not lead to new crossings. So in both cases the number of crossings decreases. ∎

Two examples for node contraction are given in Figures 1(b) and 1(c). Note that the contraction shown in Figure 1(b) removed both crossings of $H$, cf. Figure 1(a). An example for edge deletion is given in Figure 1(d). The recursive application of Lemma 1 shows that all crossings can be removed with these two operations. Thus after $k$ contraction or removal operations the resulting graph is planar and a planar Max-Cut algorithm can be applied to compute a maximum cut.

The following lemma shows how to project a cut in $G/ab$ or $G-e_{ab}$ back onto $G$. Note that we require $a$ and $b$ to be on the same side of the given cut in $G-e_{ab}$ for the cut to have the same value in $G-e_{ab}$ and $G$.

Lemma 2**.**

Let $G=(V,E,c)$ be a weighted graph, $a,b\in V$ and $a\neq b$.

1. (i)

If $\delta(S{,G/ab})$ is a cut in $G/ab$, then the cut $\delta(\texttt{{Split}}(S,v_{ab}),G)$ has the same value in $G$ as $\delta(S{,G/ab})$ in $G/ab$. 2. (ii)

If $a$ and $b$ are on the same side of the cut $\delta(S{,G-e_{ab}})$, i.e. $a,b\in S$ or $a,b\in\overline{S}$ for $S\subseteq V$, then $\delta(S,G)=\delta(S{,G-e_{ab}})$ for $e_{ab}\in E$.

Proof.

(i) For $S\subseteq V\setminus\{a,b\}\cup\{v_{ab}\}$ the set $S$ defines a cut in $G/ab$. If the contracted node $v_{ab}$ is split the cut is projected from $G/ab$ to $G$. The corresponding set of nodes in $G$ is $S{{}^{\prime}}=\texttt{{Split}}(S,v_{ab})$. It defines a cut in $G$. If $v_{ab}\notin S$ then $S{{}^{\prime}}=S$. The weight of an edge $e\in\delta(S{,G/ab})$ in $G/ab$ is either the same as the weight of the corresponding edge $e^{\prime}\in\delta(S{{}^{\prime},G})$ in $G$ or it is split between two edges $e^{\prime},e^{\prime\prime}\in\delta(S{{}^{\prime},G})$ in $G$. The only edge that might exist in $G$ but not in $G/ab$ is $e_{ab}$. Since $a$ and $b$ were contracted in $G/ab$, they are either both in $S{{}^{\prime}}$ or both in $\overline{S{{}^{\prime}}}$. Therefore the only edge that could be added in $G$ by splitting $v_{ab}$ can not add to the value of $\delta(S{{}^{\prime},G})$ in $G$. So no weights are lost or added due to the projection and the two cuts have the same value.

(ii) This is obvious because $e_{ab}$ is in neither of the two cuts. ∎

3.2 The Algorithm

We use three operations to successively remove all crossings of a 1-planar graph. All planar instances obtained in this way are then solved by a Max-Cut algorithm for planar graphs. From the solutions of the planar graphs a solution for the original graph is constructed. Note that the algorithm does only need the graph $G$ and the set of edge crossings $X$ as input. However, the 1-planar embedding is needed to show the correctness of the algorithm.

Algorithm 1 realizes this approach by a recursive function, which is initially called with the input graph $G$ and the set of crossings $X$ present in its embedding. As the algorithm progresses, the graph is successively modified and the set of crossings is adjusted according to the modifications applied. If the graph $G$, passed as parameter to the function, is planar ($X=\emptyset$), then a planar Max-Cut algorithm is called (line 2). If there are still crossings remaining, an arbitrary crossing is selected and removed in three different ways: Let $y$ be an arbitrary endpoint of one crossing edge and $e_{wz}$, $w\neq y$, $z\neq y$, the other crossing edge, then (I) the nodes $y$ and $w$ are contracted, (II) the nodes $y$ and $z$ are contracted, and (III) the edge $e_{wz}$ is deleted. Each operation removes at least the selected crossing, but in cases (I) and (II) other crossing may be affected as well. Therefore, the set of crossings $X$ is adjusted by the function Update. If two nodes $w,y$ are contracted, $\texttt{{Update}}(X,w,y)$ removes every crossing in $X$, which was dissolved by contracting $w$ and $y$, and replaces every appearance of $w$ or $y$ in $X$ with the contracted node $v_{wy}$. To check if a crossing was dissolved, Update checks if $w$ and $y$ are both part of the crossing. Since every crossing needs to be checked once, Update has a linear running time. For each case the recursive function is called with the modified graph and crossing set as a parameter (lines 6-10). Each call returns a node set defining a maximum cut in the modified instance. The cut with the maximum value is then transferred back to $G$. If the maximum cut is obtained for a graph with contracted nodes, i.e., case (I) or (II), then the original nodes are restored by the function $\texttt{{Split}}(S_{i},v_{wy})$, which replaces $v_{wy}$ with $w$ and $y$ if $S_{i}$ contains the contracted node. If the maximum cut is obtained for a graph with a deleted edge, i.e., case (III), the nodeset is passed directly to the return value $S$. In this case we can assume that the two nodes of the removed edge are on the same side of the cut. Otherwise one of the other two cuts would have an equal value and would have been chosen instead. The cut defining set $S$ is then returned as the solution to the subproblem.

Example 3**.**

Let $H$ be the 2-almost-planar graph shown in Figure 1(a) with uniform edge weights, e.g. 1. First the algorithm removes the crossing on the left in the three described ways. The resulting graphs are shown in Figure 1(b)-1(d). For them the algorithm is called recursively. The first graph $H/bc$ is already planar because the crossing on the right was dissolved when merging $b$ and $c$. Therefore a planar Max-Cut algorithm is called. For the other two graphs the algorithm creates six planar graphs, three each, for which again a planar Max-Cut algorithm is called. The largest of the three calculated cuts is then transfered back to the original graph $H/cd$ resp. $H-e_{bd}$. The recursively calculated cuts of the three graphs $H/bc$, $H/cd$ and $H-e_{bd}$ are depicted in Figure 2(a)-2(c) with 2(b) showing the largest cut. This cut is transferred back to $H$ by splitting the contracted node $v_{cd}$. The resulting cut is shown in Figure 2(d). It is a maximum cut in $H$.

3.3 Analysis

The four endpoints of a crossing can be partitioned in eight non-isomorphic ways, cf. Figure 3: (a) all endpoints in one set, (b)/(c)/(d)/(e) three endpoints in one set without $v$/$w$/$y$/$z$, (f)/(g) two endpoints of different crossing edges in one set each, or (h) the two endpoints of the same crossing edge in one set each. For arbitrary graphs the induced cut might differ from the cuts shown in Figure 3 because non-crossing edges might be replaced with a path or might not exist at all.

Lemma 4**.**

Let $G=(V,E,c)$ be a 1-planar graph with a 1-planar embedding $(X,\Pi)$, $S\subseteq V$, and $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing.

1. (i)

Let $\delta(S,G)$ separate the four endpoints of $\chi$ in $G$ as shown in Figure 3 (a), (b), (e) or (g). Then $S{{}_{1}}=S{/wy}$ defines a cut in $G/wy$ with the same value. If $\delta(S,G)$ is maximum in $G$, so is $\delta(S{{}_{1},G/wy})$ in $G/wy$. 2. (ii)

Let $\delta(S,G)$ separate the four endpoints of $\chi$ in $G$ as shown in Figure 3 (a), (b), (c) or (f). Then $S{{}_{2}}=S{/yz}$ defines a cut in $G/yz$ with the same value. If $\delta(S,G)$ is maximum in $G$, so is $\delta(S{{}_{2},G/yz})$ in $G/yz$. 3. (iii)

Let $\delta(S,G)$ separate the four endpoints of $\chi$ in $G$ as shown in Figure 3 (a), (b), (d) or (h). Then $S{{}_{3}}=S$ defines a cut in $G-e_{wz}$ with the same value. If $\delta(S,G)$ is maximum in $G$, so is $\delta(S{{}_{3},G-e_{wz}})$ in $G-e_{wz}$.

Proof.

(i) Let $S$ define a cut in $G$ that separates the endpoints of $\chi$ as shown in Figure 3 (a), (b), (e) or (g). By contracting $w$ and $y$, the set of nodes is projected to $G/wy$ and $\delta(S{{}_{1},G/wy})$ is a cut in $G/wy$. The only edge that might have been removed in $G/wy$ does not add to the value of $\delta(S,G)$ in $G$ because $w$ and $y$ are not separated by the cut (cf. Fig. 3 (a), (b), (e) or (g)). Therefore the two cuts have the same value in both graphs. Let $S$ define a maximum cut in $G$ (with the required property). If there was a cut $\delta(S{{}^{\prime},G/wy})$ in $G/wy$ larger than $\delta(S{{}_{1},G/wy})$, then $\texttt{{Split}}(S{{}^{\prime}},v_{wy})$ would define a cut in $G$ with the same value as $\delta(S{{}^{\prime},G})$ (Lemma 2 i), contradicting that $\delta(S,G)$ is maximum in $G$.

(ii) The proof of the second proposition is analogous to the proof of the first.

(iii) Let $S$ define a cut in $G$ that separates the endpoints of $\chi$ as shown in Figure 3 (a), (b), (d) or (h). Since $G$ and $G-e_{wz}$ have the same set of nodes, $\delta(S{{}_{3},G-e_{wz}})$ is a cut in $G-e_{wz}$ as well. We know that $w$ and $z$ are not separated by the cut (cf. Fig. 3 (a), (b), (d) or (h)). Therefore the only edge that was removed in $G-e_{wz}$ does not add to the value of the cut in $G$ and the cut has the same value in both graphs. Let $S$ define a maximum cut in $G$ (with the required property). If there was a cut $\delta(S{{}^{\prime},G-e_{wz}})$ in $G-e_{wz}$ larger than $\delta(S{{}_{3},G-e_{wz}})$, then $\delta(S{{}^{\prime},G})$ would be a cut in $G$ as well (Lemma 2 ii), contradicting that $\delta(S,G)$ is maximum in $G$. ∎

Theorem 5**.**

Algorithm 1 computes a maximum cut in a weighted 1-planar graph $G$ with non-negative edge weights, given a set of crossing edges $X$ in a 1-planar embedding of $G$.

Proof.

We prove its optimality by induction over $k=|X|$. Let $G$ be a weighted $k$-almost-planar graph. For $k=0$ the given graph is planar. Thus a Max-Cut algorithm for planar graphs calculates a node set defining a maximum cut in $G$. For $k>0$ we show that the value of the calculated cut is not smaller than the value of a maximum cut in $G$. Let $S{{}^{*}}$ define a maximum cut in $G$ and let $\delta(S,G)$ be the cut defined by the calculated node set $S$. Let $G_{1}=G/wy,G_{2}=G/yz$ and $G_{3}=G-e_{wz}$ be the $(k-1)$-almost-planar graphs (Lemma 1), whose cuts $\delta(S{{}_{1},G_{1}}),\delta(S{{}_{2},G_{2}})$ and $\delta(S{{}_{3},G_{3}})$ were calculated recursively by the algorithm. There are 8 possible ways for $S{{}^{*}}$ to separate the four endpoints of $\chi$. These are shown in Figure 3 (a)–(h). If the endpoints of $\chi$ are separated as shown in (a), (b), (e) or (g), $\delta(S{{}^{*},G})$ has the same value as a maximum cut $\delta(S{{}_{1}^{*},G_{1}})$ in $G_{1}$ (Lemma 4 i). Due to the induction hypothesis (IH), $c(\delta(S{{}_{1},G_{1}}))$ is not smaller than $c(\delta(S{{}_{1}^{*},G_{1}}))$. If the endpoints of $\chi$ are separated as shown in (c) or (f), $\delta(S{{}^{*},G})$ has the same value as a maximum cut $\delta(S{{}_{2}^{*},G_{2}})$ in $G_{2}$ (Lemma 4 ii). Due to the induction hypothesis, $c(\delta(S{{}_{2},G_{2}}))$ is not smaller than $c(\delta(S{{}_{2}^{*},G_{2}}))$. If the endpoints of $\chi$ are separated as shown in (d) or (h), $\delta(S{{}^{*},G})$ has the same value as a maximum cut $\delta(S{{}_{3}^{*},G_{3}})$ in $G_{3}$ (Lemma 4 iii). Due to the induction hypothesis, $c(\delta(S{{}_{3},G_{3}}))$ is not smaller than $c(\delta(S{{}_{3}^{*},G_{3}}))$. The algorithm chooses the node set defining the cut with the highest value (line 11–18) and transfers it back to $G$ without changing its value (Lemma 2). Thus the value of the calculated cut $\delta(S,G)$ is not smaller than $c(\delta(S{{}^{*},G}))$ and $\delta(S,G)$ is therefore maximum in $G$. ∎

The following equation summarizes the argumentation of the previous proof in the corresponding case, with $i=1,2,3$:

[TABLE]

In order to apply Lemma 2 (ii) to $\delta(S{{}_{3},G_{3}})$ we need to assure that the two nodes of the removed edge $e_{wz}$ are on the same side of the cut. In the proof the assumption can be made because the endpoints of $\chi$ are separated as shown in Figure 3 (d) or (h). For the algorithm, however, this means that it can only choose $S_{3}$ if the value of the other two cuts are truly smaller than the value of the cut defined by $S_{3}$.

3.4 Running time

Let $n$ be the number of nodes and $m$ be the number of edges of a given graph. It is well known that a 1-planar graph has at most $4n-8$ edges [29]. For an arbitrary 1-planar embedding, the number of crossings is bounded by $\frac{m}{2}$, since every edge can be crossed at most once and every crossing needs two edges. With the previous observation, we can establish a bound depending on the number of nodes: $k\leq 2n-4$.

Theorem 6**.**

Algorithm 1 computes a maximum cut in an embedded non-negatively edge-weighted 1- planar graph with $n$ nodes and $k$ crossings in time $\mathcal{O}(3^{k}\cdot n^{3/2}\log n)$ if one of the planar Max-Cut algorithm suggested in [23] or [31] is used.

Proof.

Let $T(k,n)$ be the running time of Algorithm 1 on an embedded non-negatively edge-weighted 1-planar graph $G$ with $n$ nodes, $m$ edges and $k$ crossings in the given embedding. If $G$ is planar, our algorithm uses a planar Max-Cut algorithm with running time $T_{p}(n)$, resulting in $T(0,n)=T_{p}(n)$. Update has a linear running time of $\mathcal{O}(k)$, since every crossing in $X$ needs to be checked only once. The contractions of $G/wy$ and $G/yz$ take time $\mathcal{O}(n+m)$ and the edge removal $G-e_{wz}$ takes time $\mathcal{O}(m)$. Reversing a contraction on a set of nodes $S_{i}$ with Split takes $|S_{i}|$ steps, resulting in a running time of $\mathcal{O}(n)$. Since $m$ is bound by $4n-8$ [29] and $k$ is bound by $2n-4$ (see above Theorem 6) the recursive running time is: $T(k,n)=3\cdot T(k-1,n)+\mathcal{O}(k+n+m)=3\cdot T(k-1,n)+\mathcal{O}(n)$. An induction proof confirms the closed form of the running time is:

[TABLE]

Since the geometric sum equals a value between 0 and 1, the overall running time is $\mathcal{O}(3^{k}\cdot(T_{p}(n)+n))$. Liers and Pardella [23] as well as Shih et al. [31] describe a planar Max-Cut algorithm with a running time of $\mathcal{O}(n^{3/2}\cdot\log n)$, resulting in a concrete running time of $\mathcal{O}(3^{k}\cdot n^{3/2}\log n)$ for our algorithm. ∎

If the number of crossings $k$ in a 1-planar embedding is fixed, the running time of Algorithm 1 is polynomial. However, in an arbitrary 1-planar embedding, $k$ is not fixed and the factor $3^{k}$ leads to an exponential worst case running time. But we can show that our algorithm is fixed-parameter tractable with parameter $k$. Since the running time of our algorithm can be split in an exponential part, depending only on the parameter $k$, ($3^{k}$) and a polynomial part in the size of the input graph ($T_{p}(n)+n$), the algorithm is fixed-parameter tractable with parameter $k$.

Corollary 7**.**

The weighted Max-Cut problem on embedded 1-planar graphs with non-negative edge weights and with $k$ crossings in the given embedding is fixed-parameter tractable with parameter $k$.

4 Counter example for crossing edges with negative weights

Considering graphs with arbitrary edge weights the algorithm introduced in Section 3 might not find the optimal solution. If a deleted edge had a negative weight it is possible that the planar Max-Cut algorithm chooses a maximum cut, which is not optimal in the original graph. This can happen if the calculated maximum cut separates the nodes of the removed edge. When transfered back to the original graph the negative weight of the before removed edge is added, decreasing the value of the cut. Hence the optimality can not be guaranteed. If the optimal cut can only be found in the subgraph $G_{3}$ and the cut separating the nodes of the removed edge is the only maximum cut in the planar subgraph, Algorithm 1 will then never find the maximum cut in $G$. An example is given in Figure 4.

Example 8**.**

Let our graph $H$ be the embedded weighted $K_{5}$ as shown in Figure 4(a) with a maximum cut value of 7. One possible maximum cut in $H$ is defined by $S_{31}=\{b,c,e\}$ (as shown in Fig. 4(a)) another is defined by $S_{32}=\{b,e\}$. The 1-planar Max-Cut algorithm introduced in Section 3 is based on the observation that the largest of the maximum cuts in $H/de$, $H/bd$ and $H-e_{be}$ has a corresponding cut in $H$ of equal value, which is maximum in $H$ (cf. Lemma 2 and Theorem 5). It is easy to see that the maximum cuts in $H/de$ and $H/bd$ are not maximum in $H$ (cf. Fig. 4(b) and Fig. 4(c)). Therefore a maximum cut in $H$ has to be found in $H-e_{be}$.

If we look at the two before mentioned cuts, defined by $S_{31}$ and $S_{32}$, in $H-e_{be}$, we can easily see that both have the same cut value in $H-e_{be}$ and in $H$, which is 7 (cf. Fig. 4(d) and Fig. 4(e)). But the maximum cut in $H-e_{be}$ has a value of 9 and is defined by $S_{33}=\{b,c\}$ (cf. Fig. 4(f)). The partition $S_{33}$ separates $b$ and $e$, lowering the cut value in $H$ by $c(e_{be})=-3$ if after the cut is transfered back to $H$. Therefore its cut value in $H$ is only 6. The algorithm would choose $S_{33}$ as the maximum cut of $H$ because it has the highest cut value of the three recursively calculated cuts. But in $H$ the cut value is only 6 due to the weight of the negative edge that was removed in $H-e_{be}$.

One could attempt to solve this problem by calculating the value of a cut, found in the subgraphs, on the original graph. However, this still does not ensure that the algorithm chooses the correct cut. While this would prevent the algorithm from choosing the wrong cut $S_{33}$, it would choose $S_{1}=\{c\}$ instead, because it does not recognize there are other cuts in $H-e_{be}$ with a higher value in $H$. Note that the maximum cut in $H$ can only be found in $H-e_{be}$ (compare Fig. 4(a) and 4(d)). But the algorithm cannot find it, because $e_{be}$ has a negative edge weight.

Algorithm 1 is based on the observation that the largest of the maximum cuts in $G/wy$, $G/yz$ and $G-e_{wz}$ has a corresponding cut in $G$ of equal value, which is maximum in $G$ (cf. Theorem 5). This only holds for 1-planar graphs with non-negative edge weights because for those graphs we can ensure that a planar Max-Cut algorithm calculates a maximum cut, which does not decrease in value when transferred back to $G$. As long as only one of the crossing edges has a negative weight we could avoid this problem by deleting the crossing edge with the non-negative weight and choosing the to be contracted nodes accordingly. This results from the fact that, by reintroducing the deleted edge into our graph, the value of the cut can only increase. If both edges of a crossing have negative edge weights, however, we need to utilize a more elaborated solution, which we introduce in the following section.

5 Max-Cut for embedded 1-planar graphs with arbitrary edge weights

To deal with the problems arising from negative weights on crossing edges, we make use of the insights we gained in Section 3. Our goal is to construct a graph that forces its maximum cut to partition the nodes of the crossing as depicted in Figure 3(d) or 3(h). Therefore we need to ensure that $\{w,z\}$ and $y$ are separated by the cut. First we remove the crossing edge $e_{wz}$ because it will not contribute to the cut (cf. Fig. 5(b)). Then we insert the edges $e_{wy}$ and $e_{yz}$ if they do not already exist (cf. Fig. 5(c)). The newly inserted edges shall each have weight [math], so they do not add to the value of the cut. Finally the two edges $e_{wy}$ and $e_{yz}$ are added to a set of fixed cut edges $C$. Using the FixedCutEdges-Max-Cut algorithm (FCE-MaxCut) introduced by Liers and Pardella [23], the edges in $C$ are forced to be in the calculated maximum cut, ensuring the separation of $\{w,z\}$ and $y$ (cf. Fig. 5(c)).

5.1 The Algorithm

To be able to deal with negative weights on crossing edges we adapt the algorithm presented in Section 3. Note that the new algorithm (cf. Algorithm 1) behaves similar to Algorithm 1. The main difference is the set of fixed cut edges $C$. Algorithm 1 expects a weighted 1-planar graph $G=(V,E,c)$, a set of crossings $X$, and a set of edges $C\subset E$ as input. The set $C$ contains the edges that are forced to be in the calculated cut. It is initialized with $C=\emptyset$.

The new algorithm initially proceeds similarly to the old one: If there are no crossings left, the algorithm computes a planar Max-Cut (line 2) and returns it. The difference is that the planar FixedCutEdges-Max-Cut algorithm (FCE-MaxCut) from Liers and Pardella is used [23]. It receives a set of edges $C$, which will be forced to be in the calculated maximum cut. If a cut respecting $C$ is impossible, e.g., because a subset of $C$ forms a circle of uneven size, FCE-MaxCut will fail to calculate a cut. In this case $S=\emptyset$ – a cut with value 0 – is returned. Contracting two nodes after their connecting edge was added to $C$, would also lead to a contradiction. In this case $S=\emptyset$ is returned as well.

The first two cuts get calculated exactly as they were in Algorithm 1: by a recursive call of MaxCut on $G/wy$ and $G/yz$. The third graph, $G_{3}$, is created by removing $e_{wz}$ from $G$ and adding the edges $e_{wy}$ and $e_{yz}$, with a weight of 0, if they do not already exist in $G$. This method is called AddEdges (line 17). The edges $e_{wy}$ and $e_{yz}$ get then added to the set of fixed cut edges $C$ (line 18). Finally the algorithm recursively calls MaxCut on $G_{3}$, using the adapted fixed cut edges set $C^{\prime}$, and saves the return value in $S_{3}$ (line 19). As described above, this ensures that $\{w,z\}$ and $y$ are separated by the cut, meaning: $\{w,z\}\subseteq S_{3}$ and $y\in\overline{S_{3}}$ or vice versa. Afterwards the algorithm once again behaves the same way as Algorithm 1. It determines which cut has the highest value (line 20), chooses the according node set (lines 22 – 26), and returns it (line 29).

As noted before, it is possible that the returned cut is $S=\emptyset$ because this is either indeed the maximum cut or because all calls of MaxCut (lines 7, 13, 19) received a set of fixed cut edges, which contradicts itself, e.g., because a subset of $C$ forms a circle of uneven size. If $S=\emptyset$, which will always have a value of 0, is chosen in line 20, every other cut has to have a non-positive value, making $S=\emptyset$ indeed the correct choice.

Example 9**.**

Let $H^{\prime}$ be the 1-almost-planar graph shown in Figure 6(a). We obtain $H^{\prime}$ by renaming the nodes of the graph $H$, used in our counter example in Section 4 (cf. Figure 4(a)), according to how the algorithm chooses $w$, $y$ and $z$. In this example we choose edge $e_{be}$ in $H$ as edge $e_{wz}$ and node $d$ in $H$ as node $y$. The last remaining node of the crossing is renamed from $c$ in $H$ to $v$ in $H^{\prime}$.

The algorithm resolves the crossing in the three different ways explained above. The resulting graphs and their calculated maximum cuts are shown in Figures 6(b) – 6(d). The cuts shown in Figures 6(b) and 6(c) are calculated using the FCE-Max-Cut algorithm with $C=\emptyset$. The cut displayed in Figure 6(d) is calculated using the FCE-Max-Cut algorithm with $C=\{e_{wy},e_{yz}\}$, forcing $e_{wy}$ and $e_{yz}$ to be in the calculated cut. Note that the cut displayed in Figure 6(e) has a higher cut value, but because it does not cut edge $e_{wy}$ FCE-Max-Cut will not consider it. The cut displayed in Figure 6(d) has the highest value of the three recursively calculated cuts, so it is transferred back to $H^{\prime}$. The resulting cut is shown in Figure 6(f). It is a maximum cut in $H^{\prime}$.

5.2 Analysis

Building on the insights gained in Section 3, we now are going to analyse Algorithm 1. First we are going to transfer some propositions about $G-e$ to the adjusted graph $\texttt{{AddEdges}}(G-e_{wz},\{e_{wy},e_{yz}\})$. From Lemma 1 in Section 3.1 we can deduce Corollary 10 and from Lemma 4 (iii) in Section 3.3 we can deduce Corollary 11.

Corollary 10**.**

Let $G$ be a $k$-almost-planar graph with a 1-planar embedding $(X,\Pi)$ and let $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing. The graph AddEdges $(G-e_{wz},\{e_{wy},e_{yz}\})$ is $(k-1)$-almost-planar.

Corollary 11**.**

Let $G=(V,E,c)$ be a 1-planar graph with a 1-planar embedding $(X,\Pi)$, $S\subseteq V$, and $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing. Let $\delta(S,G)$ separate the four endpoints of $\chi$ as shown in Figure 3 (d) or (h). Then $S{{}_{3}}=S$ defines a cut in $G_{3}=\texttt{{AddEdges}}(G-e_{wz},\{e_{wy},e_{yz}\})$ with the same value. If $\delta(S,G)$ is maximum in $G$, so is $\delta(S{{}_{3},G_{3}})$ in $G_{3}$ under the condition that $e_{wy}$ and $e_{yz}$ are fixed cut edges.

In lines 5 and 11, the algorithm checks if merging two nodes would contradict the requirement that all edges in $C$ need to be in the calculated cut. Without this check the algorithm might run into inconsistencies because an edge cannot be forced in a cut after its nodes were merged. In the following theorem we show that a cut calculated by Algorithm 1 is indeed maximum.

Theorem 12**.**

Algorithm 1 computes a maximum cut in a weighted 1- planar graph $G$ with arbitrary edge weights, given a set of crossing edges $X$ in a 1-planar embedding of $G$ and a set of fixed cut edges $C\subseteq E_{G}$.

Proof.

We prove its optimality by induction over $k=|X|$. Let $G$ be a weighted $k$-almost-planar graph. For $k=0$ the given graph is planar. Thus the FixedCutEdges-Max-Cut algorithm for planar graphs calculates a node set defining a maximum cut in $G$ [23]. For $k>0$ we show that the value of the calculated cut is not smaller than the value of a maximum cut in $G$. Let $S{{}^{*}}$ define a maximum cut in $G$ and let $\delta(S,G)$ be the cut defined by the calculated node set $S$. Let $\chi=\{e_{vy},e_{wz}\}\in X$ be an arbitrary crossing. Let $G_{1}=G/wy,G_{2}=G/yz$ and $G_{3}=\texttt{{AddEdges}}(G-e_{wz},\{e_{wy},e_{yz}\})$ be the $(k-1)$-almost-planar graphs (Lemma 1, Corollary 10), whose cuts $\delta(S{{}_{1},G_{1}}),\delta(S{{}_{2},G_{2}})$ and $\delta(S{{}_{3},G_{3}})$ were calculated recursively by the algorithm. There are 8 possible ways for $S{{}^{*}}$ to separate the four endpoints of $\chi$. These are shown in Figure 3 (a)–(h). If the endpoints of $\chi$ are separated as shown in (a), (b), (c), (e), (f) or (g), the maximum of $c(\delta(S{{}_{1},G_{1}}))$ and $c(\delta(S{{}_{2},G_{2}}))$ is not smaller than $c(\delta(S{{}^{*},G}))$ (Theorem 5). If the endpoints of $\chi$ are separated as shown in (d) or (h), $\delta(S{{}^{*},G})$ has the same value as a maximum cut $\delta(S{{}_{3}^{*},G_{3}})$ in $G_{3}$ (Corollary 11). Due to the induction hypothesis, $c(\delta(S{{}_{3},G_{3}}))$ is not smaller than $c(\delta(S{{}_{3}^{*},G_{3}}))$. The algorithm chooses the node set defining the cut with the highest value (line 20–27) and transfers it back to $G$ without changing its value (Lemma 2). Thus the value of the calculated cut $\delta(S,G)$ is not smaller than $c(\delta(S{{}^{*},G}))$ and $\delta(S,G)$ is therefore maximum in $G$. ∎

In order to gain an intuition about the running time of Algorithm 1, we consider its recursion tree. At each inner node a crossing is resolved by performing three recursive calls, leading to three children. Therefore, the height of the tree corresponds to the number of crossings and the leaves represent the planar problem instances. Assuming we have $k$ crossings, there are $3^{k}$ leaves, on which a planar problem instance must be solved. The running time required for this dominates the running time required at the inner nodes. We now give a formal proof of the running time.

Theorem 13**.**

Let $G$ be an embedded edge-weighted 1-planar graph with $n$ nodes and $k$ crossings. Algorithm 1 computes a maximum cut in $G$ in time $\mathcal{O}(3^{k}\cdot n^{3/2}\log n)$ if the planar FixedCutEdges-Max-Cut algorithm suggested in [23] is used.

Proof.

Let $T(k,n)$ be the running time of Algorithm 1 on an embedded edge-weighted 1-planar graph $G$ with $n$ nodes, $m$ edges and $k$ crossings in the given embedding. Let $T_{p}(n)$ be the running time of the planar FCE-MaxCut algorithm suggested by Liers and Pardella [23]. If $G$ is planar, the running time is $T(0,n)=T_{p}(n)$.

For $k>0$ choosing an arbitrary crossing can be done in constant time. Update has a linear running time of $\mathcal{O}(k)$, since every crossing in $X$ needs to be checked only once. The contractions of $G/wy$ and $G/yz$ take time $\mathcal{O}(n+m)$ and the edge removal $G-e_{wz}$ takes time $\mathcal{O}(m)$. AddEdges takes $\mathcal{O}(m)$ time because it needs to check if the edges already exist in the given graph, before adding them. For every crossing two edges are added to $C$. Therefore $|C|$ is bound by $2k$. To check if two nodes, that are about to be merged, are connected by an edge in $C$ (which would contradict the requirement that all edges in $C$ need to be in the calculated cut) takes $\mathcal{O}(|C|)=\mathcal{O}(k)$ time. Reversing a contraction on a set of nodes $S_{i}$ with Split takes $|S_{i}|$ steps, resulting in a running time of $\mathcal{O}(n)$.

Since $m$ is bound by $4n-8$ [29] and $k$ is bound by $2n-4$ (see above Theorem 6) the recursive running time is: $T(k,n)=3\cdot T(k-1,n)+\mathcal{O}(k+n+m)=3\cdot T(k-1,n)+\mathcal{O}(n)$. An induction proof confirms the closed form of the running time:

[TABLE]

Since the geometric sum equals a value between 0 and 1, the overall running time is $\mathcal{O}(3^{k}\cdot(T_{p}(n)+n))$. The planar FixedCutEdges-Max-Cut algorithm has a running time of $T_{p}(n)=\mathcal{O}(n^{3/2}\log n)$ [23], leading to the concrete running time of $\mathcal{O}(3^{k}\cdot n^{3/2}\log n)$ for our algorithm. ∎

In the above drawn picture of the recursion tree, $\mathcal{O}(n)$ would be the running time required at an inner node of the tree and $T_{p}(n)=\mathcal{O}(n^{3/2}\log n)$ would be the running time required at a leaf of the tree. The tree has at most $3^{k}$ leaves and less than $3^{k}$ inner nodes. Therefore the running time is $\mathcal{O}(3^{k}\cdot(T_{p}(n)+n))$. Since $T_{p}(n)=\mathcal{O}(n^{3/2}\log n)$ dominates $\mathcal{O}(n)$ the overall running time is $\mathcal{O}(3^{k}\cdot n^{3/2}\log n)$.

Regarding the parameterization of Algorithm 1, we can deduce that it is fixed-parameter tractable with parameter $k$ with the same arguments as in Section 3.4. This leads to the following conclusion about the weighted Max-Cut problem on embedded 1-planar graphs:

Corollary 14**.**

The weighted Max-Cut problem on embedded 1-planar graphs with arbitrary edge weights and with $k$ crossings in the given embedding is fixed-parameter tractable with parameter $k$.

6 Conclusion and open problems

We have presented two polynomial time algorithms for computing a weighted Max-Cut in a 1-planar graph with non-negative resp. arbitrary edge weights given a 1-planar embedding with a constant number of crossings. If the number of crossings $k$ in the given embedding is not constant, we showed that the weighted Max-Cut problem on embedded 1-planar graphs is in the class FPT parameterized by $k$.

The question arises if our approach can be extended to general graphs with up to $k$ crossings per edge, so called $k$-planar graphs. Our approach is based on the fact that node contractions and edge deletions decrease the number of crossings. Figure 7 shows that this is no more true if an edge is crossed more than once. In this case there are crossings that do not have direct half edges connecting it to its endpoints like, e.g., the crossing $(ad,cf)$ in Figure 7. If we contract $d$ and $f$, we get plenty of new crossings in the new graph $G/df$. This shows that it is not trivial to generalize our approach to embedded $k$-planar graphs.

Another interesting question would be to drop the assumption that we are given a 1-planar embedding. Note that our algorithm does not need such an embedding as input, it only needs to get a list of edge crossings. However, for our correctness analysis it is important to have a 1-planar embedding of the graph.

In follow up works Chimani et al. [7] and Kobayashi et al. [21] extended our approach to general graphs and improved the running time to $\mathcal{O}(2^{k}\cdot(n+k)^{3/2}\log(n+k))$, where $n$ is the number of nodes and $k$ is the number of crossings in a given embedded graph. Furthermore, Chimani et al. [7] were able to drop the assumption of a given embedding to show that Max-Cut is fixed-parameter tractable with respect to the crossing number of the given graph. Moreover, they showed that this result naturally carries over to the minor-monotone-version of the crossing number [7].

It remains an open question whether the basis of the exponential dependency on $k$ can be reduced to less than $2$ or if the running time of the planar Max-Cut algorithm and thus our overall running time can be improved further.