Given an edge weighted undirected graph and two vertices s and t, weights are non-negative.
Shortest Even Path Problem is to find an s,t-path P having an even number of edges whose total weight is as small as possible. How to reduce Shortest Even Path Problem to minimum weight perfect matching problem
Start with the given graph, imagine painting the nodes blue, and call it Gblue. It has nodes, including sblue and tblue, and undirected edges like ablue <-> bblue.
Make a copy of the graph, paint its nodes green and call it Ggreen.
Now reconnect all of the edges, so that ablue<->bblue and agreen<->bgreen (which have equal weights) become ablue<->bgreen and agreen<->bblue (which have the same weights).
In this combined graph, every edge is between a blue node and a green node, so every path alternates between blue and green. So every path from sblue that has a even number of steps, will end on a green node.
Now on this combined graph, seek the minimum-weight path from sblue to tgreen.
Finally, remove the subscripts.
Related
I have a directed graph with colored edges (red & blue) that may contain cycles. The question is to write an algorithm given two vertices (s,t) that finds the path with the minimal number of color changes between s and t (if such path exists).
I have found a solution using a variation of Dijkstra (I created a new graph where each vertex correspond to an edge of the previous graph, and contains the color of the edge. For example: if (1,2) is an edge in the old graph, then (1/2) is a vertex in the new one. I connected "adjacent edges" vertices, and edges in the new graph that change color got a weight of 1, where same color transition is 0).
I am looking for a solution in linear time (of V and E). The above one uses VxE edges in the new graph.
Is there such solution to find the minimal path?
First phase: Reduction to the shortest path problem.
For every node i we create two nodes i_red and i_blue.
For every blue edge i->j we create two edges i_red->j_blue with weight 1 and i_blue->j_blue with weight 0.
We handle red edges in similar fashion.
We also need a start node which is connected with start_red and start_blue with connection weight of 0.
Similar to the target node, which is connected with target_red and target_blue with weight 0-connections.
Now, search for the shortest path from newly created start node to the newly created target node. There are twice as many nodes and twice as many edges as in the original graph, so the reduction is linear.
After you reduced the problem to the shortest path search, you could do the following:
Step: use only edges with weight 0, treat the graph as undirected one and with help of bfs you can find all components in this 0-edge-graph in linear time.
Step: run bfs on the graph where the components from the prior step are glued together as super-nodes, so all edges have weight 1 and bfs will find the shortest path.
Obviously all three parts of this algorithm (bfs in 0-edge-graph, glueing the components to super-nodes and the bfs in the resulting graph) run in linear time.
Input: We have a directed graph G=(V,E) and each edge has a weight and a colour {red,green}. We are also given a starting node s.Problem/Algorithm: Can we find for all u edges of G, the shortest paths s-u with at most k red edges ? First approach: We save for each node the shortest path with 0,1...k red edges. We modify Dijkstra's algorithm and depending on the colour of the edges we are looking into, we update the distances respectively. This approach fails due to its complexity. Second approach: We make k copies of G graph (G1,G2 ...Gk+1). In order to utilise the k red edges constraint, while we are searching for shortest paths with Dijkstra, every time we "meet" a red edge {ui,vi} in Gi, we connect ui with vi+1 in Gi+1. Because Gk+1 doesn't have any red edges, we can only reach Gk+1 with at most k edges.But it fails. For example with k=2 if a 2 red edges shortest path is found to X node then will not take into consideration a heavier path with less red edges which could lead to an undiscovered node. (If i had enough reputation i could post an image as example). Any ideas ?
I think your approaches are actually equivalent, provided that for approach #1, you record only the shortest distance to each node for each number of red edges used -- you don't need to record the entire path (just as you don't need to record it for ordinary Dijkstra on an ordinary shortest path problem)
Also this approach is sound. In particular, your reasoning that approach #2 is faulty is itself wrong: for any node X in the original graph, there is no single corresponding node X in the new graph; instead there are separate vertices for each number of red edges used. So the two paths "to X" you are considering are not actually to the same node: one is to (X, 2 red edges used) and one is to e.g. (X, 1 red edge used). Then you can use a single Dijkstra run to calculate shortest paths to all k+1 copies of every vertex (i.e. to the vertices (v, i red edges used) for each 0 <= i <= k and for each v in V(G)), and return the lowest. (I'm assuming here that when you wrote "Can we find for all u edges of G, the shortest paths s-u", you meant "for all nodes u of G, the shortest paths s-u".)
Finally, you need to make sure that for any red edge {u, v} in G, you delete the corresponding edge {ui, vi} for all Gi (as well as add in the edge {ui, vi+1}). You probably intended this, but you weren't explicit about it.
I have an undirected graph with all vertices of even degree. In this graph there is a set of edges that must be covered exactly once, and a set of edges that should not be covered at all unless absolutely necessary. I need to find a set of one or more paths through the graph such that all of the required edges are covered exactly once, and the number of undesired edges traversed is minimized. No required edge can be traversed by more than one path, but the undesired edges can be traversed by any number of paths. It is not quite a Eulerian path because there are optional edges.
Each individual path's length is limited by a maximum number of required edges it can cover, although a path can cover any number of undesired edges.
The starting points and ending points need not be the same, but there is a set of possible starting points.
Some of the undesired edges are coincident with the required edges -- that is, a pair of vertices might have both a required edge and an undesired edge between them (although there will never be more than one edge of each type between a given pair of vertices).
What's a good algorithm to start with? Fundamentally, I am looking for an algorithm that can find a path that traverses required edges exactly once and avoids undesired edges when possible (but can traverse them more than once if necessary). I can build on that to do the rest.
You are looking for a subgraph within the original graph, such that it contains all the required edges, with a minimum of undesired edges such that it contains an Eulerian path.
It is known that a graph contains an Eulerian path if and only if it is CONNECTED and has all vertices ( except 2 ) of EVEN DEGREE. This can be ensured by doing the following :
Start by directly including all the desired edges in the final subgraph. You now have a graph with one or more connected components.
CASE 1 :
If the number of components in this subgraph is one, (i.e, all the edges are connected to each other ), we only have to ensure that all vertices ( except 2 ) have even degree. Since your original graph does have all vertices of even degree, it is possible to do this, but we also want to take care that the number of edges we add to achieve this is minimum ( since only undesired edges are left to add ).
One good heuristic way to do this, start from each of the odd degree vertices, and do a BFS ( breadth first search ) till you reach another vertex with odd degree. Do this for all the odd degree vertices, choose the 2 vertices which take the maximum undesired path between them to achieve this, and delete this path. Now the graph will have an Eulerian Path
( One thing to note is that such a pairing of odd vertices is always possible, since no graph can have an odd number of vertices of odd degree )
CASE 2 :
The subgraph consisting of only desired edges has more than one component. To ensure connectivity, do the following - Take the component with the minimum number of vertices. Do a BFS from each of the vertices, and choose the minimum length path that connects this component to ANY OTHER component.
Repeat this procedure till all components merge to form a single component. Now for even-ness follow the procedure outlined before for CASE 1.
I think this can be reduced into the Travelling Salesman problem. Create a transformed graph where the nodes represent compulsory edges and the edge weights represent the number of optional edges that must be traversed to get from one compulsory edge to the other.
Now the problem is to find the shortest path in this transformed graph which goes through all the nodes (aka compulsory edges). This is the TSP, which is NP-hard.
There will be some complications because the paths you can take after a compulsory edge depend on the direction in which you took it. You could solve this by turning each compulsory edge into two nodes, one for each direction. The TSP would then have to visit exactly one node from every pair.
e.g.
A===C
| /
| / (edges A<->B and B<->C are compulsory, A<=>C is optional)
|/
B
Transformed graph:
Nodes = { AB, BA, BC, CB }
Edges = { AB -> BC (cost 0), BA -> CB (cost 1), CB -> BA (cost 0), BC -> AB (cost 1) }
This is NP-hard: an instance of the Hamiltonian path problem can be transformed to an instance of your problem. Therefore, if you know how to solve your problem, you know how to solve the Hamiltonian path problem.
To transform, take a directed graph and double each vertex, say, into a red and a blue vertex. For each former vertex, make all inbound edges go to the red vertex, and all outbound edges go out of the blue vertex. Make a single new edge from the red to the blue vertex. Obviously if you can solve the Hamiltonian cycle problem for this graph, you can do so for the original graph.
Now label all new edges compulsory, all the old edges as optional. Mark a single red vertex as a possible entry point. If there's a solution to your problem, then it consists of a single path, which a Hamiltonian path for the original graph.
There is an undirected graph in which every node is assigned some color. I have to find the shortest path from any blue colored node to any red colored node. (Other colors may also exist in the graph and although it doesnt matter but it is not known how many colors are there.) How can I do it in polynomial time?
As a hint, add two new nodes to the graph- call them s and t. Connect s to each blue node with an edge of cost 0 and each red node to t with an edge of cost 0. Then find the shortest path from s to t.
Hope this helps!
Given a directed graph G, with edges colored either green or purple, and a vertex S in G, I must find an algorithm that finds the shortest path from s to each vertex in G so the path includes at most two purple edges (and green as much as needed).
I thought of BFS on G after removing all the purple edges, and for every vertex that the shortest path is still infinity, do something to try to find it, but I'm kinda stuck, and it takes alot of the running time as well...
Any other suggestions?
Thanks in advance
Duplicate your graph, so you have G1, G2, G3, such in each graph you redirect purple edges as follows: if (u1, v1) is a purple edge in G1, then change it to (u1, v2).
I.e. You have three graphs where each time you take a purple edge it moves you to the next graph, and on G3 there are no more purple edges. That construction builds the purple restriction into the structure, and will then be enforced automatically.
Now you simply find the shortest path from s to all nodes as usual. With the results you have to choose which is shorter between each path from s to u1, u2, u3.
All in all the construction takes linear time, and the new graph size is O(1) times larger than the original, so APSP takes the same time, and the final run to determine which of the three paths found is shortest is also linear.
You need three shortest paths to each vertex: paths with 0, 1 and 2 purple edges. In your algorithm, you need to store three different path lengths at each vertex. When you consider an s-t path with k purple edges and an edge t-u, if the edge is green then the potential s-t-u path has k purple edges, and if the s-t-u path is shorter than other s-u paths with k purple edges, you store its length at slot k of vertex u. Alternatively, if the t-u edge is purple, you work with slot k+1 of vertex u. Can you work out the rest by yourself?
Note that any path without loops in a graph like yours with n vertices can be at most n-1 long.
Assign length n to each purple edge where the n is the number of vertices. Find the shortest path from S to every other vertex, using, e.g. the Dijkstra algorithm.
Now, examine the path lengths:
if the path length is less than n, then you have a path of only green edges, since even one purple edge will increase the path length over n-1;
if the path length is inside [n, 2n), then you have exactly one purple edge, since two or more purple edges will increase the path length over 2n-1;
if the path length is inside [2n, 3n), then you have exactly two purple edges, since three or more purple edges will increase the path length over 3n-1;
otherwise a path with at most two purple edges does not exist.