Showing papers on "Longest path problem published in 1998"
TL;DR: A new 0-1 linear programming formulation of the Project Scheduling Problem with resource constraints, corresponding to all feasible subsets of activities that can be simultaneously executed without violating resource or precedence constraints is presented.
Abstract: In this paper we consider the Project Scheduling Problem with resource constraints, where the objective is to minimize the project makespan. We present a new 0-1 linear programming formulation of the problem that requires an exponential number of variables, corresponding to all feasible subsets of activities that can be simultaneously executed without violating resource or precedence constraints. Different relaxations of the above formulation are used to derive new lower bounds, which dominate the value of the longest path on the precedence graph and are tighter than the bound proposed by Stinson et al. (1978). A tree search algorithm, based on the above formulation, that uses new lower bounds and dominance criteria is also presented. Computational results indicate that the exact algorithm can solve hard instances that cannot be solved by the best algorithms reported in the literature.
359 citations
TL;DR: A simple heuristic for finding a good robust shortest path is provided, and the worst case performance is analyzed, and it is shown that the robust SP problem is strongly NP-hard.
194 citations
01 Jan 1998
TL;DR: This work finds a salesman tour of total cost at most (1 + E) times optimal in time n for any E > 6, and presents a quasi-polynomial time algorithm for the Steiner version of this problem.
Abstract: Given a planar Rraph on n nodes with costs (weights) on its edges,define ;he distance between nodes i &d 2 as’ the length of the shortest path between i and i. Consider this as &I instance of me& TSP. For any E > 6, our algorithm finds a salesman tour of total cost at most (1 + E) times optimal in time n”(llea). We also present a quasi-polynomial time algorithm for the Steiner version of this problem.
141 citations
Patent•
11 Dec 1998TL;DR: In this article, a one-to-all route selection method with multiple QoS metrics is proposed. But the problem is to find a path between a source node and each node in a communications network such that the delay of the path does not exceed a path delay constraint and the cost of the route is minimized.
Abstract: A method is described for one-to-all route selection in Communications Networks with multiple QoS metrics. This method takes a first metric (say, delay) as a constraint and a second metric (say, cost) as an optimization target. A potential objective is to find a path between a source node and each node in a communications network such that the delay of the path does not exceed a path delay constraint and the cost of the path is minimized. The method selects a first path which is a shortest path from a source node to each node in terms of the first metric using Dijkstra's algorithm. A reachability graph is then constructed based on the first metric path constraint. Within the reachability graph, another path is found, which is a shortest path from a source node to each node in terms of the second metric, using Dijkstra's algorithm. Any path to a particular node selected within the reachability graph replaces the first path to said particular node. This method can guarantee to find a nearly optimal path with the given constraint satisfied as long as there exists such a path.
117 citations
Proceedings Article•
01 Aug 1998
TL;DR: This paper shows that the 2D curvature constrained shortest-path problem in two dimensions is NP-hard, when the obstacles are polygons with a total of N vertices and the vertex positions are given withinO(N) bits of precision.
Abstract: The motion planning problems for non-holonomic car-like robots have been extensively studied in the literature. The curvature-constrained shortest-path problem is to plan a path from an initial con guration to a nal con guration (where a con guration is de ned by a location and an orientation), in the presence of obstacles, such that the path is a shortest among all paths with a prescribed curvature bound. The curvature-constrained shortest-path problem can also be seen as nding a shortest path for a point car-like robot moving forward at constant speed with a radius of curvature bounded from above by some constant. Previously, there is no known hardness result for the 2D curvature constrained shortest-path problem. This paper shows that the above problem in two dimensions is NP-hard, when the obstacles are polygons with a total of N vertices and the vertex positions are given withinO(N) bits of precision. Our reduction is computed by a family of polynomial-size circuits. This NP-hardness result provides evidence that there are no eÆcient exact algorithms for curvature-constrained shortest-path planning in arbitrary environments, and it justi es the approaches based on approximation and discretization used in most of the previous papers on curvature-constrained path planning. Surface address: INRIA Lorraine-Loria, 615, rue du Jardin Botanique, B.P. 101, 54602 Villers-ls-Nancy cedex, FRANCE E-mail: lazard@loria.fr Surface address: Department of Computer Science, Duke University, Durham, NC 27708-0129. E-mail: reif@cs.duke.edu. Supported in part by Grants NSF/DARPA CCR9725021, CCR-96-33567, NSF IRI9619647, ARO contract DAAH-04-96-1-0448, and ONR contract N00014-99-1-0406. This paper was presented in the Workshop on the Algorithmic Foundations of Robotics (WAFR98), Houston, Texas,June, 1998.
101 citations
01 Jan 1998
TL;DR: Experimental results show how the proposed method can be a viable solution for node assignment in a VLIW compiler for clustered machines and the low computational complexity of this approach is shown.
Abstract: This report proposes a new heuristic/model driven approach to assign nodes of a computational DAG to clusters for a VLIW machine with a partitioned register file. Our approach exploits a heuristically found initial clustering to speed up the convergence of a deterministic descent algorithm. The initial configuration is determined through a longest path driven strategy that collects a number of paths or sub-dags starting from the DAG's leaves. The initial node assignment problem is then simplified to the assignment of these partial components to one of the k clusters. We approach the component assignment problem in two different ways depending upon some heuristically detected DAG symmetries. The descent algorithm starts from the initial configuration and modifies the assignment for each partial component by minimizing a cost function being an estimate of the schedule length for all nodes in the DAG on a given machine. The estimate is carried out by a simplified list scheduler taking quantitatively into account things like register pressure, resources allocation, etc. We compared our approach with a common heuristic known as BUG (Bottom Up Greedy) on a set of scientific and multimedia-like computational kernels. Experimental results show a reduction from 5 to 50% in the static schedule length depending from the DAG's complexity, symmetry and intrinsic parallelism and from architectural parameters like number of clusters, registers banks size, etc. Best results were obtained for large DAGs (hundreds of nodes) where the assignment of nodes to clusters is determinant to reduce the inter-cluster copies and the resource conflicts; another important factor is sometimes the reduction in register spills to/from memory due to the load balancing between clusters. These results and the low computational complexity of this approach show how the proposed method can be a viable solution for node assignment in a VLIW compiler for clustered machines.
83 citations
TL;DR: The problem considered in this paper is to find the shortest path in a new kind of time-constrained network, called a mixed time-schedule network, in which departures from some nodes are only allowed at some discrete points.
78 citations
TL;DR: This paper performs an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bounded algorithms proposed by Ramalingam and Reps in [30] and by Frigioni, Marchetti-Spaccamela and Nanni in [18], respectively.
Abstract: In this paper we propose the first experimental study of the fully dynamic single-source shortest-paths problem on directed graphs with positive real edge weights. In particular, we perform an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bounded algorithms proposed by Ramalingam and Reps in [30] and by Frigioni, Marchetti-Spaccamela and Nanni in [18], respectively. The main goal of this paper is to provide a first experimental evidence for: (a) the effectiveness of dynamic algorithms for shortest paths with respect to a traditional static approach to this problem; (b) the validity of the theoretical model of output boundedness to analyze dynamic graph algorithms. Beside random generated graphs, useful to capture the "asymptotic" behavior of the algorithms, we also developed experiments by considering a widely used graph from the real world, i.e., the Internet graph.
77 citations
TL;DR: The algorithms for the incremental problem (handling edge insertions and cost decrements) work for any graph; they have optimal space requirements and query time, but their performances depend on the class of the considered graph.
Abstract: We consider the problem of updating a single-source shortest path in either a directed or an undirected graph, with positive real edge weights. Our algorithms for the incremental problem (handling edge insertions and cost decrements) work for any graph; they have optimal space requirements and query time, but their performances depend on the class of the considered graph. The cost of updates is computed in terms of amortized complexity and depends on the size of the output modifications. In the case of graphs with bounded genus (including planar graphs), graphs with bounded arboricity (including bounded degree graphs), and graphs with bounded treewidth, the incremental algorithms require O(log n) amortized time per vertex update, where a vertex is considered updated if it reduces its distance from the source. For general graphs with n vertices and m edges our incremental solution requires O(\(\)log n) amortized time per vertex update. We also consider the decremental problem for planar graphs, providing algorithms and data structures with analogous performances. The algorithms, based on Dijkstra's technique [6], require simple data structures that are really suitable for a practical and straightforward implementation.
74 citations
TL;DR: Several simulation results of specific task-oriented variants of the basic path planning problem using the proposed genetic algorithm using a bit-string encoding of selected graph vertices show higher or at least equally well performance for the genetic algorithm.
Abstract: A genetic algorithm for the path planning problem of a mobile robot which is moving and picking up loads on its way is presented. Assuming a findpath problem in a graph, the proposed algorithm determines a near-optimal path solution using a bit-string encoding of selected graph vertices. Several simulation results of specific task-oriented variants of the basic path planning problem using the proposed genetic algorithm are provided. The results obtained are compared with ones yielded by hill-climbing and simulated annealing techniques, showing a higher or at least equally well performance for the genetic algorithm.
65 citations
08 Nov 1998
TL;DR: Chen et al. conjectured that map graphs can be recognized in polynomial time, and in this paper, their conjecture is settled affirmatively.
Abstract: Z. Chen et al. (1997, 1998) have introduced a modified notion of planarity, where two faces are considered adjacent if they share at least one point. The corresponding abstract graphs are called map graphs. Chen et al. raised the question of whether map graphs can be recognized in polynomial time. They showed that the decision problem is in NP and presented a polynomial time algorithm for the special case where we allow at most 4 faces to intersect in any point-for only 3 are allowed to intersect in a point, we get the usual planar graphs. Chen et al. conjectured that map graphs can be recognized in polynomial time, and in this paper, their conjecture is settled affirmatively.
TL;DR: In this paper, an iterative improvement approach based on Benders' decomposition is presented to schedule non-preemptive open shops with the objective of minimizing makespan, which is the dual of a longest path problem that can be efficiently solved by the well known label correcting method.
08 Jul 1998
TL;DR: Given an alphabet σ, a (directed) graph G whose edges are weighted and σ-labeled, and a formal language L \(\subseteq\) σ*, this work considers the problem of finding a shortest (simple) path p in G complying with the additional constraint that l(p) ∃ L.
Abstract: Given an alphabet σ, a (directed) graph G whose edges are weighted and σ-labeled, and a formal language L \(\subseteq\) σ*, we consider the problem of finding a shortest (simple) path p in G complying with the additional constraint that l(p) ∃ L Here l(p) denotes the unique word given by concatenating the σ-labels in G along the path p
TL;DR: This paper shows that, after sorting the input intervals by their endpoints, a data structure can be constructed sequentially in O(n) time and O( n) space; using this data structure, each query on the length of the shortest path between any two intervals can be answered in O (1) time.
Abstract: In this paper, we study the following all-pair shortest path query problem: Given the interval model of an unweighted interval graph of n vertices, build a data structure such that each query on the shortest path (or its length) between any pair of vertices of the graph can be processed efficiently (both sequentially and in parallel). We show that, after sorting the input intervals by their endpoints, a data structure can be constructed sequentially in O(n) time and O(n) space; using this data structure, each query on the length of the shortest path between any two intervals can be answered in O(1) time, and each query on the actual shortest path can be answered in O(k) time, where k is the number of intervals on that path. Furthermore, this data structure can be constructed optimally in parallel, in O(log n) time using O(n/log n) CREW PRAM processors; each query on the actual shortest path can be answered in O(1) time using k processors. Our techniques can be extended to solving the all-pair shortest path query problem on circular-arc graphs, both sequentially and in parallel, in the same complexity bounds. As an immediate consequence of our results, we improve by a factor of n the space complexity of the previously best-known sequential all-pair shortest path algorithm for unweighted interval graphs.
TL;DR: η a and π are determined for several classes of graphs and a characterization of all graphs with Δ ⩽ 4 and η a = Δ − 1 is obtained and the minimum cardinality of the path partition number of G is determined.
04 Jan 1998
TL;DR: Two efficient methods that consider only dominant long paths are employed to approach this problem and show that the probability distribution obtained is well tracked to the distribution obtained by the whole circuit simulation with much less computation time.
Abstract: In this paper a new problem definition of statistical timing analysis is formulated. Two efficient methods that consider only dominant long paths are employed to approach this problem. The influence of the correlation of node delays on the probability distribution of the longest path delay is studied in detail. The experimental results show that the probability distribution of the longest path delay is greatly influenced by the correlation of nodes and by the presence of many dominant long paths. The results also show that the probability distribution obtained by our approaches is well tracked to the distribution obtained by the whole circuit simulation with much less computation time.
TL;DR: A preprocessing algorithm which requires linear storage is presented, substantially faster than the general algorithms without preprocessing, which are very slow if the road network is large.
Abstract: One of the basic problems in transportation planning systems is the calculation of the fastest route between two points in a road network. General shortest path algorithms, which examine a large part of the whole graph for each shortest path, are very slow if the road network is large. Since the road network does not change very often it is possible to calculate auxiliary information in a preprocessing step. I will present a preprocessing algorithm which requires linear storage. It is substantially faster than the general algorithms without preprocessing.
01 Jan 1998
TL;DR: A novel and fast path planning method for a mobile robot (MR) among objects of arbitrary shape that uses both the fast distance transformation (FDT) and variations of some topological methods as thinning and skeletonization, to obtain the free space skeleton.
Abstract: A novel and fast path planning method for a mobile robot (MR) among objects of arbitrary shape is described. It comprises two phases. During the first phase, the graph including all possible collision-free paths from a top view of the environment is first obtained. During the second phase, the optimal path for the MR is then selected. For this, the proposed method uses both the fast distance transformation (FDT) and variations of some topological methods as thinning and skeletonization, to obtain the free space skeleton. Unlike conventional methods, the proposed approach is capable to include the MR and the target intrinsically in the path and, at the same time it obtains the collision-free path's graph, taking advantage of the topological concept of hole. We propose to use a logical operator over the FDT instead of the classical morphologic operators over the discrete array (erosion and dilation), to obtain a much faster algorithm. The optimal path (in terms of length) is next selected and smoothed by conventional algorithms. The resultant path is finally used as a reference by the mobile robot.
Journal Article•
TL;DR: The detour matrix (DD) of a graph has for its (i,j) entry the length of the longest path between vertices i and j and the sum of all entries above the main diagonal gives the detour index dd as mentioned in this paper.
Abstract: The detour matrix (DD) of a graph has for its (i,j) entry the length of the longest path between vertices i and j. The sum of all entries above the main diagonal gives the detour index dd. Distinct graphs that have the same detour index have been reported in the literature. We examined such graphs and others that we have found and report on some of their regularities. We noticed that many graphs have not only the same detour index but also the same detour matrix. We considered in particular graphs for which the elements of the detour matrix are maximal. Such graphs are called saturated graphs. The detour matrix of a saturated graph is the same as that of the complete graph having the same number or vertices.
TL;DR: In this article, the authors give a simple proof that the obvious necessary conditions for a graph to contain the kth power of a Hamiltonian path are sufficient for the class of interval graphs.
Abstract: We give a simple proof that the obvious necessary conditions for a graph to contain the kth power of a Hamiltonian path are sufficient for the class of interval graphs. The proof is based on showing that a greedy algorithm tests for the existence of Hamiltonian path powers in interval graphs. We will also discuss covers by powers of paths and analogues of the Hamiltonian completion number. © 1998 John Wiley & Sons, Inc. J Graph Theory 28: 31–38, 1998
28 Aug 1998
TL;DR: These are the first parallel algorithms which achieve bounds for any class of graphs except trees, when the treewidth is a constant: computing a shortest path tree, or finding a negative cycle in O(log 2 n) time using O(n) work.
Abstract: We consider the problem of preprocessing an n-vertex digraph with real edge weights so that subsequent queries for the shortest path or distance between any two vertices can be efficiently answered. We give parallel algorithms for the EREW PRAM model of computation that depend on the treewidth of the input graph. When the treewidth is a constant, our algorithms can answer distance queries in O(α(n)) time using a single processor, after a preprocessing of O(log2n) time and O(n) work, where α(n) is the inverse of Ackermann's function. The class of constant treewidth graphs contains outerplanar graphs and series-parallel graphs, among others. To the best of our knowledge, these are the first parallel algorithms which achieve these bounds for any class of graphs except trees. We also give a dynamic algorithm which, after a change in an edge weight, updates our data structures in O(log n) time using O(nβ) work, for any constant 0
TL;DR: It is shown that several classes of graphs have this partition property and the vertex set V (G) can be partitioned into two subsets V1 and V2 such that τ(G[V1] ≤ k1 and τ( G[V2]) ≤ k2.
Abstract: Let τ(G) denote the number of vertices in a longest path of the graph G and let k1 and k2 be positive integers such that τ(G) = k1+k2. The question at hand is whether the vertex set V (G) can be partitioned into two subsets V1 and V2 such that τ(G[V1]) ≤ k1 and τ(G[V2]) ≤ k2. We show that several classes of graphs have this partition property.
TL;DR: A computational study is presented which shows the superiority of the algorithm proposed in this paper over other existing algorithms to generate the entire set E of efficient paths of the SMBPP.
TL;DR: The complexity of budget-constrained flow improvement problems is investigated and it is shown that the problem can be solved in polynomial time even if the improvement strategy is required to be integral.
25 Feb 1998
TL;DR: In this paper, the mutual exclusion scheduling problem for comparability graphs was shown to be NP-complete for permutation graphs and for each fixed constant m ≥ 6, and it was shown that the problem is also NP-hard for comparality graphs.
Abstract: In this paper, we consider the mutual exclusion scheduling problem for comparability graphs. Given an undirected graph G and a fixed constant m, the problem is to find a minimum coloring of G such that each color is used at most m times. The complexity of this problem for comparability graphs was mentioned as an open problem by Mohring (1985) and for permutation graphs (a subclass of comparability graphs) as an open problem by Lonc (1991). We prove that this problem is already NP-complete for permutation graphs and for each fixed constant m ≥ 6.
TL;DR: A linear-time algorithm for the path-partition problem in bipartite distance-hereditary graphs with solution to the challenge of finding a path partition of minimum size.
Abstract: A path partition of a graph is a collection of vertex-disjoint paths that cover all vertices of the graph. The path-partition problem is to nd a path partition of minimum size. This paper gives a linear-time algorithm for the path-partition problem in bipartite distance-hereditary graphs.
TL;DR: Broadcasting in processor networks means disseminating a single piece of information, which is originally known only at some nodes, to all members of the network.
TL;DR: It is shown that the minimum transmission time problem with integer capacities and integer delays is equivalent to the maximal dynamic flow problem studied by Ford and Fulkerson in 1962 and therefore can be solved efficiently by their path decomposition algorithm.
TL;DR: A practical polynomial time solution to the Travelling Salesman Problem in a rich class of directed graphs (including edge weighted binary de Bruijn graphs), and bounded-error approximation algorithms for the maximum weight TSP in a superset of those directed graphs.
01 Jan 1998
TL;DR: A process-based clientserver approach is presented that permits concurrent sensor-based map and localization-correction updates as well as concurrent path computation and execution that helps alleviate the influence of uncertainty on path planning.
Abstract: Sensor-based discovery path planning is problematic because the path needs to be continually recomputed as new information is discovered. A process-based clientserver approach is presented that permits concurrent sensor-based map and localization-correction updates as well as concurrent path computation and execution. Laplace’s equation is constantly solved (i.e., a harmonic function) by using an iteration kernel convolved with an occupancy-grid representation of the current free space. The path produced (i.e., by steepest gradient descent on the harmonic function) is optimal in the sense of minimizing the distance to the goal as well as a hitting probability. This helps alleviate the influence of uncertainty on path planning. An initial heuristic estimate provides the path planner with instantaneous response (i.e., reactive), but with some deliberation it able to produce optimal paths. In addition, the computation time for generating the path is insignificant provided that the harmonic function has converged. On a regular grid, the computation of the harmonic function is linear in the total number of grid elements. A quad-tree representation is used to minimize the computation time by reducing the number of grid elements and minimally representing large spaces void of obstacles and goals.