shortest-path

I would like to know if there is an algorithm for finding the shortest sequence of nodes though a graph from its a head node to the tail node. The graph branches out from the head node and is arbitrarily complex and converges at the tail node. All connections between nodes are unweighted. I'm considering tackling this problem taking exploratory steps from the head and tail nodes and until the nodes from either end of the graph touch etc, but I'd like to know if a "better wheel" exists before I (re)invent one. Use breadth first search , which runs in O(E+V). It's the fastest you'll get on an

We are given a weighed graph G and its Shortest path distance's matrix delta. So that delta(i,j) denotes the weight of shortest path from i to j (i and j are two vertexes of the graph). delta is initially given containing the value of the shortest paths. Suddenly weight of edge E is decreased from W to W'. How to update delta(i,j) in O(n^2)? (n=number of vertexes of graph) The problem is NOT computing all-pair shortest paths again which has the best O(n^3) complexity. the problem is UPDATING delta, so that we won't need to re-compute all-pair shortest paths. More clarified : All we have is a

I am applying the all-pairs shortest path algorithm ( Floyd-Warshall ) to this directed graph: The graph is represented by its adjacency matrix. The simple code looks like this: public class ShortestPath { public static void main(String[] args) { int x = Integer.MAX_VALUE; int [][] adj= { {0, 6, x, 6, 7}, {x, 0, 5, x, x}, {x, x, 0, 9, 3}, {x, x, 9, 0, 7}, {x, 4, x, x, 0}}; int [][] D = adj; for (int k=0; k<5; k++){ for (int i=0; i<5; i++){ for (int j=0; j<5; j++){ if(D[i][k] != x && D[k][j] != x && D[i][k]+D[k][j] < D[i][j]){ D[i][j] = D[i][k]+D[k][j]; } } } } //Print out the paths for (int r

I know that R is statistical pkg, but probably there is library to work with graphs and find shortest path btw 2 nodes. PS actually, I've found igraph and e1071, which one is better? Thank you Sure, there's a Task View that gathers a fair number of the graph-related Packages. (The page linked to is a CRAN portal, which uses iframes, so i can't directly link to the Graph Task View. So from the page linked to here, click on Task Views near the top of the LHS column, then click on the Task View gR , near the bottom of the list. Among the Packages there, igraph , for instance, has graph-theoretic

Even though I'm still a beginner, I love solving graph related problems (shortest path, searches, etc). Recently I faced a problem like this : Given a non-directed, weighted (no negative values) graph with N nodes and E edges (a maximum of 1 edge between two nodes, an edge can only be placed between two different nodes) and a list of X nodes that you must visit, find the shortest path that starts from node 0, visits all X nodes and returns to node 0. There's always at least one path connecting any two nodes. Limits are 1 <= N <= 40 000 / 1 <= X <= 15 / 1 <= E <= 50 000 Here's an example : The

Okay, first of all I know Dijkstra does not work for negative weights and we can use Bellman-ford instead of it. But in a problem I was given it states that all the edges have weights from 0 to 1 (0 and 1 are not included). And the cost of the path is actually the product. So what I was thinking is just take the log. Now all the edges are negative. Now I know Dijkstra won't work for negative weights but in this case all the edges are negative so can't we do something so that Dijkstra would work. I though of multiplying all the weights by -1 but then the shortest path becomes the longest path.

I have a directed graph, that looks like this: I want to find the cheapest path from Start to End where the orange dotted lines are all required for the path to be valid. The natural shortest path would be: Start -> A -> B -> End with the resultant cost = 5, but we have not met all required edge visits. The path I want to find (via a general solution) is Start -> A -> B -> C -> D -> B -> End where the cost = 7 and we have met all required edge visits. Does anyone have any thoughts on how to require such edge traversals? Let R be the set of required edges and F = | R |. Let G be the input graph