# Find the minimum number of moves needed to move from one cell of matrix to another

• Difficulty Level : Easy
• Last Updated : 30 Mar, 2021

Given a N X N matrix (M) filled with 1 , 0 , 2 , 3 . Find the minimum numbers of moves needed to move from source to destination (sink) . while traversing through blank cells only. You can traverse up, down, right and left.
A value of cell 1 means Source.
A value of cell 2 means Destination.
A value of cell 3 means Blank cell.
A value of cell 0 means Blank Wall.

Note : there is only single source and single destination.they may be more than one path from source to destination(sink).each move in matrix we consider as ‘1’

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

```Input : M = {{ 0 , 3 , 2 },
{ 3 , 3 , 0 },
{ 1 , 3 , 0 }};
Output : 4

Input : M = {{ 3 , 3 , 1 , 0 },
{ 3 , 0 , 3 , 3 },
{ 2 , 3 , 0 , 3 },
{ 0 , 3 , 3 , 3 }};
Output : 4```

. The idea is to use a Level graph ( Breadth First Traversal ). Consider each cell as a node and each boundary between any two adjacent cells be an edge. so the total number of Node is N*N.

1. 1. Create an empty Graph having N*N node ( Vertex ).
2. 2. Push all nodes into a graph.
3. 3. Note down the source and sink vertices.
4. 4. Now Apply level graph concept ( that we achieve using BFS). In which we find the level of every node from the source vertex. After that, we return  ‘Level[d]’ ( d is the destination ). (which is the minimum move from source to sink )

Below is the implementation of the above idea.

## C++

 `// C++ program to find the minimum numbers``// of moves needed to move from source to``// destination .``#include``using` `namespace` `std;``#define N 4` `class` `Graph``{``    ``int` `V ;``    ``list < ``int` `> *adj;``public` `:``    ``Graph( ``int` `V )``    ``{``        ``this``->V = V ;``        ``adj = ``new` `list<``int``>[V];``    ``}``    ``void` `addEdge( ``int` `s , ``int` `d ) ;``    ``int` `BFS ( ``int` `s , ``int` `d) ;``};` `// add edge to graph``void` `Graph :: addEdge ( ``int` `s , ``int` `d )``{``    ``adj[s].push_back(d);``    ``adj[d].push_back(s);``}` `// Level  BFS function to find minimum path``// from source to sink``int` `Graph :: BFS(``int` `s, ``int` `d)``{``    ``// Base case``    ``if` `(s == d)``        ``return` `0;` `    ``// make initial distance of all vertex -1``    ``// from source``    ``int` `*level = ``new` `int``[V];``    ``for` `(``int` `i = 0; i < V; i++)``        ``level[i] = -1  ;` `    ``// Create a queue for BFS``    ``list<``int``> queue;` `    ``// Mark the source node level[s] = '0'``    ``level[s] = 0 ;``    ``queue.push_back(s);` `    ``// it will be used to get all adjacent``    ``// vertices of a vertex``    ``list<``int``>::iterator i;` `    ``while` `(!queue.empty())``    ``{``        ``// Dequeue a vertex from queue``        ``s = queue.front();``        ``queue.pop_front();` `        ``// Get all adjacent vertices of the``        ``// dequeued vertex s. If a adjacent has``        ``// not been visited ( level[i] < '0') ,``        ``// then update level[i] == parent_level[s] + 1``        ``// and enqueue it``        ``for` `(i = adj[s].begin(); i != adj[s].end(); ++i)``        ``{``            ``// Else, continue to do BFS``            ``if` `(level[*i] < 0 || level[*i] > level[s] + 1 )``            ``{``                ``level[*i] = level[s] + 1 ;``                ``queue.push_back(*i);``            ``}``        ``}` `    ``}` `    ``// return minimum moves from source to sink``    ``return` `level[d] ;``}` `bool` `isSafe(``int` `i, ``int` `j, ``int` `M[][N])``{``    ``if` `((i < 0 || i >= N) ||``            ``(j < 0 || j >= N ) || M[i][j] == 0)``        ``return` `false``;``    ``return` `true``;``}` `// Returns minimum numbers of  moves  from a source (a``// cell with value 1) to a destination (a cell with``// value 2)``int` `MinimumPath(``int` `M[][N])``{``    ``int` `s , d ; ``// source and destination``    ``int` `V = N*N+2;``    ``Graph g(V);` `    ``// create graph with n*n node``    ``// each cell consider as node``    ``int` `k = 1 ; ``// Number of current vertex``    ``for` `(``int` `i =0 ; i < N ; i++)``    ``{``        ``for` `(``int` `j = 0 ; j < N; j++)``        ``{``            ``if` `(M[i][j] != 0)``            ``{``                ``// connect all 4 adjacent cell to``                ``// current cell``                ``if` `( isSafe ( i , j+1 , M ) )``                    ``g.addEdge ( k , k+1 );``                ``if` `( isSafe ( i , j-1 , M ) )``                    ``g.addEdge ( k , k-1 );``                ``if` `(j< N-1 && isSafe ( i+1 , j , M ) )``                    ``g.addEdge ( k , k+N );``                ``if` `( i > 0 && isSafe ( i-1 , j , M ) )``                    ``g.addEdge ( k , k-N );``            ``}` `            ``// source index``            ``if``( M[i][j] == 1 )``                ``s = k ;` `            ``// destination index``            ``if` `(M[i][j] == 2)``                ``d = k;``            ``k++;``        ``}``    ``}` `    ``// find minimum moves``    ``return` `g.BFS (s, d) ;``}` `// driver program to check above function``int` `main()``{``    ``int` `M[N][N] = {{ 3 , 3 , 1 , 0 },``        ``{ 3 , 0 , 3 , 3 },``        ``{ 2 , 3 , 0 , 3 },``        ``{ 0 , 3 , 3 , 3 }``    ``};` `    ``cout << MinimumPath(M) << endl;` `    ``return` `0;``}`

## Python3

 `# Python3 program to find the minimum numbers``# of moves needed to move from source to``# destination .` `class` `Graph:``    ``def` `__init__(``self``, V):``        ``self``.V ``=` `V``        ``self``.adj ``=` `[[] ``for` `i ``in` `range``(V)]` `    ``# add edge to graph``    ``def` `addEdge (``self``, s , d ):``        ``self``.adj[s].append(d)``        ``self``.adj[d].append(s)``    ` `    ``# Level BFS function to find minimum``    ``# path from source to sink``    ``def` `BFS(``self``, s, d):``        ` `        ``# Base case``        ``if` `(s ``=``=` `d):``            ``return` `0``    ` `        ``# make initial distance of all``        ``# vertex -1 from source``        ``level ``=` `[``-``1``] ``*` `self``.V``    ` `        ``# Create a queue for BFS``        ``queue ``=` `[]``    ` `        ``# Mark the source node level[s] = '0'``        ``level[s] ``=` `0``        ``queue.append(s)``    ` `        ``# it will be used to get all adjacent``        ``# vertices of a vertex``    ` `        ``while` `(``len``(queue) !``=` `0``):``            ` `            ``# Dequeue a vertex from queue``            ``s ``=` `queue.pop()``    ` `            ``# Get all adjacent vertices of the``            ``# dequeued vertex s. If a adjacent has``            ``# not been visited ( level[i] < '0') ,``            ``# then update level[i] == parent_level[s] + 1``            ``# and enqueue it``            ``i ``=` `0``            ``while` `i < ``len``(``self``.adj[s]):``                ` `                ``# Else, continue to do BFS``                ``if` `(level[``self``.adj[s][i]] < ``0` `or``                    ``level[``self``.adj[s][i]] > level[s] ``+` `1` `):``                    ``level[``self``.adj[s][i]] ``=` `level[s] ``+` `1``                    ``queue.append(``self``.adj[s][i])``                ``i ``+``=` `1``    ` `        ``# return minimum moves from source``        ``# to sink``        ``return` `level[d]` `def` `isSafe(i, j, M):``    ``global` `N``    ``if` `((i < ``0` `or` `i >``=` `N) ``or``        ``(j < ``0` `or` `j >``=` `N ) ``or` `M[i][j] ``=``=` `0``):``        ``return` `False``    ``return` `True` `# Returns minimum numbers of moves from a``# source (a cell with value 1) to a destination``# (a cell with value 2)``def` `MinimumPath(M):``    ``global` `N``    ``s , d ``=` `None``, ``None` `# source and destination``    ``V ``=` `N ``*` `N ``+` `2``    ``g ``=` `Graph(V)` `    ``# create graph with n*n node``    ``# each cell consider as node``    ``k ``=` `1` `# Number of current vertex``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(N):``            ``if` `(M[i][j] !``=` `0``):``                ` `                ``# connect all 4 adjacent cell to``                ``# current cell``                ``if` `(isSafe (i , j ``+` `1` `, M)):``                    ``g.addEdge (k , k ``+` `1``)``                ``if` `(isSafe (i , j ``-` `1` `, M)):``                    ``g.addEdge (k , k ``-` `1``)``                ``if` `(j < N ``-` `1` `and` `isSafe (i ``+` `1` `, j , M)):``                    ``g.addEdge (k , k ``+` `N)``                ``if` `(i > ``0` `and` `isSafe (i ``-` `1` `, j , M)):``                    ``g.addEdge (k , k ``-` `N)` `            ``# source index``            ``if``(M[i][j] ``=``=` `1``):``                ``s ``=` `k` `            ``# destination index``            ``if` `(M[i][j] ``=``=` `2``):``                ``d ``=` `k``            ``k ``+``=` `1` `    ``# find minimum moves``    ``return` `g.BFS (s, d)` `# Driver Code``N ``=` `4``M ``=` `[[``3` `, ``3` `, ``1` `, ``0` `], [``3` `, ``0` `, ``3` `, ``3` `],``     ``[``2` `, ``3` `, ``0` `, ``3` `], [``0` `, ``3` `, ``3` `, ``3``]]` `print``(MinimumPath(M))` `# This code is contributed by PranchalK`

Output:

`4`

Another Approach: (DFS Implementation of the problem)

The same can be implemented using DFS where the complete path from the source is compared to get the minimum moves to the destination

Approach:

1. Loop through every element in the input matrix and create a Graph from that matrix
1. Create a graph with N*N vertices.
2. Add the edge from the k vertex to k+1/ k-1 (if the edge is to the left or right element in the matrix) or k to k+N/ k-N(if the edge is to the top or bottom element in the matrix).
3. Always check whether the element exists in the matrix and element != 0.
4. if(element == 1) map the source if (element == 2) map the destination.
2. Perform DFS to the graph formed, from source to destination.
1. Base condition: if source==destination returns 0 as the number of minimum moves.
2. Minimum moves will be the minimum(the result of DFS performed on the unvisited adjacent vertices).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``#define N 4` `// To be used in DFS while comparing the``// minimum element``#define MAX (INT_MAX - 1)``using` `namespace` `std;` `// Graph with the adjacency``// list representationo``class` `Graph {``private``:``    ``int` `V;``    ``vector<``int``>* adj;` `public``:``    ``Graph(``int` `V)``        ``: V{ V }``    ``{``        ` `        ``// Initializing the``        ``// adjacency list``        ``adj = ``new` `vector<``int``>[V];``    ``}``  ` `    ``// Clearing the memory after``    ``// its use (best practice)``    ``~Graph()``    ``{``        ``delete``[] adj;``    ``}` `    ``// Adding the element to the``    ``// adjacency list matrix``    ``// representation``    ``void` `add_edges(``int` `u, ``int` `v)``    ``{``      ``adj[u].push_back(v);``    ``}` `    ``// performing the DFS for the minimum moves``    ``int` `DFS(``int` `s, ``int` `d, unordered_set<``int``>& visited)``    ``{``        ` `        ``// Base condition for the recursion``        ``if` `(s == d)``            ``return` `0;``      ` `        ``// Initializing the result``        ``int` `res{ MAX };``        ``visited.insert(s);``        ``for` `(``int` `item : adj[s])``            ``if` `(visited.find(item) ==``                         ``visited.end())``              ` `                ``// comparing the res with``                ``// the result of DFS``                ``// to get the minimum moves``                ``res = min(res, 1 + DFS(item, d, visited));``        ``return` `res;``    ``}``};` `// ruling out the cases where the element``// to be inserted is outside the matrix``bool` `is_safe(``int` `arr[], ``int` `i, ``int` `j)``{``    ``if` `((i < 0 || i >= N) || (j < 0 || j >= N)``        ``|| arr[i][j] == 0)``        ``return` `false``;``    ``return` `true``;``}` `int` `min_moves(``int` `arr[][N])``{``    ``int` `s{ -1 }, d{ -1 }, V{ N * N };``  ` `    ``/* k be the variable which represents the``       ``positions( 0 - N*N ) inside the graph.``    ``*/``  ` `     ``// k moves from top-left to bottom-right``    ``int` `k{ 0 };``    ``Graph g{ V };``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < N; j++) {``          ` `            ``// Adding the edge``            ``if` `(arr[i][j] != 0) {``                ``if` `(is_safe(arr, i, j + 1))``                    ``g.add_edges(k, k + 1); ``// left``                ``if` `(is_safe(arr, i, j - 1))``                    ``g.add_edges(k, k - 1); ``// right``                ``if` `(is_safe(arr, i + 1, j))``                    ``g.add_edges(k, k + N); ``// bottom``                ``if` `(is_safe(arr, i - 1, j))``                    ``g.add_edges(k, k - N); ``// top``            ``}``          ` `            ``// Source from which DFS to be``            ``// performed``            ``if` `(arr[i][j] == 1)``                ``s = k;``          ` `            ``// Destination``            ``else` `if` `(arr[i][j] == 2)``                ``d = k;``          ` `            ``// Moving k from top-left``            ``// to bottom-right``            ``k++;``        ``}``    ``}``    ``unordered_set<``int``> visited;``  ` `    ``// DFS performed from``    ``// source to destination``    ``return` `g.DFS(s, d, visited);``}` `int32_t main()``{``    ``int` `arr[][N] = { { 3, 3, 1, 0 },``                     ``{ 3, 0, 3, 3 },``                     ``{ 2, 3, 0, 3 },``                     ``{ 0, 3, 3, 3 } };``  ` `    ``// if(min_moves(arr) == MAX) there``    ``// doesn't exist a path``    ``// from source to destination``    ``cout << min_moves(arr) << endl;``    ``return` `0;``  ` `    ``// the DFS approach and code``    ``// is contributed by Lisho``    ``// Thomas``}`

## Python3

 `# Python3 program for the above approach` `# To be used in DFS while comparing the``# minimum element``# define MAX (I4T_MAX - 1)``visited ``=` `{}``adj ``=` `[[] ``for` `i ``in` `range``(``16``)]` `# Performing the DFS for the minimum moves``def` `add_edges(u, v):``    ` `    ``global` `adj``    ``adj[u].append(v)` `def` `DFS(s, d):``    ` `    ``global` `visited` `    ``# Base condition for the recursion``    ``if` `(s ``=``=` `d):``        ``return` `0` `    ``# Initializing the result``    ``res ``=` `10``*``*``9``    ``visited[s] ``=` `1``    ` `    ``for` `item ``in` `adj[s]:``        ``if` `(item ``not` `in` `visited):``            ` `            ``# Comparing the res with``            ``# the result of DFS``            ``# to get the minimum moves``            ``res ``=` `min``(res, ``1` `+` `DFS(item, d))` `    ``return` `res` `# Ruling out the cases where the element``# to be inserted is outside the matrix``def` `is_safe(arr, i, j):``    ` `    ``if` `((i < ``0` `or` `i >``=` `4``) ``or``        ``(j < ``0` `or` `j >``=` `4``) ``or` `arr[i][j] ``=``=` `0``):``        ``return` `False``        ` `    ``return` `True` `def` `min_moves(arr):` `    ``s, d, V ``=` `-``1``,``-``1``, ``16``    ``# k be the variable which represents the``    ``# positions( 0 - 4*4 ) inside the graph.``    ` `    ``# k moves from top-left to bottom-right``    ``k ``=` `0``    ``for` `i ``in` `range``(``4``):``        ``for` `j ``in` `range``(``4``):``            ` `            ``# Adding the edge``            ``if` `(arr[i][j] !``=` `0``):``                ``if` `(is_safe(arr, i, j ``+` `1``)):``                    ``add_edges(k, k ``+` `1``) ``# left``                ``if` `(is_safe(arr, i, j ``-` `1``)):``                    ``add_edges(k, k ``-` `1``) ``# right``                ``if` `(is_safe(arr, i ``+` `1``, j)):``                    ``add_edges(k, k ``+` `4``) ``# bottom``                ``if` `(is_safe(arr, i ``-` `1``, j)):``                    ``add_edges(k, k ``-` `4``) ``# top` `            ``# Source from which DFS to be``            ``# performed``            ``if` `(arr[i][j] ``=``=` `1``):``                ``s ``=` `k``                ` `            ``# Destination``            ``elif` `(arr[i][j] ``=``=` `2``):``                ``d ``=` `k``                ` `            ``# Moving k from top-left``            ``# to bottom-right``            ``k ``+``=` `1` `    ``# DFS performed from``    ``# source to destination``    ``return` `DFS(s, d)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ [ ``3``, ``3``, ``1``, ``0` `],``            ``[ ``3``, ``0``, ``3``, ``3` `],``            ``[ ``2``, ``3``, ``0``, ``3` `],``            ``[ ``0``, ``3``, ``3``, ``3` `] ]` `    ``# If(min_moves(arr) == MAX) there``    ``# doesn't exist a path``    ``# from source to destination``    ``print``(min_moves(arr))` `# This code is contributed by mohit kumar 29`
Output
`4`

This article is contributed by Nishant Singh . 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.