Bellman–Ford algorithm Puns

Relaxing the edges from node 0 to V and using DP should give us the shortest path to each edge. I know BF covers negative cycles, but why exactly do we have to iterate V-1 times to figure out the shortest path and if a negative cycle exists or not? Can someone please explain BF a bit more clearly?

My professor has asked me to figure out a pseudocode that uses the technique used in Bellman-ford algorithm and find the all pairs shortest paths. The graph contains negative edges and is a directed and weighted graph.

My professor follows the CLRS book and I did read it and found that if you run a single source shortest path algo like the bellman-ford algo V times like for all the vertices, this will find the all pairs shortest path.

Should the pseudocode be like this?

Mod-Bellman-Ford(G,w,s)

Initialise-Single-Source(G,s)

For each vertex v that belongs to V

For i=1 to |G.V|-1

For each edge (u,v) that belongs to G.E

Relax(u,v,w)

For each edge (u,v) that belongs to G.E

If v.d > u.d + w(u,v)

Return False

Return True

Can anybody help me with this? :( i don't know if its correct or not. Just want to verify whether its correct or completely wrong.

So, I've been taught in my class that the Bellman Ford algorithm has a time complexity of O(|v*e|) where v is the number of vertices of a graph and e is the number of edges. Although that time complexity is particularly for a directed weighted graph with a potential cycle, and a negative one at that. So I'm wondering what would the time complexity of the Bellman Ford algorithm be for a weighted directed graph with no cycles? I looked it up, and apparently it is O(|v|+|e|), or linear time. Is this true?

Update: no it's not.

After reading up on them I am still a bit comfused

In example from CLSR pg 652, we are getting -2 at the z node, so it must return FALSE as there is negative cycle is present. But it says it will return TRUE.

https://imgur.com/a/SFJn8

As above has anyone heard of so called Bellman's algorithm or recognise the description? I was taking a look through an old course book and came across it. It's a shortest path algorithm whose key benefit was in detecting negative length cycles. Only thing is I can't find any reference to it online. Does anyone have much info on what another name for this algorithm is?

https://preview.redd.it/zfworimwkxr11.jpg?width=2610&format=pjpg&auto=webp&s=4c6a227caf648aec1388ea7e6917bcf65185cbd5

https://imgur.com/a/USLJs

I didn't know where else to post this question so i posted here.

If you look at the first row in the table it says that d(w) is 0, but in the second row it says that d(w) is 2. I'm having a hard time understanding as to why is d(w) = 0 in the first line and 2 in the second? And also when in the real world would someone use a bellman-ford algorithm?

I am watching a video on coursera and the following case was stated to be obvious by contradiction.

Let G = (V,E) be a directed graph with edge lengths C(e) and source vertex s. For every v in set V and i less than |v| let P = shortest s-v path with at most i edges.

Case 1: If P has <= (i - 1) edges, it is a shortest s-v path with <= (i - 1) edges.

My attempt at proof by contradiction is:

Suppose P is a shortest S-V path and has greater than (i-1) edges. Then P is a shortest path with >(i-1) and <=(i-1) edges. It cannot be the case that P has both >(i-1) and <=(i-1) edges, and so P must have <=(i-1) edges. This seems kind of silly to me.

I understand how to implement A*, but I don't understand the theory behind it, and I don't understand these two algorithms at all

I'm trying to code a program for a class that simulates a router and so far I have the basics set up ("router" can send and receive packets through an emulated server to other "routers" connected to the server). Each packet contains only the distance vector for that router. When a router receives a packet it is supposed to update it's own distance vector accordingly using the bellman-ford algorithm. The problem i'm having is that I am finding myself unable to implement the actual algorithm without cheating and using an adjacency matrix.

For example, say I have 3 routers connected as follows:

A ---1--- B ---2--- C

That is, A and B are connected with a link cost of 1, and B and C are connected with a link cost of 2. So when the routers are all started, they will send a packet to each of their directly connected neighbors containing their distance vector info. So A would send router B (0, 1, INF), B would send A and C (1, 0, 2) and C would send B (INF, 2, 0) where INF means the 2 routers are not directly connected.

So lets look at router A receiving a packet from router B. To calculate the minimum costs to each other router using the Bellman-Ford algorithm is as follows.

Mincost(a,b) = min((cost(a,b) + distance(b,b)),(cost(a,c) + distance(c,b))

Mincost(a,c) = min((cost(a,b) + distance(b,c)),(cost(a,c) + distance(c,c))

So the problem I am running into is that I cannot for the life of me figure out how to implement an algorithm that will calculate the minimum path for a router to every other router. It's easy enough to make one if you know exactly how many routers there are going to be but how would you do it when the number of routers can be arbitrarily big?

I understand what they are for, and I even implemented Dijkstra's in some code a while back, but I am having a hard time wrapping my head around the Bellman-Ford Algorithm. Is there a heuristic to understand it?

Topic: Reinforcement Learning Math Discussion

Meeting Recording:

https://us02web.zoom.us/rec/share/xcdlLPLzrmxLfNbNuFHud4UtFaTVeaa823IYr6dYzUw-uzo3Q0gjSQwweD9oLgzf

I did Bellman-Ford for Gold #2 because it seemed pretty obvious. However, I ended up doing N-1 relaxations which were unnecessary after thinking about it after the contest was over. Then, I realized that you only need K-1 relaxations. Is this approach correct?

K < 50

N < 50000

With these numbers, doing K-1 relaxations seems to be 1000x faster than N-1 relaxations which seems like a great optimization. I only got test cases 1, 2, 3, 5 with the N-1 relaxations method. Will I get all the test cases with K-1 relaxations? The thing about relaxations in Bellman-Ford is, is that if you go over the optimal number of relaxations, you'll still get the correct answer, but slower so I could technically set the for loop to go to a max of 50 relaxations which is still pretty fast.

If you want to test your Bellman-Ford algorithm and want to know what the expected output is for each file:

https://preview.redd.it/zb8qc5ydgiz31.png?width=1568&format=png&auto=webp&s=6545e0d5509b882bffb8aa438b3dac1452c972ad

https://preview.redd.it/6hp8m80ggiz31.png?width=1590&format=png&auto=webp&s=281b86bd359e82c07101884f0903cdeca34f81ba

https://preview.redd.it/h3yis0dhgiz31.png?width=1528&format=png&auto=webp&s=9d3b26fa7c82975aa12ef68b50120fb6e6333d09

https://preview.redd.it/d4ke8vsigiz31.png?width=1553&format=png&auto=webp&s=8bd4479a0c11ed610c755e10442b62e7a5901bc8

I might make more testers later on (if I have time) and I'll post them here too

Min åsikt är att alla som säger ”en Bellman” bör tvångsomhändertas av Svenska Akademien.

Diskutera i grupp och återkom.

EDIT: Nationaliteter diskuterar vi imorgon.

i cant be the only one.

I cannot find an easily consumable explanation of the process here, and how it manages to run faster than N! time for traveling sales person problem for a Hamiltonian cycle where shortest path S(s,v) where S is the start vertex and v is the destination vertex. But s=v

Starts and finishes at same vertex

Hello all,

I try to wrap my head around a extended version of the Bellman Ford shortest path algorithm. In k iterations the standard Bellman Ford algorithm can produce shortest path using more than k edges.

Here is a fairly naive idea that uses k-iterations of the standard algorithm:

• In the i-th iteration only nodes that are not more than i edges away from the starting node, will be considered. Eg: In the first iteration only the nodes that are adjacent to the starting node, in the second iteration the nodes above plus the nodes that are adjacent to the prior.
• Edge relaxation is only allowed when the resulting path does not use more edges.

This should be easy to implement. Do you think this will work, or are there any flaws that I have overseen?