Search

For going to do good science research, it must use mathematical tools. However, almost all branch of mathematics, cannot leave the greatest common factor and Euclidean algorithm. Euclidean algorithm is the most basic and the most important role. If there is no Euclidean algorithm, almost every branch of mathematics is not in-depth research. In this paper, we introduce the Euclidean algorithm, as well as the method of Euclidean algorithm is used to determine the greatest common factor of natural numbers.

In the automated storage and retrieval system (AS/RS), a reasonable path-planning is fundamental for the effective work of AGV. For the rectangular environment map of the AS/RS system, the traditional Dijkstra algorithm can only find one shortest path, and skip over other paths with the same distance. An improved Dijkstra algorithm is proposed to solve the path-planning problem in the rectangular environment, which can find all equidistant shortest paths. The optimal path with both the shortest distance and time is obtained by adding running time to the path-planning evaluation. The algorithm is programmed using Visual C++, and the simulation results show that the algorithm is effective and feasible for path-planning in the AS/RS system.

One of the key algorithm research areas for unpiloted aerial vehicles team cooperative control is solution of network optimization models. Computational speed is an important success criterion as much of the cooperative work is done in real time. In this paper a neural network (NN) approach to solving the shortest path problem in the context of cooperative control problems will be introduced. We prove the optimality of our approach mathematically. Computational time will be used as a comparison and it will be shown that significant time savings result from the NN approach.

Many applications like transportation and communication network use shortest path algorithm to find out the shortest path between two or more nodes. In the Single source shortest path algorithm, a shortest path is calculated from one node to another node. In this paper, I have compared the results of the shortest path algorithms (Dijkstra, Bellman Ford) on the basis of running time. I used C# programming language to compare the algorithms. I compared the algorithms on the basis of complexity and space. I also tried to give some advantages and disadvantages of both the algorithms. Keywords— Shortest Path, Dijkstra, Bellman Ford, Run-time Analysis -----------------------------------------------------------------------***

This article showed how numerical experiments conducted on small to large networks compare the robust optimization-based strategy to the classical deterministic shortest path in terms of the uncertainty. A robust optimization approach for the shortest path problem where travel cost is uncertain and exact information on the distribution function is unavailable is developed. The article showed that under such conditions the robust shortest path problem can be formulated as a binary nonlinear integer program, which can then be reformulated as a mixed integer conic quadratic program. This article presented an outer approximation algorithm as a solution algorithm, which is shown to be highly efficient for this class of programs.

For the class of shortest path games, we propose a family of new cost sharing rules satisfying core selection. These rules allocate shares according to some lexicographic preference relation. A computational procedure is provided. Our results relate to those of Tijs et al. (2011).

In the Switching Tower of Hanoi interpretation of Sierpinski graphs S p n , the P2 decision problem is to find out whether the largest moving disc has to be transferred once or twice in a shortest path between two given states/vertices. We construct an essentially optimal algorithm thus extending Romik’s approach for p = 3 to the general case. The algorithm makes use of three automata and the underlying theory includes a simple argument for the fact that there are at most two shortest paths between any two vertices. The total number of pairs leading to non-unique solutions is determined and employing a Markov chain argument it is shown that the number of input pairs needed for the decision is bounded above by a number independent of n . Elementary algorithms for the length of the shortest path(s) and the best first move/edge are also presented.

Many cognitive studies have indicated that the path simplicity may be as important as its distance travelled. However, the optimality of paths for current navigation system is often judged purely on the distance travelled or time cost, and not the path simplicity. To balance these factors, this paper presented an algorithm to compute a path that not only possesses fewest turns but also is as short as possible by utilizing the breadth-first-search strategy. The proposed algorithm started searching from a starting point, and expanded layer by layer through searching zero-level reachable points until the endpoint is found, and then deleted unnecessary points in the reverse direction. The forward searching and backward cleaning strategies were presented to build a hierarchical graph of zero-level reachable points, and form a fewest-turn-path graph (G*). After that, a classic Dijkstra shortest path algorithm was executed on the G* to obtain a fewest-turn-and-shortest path. Comparing with the shortest path in B...

The Max-Cut Problem is considered in an undirected graph whose vertices are points of a q-dimensional Euclidean space. The two cases are investigated, where the weights of the edges are equal to (i) the Euclidean distances between the points and (ii) the squares of these distances. It is proved that in both cases the problem is NP-hard in the strong sense. It is also shown that under the assumption P≠=NP there is no fully polynomial time approximation scheme (FPTAS).

Inverse Combinatorial Optimization has become a relevant research subject over the past decades. In graph theory, the Inverse Shortest Path Length problem becomes relevant when people don't have access to the real cost of the arcs and want to infer their value so that the system has a specific outcome, such as one or more shortest paths between nodes. Several approaches have been proposed to tackle this problem, relying on different methods, and several applications have been suggested. This study explores an innovative evolutionary approach relying on a genetic algorithm. Two scenarios and corresponding representations are presented and experiments are conducted to test how they react to different graph characteristics and parameters. Their behaviour and differences are thoroughly discussed. The outcome supports that evolutionary algorithms may be a viable venue to tackle Inverse Shortest Path problems.

The shortest covering path (SCP) problem involves finding the shortest path between an origin node and a destination node, where the path traverses the network and passes within a maximal covering distance of all nodes of the network. This problem was originally proposed by Current, ReVelle, and Cohon. Since that time researchers have proposed both heuristic and optimal approaches for this problem as well as have developed more general forms, including the maximal covering shortest path problem. From the outset, it has been assumed that any optimal covering path would never loop or double back on itself. This assumption is examined in detail. We demonstrate that this assumption can lead to longer than necessary covering paths. We also present a new, more general construct, which can be used to generate optimal SCPs and demonstrate its use on an example problem.

Let s and t be two points on the boundary of a simple polygon, how to compute the Euclidean shortest path between s and t which visits a sequence of segments given in the simple polygon is the problem to be discussed, especially, the situation of the adjacent segments intersect is the focus of our study. In this paper, we first analyze the degeneration applying rubber-band algorithm to solve the problem. Then based on rubber-band algorithm, we present an improved algorithm which can solve the degeneration by the method of crossing over two segments to deal with intersection and in our algorithm the adjacent segments order can be changed when they intersect. Particularly, we have implemented the algorithm and have applied a large of test data to test it. The experiments demonstrate that our algorithm is correct and efficient, and it has the same time complexity as the rubber-band algorithm.

The robust shortest path problem is a network optimization problem that can be defined to deal with uncertainty of costs associated with the arcs of a network. Two models have been considered for the robust shortest path problem: interval data and discrete data sets. This work addresses the robust shortest path problem with a minmax regret objective function on a finite multi-scenario model. This problem consists in finding an optimal path in the sense that it has the minimum maximum deviation from the shortest one over all scenarios. With this goal some properties of the problem and of its optimal solutions are derived. These results allow to introduce three approaches, a labeling algorithm, an algorithm based on ranking loopless paths, and a hybrid algorithm which ranks loopless paths in a suitable way to apply the early elimination of useless solutions. The algorithms are tested on random networks and compared with a previous method for the same problem. The obtained computational results are reported and discussed. They show that the labeling and the hybrid approaches outperform the others.

Let S be a subdivision of the plane into polygonal regions, where each region has an associated positive weight. The weighted region shortest path problem is to determine a shortest path in S between two points s , t ∈ R 2 , where the distances are measured according to the weighted Euclidean metric—the length of a path is defined to be the weighted sum of (Euclidean) lengths of the sub-paths within each region. We show that this problem cannot be solved in the Algebraic Computation Model over the Rational Numbers ( ACM Q ). In the ACM Q , one can compute exactly any number that can be obtained from the rationals Q by applying a finite number of operations from +, −, ×, ÷, ⋅ k , for any integer k ⩾ 2 . Our proof uses Galois theory and is based on Bajaj's technique.

This paper proposes the optimal shortest path set problem in an undirected graph $$G=(V,E)$$ G = ( V , E ) , in which some vehicles have to go from a source node $$s$$ s to a destination node $$t$$ t . However, at most $$k$$ k edges in the graph may be blocked during the traveling. The goal is to find a minimum collection of paths for the vehicles before they start off to assure the fastest arrival of at least one vehicle, no matter which $$l$$ l $$(0\le l\le k)$$ ( 0 ≤ l ≤ k ) edges are blocked. We consider two scenarios for this problem. In the first scenario with $$k=1$$ k = 1 , we propose the concept of common replacement path and design the Least-Overlap Algorithm to find the common replacement path. Based on this, an algorithm to compute the optimal shortest path set is presented and its time complexity is proved to be $$O(n^2)$$ O ( n 2 ) . In the second scenario with $$k>1$$ k > 1 , we consider the case where the blocked edges are consecutive ones on a shortest path from $$s$$ s to $$t$$ t and the vertices connecting two blocked edges are also blocked (i.e., routes passing through these vertices are not allowed), and an algorithm is presented to compute the optimal shortest path set in this scenario with time complexity $$O(mn+k^2n^2\log n)$$ O ( m n + k 2 n 2 log n ) .

Algorithms for finding shortest paths and their numerous variants have been studied extensively over several decades in graph theory, computational geometry, and in operations research. Still, design of such algorithms poses newer challenges in various emerging areas of image analysis and computer vision. This mandates further investigation of application-specific shortest-path problems in the framework of digital geometry. We present here an efficient combinatorial algorithm for finding a shortest isothetic path (SIP) between two grid points in a digital object without any hole, such that the SIP lies entirely inside the object. Our algorithm first determines a maximum-area isothetic polygon that is inscribed within the object. Certain combinatorial rules are then used to construct the SIP on the basis of its constituent monotone sub-paths, the number of which is invariant regardless of the choice of SIP between two given grid points. For a given grid size, the proposed algorithm runs in O(nlogn)$O(n\log n)$ time, where n is the number of grid points appearing on the boundary of the inscribed polygon. Experimental results show the effectiveness of the algorithm and its further prospects in shape analysis.

Shortest path is a fundamental graph problem with numerous applications. However, the concept of classic shortest path is insufficient or even flawed in a temporal graph, as the temporal information determines the order of activities along any path. In this paper, we show the shortcomings of classic shortest path in a temporal graph, and study various concepts of "shortest" path for temporal graphs. Computing these temporal paths is challenging as subpaths of a "shortest" path may not be "shortest" in a temporal graph. We investigate properties of the temporal paths and propose efficient algorithms to compute them. We tested our algorithms on real world temporal graphs to verify their efficiency, and also show that temporal paths are essential for studying temporal graphs by comparing shortest paths in normal static graphs.

The weight constrained shortest path problem with replenishment (WCSPP-R) generalizes the constrained shortest path problem (CSP) and has multiple applications in transportation, scheduling, and telecommunications. We present an exact algorithm based on a recursive depth-first search that combines and extends ideas proposed in state-of-the-art algorithms for the CSP and the WCSPP-R. The novelty lies in a set of acceleration strategies that significantly improves the algorithm’s performance. We conducted experiments over large real-road networks with up to 6 million nodes and 15 million arcs, achieving speedups of up to 219 times against the state-of-the-art algorithm.

A constant-work-space algorithm has read-only access to an input array and may use only O(1) additional words of bits, where n is the input size. We show how to triangulate a plane straight-line graph with n vertices in O(n2) time and constant work-space. We also consider the problem of preprocessing a simple polygon P for shortest path queries, where P is given by the ordered sequence of its n vertices. For this, we relax the space constraint to allow s words of work-space. After quadratic preprocessing, the shortest path between any two points inside P can be found in O(n2/s) time. Keywords: Space–time trade-off; Constant workspace; Triangulation; Shortest path; Simple polygon Tetsuo Asano, Kevin Buchin, Maike Buchin, Matias Korman, Wolfgang Mulzer, Günter Rote, André Schulz Memory-constrained algorithms for simple polygons Computational Geometry, Volume 46, Issue 8, October 2013, Pages 959-969 http://dx.doi.org/10.1016/j.comgeo.2013.04.005

In Euclidean and/or λ-geometry planes with obstacles, the shortest path problem involves determining the shortest path between a source and a destination. There are three different approaches to solve this problem in the Euclidean plane: roadmaps, cell decomposition, and potential field. In the roadmaps approach, a visibility graph is considered to be one of the most widely used methods. In this paper, we present a novel method based on the concepts of Delaunay triangulation, an improved Dijkstra algorithm and the Fermat points to construct a reduced visibility graph that can obtain the near-shortest path in a very short amount of computational time. The length of path obtained using our algorithm is the shortest in comparison to the other fastest algorithms with O(n log n) time complexity. The proposed fast algorithm is especially suitable for those applications which require determining the shortest connectivity between points in the Euclidean plane, such as the robot arm path planning and motion planning for a vehicle.

We consider the variant of the shortest path problem in which a given set of paths is forbidden to occur as a subpath in an optimal path. We establish that the most-efficient algorithm for its solution, a dynamic programming algorithm, has polynomial time complexity; it had previously been conjectured that the algorithm has pseudo-polynomial time complexity. Furthermore, we show that this algorithm can be extended, without increasing its time complexity, to handle non elementary forbidden paths. © 2014 Wiley Periodicals, Inc. NETWORKS, Vol. 633, 239-242 2014

In this paper, how to calibrate a fixed multi-camera system and simultaneously achieve a Euclidean reconstruction from a set of segments is addressed. It is well known that only a projective reconstruction could be achieved without any prior information. Here, the known segment lengths are exploited to upgrade the projective reconstruction to a Euclidean reconstruction and simultaneously calibrate the intrinsic and extrinsic camera parameters. At first, a DLT(Direct Linear Transformation)-like algorithm for the Euclidean upgrading from segment lengths is derived in a very simple way. Although the intermediate results in the DLT-like algorithm are essentially equivalent to the quadric of segments (QoS), the DLT-like algorithm is of higher accuracy than the existing linear algorithms derived from the QoS because of a more accurate way to extract the plane at infinity from the intermediate results. Then, to further improve the accuracy of Euclidean upgrading, two weighted DLT-like algorithms are presented by weighting the linear constraint equations in the original DLT-like algorithm. Finally, using the results of these linear algorithms as the initial values, a new weighted nonlinear algorithm for Euclidean upgrading is explored to recover the Euclidean structure more accurately. Extensive experimental results on both the synthetic data and the real image data demonstrate the effectiveness of our proposed algorithms in Euclidean upgrading and multi-camera calibration.

In this paper, we present a new algorithm of the time-dependent shortest path problem with time windows. Give a directed graph , where V is a set of nodes, E is a set of edges with a non-negative transit-time function . For each node , a time window within which the node may be visited and , is non-negative of the service and leaving time of the node. A source node s, a destination node d and a departure time t0, the time-dependent shortest path problem with time windows asks to find an s, d-path that leaves a source node s at a departure time t0; and minimizes the total arrival time at a destination node d. This formulation generalizes the classical shortest path problem in which ce are constants. Our algorithm of the time windows gave the generalization of the ALT algorithm and A* algorithm for the classical problem according to Goldberg and Harrelson [1], Dreyfus [2] and Hart et al. [3].

We present an approximation algorithm for the shortest descending path problem. Given a source $s$ and a destination $t$ on a terrain, a shortest descending path from $s$ to $t$ is a path of minimum Euclidean length on the terrain subject to the constraint that the height decreases monotonically as we traverse that path from $s$ to $t$. Given any $\varepsilon \in (0,1)$, our algorithm returns in $O(n^4\log (n/\varepsilon))$ time a descending path of length at most $1+\varepsilon$ times the optimum. This is the first algorithm whose running time is polynomial in $n$ and $\log(1/\varepsilon)$ and independent of the terrain geometry.

The shortest path problem is among the most fundamental combinatorial optimization problems to answer reach-ability queries. A single pair shortest path computation using Dijkstra’s algorithm requires few seconds on a very large social network. Many traversal algorithms imply precomputed information to speed up the runtime query process. However, computing eective auxiliary data in a reasonable time is still an active problem. It is hard to determine which vertices or edges are visited during shortest path traversals. In this paper, we provide an empirical analysis on how traversal algorithms behave on dierent real life networks. First, we compute the shortest paths between a set of vertices. Each shortest path is considered as one transaction. Second, we utilize the pattern mining approach to identify the frequency of occurrence of the vertices appear together. Further, we evaluate the results in terms of network properties, i.e. degree distribution, average shortest path, and clustering coecient, along with the visual analysis.

A sufficient condition of Euclidean rings is given by polynomial optimization. Then, through computation, we give all norm-Euclidean square number fields, four examples of norm-Euclidean cubic number fields and two examples of norm-Euclidean cyclotomic fields, with the absolute of a norm less than 1 over the corresponding box, respectively.

This paper describes a new algorithm for the stochastic shortest path problem where path costs are a weighted sum of expected cost and cost standard deviation. We allow correlation between link costs, subject to a regularity condition excluding unbounded solutions. The chief complication in this variant is that path costs are not an additive sum of link costs. In this paper, we reformulate this problem as a conic quadratic program, and develop an outer-approximation algorithm based on this formulation. Numerical experiments show that the outer-approximation algorithm significantly outperforms standard integer programming algorithms implemented in solvers.

In this paper, we study the following replacement paths problem for undirected graphs in case of edge or node failures.1.In the edge failure problem, for each edge e on a shortest s-t path in G, we are required to find a shortest s-t path in G-e. 2.In the node failure problem, for each node v on a shortest s-t path, we need to report a shortest s-t path in G-v. 3.In the detour critical problem, for each edge (u,v) on a shortest s-t path, we have to report a shortest u-t path in G-(u,v). If m is the number of edges and d is the distance between s and t, which in turn will be bounded by the diameter of the graph, the proposed algorithm for all these problems takes O(m+d^2) time, for graphs with integer weights (on the RAM model) and on planar graphs. For typically dense graphs, or graphs with small diameter (formally, when d=O(m)), the algorithms take linear time.

In this paper, we study the shortest path tour problem in which a shortest path from a given origin node to a given destination node must be found in a directed graph with non-negative arc lengths. Such path needs to across a sequence of node subsets that are given in a fixed order. The subsets are disjoint and may be different-sized. A polynomial reduction of the problem to a classical shortest path problem over a modified digraph is described and two solution approaches based on the above reduction and Dynamic Programming, respectively, are proposed and compared with the state-of-the-art solving procedure. The proposed approaches are tested on existing datasets for this problem and on a large class of new benchmark instances. The computational experience shows that both the proposed approaches exhibit a consistent improved performance in terms of computational time with respect to the existing solving method.

The Shortest Path Reconfiguration problem has as input a graph G (with unit edge lengths) with vertices s and t, and two shortest st-paths P and Q. The question is whether there exists a sequence of shortest st-paths that starts with P and ends with Q, such that subsequent paths differ in only one vertex. This is called a rerouting sequence. This problem is shown to be PSPACE-complete. For claw-free graphs and chordal graphs, it is shown that the problem can be solved in polynomial time, and that shortest rerouting sequences have linear length. For these classes, it is also shown that deciding whether a rerouting sequence exists between all pairs of shortest st-paths can be done in polynomial time. Finally, a polynomial time algorithm for counting the number of isolated paths is given., Comment: The results on claw-free graphs, chordal graphs and isolated paths have been added in version 2 (april 2012). Version 1 (September 2010) only contained the PSPACE-hardness result. (Version 2 has been submitted.)

Given a set P of points in the plane, an Euclidean t-spanner for P is a geometric graph that preserves the Euclidean distances between every pair of points in P up to a constant factor t. The weight of a geometric graph refers to the total length of its edges. In this paper we show that the problem of deciding whether there exists an Euclidean t-spanner, for a given set of points in the plane, of weight at most w is NP-hard for every real constant t>1, both whether planarity of the t-spanner is required or not.

Given a set of n open rectangles that represent obstacles in the Euclidean plane, we consider the problem of finding a shortest rectilinear path between two given points such that each segment of the path has a certain minimum length. A rectilinear path consists of horizontal and vertical segments only and may not intersect with an obstacle. We show how to solve the resulting shortest path problem with minimum segment lengths in polynomial time by constructing an extended Hanan grid of the instance first, and then run an adapted shortest path algorithm to find a respective solution. While the extended Hanan grid as basic underlying structure can be stored in O(n^2) space, the approach yields an O(n^4logn) time and O(n^4) space algorithm. The problem at hand typically arises in the area of VLSI design, where rectilinear paths are utilized to create wiring interconnects. There, the lithographic production process dictates certain minimum run lengths for the wires in order to avoid infeasible patterns. Another application arises in robot motion planning when acceleration and breaking distances need to be obeyed.

For dual spaces, and also for L1, it is proved that every system of points in such a space admits a shortest network connecting the points. An example of a Banach space is presented in which, for every n ≥ 3, there is a system of n points which cannot be connected by a shortest network.

A Euclidean graph is a straight line embedding of a graph in the plane such that there is no crossing between any pair of edges and the length of an edge is the Euclidean distance between its two endpoints. A Euclidean chain C=(x"1,x"2,...,x"n) is a planar straight line graph with vertex set {x"1,x"2,...,x"n} and edge set {x"ix"i"+"1:1@?i@?n-1}. Given a Euclidean chain C in the plane, we study the problem of finding a pair of points on C such that the new Euclidean graph obtained from C by adding a straight line segment (called a shortcut) between this pair of points has the minimum diameter. We also study the ratio between the diameter of the new graph and the length of C. We give necessary and sufficient conditions for optimal shortcuts. We present an approximation algorithm for computing the optimal shortcuts of chains. In addition, we introduce two types of chains: a strongly monotonic chain and a simple chain. We provide properties for these two types of chains and their shortcuts.

We propose a new fast algorithm (E-JOB) for finding a global shortest path connecting two points while avoiding obstacles in a region by solving an initial value problem of ordinary differential equations under random perturbations. The idea is based on the fact that every shortest path possesses a simple geometric structure. This enables us to restrict the search in a set of feasible paths that share the same structure. The resulting search set is a union of sets of finite dimensional compact manifolds. Then, we use a gradient flow, based on an intermittent diffusion method in conjunction with the level set framework, to obtain global shortest paths by solving a system of randomly perturbed ordinary differential equations with initial conditions. Compared to the existing methods, such as combinatorial methods or partial differential equation methods, our algorithm seems to be faster and easier to implement. We can also handle cases in which obstacle shapes are arbitrary and/or the dimension of the base space is three or higher.

We consider a robust shortest path problem when the cost coefficient is the product of two uncertain factors. We first show that the robust problem can be solved in polynomial time by a dual-variable enumeration with shortest path problems as subproblems. We also propose a path enumeration approach using a K -shortest paths finding algorithm that may be efficient in many real cases. An application in hazardous materials transportation is discussed, and the solution methods are illustrated by numerical examples. © 2013 Wiley Periodicals, Inc. Naval Research Logistics, 2013

International audience; This paper considers a stochastic version of the shortest path problem, the Distributionally Robust Stochastic Shortest Path Problem(DRSSPP) on directed graphs. In this model, the arc costs are deterministic, while each arc has a random delay. The mean vector and the second-moment matrix of the uncertain data are assumed known, but the exact information of the distribution is unknown. A penalty occurs when the given delay constraint is not satisfied. The objective is to minimize the sum of the path cost and the expected path delay penalty. As it is NP-hard, we approximate the DRSSPP with a semidefinite programming (SDP for short) problem, which is solvable in polynomial time and provides tight lower bounds.

To model a driver's route choice behavior under inherent traffic system stochasticity and to further provide better route guidance with travel-time reliability guarantees, this paper examines two models to evaluate the travel-time robustness: absolute robust shortest path (ARSP) and α -percentile robust shortest path (PRSP) problems. A Lagrangian relaxation approach and a scenario-based representation scheme are integrated to reformulate the minimax and percentile criteria under day-dependent random travel times. The complex problem structure is decomposed into several subproblems that can be efficiently solved as standard shortest path problems or univariate linear programming problems. Large-scale numerical experiments with real-world data are provided to demonstrate the efficiency of the proposed algorithms.

C-FOREST is a parallelization framework for single-query sampling-based shortest path-planning algorithms. Multiple search trees are grown in parallel (e.g., 1 per CPU). Each time a better path is found, it is exchanged between trees so that all trees can benefit from its data. Specifically, the path's nodes increase the other trees' configuration space visibility, while the length of the path is used to prune irrelevant nodes and to avoid sampling from irrelevant portions of the configuration space. Experiments with a robotic team, a manipulator arm, and the alpha benchmark demonstrate that C-FOREST achieves significant superlinear speedup in practice for shortest path-planning problems (team and arm), but not for feasible path panning (alpha).

This paper addresses the elementary shortest path problem with forbidden paths. The main aim is to find the shortest paths from a single origin node to every other node of a directed graph, such that the solution does not contain any path belonging to a given set (i.e.; the forbidden set). It is imposed that no cycle can be included in the solution. The problem at hand is formulated as a particular instance of the shortest path problem with resource constraints and two different solution approaches are defined and implemented. One is a Branch & Bound based algorithm, the other is a dynamic programming approach. Different versions of the proposed solution strategies are developed and tested on a large set of test problems. © 2012 Elsevier B.V. All rights reserved.

By using object oriented method design graph vertices into class, and in this foundation to increase visual member, realize from the source point to the other vertex of the shortest path algorithm of dynamic visualization. Around the two sync window animation, the left window with thick lines drawn through the vertices and edges, " revealed the source point to the other vertex of the shortest path " list box display shortest path sequence and path length, the right window demonstration algorithm dynamic implementation process, and in the " S " text box to display the current most find shortest path vertices. The system has friendly interface, visual image.

Several algorithms exist to determine the shortest path in a network for the crisp case where the weights are real numbers. In the real world, these weights represent parameters like cost, packet arrival time, link capacity etc which are not naturally precise. To model the uncertainty involved, for the first time we use the Gaussian fuzzy numbers as weights and a method has been presented in this paper to determine the fuzzy shortest path. Gaussian membership functions are preferred over other membership functions (triangular and trapezoidal) that are easy to analyze because it is continuous and differentiable enabling efficient gradient based optimization and it is simpler to represent because it requires fewer parameters. The issue of performing fuzzy arithmetic operations to calculate the fuzzy shortest path length and the corresponding fuzzy shortest path in the network has been addressed and to tackle it the concept of decomposed fuzzy numbers has been used. Also, a greedy algorithm which is an extension of Dijkstra’s algorithm for fuzzy shortest path problem has been proposed.

In this paper, the shortest path problem with forbidden paths is addressed. The problem under consideration is formulated as a particular instance of the resource-constrained shortest path problem. Different versions of a dynamic programming-based solution approach are defined and implemented. The proposed algorithms can be viewed as an extension of the node selection approach proposed by Desrochers in 1988. An extensive computational test is carried out on a meaningful number of random instances with the purpose of assessing the behaviour of the developed solution approaches. A comparison with the state-of-the-art method proposed to address the problem under study is also made. The computational results are very encouraging and highlight that the proposed algorithms are very efficient. © 2013 Copyright Taylor and Francis Group, LLC.

This article addresses the problem of determining the shortest path that connects a given initial configuration (position, heading angle, and flight path angle) to a given rectilinear or a circular path in three-dimensional space for a constant speed and turn-rate constrained aerial vehicle. The final path is assumed to be located relatively far from the starting point. Due to its simplicity and low computational requirements the algorithm can be implemented on a fixed-wing type unmanned air vehicle in real time in missions where the final path may change dynamically. As wind has a very significant effect on the flight of small aerial vehicles, the method of optimal path planning is extended to meet the same objective in the presence of wind comparable to the speed of the aerial vehicles. But, if the path to be followed is closer to the initial point, an off-line method based on multiple shooting, in combination with a direct transcription technique, is used to obtain the optimal solution. Optimal paths are generated for a variety of cases to show the efficiency of the algorithm. Simulations are presented to demonstrate tracking results using a 6-degrees-of-freedom model of an unmanned air vehicle.

In this paper, we propose an algorithm for computing a shortest descending path from a start point s to a destination point t on an arbitrary convex terrain. Our algorithm requires O(nlogn) time and space, which is an improvement of the algorithm provided in S. Roy (2012) [3].

Computing the shortest path, overcoming obstacles in a plane, is a well-known geometric problem. However, widely assumed obstacles are polygonal in nature. Very few papers have focused on curved obstacles, and in particular, for curved multiply-connected domains (domains having holes). Given a set of parametric curves forming a multiply-connected domain (MCD), with one closed curve acting as an outer boundary and several non-intersecting inner curves (loops) as representing holes and two distinct points S and E lying on the outer boundary, this paper provides an algorithm to find the shortest interior path (SIP) between the two points in the domain. SIP consists of portions of curves along with straight line segments that are tangential to the curve. The algorithm initially computes point-curve tangents (PCTs) and bitangents (BTs) using their respective constraints. A generalized region lemma is proposed, which is then employed to remove PCTs/BTs that will not contribute to the potential path and subsequently aiding in removing a few inner loops. The algorithm is designed to explore all potential paths. Merging of paths is also proposed to avoid redundant computations. A final SIP is chosen from potential paths using the length of each path. The algorithm also has the potential to give all paths of equal lengths contributing to shortest paths (within a tolerance level). As the algorithm computes all the potential paths on the fly, there is no need to employ a visibility graph to compute the shortest path. Curves are represented using non-uniform rational B-splines (NURBS). The algorithm uses the curves as such and does not discretize into point-sets or polygons. Extensions to handle curves with C1 discontinuities and S and E not on the outer boundary have also been described. Results of the implementation are provided and complexity of the algorithm is also discussed. This paper follows up the one presented for simply-connected domains (SCDs) in Bharath Ram and Ramanathan (2011) [4]. � 2012 Elsevier Ltd. All rights reserved.