Showing papers on "Longest path problem published in 1990"
TL;DR: The shortest-path problem in networks in which the delay (or weight) of the edges changes with time according to arbitrary functions is considered and algorithms for finding the shortest path and minimum delay under various waiting constraints are presented.
Abstract: In this paper the shortest-path problem in networks in which the delay (or weight) of the edges changes with time according to arbitrary functions is considered. Algorithms for finding the shortest path and minimum delay under various waiting constraints are presented and the properties of the derived path are investigated. It is shown that if departure time from the source node is unrestricted, then a shortest path can be found that is simple and achieves a delay as short as the most unrestricted path. In the case of restricted transit, it is shown that there exist cases in which the minimum delay is finite, but the path that achieves it is infinite.
550 citations
TL;DR: This work presents a linear algorithm for this problem on interval graphs, given the adjacency lists of an interval graph with n vertices and m edges, that runs in O(m+n) time.
111 citations
TL;DR: Results from Lagrangian duality for convex programs, the length-width inequality, and Dilworth's Theorem for directed acyclic graphs are used to obtain a strong relationship between optimal solutions of this problem and its dual.
Abstract: Consider the following resource allocation problem on a directed acyclic graph the precedence graph. Each vertex has a known work load, and a fixed amount of total resource is available. The time required to process a vertex is inversely proportional to the amount of the resource allocated to it. The time to complete all of the work is the length of time to complete a longest chain in the graph. The problem of finding an allocation which minimizes the time required to complete all of the work subject to the limited resource availability can be formulated as a separable convex programming problem.
We use results from Lagrangian duality for convex programs, the length-width inequality, and Dilworth's Theorem for directed acyclic graphs, to obtain a strong relationship between optimal solutions of this problem and its dual. This allows us to obtain closed-form solutions for certain special classes of graphs, and leads to a generalization of the LYM Property for partially ordered sets. The computational complexity of the general problem is an open question. However, the ellipsoid method yields a fully-polynomial approximation scheme, and some light can be shed on the associated decision problem. The results of this paper are shown to extend to resource allocation problems on perfect graphs.
97 citations
01 Jan 1990
TL;DR: A large variety of problems in computer science can be viewed from a common viewpoint as instances of “algebraic” path problems, such as the shortest path problem or problems of finding optimal paths with respect to more generally defined objective functions.
Abstract: Path Problems in Graphs. A large variety of problems in computer science can be viewed from a common viewpoint as instances of “algebraic” path problems. Among them are of course path problems in graphs such as the shortest path problem or problems of finding optimal paths with respect to more generally defined objective functions; but also graph problems whose formulations do not directly involve the concept of a path, such as finding all bridges and articulation points of a graph. Moreover, there are even problems which seemingly have nothing to do with graphs, such as the solution of systems of linear equations, partial differentiation, or the determination of the regular expression describing the language accepted by a finite automaton.
96 citations
Proceedings Article•
01 Jan 1990
TL;DR: This paper uses the isoefficiency metric to analyze the scalability of several parallel algorithms for finding shortest paths between all pairs of nodes in a densely connected graph and demonstrates that isoe efficiency functions are a compact and useful predictor of performance.
90 citations
IMEC1
TL;DR: A new approach to the false path problem in timing verifiers is presented, based on the modeling of both the logic and timing behavior of a circuit, which succeeds in curbing the combinatorial explosion associated with the longest statically sensitizable path search.
Abstract: A new approach to the false path problem in timing verifiers is presented. This approach is based on the modeling of both the logic and timing behavior of a circuit. Using the logic propagation conditions associated with each delay, efficient algorithms have been developed to find statically sensitizable paths. These algorithms simultaneously perform a longest path search and a partial verification of the sensitization of the paths. The resulting paths undergo a final and complete sensitization. The algorithms find the longest statically sensitizable path, whose length is a lower bound to the critical path length, and its associated sensitizing input vector. The algorithms can be easily modified to provide an ordered list of all the statically sensitizable paths above a given threshold. An initial analysis of the circuit by the PERT algorithm guides the critical path search and allows pruning of subgraphs that cannot lead to the solution. Results show that these techniques succeed in curbing the combinatorial explosion associated with the longest statically sensitizable path search. >
80 citations
TL;DR: A survey of results and conjectures concerning sufficient conditions in terms of connectivity and independence number for which a graph or digraph has various path or cyclic properties, for example hamilton path/ cycle, hamilton connected, pancyclic, path/cycle covers, 2-cyclic.
42 citations
13 May 1990
TL;DR: The algorithm SCOUT is proposed to solve the path-planning problem for robots moving between stationary obstacles by finding a first path quickly, then improves on the length of the path by testing more parts of the configuration space, and finally converges to the optimal path for any imposed metric.
Abstract: The algorithm SCOUT is proposed to solve the path-planning problem for robots moving between stationary obstacles. The configuration space of a robot is represented as a binary tree of blocks, each of which can be efficiently tested for collisions using a hierarchy of bubbles in work space. The configuration space is explored independently from start and goal until a contiguous path of free blocks connecting the two is found. The algorithm finds a first path quickly, then improves on the length of the path by testing more parts of the configuration space, and finally converges to the optimal path for any imposed metric. The tradeoff between the length of the path and time/memory usage is explicit and can be used to the advantage of integrated systems. The method is applicable to mobile robots as well as to manipulators. Results are shown for a 2 d.o.f. planar arm and a 5 d.o.f industrial manipulator. >
35 citations
TL;DR: This paper considers on which classes of networks the optimal facility location can be found in polynomial time for median and center, min and max problems, and shows many of the problems that use pseudo-polynomial time are shown to be NP-complete on outerplanar graphs.
Abstract: This paper concerns the problem of locating a path- or tree-shaped facility on a network. For median and center, min and max problems, we consider on which classes of networks the optimal facility location can be found in polynomial time. Some of these problems can be solved on series-parallel graphs, but by high-order polynomial- or pseudo-polynomial-time algorithms. Many of the problems that use pseudo-polynomial time are shown to be NP-complete on outerplanar graphs, a subset of series-parallel graphs.
35 citations
TL;DR: It is shown that computing this measure is computationally difficult, in particular #P-complete, and efficient algorithms for the K-terminal reliability problem on two classes of perfect graphs; interval graphs and permutation graphs are presented.
Abstract: A stochastic network in which nodes fail randomly with known probabilities is modeled by a probabilistic graph with unreliable nodes and perfect edges. The K-terminal reliability of such a network is the probability that there exists a Steiner tree connecting a subset of the nodes K (target nodes). Although the K-terminal reliability problem has been widely studied for networks with unreliable links, very little is known about the problem for networks with unreliable nodes. We show that computing this measure is computationally difficult, in particular #P-complete. We then present efficient algorithms for the K-terminal reliability problem on two classes of perfect graphs; interval graphs and permutation graphs. Computing the reliability on these two classes of graphs is of particular interest since the problem remains #P-complete for larger classes in the hierarchy of perfect graphs, namely, comparability and chordal graphs. The model presented in this paper is appropriate for radio broadcast networks and for fault-tolerant multiprocessor networks.
31 citations
28 May 1990
TL;DR: In this article, the authors consider a more general version of the problem when the vertices as well as edges have capacity constraints, and study different versions of the planar flow problem (all of which have been extensively investigated in the context of edge capacities).
Abstract: Max-flow in planar graphs has always been studied with the assumption that there are capacities only on the edges. Here we consider a more general version of the problem when the vertices as well as edges have capacity constraints. In the context of general graphs considering only edge capacities is not restrictive, since the vertex-capacity problem can be reduced to the edge-capacity problem. However, in the case of planar graphs this reduction does not maintainplanarity and cannot be used. We study different versions of the planar flow problem (all of which have been extensively investigated in the context of edge capacities).
TL;DR: It is proved that the problem to decide whether a given connected graph (guest network) G can be uniformly emulated on a path or a ring network is NP-complete, even if G is required to be a binary tree.
Abstract: Uniform emulations are a method to obtain efficient, balanced simulations of large processor networks (guests) on smaller processor networks (hosts). Each uniform emulation has associated with it a constant c, called the computation factor, which is the size of the guest network divided by the size of the host network. In this paper we prove that the problem to decide whether a given connected graph (guest network) G can be uniformly emulated on a path or a ring network is NP-complete, even if G is required to be a binary tree. If the computation factor c is fixed, then these problems become solvable in polynomial time for arbitrary connected graphs G. However, if we keep the computation factor fixed at at least 4 or 2 for the path- or ring-version, respectively, but allow disconnected graphs G, then the problem again is NP-complete. Similar results are shown for directed graphs.
01 Jan 1990
TL;DR: A data structure that supports insertion and regular path existence queries inO(nk2) amortized time andO(|F|) worst-case time, respectively is presented and it is shown how this data structure and the techniques used for building it are applicable to the area of knowledge base querying.
Abstract: If $G$ is a directed graph with labeled edges and $L$ is a fixed regular language, the {\em regular path problem}, given two nodes, $u$ and $v$, in $G$, is to find a path between $u$ and $v$ such that the labels on the arcs along that path form a string which is a member of $L$. We consider a dynamic version of this problem, adding arcs to and performing regular path queries on $G$ over $L$, and present a data structure that solves both problems in average time per operation linear in the number of nodes of the graph for any fixed regular language.
01 Aug 1990
TL;DR: A preprocessing of planar digraphs is presented which yields processor-efficient, poly-log time algorithms for the single-source and all-pairs shortest-path problems, breadth-first search and reachability in planar Digraphs.
Abstract: We present a preprocessing of planar digraphs which yields processor-efficient, poly-log time algorithms for the single-source and all-pairs shortest-path problems, breadth-first search and reachability in planar digraphs.
24 Jun 1990
TL;DR: An 1-d hierarchical module assembly method is shown to be free from the x-y interlock problem and achieves significant improvement in space and time requirements by exploiting hierarchy.
Abstract: Key algorithms and properties of 1-d IC layout compaction are presented. In particular, the spacing constraint formulation problem is mapped into the vertical visibility graph construction problem, whose time complexity is O(n log n) if element swappings are not considered. This approach generates enough constraints for the later automatic jogging purposes, while maintaining graph sparsity. The graph solution algorithm is made event-driven to achieve O(n/sup 1.5/ log n) expected running time. For hierarchical module assembly. a simple port abstraction method is used with O(n/sup 1.5/ log n) worst-case time complexity that allows cells to stretch and pitch match. The speed involvement is due to a transformation to ensure all weights are nonpositive, where the fast Dijkstra's longest path algorithm call be used. A reverse transformation is required to obtain the solution. An integrated leaf cell compaction and module assembly algorithm was proved to be free from the xy interlock problem. The module assembly problem was established as an integer linear programming problem where there is no known fast algorithm. A heuristic method is used instead to explore layout hierarchy as a practical solution with high speed, low memory and minor area penalties. >
01 May 1990
TL;DR: The techniques used involve a fast computation of staircase separators, and a scheme for partitioning the obstacles' boundaries in a way that ensures that the resulting path length matrices have a monotonicity property that is apparently absent before applying the partitioning scheme.
Abstract: Given a redilinear convex polygon P having O(n) vertices and which conlains n pairwise disjoint. rectangular rectilinear obstacles, we compute, in parallel, a data structure that supports queries about shortest rectilinear obstacle-avoiding paths in P. That is, a query specifies a Bource and a destination, and the data structure enables effi~ dent processing of the query. We construct the data structure in O(log2 n) time, with O(n2jlog2 n) prace6S0rs in the CREW-PRAM model if all queries are such that the source and the destination are on the boundary of P, with O(n2 jlogn) processors if the source is an obstacle vertex and the destination is on the boundary of P, and with 0(n) processors if both the source and destination are arbitrary points in the plane. The data strucLure we compute enables one processor to obtain the path length for any pair of query vertices (of obsLacles or of P) in constant time, or O( p:/ log n1) processors to retrieve the shortest path itself in logarithmic time, where k is the number of segments of that path. If the two query points are arbitrary rather than vertices, then one processor takes O(log n) time (instead of constant time) for finding the path length, while the complexity bounds for reporting an actuailihortest path remain unchanged. A number of other related shortest paths problems are solved. The techniques we use involve a fast computation of staircase separators, and a scheme for partitioning the obstacles' boundaries in a way that ensures that the resulting path length matrices have a monotonicity property that is apparently absent before applying our partitioning scheme. Sequentially, the data structure can be built in O(n2) time.
01 May 1990
TL;DR: In this article, an O(b S(n,m)) time algorithm is proposed, where n, m, and b are the numbers of vertices, edges, and backward edges (corresponding to the user-defined design rules) in the graph, and S(m) is the time needed in the Dijkstra algorithm.
Abstract: The problems of finding positive cycles and calculating the longest path lengths in a given constraint graph are considered. An O(b S(n,m)) time algorithm is proposed, where n, m, and b are the numbers of vertices, edges, and backward edges (corresponding to the user-defined design rules) in the graph, and S(n,m) is the time needed in the Dijkstra algorithm. Experimental results are shown. >
01 Jan 1990
TL;DR: In this paper, a parallel algorithm for the two-processor scheduling problem is presented, which runs in polylog time on a polynomial number of processors, with an algorithm to find transitive orientations of graphs where they exist.
Abstract: Applications of Parallel Scheduling Algorithms to Families of Perfect Graphs. We combine a parallel algorithm for the two processor scheduling problem, which runs in polylog time on a polynomial number of processors, with an algorithm to find transitive orientations of graphs where they exist. Both algorithms together solve the maximum clique problem and the minimum coloring problem for comparability graphs, and the maximum matching problem for co-comparability graphs. The transitive orientation algorithm can also be used to identify permutation graphs, another important subclass of perfect graphs.
01 Nov 1990
TL;DR: It is proved that the all pairs shortest path problem can be solved by the repeated “plus-min” algorithm for computing the closure of the distance matrix of the graph in O((n3/p)log log n) average time by p, 1 ≤ p ≤n3.
Abstract: We consider the all pairs shortest path problem in a directed complete graph with n vertices, whose edge distances are non-negative random variables on parallel computers. We prove that the all pairs shortest path problem can be solved by the repeated “plus-min” algorithm for computing the closure of the distance matrix of the graph in O((n3/p)log log n) average time by p, 1 ≤ p ≤n3, processors on an SIMD-SM-RW computer for the graph whose edge distances are independent random variables drawn from [0, +∞] according to an arbitrary identical probability distribution.
TL;DR: In this paper, the authors determined numerically the probability distribution for the longest self-avoiding path length connecting two distant points on a diluted hierarchical lattice at the percolation threshold.
Abstract: We determine numerically the probability distribution for the longest self-avoiding path lengths connecting two distant points on a diluted hierarchical lattice at the percolation threshold. The evolution of this distribution with the system size is studied and the distribution is observed to approach a universal scale-invariant form under proper rescaling of its argument. The longest path length scales as |Δp
ζmax| and our estimate for ζmax=1.816±0.013 is clearly different from the previously estimated ζmin=1.531+0.002 for the shortest path lengths on the same hierarchical lattice. This gives support to the multifractal behavior of SAWs on percolating clusters.
Journal Article•
TL;DR: It is shown that when additional variable bounds are imposed, the network structure remains exploitable and the elegant closed-form solution derived by Berck and Bible is precisely a readily obtained longest path solution.
Abstract: Berck and Bible (1984) have suggested a solution approach for harvest scheduling problems based on the Dantzig-Wolfe (1960) decomposition algorithm. We first expose the fact that the area constraints in their problem possess a network structure, requiring the solution of a single longest path problem, and show that the elegant closed-form solution derived by Berck and Bible is precisely a readily obtained longest path solution. Moreover, we show that when additional variable bounds are imposed, the network structure remains exploitable (...)
TL;DR: In this paper, a vectorized computer code is developed for the enumeration of walks through the matrix power method for directed graphs, which can be used to enumerate self-avoiding walks on some graphs.
Abstract: A vectorized computer code is developed for the enumeration of walks through the matrix power method for directed graphs. Application of this code to several graphs is considered. It is shown that the coefficients in the generating functions for signed graphs are much smaller in magnitude. It is shown that self-avoiding walks on some graphs can be enumerated as a linear combination of walk GFs of directed paths and rooted-directed paths.
20 Jun 1990
TL;DR: Techniques which exhibit optimal processor-time tradeoff for many important problems on sparse graphs, including maximal coloring and maximal independent set in trees and bounded degree graphs and maximum independent set, maximum matching and Hamiltonian path on rectangular grid graphs are presented.
Abstract: We present here techniques which exhibit optimal processor-time tradeoff for many important problems on sparse graphs. These problems include: maximal coloring and maximal independent set in trees and bounded degree graphs; 7-colorability, maximal independent set and maximal matching in planar graphs; maximum independent set, maximum matching and Hamiltonian path on rectangular grid graphs. Our techniques are based on the general list ranking problem: given k lists having a total of n elements, find for each element the membership relation and the rank of the element in its list. We solve this problem in O(log n) time with n/log n processors on an EREW PRAM. For trees and bounded degree graphs our methods need O(log n) time and n/log n processors on an EREW PRAM. For planar graphs they need O(log2n) time and n/log2n processors on an EREW PRAM using linear space. For the case of rectangular grid graphs they need O(log n) time with n/log n processors on a CRCW PRAM, or on an EREW PRAM (if the embedding is given).
TL;DR: The vertices of the graph can be laid out on a line so that each path is stretched no more than its bound and the problem is solvable in polynomial time for fixed bounds and path lengths.
01 Apr 1990
TL;DR: In this paper, the use of a Boltzmann machine to search for the shortest path in a directed graph (digraph) whose edge weights are equal is discussed, and an example application of the proposed method employing a 10-node digraph is demonstrated.
Abstract: The use of a Boltzmann machine to search for the shortest path in a directed graph (digraph) whose edge weights are equal is discussed. The adjacency matrix of the digraph is employed in the Boltzmann machine topology such that each entry in the adjacency matrix corresponds to a computation node of the Boltzmann machine. The quadratic performance function, for which the Boltzmann machine finds minima, is defined using the syntactic constraints that a path specification has to satisfy. An example application of the proposed method employing a 10-node digraph is demonstrated. >
03 Jul 1990
TL;DR: The author shows that for a fixed sequence of vertices, a linear time algorithm solves the problem of choosing the edge costs to satisfy the vertex cost constraints along the path.
Abstract: Consider a graph with a range of costs associated with each vertex and each edge of the graph. The author studies paths in such graphs where the cost of each edge of the path must be chosen within the range of costs for that edge and the sum of the chosen costs of the edges from the start of the path to any vertex in the path must belong to the range of allowable costs for that vertex. He shows that for a fixed sequence of vertices, a linear time algorithm solves the problem of choosing the edge costs to satisfy the vertex cost constraints along the path. The problem of deciding if such a path exists from a given vertex to another specified vertex (without specifying the intermediate vertices on the path) is NP-complete. The problem of finding a tour of the vertices satisfying the cost constraints is also shown to be NP-complete. The study of these graphs is motivated by problems concerned with the routing of a robot vehicle with upper and lower speed limits and timing constraints for reaching each workcell. >
01 Jan 1990
TL;DR: This dissertation generalizes the tour partitioning heuristic to the multi-depot case of capacitated vehicle routing and discusses the vehicle routing problem with constraints on the total distance traveled by each vehicle.
Abstract: The problem of finding disjoint paths in a network arises in routing "non-interfering" messages through communication networks. In this document, we first consider the problem of finding disjoint paths between two given points in a network such that some objective function is minimized. This includes minimizing the length of the longest path and minimizing the sum of the cost of the paths. The disjoint path problem with non-uniform cost structure is also considered.
We next discuss two problems which are related to the disjoint path problem, namely, the point-to-point delivery and point-to-point connection problems. A point-to-point delivery network is a network containing terminal vertices and distribution centers. All traffic originates at and is destined for terminal vertices, while distribution centers are vertices for intermediate transshipment. The objective is to use trucks to ship one item of a single good from each source vertex, and to have one item reach each destination vertex, so as to minimize the total transportation cost, subject to a constraint on truck capacity. The point-to-point connection problem is to find a minimum cost arc subset containing paths connecting each source-destination pair. This connection problem is closely related to the point-to-point delivery problem with large truck capacities.
The capacitated vehicle routing problem is a basic model in vehicle routing. In this problem, a set of customers has to be served by a fleet of identical vehicles each of which has a limited capacity and is initially located at a given depot. A well known heuristic for the single-depot capacitated vehicle routing problem is the tour partitioning heuristic which is based on partitioning a traveling salesman tour through all the customers. In this dissertation, we generalize the tour partitioning heuristic to the multi-depot case. We also discuss the vehicle routing problem with constraints on the total distance traveled by each vehicle.
The approach we use to analyze these problems is a combinatorial approach, which includes computational complexity analysis and worst-case analysis.
Proceedings Article•
01 Jan 1990
TL;DR: ..................................................................i Executive summary .............................................................................................................. iii Sommaire..............................................................................................................................iv Table of
Abstract: ..................................................................................................................................i Executive summary .............................................................................................................. iii Sommaire..............................................................................................................................iv Table of
TL;DR: It is proved that any simple graph G with d(G) = 3 has a [2,0] path partition and that anysimple graph with d (G)= 4 has a[2, l] path partitions, where d( G) is the maximum degree in the graph G, and efficient sequential and parallel algorithms are presented.
01 Jan 1990
TL;DR: It is shown that on an acyclic graph, determining K ≥ 2 node disjoint paths between the first node 1 and the last node n such that the length of the shortest path among the K paths is maximized is also NP-Complete.
Abstract: Proof: The decision version of PS-K is defined on the same acyclic graph G(N,A) as for PS-1. Given a solution for which the answer is yes, its correctness can be verified in polynomial time; therefore, the problem belongs to NP. Li et al. (1990) introduced several versions of the Min Max Disjoint Path problem on a graph. One such version is: Given a directed graph G(N,A) with non-negative, integer arc lengths ci,j for each arc (i, j)∈A, determine K node disjoint paths between source node s and destination node t such that the length of the longest path is minimized. If G(N,A) allows cycles, this problem is strongly NP-Complete for K ≥ 2 (Li et al. 1990). If G(N,A) is acyclic, the problem is still NP-Complete for K ≥ 2, but a pseudo-polynomial algorithm exits. It therefore follows that on an acyclic graph, determining K ≥ 2 node disjoint paths between the first node 1 and the last node n such that the length of the shortest path among the K paths is maximized is also NP-Complete. We refer to this problem as MaxMinD-K. Given a threshold length T , the decision version of MaxMinD-K is: Do there exist K node disjoint paths in G(N,A) from node 1 to node n such that the length of the shortest path among the K paths is at least T? We now proceed to show that the decision version of MaxMinD-K reduces to an instance of the decision version of PS-K. Any acyclic graph G(N1,A1) on which MaxMinD-K is defined can be