Showing papers in "SIAM Journal on Computing in 1990"
TL;DR: A simple and efficient method for evaluating the performance of an algorithm, rendered as a directed acyclic graph, on any parallel computer is presented and its application to several common algorithms shows that it is surprisingly accurate.
Abstract: A simple and efficient method for evaluating the performance of an algorithm, rendered as a directed acyclic graph, on any parallel computer is presented. The crucial ingredient is an efficient approximation algorithm for a particular scheduling problem. The only parameter of the parallel computer needed by our method is the message-to-instruction ratio $\tau$. Although the method used in this paper does not take into account the number of processors available, its application to several common algorithms shows that it is surprisingly accurate.
422 citations
TL;DR: The Boolean hierarchy is generalized in such a way that it is possible to characterize P and O in terms of the generalization, and the class $P^{\text{NP}}[O(\log n)]$ can be characterized in very different ways.
Abstract: Polynomial time machines having restricted access to an NP oracle are investigated. Restricted access means that the number of queries to the oracle is restricted or the way in which the queries are made is restricted (e.g., queries made during truth-table reductions). Very different kinds of such restrictions result in the same or comparable complexity classes. In particular, the class $P^{\text{NP}}[O(\log n)]$ can be characterized in very different ways. Furthermore, the Boolean hierarchy is generalized in such a way that it is possible to characterize $P^{\text{NP}}$ and $P^{\text{NP}}[O(\log n)]$ in terms of the generalization.
328 citations
PARC1
TL;DR: A new algorithm based on breadth-first search is presented that runs in faster asymptotic time than Natarajan’s algorithms, and in addition finds the shortest possible reset sequence if such a sequence exists.
Abstract: Natarajan reduced the problem of designing a certain type of mechanical parts orienter to that of finding reset sequences for monotonic deterministic finite automata. He gave algorithms that in polynomial time either find such sequences or prove that no such sequence exists. In this paper a new algorithm based on breadth-first search is presented that runs in faster asymptotic time than Natarajan’s algorithms, and in addition finds the shortest possible reset sequence if such a sequence exists. Tight bounds on the length of the minimum reset sequence are given. The time and space bounds of another algorithm given by Natarajan are further improved.That algorithm finds reset sequences for arbitrary deterministicfinite automata when all states are initially possible.
291 citations
TL;DR: An algebraic framework is developed that exposes the structural kinship among the deBruijn, shujCfle-exchange, butterjy, and cube-connected cycles networks and shows a family of "leveled" algorithms which run as efficiently on T/ as they do on (the much larger) G.
Abstract: The authors develop an algebraic framework that exposes the structural kinship among the deBruijn, shujCfle-exchange, butterjy, and cube-connected cycles networks and illustrate algorithmic benefits that ensue from the exposed relationships. The framework builds on two alge- braically specified genres of graphs: A group action graph (GAG, for short) is given by a set V of vertices and a set H of permutations of V: For each v E V and each r EII, there is an arc labeled r from vertex v to vertex v. A Cayley graph is a GAG (V, H), where V is the group Gr(H) generated by H and where each r 6 H acts on each g 6 Gr(H) by right multiplication. The graphs (Gr(H), H) and (V, H) are called associated graphs. It is shown that every GAG is a quotient graph of its associated Cayley graph. By applying such general results, the authors determine the following: The butterfly network (a Cayley graph) and the deBruijn network (a GAG) are associated graphs. The cube-connected cycles network (a Cayley graph) and the shuffle-exchange network (a GAG) are associated graphs. The order-n instance of both the butterfly and the cube-connected cycles share the same underlying group, but have slightly different generator sets II. By analyzing these algebraic results, it is delimited, for any Cayley graph G and associated GAG 7-/, a family of "leveled" algorithms which run as efficiently on T/ as they do on (the much larger) G. Further analysis of the results yields new, surprisingly efficient simulations by the shuffle-oriented networks (the shuffle-exchange and deBruijn networks) of like-sized butterfly-oriented networks (the butterfly and cube-connected cycles networks): An N-vertex butterfly-oriented network can be simulated by the smallest shuffle-oriented network that is big enough to hold it with slowdown O(log log N). This simulation is exponentially faster than the anticipated logarithmic slowdown. The mappings that underlie the simulation can be computed in linear time; and they afford one an algorithmic tech- nique for translating any program developed for a butterfly-oriented architecture into an equivalent program for a shuffle-oriented architecture, the latter program incurring only the indicated slowdown factor.
227 citations
TL;DR: Given a text string, a pattern string, and an integer k, a new algorithm for finding all occurrences of the pattern string in the text string with at most k differences is presented.
Abstract: Given a text string, a pattern string, and an integer k, a new algorithm for finding all occurrences of the pattern string in the text string with at most k differences is presented. Both its theoretical and practical variants improve upon the known algorithms.
186 citations
TL;DR: For finite tree automata with weights in a field R, a polynomial time algorithm is presented for deciding ambiguity-equivalence, provided R-operations and R-tests for 0 can be performed in constant time.
Abstract: It is shown that for every constant m it can be decided in polynomial time whether or not two m-ambiguous finite tree automata are equivalent. In general, inequivalence for finite tree automata is DEXPTIME-complete with respect to logspace reductions, and PSPACE-complete with respect to logspace reductions, if the automata in question are supposed to accept only finite languages. For finite tree automata with weights in a field R, a polynomial time algorithm is presented for deciding ambiguity-equivalence, provided R-operations and R-tests for 0 can be performed in constant time. This result is used to construct an algorithm deciding ambiguity-inequivalence of finite tree automata in randomized polynomial time. Finally, for every constant m it is shown that it can be decided in polynomial time whether or not a given finite tree automaton is m-ambiguous.
176 citations
TL;DR: A very simple version of the Gomory–Hu cut tree method that finds one minimum cut for every pair of nodes is derived, and it is shown that the seemingly fundamental operation of that method, node contraction, is not needed, nor must crossing cuts be avoided.
Abstract: A very simple algorithm for the classical problem of computing the maximum network flow value between every pair of nodes in an undirected, capacitated n node graph is presented; as in the well-known Gomory–Hu method, the method given here uses only $n - 1$ maximum flow computations Our algorithm is implemented by adding only five simple lines of code to any program that produces a minimum cut; a program to produce an equivalent flow tree, which is a compact representation of the flow values, is obtained by adding only three simple lines of code to any program producing a minimum cut A very simple version of the Gomory–Hu cut tree method that finds one minimum cut for every pair of nodes is also derived, and it is shown that the seemingly fundamental operation of that method, node contraction, is not needed, nor must crossing cuts be avoided As a result, this version of the Gomory–Hu method is implemented by adding less than ten simple lines of code to any program that produces a minimum cut The algor
172 citations
TL;DR: Efficient PRAM parallel algorithms for the string editing problem for input strings x and y and the CREW bound is $O(\log m \log n)$ time with $O({{mn} / {\log m}})$ processors.
Abstract: The string editing problem for input strings x and y consists of transforming x into y by performing a series of weighted edit operations on x of overall minimum cost. An edit operation on x can be the deletion of a symbol from x, the insertion of a symbol in x or the substitution of a symbol x with another symbol. This problem has a well known O((absolute value of x)(absolute value of y)) time sequential solution (25). The efficient Program Requirements Analysis Methods (PRAM) parallel algorithms for the string editing problem are given. If m = ((absolute value of x),(absolute value of y)) and n = max((absolute value of x),(absolute value of y)), then the CREW bound is O (log m log n) time with O (mn/log m) processors. In all algorithms, space is O (mn).
168 citations
TL;DR: This paper presents resource-bounded category and resource- bounded measure—two new tools for computational complexity theory—and some applications of these tools to the structure theory of exponentiation.
Abstract: This paper presents resource-bounded category and resource-bounded measure—two new tools for computational complexity theory—and some applications of these tools to the structure theory of exponent...
128 citations
TL;DR: It is shown that if a two-way probabilistic finite-state automaton (2pfa) M recognizes a nonregular language L with error probability bounded below $\frac{1}{2}$, then there is a positive constant b such that, for infinitely many inputs x, the expected running time of M on input x must exceed $2^{n^{b}}$ where n is the length of x.
Abstract: It is shown that if a two-way probabilistic finite-state automaton (2pfa) M recognizes a nonregular language L with error probability bounded below $\frac{1}{2}$, then there is a positive constant b (depending on M) such that, for infinitely many inputs x, the expected running time of M on input x must exceed $2^{n^{b}}$ where n is the length of x. This complements a result of Freivalds showing that 2pfa’s can recognize certain nonregular languages in exponential expected time. It also establishes a time complexity gap for 2pfa’s, since any regular language can be recognized by some 2pfa in linear time. Other results give roughly exponential upper and lower bounds on the worst-case increase in the number of states when converting a polynomial-time 2pfa to an equivalent two-way nondeterministic finite-state automaton or to an equivalent one-way deterministic finite-state automaton.
109 citations
TL;DR: Bennett shows how to construct an equivalent reversible program with running time T and space complexity O and proves that the reversible program actually runs in time $\Theta ({{T^{1 + \varepsilon}} / {S^{\varePSilon}}})$ and space $\TheTA (S(1+\ln ({T / S})))$.
Abstract: Given any irreversible program with running time T and space complexity S, and given any $\varepsilon > 0$, Bennett shows how to construct an equivalent reversible program with running time $O(T^{1+\varepsilon })$ and space complexity $O(S \ln T)$. Although these loose upper bounds are formally correct, they are misleading due to a hidden constant factor in the space bound. It is shown that this constant factor is approximately $\varepsilon 2^{1 / \varepsilon}$, which diverges exponentially as $\varepsilon$ approaches 0. Bennett’s analysis is simplified using recurrence equations and it is proven that the reversible program actually runs in time $\Theta ({{T^{1 + \varepsilon}} / {S^{\varepsilon}}})$ and space $\Theta (S(1+\ln ({T / S})))$.Bennett claims that for any $\varepsilon > 0$, the reversible program can be made to run in time $O(T)$ and space $O(ST^{\varepsilon })$. This claim is corrected and tightened as follows: whenever $T \geqq 2S$ and for any $\varepsilon \geqq {1 / {(0.58 \lg ({T / S}))}}$,...
TL;DR: It is demonstrated that some basic packing strategies such as NFDH and FFDH for two-dimensional packing have unbounded worst-case performance ratios in the three-dimensional case.
Abstract: The three-dimensional packing problem is discussed in this paper. The problem is a generalization of the one- and two-dimensional packing problems. It is demonstrated that some basic packing strategies such as NFDH and FFDH for two-dimensional packing have unbounded worst-case performance ratios in the three-dimensional case. Let $r(A)$ denote the asymptotic performance bound of an approximation algorithm A. An approximation algorithm G is developed, and it is shown that $4.333 \leqq r(G) \leqq 4.571$. The algorithm is improved to algorithm C and it is proven that $r(C) = 3.25$. For the special case when all boxes have square bottoms, the two algorithms are adapted to algorithms $G_1 $ and $C_1 $, respectively, with $r(G_1 ) = 4$ and $r(C_1 ) = 2.6875$. For the case when both sides of the bottom of a box are no larger then ${1 / m}$, two families of algorithms, $G^* _m (m \geqq 3)$ and $C^* _m (m \geqq 2)$, are presented. It is shown that $r(G^* _m ) = {m / {(m -2)}}$ and $r(C^* _m ) = {{(m+1)} / {(m-1)}}...
TL;DR: An optimal $O(\log \log n)$ time parallel algorithm for string matching on CROW-PRAM is presented and improves previous results of Galil and Vishkin.
Abstract: An optimal $O(\log \log n)$ time parallel algorithm for string matching on CROW-PRAM is presented. It improves previous results of Galil [Inform, and Control, 67 (1985), pp. 144–157] and Vishkin [Inform, and Control, 67 (1985), pp. 91–113].
TL;DR: Two space-efficient near- shortest path routing schemes are given for any class of networks whose members can be decomposed recursively by a separator of size at most a constant c, where $c \geqslant 2$.
Abstract: The problem of routing messages along near-shortest paths in a distributed network without using complete routing tables is considered. It is assumed that the nodes of the network can be assigned suitable short names at the time the network is established. Two space-efficient near- shortest path routing schemes are given for any class of networks whose members can be decomposed recursively by a separator of size at most a constant c, where $c \geqslant 2$. For an n-node network, the first scheme uses a total of $O(cn \log n)$ items of routing information, each $O(\log n)$ bits long, and $O(\log n)$-bit names, generated from a separator-based decomposition of the network, to achieve routings that are at most three times longer than shortest routings in worst case.l The second scheme augments the node names with $O(c \log c \log n)$ additional bits and uses this to reduce the bound on the routings to $(2 / \alpha) + 1$, where $\alpha, 1 < \alpha \leq 2$, is the root of the equation $\alpha ^{\lceil (c+1) / ...
TL;DR: It is shown that the problem of finding a directed cycle separator is in randomized NC and it is proved that computing cycle separators and conducting depth-first search in directed graphs are deterministically NC-equivalent, yielding the first randomized NC algorithm for depth- first search in general directed graphs.
Abstract: A directed cycle separator of an n-vertex directed graph is a vertex-simple directed cycle such that when the vertices of the cycle are deleted, the resulting graph has no strongly connected component with more than ${n / 2}$ vertices. It is shown that the problem of finding a directed cycle separator is in randomized NC. It is also proved that computing cycle separators and conducting depth-first search in directed graphs are deterministically NC-equivalent. These two results together yield the first randomized NC algorithm for depth-first search in general directed graphs.
TL;DR: It is shown that the problem of determining for a given tree T and integer k if T is a partial subgraph of a k-dimensional cube is NP-complete.
Abstract: An important family of graphs is the n-dimensional hypercube, the graph with $2^{n}$ nodes labelled $0,1,\cdots, 2^{n}-1$, and an edge joining two nodes whenever their binary representation differs in a single coordinate. The problem of deciding if a given source graph is a partial subgraph of an n-dimensional cube has recently been shown to be NP-complete. In this paper the same problem on a very restricted family of source graphs, trees, is considered. It is shown that the problem of determining for a given tree T and integer k if T is a partial subgraph of a k-dimensional cube is NP-complete.
TL;DR: The problem of determining whether an arbitrary pair is stable in a given problem instance is studied and it is shown that the problem has a lower bound of $\Omega (n^{2})$ in the worst case.
Abstract: In an instance of the stable marriage problem of size n, n men and n women, each participant ranks members of the opposite sex in order of preference. A stable marriage is a complete matching $M = \{ (m_{1}, w_{i_{1}}), (m_{2}, w_{i_{2}}),\cdots, (m_{n}, w_{i_{n}})\}$ such that no unmatched man and woman prefer each other to their partners in M. There exists an efficient algorithm, due to Gale and Shapley, that finds a stable marriage for any given problem instance. A pair $(m_{i} w_{j})$ is stable if it is contained in some stable marriage. In this paper, the problem of determining whether an arbitrary pair is stable in a given problem instance is studied. It is shown that the problem has a lower bound of $\Omega (n^{2})$ in the worst case. Hence, a previous known algorithm for the problem is asymptotically optimal. As corollaries of these results, the lower bound of $\Omega (n^{2})$ is established for several stable marriage related problems. Knuth, in his treatise on stable marriage, asks if there is a...
TL;DR: The problem of searching for a mobile robber in a simple polygon by a number of searchlights is considered and it is shown that the problem of obtaining a search schedule for an instance having at least one searchlight on the polygon boundary can be reduced to that for instances having no searchlights on thepolygon boundary.
Abstract: The problem of searching for a mobile robber in a simple polygon by a number of searchlights is considered. A searchlight is a stationary point which emits a single ray that cannot penetrate the boundary of the polygon. The direction of the ray can be changed continuously, and a point is detected by a searchlight at a given time if and only if it is on the ray. A robber is a point that can move continuously with unbounded speed. First, it is shown that the problem of obtaining a search schedule for an instance having at least one searchlight on the polygon boundary can be reduced to that for instances having no searchlight on the polygon boundary. The reduction is achieved by a recursive search strategy called the one-way sweep strategy. Then various sufficient conditions for the existence of a search schedule are presented by using the concept of a searchlight visibility graph. Finally, a simple necessary and sufficient condition for the existence of a search schedule for instances having exactly two sea...
TL;DR: A new projective algorithm converging in O(L\sqrt n) iterations is developed that does not require centering conditions, and its convergence speed is improved by a factor over Karmarkar’s projective algorithms and by a constant over the recent affine potential reduction algorithm.
Abstract: A class of projective transformations under which potential functions are invariant for linear programming is described. As a result, a new projective algorithm converging in $O(L\sqrt n)$ iterations is developed. The algorithm does not require centering conditions, and its convergence speed is improved by a factor $\sqrt n $ over Karmarkar’s projective algorithm and by a constant over the recent affine potential reduction algorithm.
TL;DR: A set of new formulae for the inverse of a block Hankel (or block Toeplitz) matrix is given, expressed in terms of certain matrix Pade forms, which approximate a matrix power series associated with the blockHankel matrix.
Abstract: A set of new formulae for the inverse of a block Hankel (or block Toeplitz) matrix is given. The formulae are expressed in terms of certain matrix Pade forms, which approximate a matrix power series associated with the block Hankel matrix.By using Frobenius-type identities between certain matrix Pade forms, the inversion formulae are shown to generalize the formulae of Gohberg–Heinig and, in the scalar case, the formulae of Gohberg–Semencul and Gohberg–Krupnik.The new formulae have the significant advantage of requiring only that the block Hankel matrix itself be nonsingular. The other formulae require, in addition, that certain submatrices be nonsingular.Since effective algorithms for computing the required matrix Pade forms are available, the formulae are practical. Indeed, some of the algorithms allow for the efficient calculation of the inverse not only of the given block Hankel matrix, but also of any nonsingular block principal minor.
TL;DR: A PLS-complete problem is exhibited such that the problem of verifying local optimality can be solved in LOGSPACE.
Abstract: The problem of finding locally optimal solutions to combinatorial problems in the framework of PLS as defined by D.S. Johnson, C.H. Papadimitriou, and M. Yannakakis [J. Comput. System Sci., 37(1988), pp. 79–100] is considered. A PLS-complete problem is exhibited such that the problem of verifying local optimality can be solved in LOGSPACE. For all previously known PLS-complete problems, verifying local optimality was P-complete, and it was conjectured in [J. Comput. System Sci., 37(1988), pp. 79–100] that this was necessary.
TL;DR: Several efficient algorithms are presented for detecting an intersection between an arc of ${\bf \Gamma }$ and an arcs of $(m, s)$ Davenport–Schinzel sequences.
Abstract: Let ${\bf \Gamma }$ be a collection of n (possibly intersecting) “red” Jordan arcs of some simple shape in the plane and let ${\bf \Gamma }^{\prime}$ be a similar collection of m “blue” arcs. Several efficient algorithms are presented for detecting an intersection between an arc of ${\bf \Gamma }$ and an arc of ${\bf \Gamma }^{\prime}$. (i) If the arcs of ${\bf \Gamma }^{\prime}$ form the boundary of a simply connected region, then the following can be detected: a “red-blue” intersection in time $O(\lambda _s (m) \log ^2 m+(\lambda _s (m)+n) \log (n+m))$ where $\lambda _s (m)$ is the (almost-linear) maximum length of $(m, s)$ Davenport–Schinzel sequences, and where s is a fixed parameter, depending on the shape of the given arcs. Another case where an intersection in close to linear time can be detected is when the union of the arcs of ${\bf \Gamma }$ and the union of the arcs of ${\bf \Gamma }^{\prime}$ are both connected. (ii) In the most general case, an intersection in time $O((m\sqrt {\lambda _s (n)}...
TL;DR: It is shown that, in the PRIORITY CROW PRAM model and for the class of undirected embedded planar graphs, depth-first search (DFS) trees are no more difficult to construct than breadth- first search (BFS) trees.
Abstract: It is shown that, in the PRIORITY CROW PRAM model and for the class of undirected embedded planar graphs, depth-first search (DFS) trees are no more difficult to construct than breadth-first search (BFS) trees.Specifically, suppose that time $T(n)\geqq \log n$ and $p(n)$ processors suffice to construct a planar embedding of a planar graph on n vertices and to compute a BFS tree of an undirected connected planar graph on $3n$ vertices. Then, given an undirected connected planar graph G on n vertices, a DFS tree of G can be computed in the stated model in $O(T(n))$ time with $p(n)$ processors.By using known results for the above problems, a DFS tree construction algorithm that runs in $O(\log n)$ time and uses $O(n^{3})$ processors is derived. The fastest previously known algorithm has time and processor bounds of $O({(\log n)}^2)$ and $O(n)$, respectively.
TL;DR: It is shown that the depth of the last node inserted in a random quad tree constructed from independent uniform random vectors is in probability asymptotic to $({2 / d}) \log n$, where log denotes the natural logarithm.
Abstract: It is shown that the depth of the last node inserted in a random quad tree constructed from independent uniform $[0,1]^d $ random vectors is in probability asymptotic to $({2 / d}) \log n$, where log denotes the natural logarithm. In addition, for $d = 2$, exact values are obtained for all the moments of the depth of the last node.
TL;DR: In this article, size-depth trade-oils for linear size circuits with depth bounded by the inverse of an Ackerman function are constructed, and it is shown that depth two circuits require O(n \log n)$ size.
Abstract: For $n=2^k $, let S be an $n \times n$ matrix whose rows and columns are indexed by $\operatorname{GF}(2)^k $ and, for $i, j \in \operatorname{GF}(2)^k , S_{i.j}=\langle i, j \rangle $, the standard inner product. Size-depth trade-oils are investigated for computing $S{\bf x}$ with circuits using only linear operations. In particular, linear size circuits with depth bounded by the inverse of an Ackerman function are constructed, and it is shown that depth two circuits require $\Omega (n \log n)$ size. The lower bound applies to any Hadamard matrix.
TL;DR: The more general result that any family of pseudosegments (a set of open simple curves on the plane such that two curves intersect each other in at most one point) lying on a planar subdivision defined by n other pseudosegment can give rise to at most $O(n^{4})$ edge sequences is proven.
Abstract: It is proven that if the shortest paths on the surface of a convex polyhedron are grouped into equivalence classes according to the sequences of edges that they cross, then the resulting number of ...
TL;DR: Algorithms for performing exponentiation in $\operatorname{GF}(2^{n})$ using a normal basis, and how they can be speeded up by using parallelization are investigated.
Abstract: A normal basis representation of $\operatorname{GF}(2^{n})$ allows squaring to be accomplished by a cyclic shift. Algorithms for multiplication in $\operatorname{GF}(2^{n})$ using a normal basis have been studied by several researchers. In this paper, algorithms for performing exponentiation in $\operatorname{GF}(2^{n})$ using a normal basis, and how they can be speeded up by using parallelization, are investigated.
TL;DR: A new class of arithmetic circuits, called feasible-size-magnitude, is introduced and used to show a feasible version of the Weierstrass approximation theorem, which means that a real function is feasible if and only if it can be sup-approximated by a division-free uniform family of feasible- Size-Magnitude arithmetic circuits over R.
Abstract: The connection between computable analysis and computational complexity is investigated by asking what it means to feasibly compute a real function. A new class of arithmetic circuits, called feasible-size-magnitude, is introduced and used to show a feasible version of the Weierstrass approximation theorem. That is, a real function is feasible if and only if it can be sup-approximated by a division-free uniform family of feasible-size-magnitude arithmetic circuits over R. This result involves a counter-intuitive simulation of Boolean circuits by arithmetic ones. It also has implications for algebraic complexity theory.
TL;DR: It is proved that the $\leqq$, satisfiability, tautology, unique Satisfiability, equivalence, and minimization problems are already $\textbf{SAT}$-complete (npolylogn, n), for verysimple Boolean formulas and for very simple systems of Boolean equations.
Abstract: The concepts of $\textbf{SAT}$-hardness and $\textbf{SAT}$-completeness modulo npolylogn time and linear size reducibility, denoted by $\textbf{SAT}$-hard (npolylogn, n) and $\textbf{SAT}$-complete (npolylogn, n), respectively, are introduced. Regardless of whether $\textbf{P} = \textbf{NP}$ or $\textbf{P}
eq \textbf{NP}$, it is shown that intuitivelyEach $\textbf{SAT}$-hard (npolylogn, n) problem requires essentially at least as much deterministic time as, andEach $\textbf{SAT}$-complete (npolylogn, n) problem requires essentially the same deterministic time as the satisfiability problem for 3CNF formulas.It is proved that the $\leqq$, satisfiability, tautology, unique satisfiability, equivalence, and minimization problems are already $\textbf{SAT}$-complete (npolylogn, n), for very simple Boolean formulas and for very simple systems of Boolean equations. These completeness results are used to characterize the deterministic time complexities of a number of problems for lattices, propositional calculi, ...
TL;DR: Kleene’s algorithm applied to this closed semiring solves the problem of determining whether a directed graph with two-dimensional labels has a zero-sum cycle or not, and is shown to run in polynomial time in the special cases of graphs with one-dimensional names, BTTSP, and graphs with bounded labels.
Abstract: Two natural operations on the set of convex polygons are shown to form a closed semiring; the two operations are vector summation and convex hull of the union. Various properties of these operations are investigated. Kleene’s algorithm applied to this closed semiring solves the problem of determining whether a directed graph with two-dimensional labels has a zero-sum cycle or not. This algorithm is shown to run in polynomial time in the special cases of graphs with one-dimensional labels, BTTSP (Backedged Two-Terminal Series-Parallel) graphs, and graphs with bounded labels. The undirected zero-sum cycle problem and the zero-sum simple cycle problem are also investigated.