Given an undirected graph **G**, the task is to find the shortest path of even-length, given **1** as Source Node and **N** as Destination Node. Path length refers to the number of edges present in a path (not the cost of the path).

**Examples:**

Input:N = 5, G is given below:Output:10Explanation:

All paths from 1(source node) to 5 (destination node) are:

1->2->5

Cost: 16 Length: 2(even)

1->2->3->5

Cost: 4 Length: 3(odd)

1->2->3->4->5

Cost: 10 Length: 4(even)

The shortest path is 1->2->3->5 with total cost 4, but it has an odd-length path and since we are interested in even-length paths only, the shortest path with even-length is 1->2->3->4->5, with total cost 10.

Input 2:N = 4, G is given below:Output:-1

Explanation:

There is no path of even-length from 1(source node) to 4(destination node).

**Approach:**

Create a new Graph (**G’**). For each node **V** in initial graph **G**, create two new nodes **V_even** and **V_odd**.

Here,

V_oddwill be represented as ((V * 10) + 1) andV_evenas ((V * 10) + 2).

For example, if nodeV= 4 thenV_odd= 41 andV_even= 42.

Now, for each edge (**U, V**) in **G**, add two new edges in **G’**, **(U_even, V_odd)** and **(U_odd, V_even)**. Finally, find the Shortest path from **(source_even)** node to **(destination_even)** node using Dijkstra Shortest Path Algorithm.

For Graph given in Input 1(above), **G’** can be represented as:

It can observed from the graph **G’** that there are only even length paths from **(1_even)** to **(5_even)**. Thus, the odd-length paths get separated in **G’** and the required shortest path can be obtained.

Below is the implementation of the above approach:

`// C++ program for the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `const` `int` `MAXX = 10000, INF = 1e9; `
` ` `// Adjacency List: to represent graph ` `vector<vector<pair<` `int` `, ` `int` `> > > `
` ` `adj(MAXX * 10 + 3); `
` ` `// Distance Array: to store shortest ` `// distance to every node ` `vector<` `int` `> dist(MAXX * 10 + 3, INF); `
` ` `// returns value which will ` `// represent even_x ` `int` `even(` `int` `x) `
`{ ` ` ` `return` `x * 10 + 2; `
`} ` `// returns value which will ` `// represent odd_x ` `int` `odd(` `int` `x) `
`{ ` ` ` `return` `x * 10 + 1; `
`} ` ` ` `// converting edge (a->b) to 2 ` `// different edges i.e. (a->b) ` `// converts to (1). even_a -> odd_b ` `// (2). odd_a -> even_b ` `// since, graph is undirected, so we ` `// push them in reverse order too ` `// hence, 4 push_back operations are ` `// there. ` `void` `addEdge(` `int` `a, ` `int` `b, ` `int` `cost) `
`{ ` ` ` `adj[even(a)].push_back( `
` ` `{ odd(b), cost }); `
` ` `adj[odd(a)].push_back( `
` ` `{ even(b), cost }); `
` ` `adj[odd(b)].push_back( `
` ` `{ even(a), cost }); `
` ` `adj[even(b)].push_back( `
` ` `{ odd(a), cost }); `
`} ` ` ` `// Function calculates shortest ` `// distance to all nodes from ` `// "source" using Dijkstra ` `// Shortest Path Algorithm ` `// and returns shortest distance ` `// to "destination" ` `int` `dijkstra(` `int` `source, `
` ` `int` `destination) `
`{ ` ` ` ` ` `/* Priority Queue/min-heap `
` ` `to store and process `
` ` `(distance, node) */`
` ` `priority_queue<pair<` `int` `, ` `int` `>, `
` ` `vector<pair<` `int` `, ` `int` `> >, `
` ` `greater<pair<` `int` `, ` `int` `> > > `
` ` `pq; `
` ` ` ` `// pushing source node to `
` ` `// priority queue and dist from `
` ` `// source to source is set to 0 `
` ` `pq.push({ 0, even(source) }); `
` ` `dist[even(source)] = 0; `
` ` ` ` `while` `(!pq.empty()) { `
` ` ` ` `// U is the node at top `
` ` `// of the priority queue `
` ` `// note that pq.top().first `
` ` `// refers to the Distance `
` ` `// and pq.top().second `
` ` `// will refer to the Node `
` ` `int` `u = pq.top().second; `
` ` `pq.pop(); `
` ` ` ` `// exploring all neighbours `
` ` `// of node u `
` ` `for` `(pair<` `int` `, ` `int` `> p : `
` ` `adj[u]) { `
` ` ` ` `/* v is neighbour node of u `
` ` `and c is the cost/weight `
` ` `of edge (u, v) */`
` ` `int` `v = p.first; `
` ` `int` `c = p.second; `
` ` ` ` `// relaxation: checking if there `
` ` `// is a shorter path to v via u `
` ` `if` `(dist[u] + c `
` ` `< dist[v]) { `
` ` ` ` `// updating distance of v `
` ` `dist[v] = dist[u] + c; `
` ` `pq.push({ dist[v], v }); `
` ` `} `
` ` `} `
` ` `} `
` ` ` ` `// returning shortest `
` ` `// distance to "destination" `
` ` `return` `dist[even(destination)]; `
`} ` ` ` `// Driver function ` `int` `main() `
`{ ` ` ` `// n = number of Nodes, `
` ` `// m = number of Edges `
` ` `int` `n = 5, m = 6; `
` ` `addEdge(1, 2, 1); `
` ` `addEdge(2, 3, 2); `
` ` `addEdge(2, 5, 15); `
` ` `addEdge(3, 5, 1); `
` ` `addEdge(3, 4, 4); `
` ` `addEdge(5, 4, 3); `
` ` ` ` `int` `source = 1; `
` ` `int` `destination = n; `
` ` `int` `ans = dijkstra(source, destination); `
` ` ` ` `// if ans is INF: There is no `
` ` `// even length path from source `
` ` `// to destination else path `
` ` `// exists and we print the `
` ` `// shortest distance `
` ` `if` `(ans == INF) `
` ` `cout << ` `"-1"`
` ` `<< ` `"\n"` `; `
` ` `else`
` ` `cout << ans << ` `"\n"` `; `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

**Output:**

10

**Time Complexity:** (E * log(V))

## Recommended Posts:

- Shortest path in a graph from a source S to destination D with exactly K edges for multiple Queries
- Shortest path from source to destination such that edge weights along path are alternatively increasing and decreasing
- Minimum edges to reverse to make path from a source to a destination
- Count all possible walks from a source to a destination with exactly k edges
- Sum of shortest distance on source to destination and back having at least a common vertex
- Print all shortest paths between given source and destination in an undirected graph
- Minimum cost path from source node to destination node via an intermediate node
- Source to destination in 2-D path with fixed sized jumps
- Shortest path with exactly k edges in a directed and weighted graph
- Dijkstra's shortest path with minimum edges
- Shortest path with exactly k edges in a directed and weighted graph | Set 2
- Multi Source Shortest Path in Unweighted Graph
- D'Esopo-Pape Algorithm : Single Source Shortest Path
- Single source shortest path between two cities
- Number of Walks from source to destination
- Print all paths from a given source to a destination
- Print all paths from a given source to a destination using BFS
- Count total ways to reach destination from source in an undirected Graph
- Check if a destination is reachable from source with two movements allowed | Set 2
- Ways to Remove Edges from a Complete Graph to make Odd Edges

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.