Showing papers on "Longest path problem published in 1999"

Fast Algorithms for Finding O(Congestion + Dilation) Packet Routing Schedules

Abstract: (c+d) steps using constant-size queues, where c is the congestion of the paths in the network, and d is the length of the longest path. The proof, however, used the Lovasz Local Lemma and was not constructive. In this paper, we show how to find such a schedule in time, with probability , for any positive constant β, where is the sum of the lengths of the paths taken by the packets in the network, and m is the number of edges used by some packet in the network. We also show how to parallelize the algorithm so that it runs in NC. The method that we use to construct the schedules is based on the algorithmic form of the Lovasz Local Lemma discovered by Beck.

On Approximation Properties of the Independent Set Problem for Low Degree Graphs

Abstract: The main problem we consider in this paper is the Independent Set problem for bounded degree graphs. It is shown that the problem remains MAX SNP-complete when the maximum degree is bounded by 3. Some related problems are also shown to be MAX SNP-complete at the lowest possible degree bounds. Next we study better poly-time approximation of the problem for degree 3 graphs, and improve the previously best ratio, 5/4, to arbitrarily close to 6/5. This result also provides improved poly-time approximation ratios, B+3/5+e, for odd degree B.

Efficient computation of geodesic shortest paths

Abstract: This paper describes an efficient algorithm for the geodesic shortest, nath oroblem. i.e. the problem of finding shortest path; bet&n pa& of points on the surface of a 3dimensional polyhedron such that the path is constrained to lie on the surface of the polyhedron. We use the wavefront method and show an O(nlog%) time bound for this problem, when there are O(n) vertices and edges on the polyhedron.

Two-point Euclidean shortest path queries in the plane

Abstract: We consider the two-point query version of the fundamental geometric shortest path problem: Given a set h of polygonal obstacles iu the plane, having a total of n vertices, build a data structure such that for any two query points s and t we can efficiently determine the length, d(s,t), of an Euclidean shortest obstacle-avoiding path, *(s,t), from s to t. Additionally, our data structure should allow one to report the path x(s, t), in time proportional to its (combinatorial) size. We present various methods for solving this two-point query problem, including algorithms with o(n), O(log n+h), 0( h log n), O(log’ n) or optimal O(log n) query times, using polynomial-space data structures, with various tradeoffs between space and query time. While severa results have been known for approtimate twepoint Euclidean shortest path queries, it has been a well-publicized open problem to obtain sublinear query time for the exact version of the problem. Our methods also yield data structures for twc+point shortest path queries on nonconvex polyhedral

Continuous-Time Dynamic Shortest Path Algorithms

Abstract: We consider the problem of computing shortest paths through a dynamic network – a network with time-varying characteristics, such as arc travel times and costs, which are known for all values of time. Many types of networks, most notably transportation networks, exhibit such predictable dynamic behavior over the course of time. Dynamic shortest path problems are currently solved in practice by algorithms which operate within a discrete-time framework. In this thesis, we introduce a new set of algorithms for computing shortest paths in continuous-time dynamic networks, and demonstrate for the first time in the literature the feasibility and the advantages of solving dynamic shortest path problems in continuous time. We assume that all time-dependent network data functions are given as piece-wise linear functions of time, a representation capable of easily modeling most common dynamic problems. Additionally, this form of representation and the solution algorithms developed in this thesis are well suited for many augmented static problems such as time-constrained minimum-cost shortest path problems and shortest path problems with time windows. We discuss the classification, formulation, and mathematical properties of all common variants of the continuous-time dynamic shortest path problem. Two classes of solution algorithms are introduced, both of which are shown to solve all variants of the problem. In problems where arc travel time functions exhibit First-In-First-Out (FIFO) behavior, we show that these algorithms have polynomial running time; although the general problem is NP-hard, we argue that the average-case running time for many common problems should be quite reasonable. Computational results are given which support the theoretical analysis of these algorithms, and which provide a comparison with existing discrete-time algorithms; in most cases, continuous-time approaches are shown to be much more efficient, both in running time and storage requirements, than their discretetime counterparts. Finally, in order to further reduce computation time, we introduce parallel algorithms, and hybrid continuous-discrete approximation algorithms which exploit favorable characteristics of algorithms from both domains. Thesis Supervisor: Ismail Chabini Title: Assistant Professor, Department of Civil and Environmental Engineering, Massachusetts Institute of Technology

Selecting tile shape for minimal execution time

Abstract: Many computationally-intensive programs, such as those for differential equations, spatial interpolation, and dynamic programming, spend a large portion of their execution time in multiply-nested loops which have a regular stencil of data dependences. Tiling is a well-known optimization that improves performance on such loops, particularly for computers with a multi-levelled hierarchy of parallelism and memory. Most previous work on tiling restricts the tile shape to be rectangular. Our previous work and its extension by Desprez, Dongarra, Rastello and Robert Showed that for doubly nested loops, using parallelograms can improve parallel execution time by decreasing the idle time, the time that a processor spends waiting for data or synchronization. In this technical report, we extend that work to more deeply nested loops, as well as to more complex loop bounds. We introduce a model which allows us to demonstrate the equivalence in complexity of linear programming and determining the execution time of a tiling in the model. We then identify a sub-class of these loops that constitute rectilinear iteration spaces for which we derive a closed form formula for their execution time. This formula can be used by a compiler to predict the execution tome of a loop nest. We then derive the tile shape that minimizes this formula. Using the duality property of linear programming, we also study how the longest path of dependent tiles within a rectilinear iteration space depends on the slope of only four of the facets defining the iteration space, independent of its dimensionality.

Path consistency on triangulated constraint graphs

Abstract: Among the local consistency techniques used in the resolution of constraint satisfaction problems (CSPs), path consistency (PC) has received a great deal of attention. A constraint graph G is PC if for any valuation of a pair of variables that satisfy the constraint in G between them, one can find values for the intermediate variables on any other path in G between those variables so that all the constraints along that path are satisfied. On complete graphs, Montanari showed that PC holds if and only if each path of length two is PC. By convention, it is therefore said that a CSP is PC if the completion of its constraint graph is PC. In this paper, we show that Montanari's theorem extends to triangulated graphs. One can therefore enforce PC on sparse graphs by triangulating instead of completing them. The advantage is that with triangulation much less universal constraints need to be added. We then compare the pruning capacity of the two approaches. We show that when the constraints are convex, the pruning capacity of PC on triangulated graphs and their completion are identical on the common edges. Furthermore, our experiments show that there is little difference for general nonconvex problems.

A Shortest Path Based Path Planning Algorithm for Nonholonomic Mobile Robots

Abstract: A path planning algorithm for a mobile robot subject to nonholonomic constraints is presented. The algorithmemploys a global- local strategy, and solves the problem in the 2D workspace of the robot, without generating the complexconfiguration space. Firstly, a visibility graph is constructed for finding a collision-free shortest path for a point. Secondly,the path for a point is evaluated to find whether it can be used as a reference to build up a feasible path for the mobile robot.If not, this path is discarded and the next shortest path is selected and evaluated until a right reference path is found. Thirdly,robot configurations are placed along the selected path in the way that the robot can move from one configuration to the nextavoiding obstacles. Lemmas are introduced to ensure that the robot travels using direct, indirect or reversal manoeuvres. Thealgorithm is computationally efficient and runs in time O(nk + n log n) for k obstacles andn vertices. The path found is near optimal in terms of distance travelled. The algorithm is tested in computersimulations and test results are presented to demonstrate its versatility in complex environments.

Optimal Compaction of Orthogonal Grid Drawings

Abstract: We consider the two-dimensional compaction problem for orthogonal grid drawings in which the task is to alter the coordinates of the vertices and edge segments while preserving the shape of the drawing so that the total edge length is minimized. The problem is closely related to two-dimensional compaction in vlsi-design and has been shown to be NP-hard. We characterize the set of feasible solutions for the two-dimensional compaction problem in terms of paths in the so-called constraint graphs in x- and y-direction. Similar graphs (known as layout graphs) have already been used for one-dimensional compaction in vlsi-design, but this is the first time that a direct connection between these graphs is established. Given the pair of constraint graphs, the two-dimensional compaction task can be viewed as extending these graphs by new arcs so that certain conditions are satisfied and the total edge length is minimized. We can recognize those instances having only one such extension; for these cases we solve the compaction problem in polynomial time. We transform the geometrical problem into a graph-theoretical one and formulate it as an integer linear program. Our computational experiments show that the new approach works well in practice.

The probabilistic longest path problem

Abstract: We study the probabilistic longest path problem. We propose a modification strategy adapting a solution for a deterministic instance to a solution for the probabilistic one, we compute the functional associated with this strategy, and we evaluate the complexities of computing this functional and of computing the deterministic solution maximizing it.

On the Approximation of Finding A(nother) Hamiltonian Cycle in Cubic Hamiltonian Graphs

Abstract: It is a simple fact that cubic Hamiltonian graphs have at least two Hamiltonian cycles. Finding such a cycle isNP-hard in general, and no polynomial-time algorithm is known for the problem of finding a second Hamiltonian cycle when one such cycle is given as part of the input. We investigate the complexity of approximating this problem where by a feasible solution we mean a(nother) cycle in the graph, and the quality of the solution is measured by cycle length. First we prove a negative result showing that the Longest Path problem is not constant approximable in cubic Hamiltonian graphs unlessP=NP. No such negative result was previously known for this problem in Hamiltonian graphs. In strong opposition with this result we show that there is a polynomial-time approximation scheme for finding a second cycle in cubic Hamiltonian graphs if a Hamiltonian cycle is given in the input.

The Square-Free 2-Factor Problem in Bipartite Graphs

Abstract: The 2-factor problem is to find, in an undirected graph, a spanning subgraph whose components are all simple cycles; hence it is a relaxation of the problem of finding a Hamilton tour in a graph. In this paper we study, in bipartite graphs, a problem of intermediate difficulty: the problem of finding a 2-factor that contains no 4-cycles. We introduce a polynomial time algorithm for this problem; we also present an "augmenting path" theorem, a polyhedral characterization, and a "Tutte-type" characterization of the bipartite graphs that contain such 2-factors.

A provably time-efficient parallel implementation of full speculation

Abstract: Speculative evaluation, including leniency and futures, is often used to produce high degrees of parallelism. Understanding the performance characteristics of such evaluation, however, requires having a detailed understanding of the implementation. For example, the particular implementaion technique used to suspend and reactivate threads can have an asymptotic effect on performance. With the goal of giving the users some understanding of performance without requiring them to understand the implementation, we present a provable implementation bound for a language based on speculative evaluation. The idea is (1) to supply the users with a semantics for a language that defines abstract costs for measuring or analyzing the performance of computations, (2) to supply the users with a mapping of these costs onto runtimes on various machine models, and (3) to describe an implementation strategy of the language and prove that it meets these mappings. For this purpose we consider a simple language based on speculative evaluation. For every computation, the semantics of the language returns a directed acyclic graph (DAG) in which each node represents a unit of computation, and each edge represents a dependence. We then describe an implementation strategy of the language and show that any computation with w work (the number of nodes in the DAG) and d depth (the length of the longest path in the DAG) will run on a p-processor PRAM in O(w/p + d log p) time. The bounds are work efficient (within a constant factor of linear speedup) when there is sufficient parallelism, w/d ≥ p log p. These are the first time bounds we know of for languages with speculative evaluation. The main challenge is in parallelizing the necessary queuing operations on suspended threads.

An external memory data structure for shortest path queries (extended abstract)

Abstract: We present results related to satisfying shortest path queries on a planar graph stored in external memory. In particular, we show how to store rooted trees in external memory so that bottom-up paths can be traversed I/O-efficiently, and we present I/O-efficient algorithms for triangulating planar graphs and computing small separators of such graphs. Using these techniques, we can construct a data structure that allows for answering shortest path queries on a planar graph I/O-efficiently.

Single sample path-based optimization of Markov chains

Abstract: Motivated by the needs of on-line optimization of real-world engineering systems, we studied single sample path-based algorithms for Markov decision problems (MDP). The sample path used in the algorithms can be obtained by observing the operation of a real system. We give a simple example to explain the advantages of the sample path-based approach over the traditional computation-based approach: matrix inversion is not required; some transition probabilities do not have to be known; it may save storage space; and it gives the flexibility of iterating the actions for a subset of the state space in each iteration. The effect of the estimation errors and the convergence property of the sample path-based approach are studied. Finally, we propose a fast algorithm, which updates the policy whenever the system reaches a particular set of states and prove that the algorithm converges to the true optimal policy with probability one under some conditions. The sample path-based approach may have important applications to the design and management of engineering systems, such as high speed communication networks.

All pairs lightest shortest paths

Abstract: Two vertices in a weighted directed graph may be connected by many shortest paths. Although all these paths are shortest in terms of weight, the number of edges on them may vary substantially. This leads us to consider the AlI Pairs Lightest Shortest Paths (APLSP) problem. A solution to this problem is a representation of shortest paths between all of pairs of vertices in the graph such that each of these shortest paths uses a minimal, or a close to minimal, number of edges. We present the following algorithms for obtaining exact or approximate solutions to the APLSP problem: l An d(n*+“) time algorithm for exactly solving the APLSP problem for directed graphs with integer weights of small absolute value, where n is the number of vertices in the graph and v < 0.747 is the solution of the equation ~(1, v, 1) = 3u, where ~(1, u, 1) is the exponent of the multiplicationof an n x R” matrix by an n” x n matrix. l An d(n’+“) time algorithm, where p < 0.575 is the solution of the equation ~(1, p, 1) = 1 + 2/~, for finding shortest paths between all pairs of vertices in a directed graph on n vertices with integer weights of small absolute value such that each shortest path found uses at most (1 + I) times the minimal number of edges required, for any fixed L > 0. . An 6(n” log W) time algorithm, where w = w(l,l,l) < 2.376 is the the exponent of square matrix multiplication, for finding paths between all pairs of vertices in a directed graph on n vertices with non-negatiue real edge weights, such that each path returned is of stretch at most ‘Department of Computer Science, Tel Aviv University, Td Aviv 69978, Israel. E-mail address: zuickmmmath.tau.as.il. Work suooorted in uart bv THE BASIC RESEARCH FOUNDATION’ administrated by’THE ISRAEL ACADEMY OF SCIENCES AND HUMANITIES. (1 + L) and uses at most (1 + e) times the minimal number of edges required, for every fixed E > 0. (In the time bound, W is the largest edge weight in the graph after the edge weights are scaled so that the smallest non-zero edge weight in the graph is 1.) These results extend results obtained recently by the author for the APSP problem.

Deferred-query : An efficient approach for some problems on interval graphs

Abstract: This paper introduces the idea of a deferred-query approach to design O(n) algorithms for the domatic partition, optimal path cover, Hamiltonian path, Hamiltonian circuit, and maximum matching problems on interval graphs given n endpoint-sorted intervals. The previous best-known algorithms run in O(n log log n) or O(n + m) time, where m is the number of edges in the corresponding interval graphs.

Method and system for performing transition fault simulation along long circuit paths for high-quality automatic test pattern generation

Abstract: A method for generating a test pattern for use in testing an integrated circuit device. The computer implemented steps of receiving and storing the netlist specification in a computer memory unit, and simulating the netlist using the computer implemented synthesis system. Using the netlist simulation, a set of circuit paths for each fault of the plurality of faults within the netlist specification is determined. From this set of paths, respective longest paths for each fault is determined. Using an ATPG (automatic test pattern generation) process, a test vector is determined for the first fault. Transition fault simulation is then performed on the first fault by applying the test vector to a first path through the first fault, wherein the first path is the longest path traversing through the first fault as determined by the ATPG process. Responsive to the transition fault simulation, a second fault that is fortuitously detected by the test vector as applied to a second path traversing through the second fault is identified. The test vector is credited with detecting the first fault, and, provided the second path is the longest path that traverses through the second fault, the test vector is credited with detecting the second fault. If the second path is not the longest path, a test vector is generated in a subsequent iteration of the method. In so doing, the method ensures transition faults are detected along long paths as opposed to short paths, thereby improving test quality.

A new dual algorithm for shortest path reoptimization

Abstract: Shortest path problems are among the most studied network flow problems, with interesting applications in various fields. Mainly in large scale transportation systems, a sequence of shortest path problems needs often to be solved, where the (k+1)-th problem differs only slightly from the k-th one. In that context, a promising line of research is to study efficient reoptimization approaches, able to exploit useful information from one shortest path computation to the next one. In this work, we shall focus on the change of the origin node in the shortest path problem to be solved. After reviewing the classical (dual) algorithms described in the literature sofar, which essentially show a Dijkstra''s like behavior, a new dual approach will be proposed, which could be particularly promising in practice.

Linear Time Algorithms for Hamiltonian Problems on (Claw, Net)-Free Graphs

Abstract: We prove that claw-free graphs, containing an induced dominating path, have a Hamiltonian path, and that two-connected claw-free graphs, containing an induced doubly dominating cycle or a pair of vertices such that there exist two internally disjoint induced dominating paths connecting them, have a Hamiltonian cycle. As a consequence, we obtain linear time algorithms for both problems if the input is restricted to (claw,net)-free graphs. These graphs enjoy those interesting structural properties.

Finding an Even Simple Path in a Directed Planar Graph

Abstract: In this paper we show that the following problem, the even simple path (ESP) problem for directed planar graphs, is solvable in polynomial time: Given: a directed planar graph G=(V,E) and two nodes s, (starting node), t ,(targetnode) \in V; Find: a simple path (i.e., without repeated nodes) from s to t of even length. (The length of the path is the number of edges it contains.)

The membership problem for switching classes with skew gains

Abstract: Gain graphs are graphs in which each edge has a gain (a label from a group so that reversing the direction of an edge inverts the gain). In this paper we take a generalized view of gain graphs in which the gain of an edge is related to the gain of the reverse edge by an anti-involution, i.e., an anti-automorphism of order at most two. We call these skew gain graphs. Switching classes are equivalence classes of gain graphs under the switching operation. The membership (or equivalence) problem is important to the theory of switching classes. The problem is to decide for two given skew gain graphs, on the same underlying graph and having gains from the same group, whether or not they belong to the same switching class. We give efficient algorithms. If a certain skew gain graph in the switching class has only abelian gains, then we can reduce the membership problem to an elegant problem on anti-involutions. Finally we show that the word problem can be reduced to the general membership problem, thereby establishing undecidability of the latter for some groups.