CODEWITHSUNDEEP
algorithmroutesdijkstra
Ben
Ben

Reputation: 1962

Dijkstra with parallel edges between two Vertices

I've got a routing problem where I need to retrieve the best n solutions between two points. I am using Dijkstra for the optimal solution and Yen Top K algorithm on top of that to get the n best solutions.

However there is a twist to it, you can have multiple parallel edges between to vertices. Lets imagine a bus network:

Line A: a -> b -> c -> d -> e
Line B: b -> c -> d -> e -> f
Line C: a -> b -> c -> g -> h

When you build your graph, how do you handle these parallel connections? I am thinking of building the graph like:

Line A: a->b,a->c,a->d a->e,b->c,b->d,b->d,b->e,c->d,c->e,d->e
Line B: b->c,b->d,b->e,e->f,c->d,c->e,c->f,d->e,d->f,e->f
Line C: a->b,a->c,a->g,a->h,b->c,b->g,b->h,c->g,c->h,g->h

With that I have direct edges for when I don't have to change bus. For each Vertex I go through I add a connection penalty weight.

So if I want to go from a->e I would probably get Line A as using Line C a->b, Line B b->e might be longer because of the connection time even if the time Line C a->b and Line B b->e might be faster than the route on Line A.

However I still need to handle parallel connections. So I guess I need to sort the parallel edges by weight.

Currently this is based on static timing information but at some point it should take actual schedule information into account. And depending on that your weights between two vertices could change. E.g. by the time you would get to point b the fastest connection via Line C wouldn't be the fastest anymore as you would have just missed Line C etc.

Are there any resources anywhere that explain how you would handle these more complex situations?

Upvotes: 2

Views: 1317

Answers (1)

amit
amit

Reputation: 178481

One approach could be to reduce the problem back to a simple graph (no parallel edges), by "splitting nodes"

That means, if you have a node u, with edges (v,u)_1, (v,u)_2, ..., (v,u)_k, you can split u to: u, u_1, u_2,...,u_k, with edges: (u_1,u), (u_2,u), ..., (u_k,u), (v,u_1), (v,u_2), ...., (v,u_k), and weights: w(u_i,u) = 0 for all i and w(v,u_i) = w((v,u)_i) for all i

Now you can run any algorithm designed for simple graph with ease, where the number of vertices is increased in a linear factor of the number of parallel edges.

Upvotes: 3

Related Questions