Given a directed graph with **N** nodes and **E** edges, a source **S** and a destination **D** nodes. The task is to find the path with the minimum XOR sum of edges from **S** to **D**. If there is no path from **S** to **D** then print **-1**.

**Examples:**

Input:N = 3, E = 3, Edges = {{{1, 2}, 5}, {{1, 3}, 9}, {{2, 3}, 1}}, S = 1, and D = 3

Output:4

The path with smallest XOR of edges weight will be 1->2->3

with XOR sum as 5^1 = 4.

Input:N = 3, E = 3, Edges = {{{3, 2}, 5}, {{3, 3}, 9}, {{3, 3}, 1}}, S = 1, and D = 3

Output:-1

**Approach:** The idea is to use Dijkstra’s shortest path algorithm with a slight variation. Below is the step-wise approach for the problem:

**Base Case:**If the source node is equal to the destination then return**0**.- Initialise a priority-queue with source node and its weight as
**0**and a visited array. - While priority queue is not empty:
- Pop the top-most element from priority queue. Let’s call it as current node.
- Check if the current node is already visited with the help of the visited array, If yes then continue.
- If the current node is the destination node then return the XOR sum distance of the current node from the source node.
- Iterate all the nodes adjacent to current node and push into priority queue and their distance as XOR sum with the current distance and edge weight.

- Otherwise there is no path from source to destination. Therefore, return -1

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the smallest ` `// xor sum of edges ` `double` `minXorSumOfEdges( ` ` ` `int` `s, ` `int` `d, ` ` ` `vector<vector<pair<` `int` `, ` `int` `> > > gr) ` `{ ` ` ` `// If the source is equal ` ` ` `// to the destination ` ` ` `if` `(s == d) ` ` ` `return` `0; ` ` ` ` ` `// Initialise the priority queue ` ` ` `set<pair<` `int` `, ` `int` `> > pq; ` ` ` `pq.insert({ 0, s }); ` ` ` ` ` `// Visited array ` ` ` `bool` `v[gr.size()] = { 0 }; ` ` ` ` ` `// While the priority-queue ` ` ` `// is not empty ` ` ` `while` `(pq.size()) { ` ` ` ` ` `// Current node ` ` ` `int` `curr = pq.begin()->second; ` ` ` ` ` `// Current xor sum of distance ` ` ` `int` `dist = pq.begin()->first; ` ` ` ` ` `// Popping the top-most element ` ` ` `pq.erase(pq.begin()); ` ` ` ` ` `// If already visited continue ` ` ` `if` `(v[curr]) ` ` ` `continue` `; ` ` ` ` ` `// Marking the node as visited ` ` ` `v[curr] = 1; ` ` ` ` ` `// If it is a destination node ` ` ` `if` `(curr == d) ` ` ` `return` `dist; ` ` ` ` ` `// Traversing the current node ` ` ` `for` `(` `auto` `it : gr[curr]) ` ` ` `pq.insert({ dist ^ it.second, ` ` ` `it.first }); ` ` ` `} ` ` ` ` ` `// If no path exists ` ` ` `return` `-1; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 3; ` ` ` ` ` `// Graph as adjacency matrix ` ` ` `vector<vector<pair<` `int` `, ` `int` `> > > ` ` ` `gr(n + 1); ` ` ` ` ` `// Input edges ` ` ` `gr[1].push_back({ 3, 9 }); ` ` ` `gr[2].push_back({ 3, 1 }); ` ` ` `gr[1].push_back({ 2, 5 }); ` ` ` ` ` `// Source and destination ` ` ` `int` `s = 1, d = 3; ` ` ` ` ` `cout << minXorSumOfEdges(s, d, gr); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` `from` `collections ` `import` `deque ` ` ` `# Function to return the smallest ` `# xor sum of edges ` `def` `minXorSumOfEdges(s, d, gr): ` ` ` ` ` `# If the source is equal ` ` ` `# to the destination ` ` ` `if` `(s ` `=` `=` `d): ` ` ` `return` `0` ` ` ` ` `# Initialise the priority queue ` ` ` `pq ` `=` `[] ` ` ` `pq.append((` `0` `, s)) ` ` ` ` ` `# Visited array ` ` ` `v ` `=` `[` `0` `] ` `*` `len` `(gr) ` ` ` ` ` `# While the priority-queue ` ` ` `# is not empty ` ` ` `while` `(` `len` `(pq) > ` `0` `): ` ` ` `pq ` `=` `sorted` `(pq) ` ` ` ` ` `# Current node ` ` ` `curr ` `=` `pq[` `0` `][` `1` `] ` ` ` ` ` `# Current xor sum of distance ` ` ` `dist ` `=` `pq[` `0` `][` `0` `] ` ` ` ` ` `# Popping the top-most element ` ` ` `del` `pq[` `0` `] ` ` ` ` ` `# If already visited continue ` ` ` `if` `(v[curr]): ` ` ` `continue` ` ` ` ` `# Marking the node as visited ` ` ` `v[curr] ` `=` `1` ` ` ` ` `# If it is a destination node ` ` ` `if` `(curr ` `=` `=` `d): ` ` ` `return` `dist ` ` ` ` ` `# Traversing the current node ` ` ` `for` `it ` `in` `gr[curr]: ` ` ` `pq.append((dist ^ it[` `1` `], ` ` ` `it[` `0` `])) ` ` ` `# If no path exists ` ` ` `return` `-` `1` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` ` ` `n ` `=` `3` ` ` ` ` `# Graph as adjacency matrix ` ` ` `gr ` `=` `[[] ` `for` `i ` `in` `range` `(n ` `+` `1` `)] ` ` ` ` ` `# Input edges ` ` ` `gr[` `1` `].append([ ` `3` `, ` `9` `]) ` ` ` `gr[` `2` `].append([ ` `3` `, ` `1` `]) ` ` ` `gr[` `1` `].append([ ` `2` `, ` `5` `]) ` ` ` ` ` `# Source and destination ` ` ` `s ` `=` `1` ` ` `d ` `=` `3` ` ` ` ` `print` `(minXorSumOfEdges(s, d, gr)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

**Output:**

4

**Time complexity:** O((E + V) logV)

## Recommended Posts:

- Shortest path with exactly k edges in a directed and weighted graph
- Shortest path with exactly k edges in a directed and weighted graph | Set 2
- Minimum edges required to make a Directed Graph Strongly Connected
- Minimum Cost Path in a directed graph via given set of intermediate nodes
- Minimum Cost of Simple Path between two nodes in a Directed and Weighted Graph
- Minimum edges to be added in a directed graph so that any node can be reachable from a given node
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Assign directions to edges so that the directed graph remains acyclic
- Longest Path in a Directed Acyclic Graph | Set 2
- Shortest Path in Directed Acyclic Graph
- Longest Path in a Directed Acyclic Graph
- Find if there is a path between two vertices in a directed graph
- Find if there is a path between two vertices in a directed graph | Set 2
- Shortest path in a directed graph by Dijkstra’s algorithm
- Longest path in a directed Acyclic graph | Dynamic Programming
- Check if incoming edges in a vertex of directed graph is equal to vertex itself or not
- Shortest path in a graph from a source S to destination D with exactly K edges for multiple Queries
- Dijkstra's shortest path with minimum edges
- Minimum number of edges between two vertices of a Graph
- Minimum number of edges between two vertices of a graph using DFS

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.