# Minimum steps required to convert X to Y where a binary matrix represents the possible conversions

Given a binary matrix of size NxN where 1 denotes that the number i can be converted to j, and 0 denotes it cannot be converted to. Also given are two numbers X(<N)and Y(<N), the task is to find the minimum number of steps required to convert the number X to Y. If there is no such way possible, print -1.

Examples:

```Input:
{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0}
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}}

X = 2, Y = 3
Output: 2
Convert 2 -> 4 -> 3, which is the minimum way possible.

Input:
{{ 0, 0, 0, 0}
{ 0, 0, 0, 1}
{ 0, 0, 0, 0}
{ 0, 1, 0, 0}}

X = 1, Y = 2
Output: -1
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem is a variant of Floyd-warshall algorithm where there is an edge of weight 1 between i and j i.e. mat[i][j]==1, else they don’t have an edge and we can assign edges as infinity as we do in Floyd-Warshall. Find the solution matrix and return dp[i][j] if it is not infinite. Return -1 if it is infinite which means there is no path possible between them.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` `#define INF 99999 ` `#define size 10 ` ` `  `int` `findMinimumSteps(``int` `mat[size][size], ``int` `x, ``int` `y, ``int` `n) ` `{ ` `    ``// dist[][] will be the output matrix that ` `    ``// will finally have the shortest ` `    ``// distances between every pair of numbers ` `    ``int` `dist[n][n], i, j, k; ` ` `  `    ``// Initially same as mat ` `    ``for` `(i = 0; i < n; i++) { ` `        ``for` `(j = 0; j < n; j++) { ` `            ``if` `(mat[i][j] == 0) ` `                ``dist[i][j] = INF; ` `            ``else` `                ``dist[i][j] = 1; ` ` `  `            ``if` `(i == j) ` `                ``dist[i][j] = 1; ` `        ``} ` `    ``} ` ` `  `    ``// Add all numbers one by one to the set ` `    ``// of intermediate numbers. Before start of  ` `    ``// an iteration, we have shortest distances  ` `    ``// between all pairs of numbers such that the  ` `    ``// shortest distances consider only the numbers  ` `    ``// in set {0, 1, 2, .. k-1} as intermediate numbers. ` `    ``// After the end of an iteration, vertex no. k is  ` `    ``// added to the set of intermediate numbers and  ` `    ``// the set becomes {0, 1, 2, .. k} ` `    ``for` `(k = 0; k < n; k++) { ` ` `  `        ``// Pick all numbers as source one by one ` `        ``for` `(i = 0; i < n; i++) { ` ` `  `            ``// Pick all numbers as destination for the ` `            ``// above picked source ` `            ``for` `(j = 0; j < n; j++) { ` ` `  `                ``// If number k is on the shortest path from ` `                ``// i to j, then update the value of dist[i][j] ` `                ``if` `(dist[i][k] + dist[k][j] < dist[i][j]) ` `                    ``dist[i][j] = dist[i][k] + dist[k][j]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// If no path ` `    ``if` `(dist[x][y] < INF) ` `        ``return` `dist[x][y]; ` `    ``else` `        ``return` `-1; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``int` `mat[size][size] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, ` `                            ``{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, ` `                            ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } }; ` ` `  `    ``int` `x = 2, y = 3; ` ` `  `    ``cout << findMinimumSteps(mat, x, y, size); ` `} `

## Java

 `// Java implementation of the above approach ` ` `  `class` `GFG ` `{ ` `     `  `    ``static` `int` `INF=``99999``; ` `     `  `    ``static` `int` `findMinimumSteps(``int` `mat[][], ``int` `x, ``int` `y, ``int` `n) ` `    ``{ ` `        ``// dist[][] will be the output matrix that ` `        ``// will finally have the shortest ` `        ``// distances between every pair of numbers ` `        ``int` `i, j, k; ` `        ``int` `[][] dist= ``new` `int``[n][n];  ` `     `  `        ``// Initially same as mat ` `        ``for` `(i = ``0``; i < n; i++) { ` `            ``for` `(j = ``0``; j < n; j++) { ` `                ``if` `(mat[i][j] == ``0``) ` `                    ``dist[i][j] = INF; ` `                ``else` `                    ``dist[i][j] = ``1``; ` `     `  `                ``if` `(i == j) ` `                    ``dist[i][j] = ``1``; ` `            ``} ` `        ``} ` `     `  `        ``// Add all numbers one by one to the set ` `        ``// of intermediate numbers. Before start of  ` `        ``// an iteration, we have shortest distances  ` `        ``// between all pairs of numbers such that the  ` `        ``// shortest distances consider only the numbers  ` `        ``// in set {0, 1, 2, .. k-1} as intermediate numbers. ` `        ``// After the end of an iteration, vertex no. k is  ` `        ``// added to the set of intermediate numbers and  ` `        ``// the set becomes {0, 1, 2, .. k} ` `        ``for` `(k = ``0``; k < n; k++) { ` `     `  `            ``// Pick all numbers as source one by one ` `            ``for` `(i = ``0``; i < n; i++) { ` `     `  `                ``// Pick all numbers as destination for the ` `                ``// above picked source ` `                ``for` `(j = ``0``; j < n; j++) { ` `     `  `                    ``// If number k is on the shortest path from ` `                    ``// i to j, then update the value of dist[i][j] ` `                    ``if` `(dist[i][k] + dist[k][j] < dist[i][j]) ` `                        ``dist[i][j] = dist[i][k] + dist[k][j]; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// If no path ` `        ``if` `(dist[x][y] < INF) ` `            ``return` `dist[x][y]; ` `        ``else` `            ``return` `-``1``; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `     `  `        ``int` `[][] mat =  { { ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``1` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, ` `                        ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``1` `} }; ` `     `  `        ``int` `x = ``2``, y = ``3``; ` `        ``int` `size=mat.length; ` `         `  `        ``System.out.println( findMinimumSteps(mat, x, y, size)); ` `    ``} ` ` `  `} ` ` `  ` `  `// This code is contributed by ihritik `

## Python3

 `# Pyton3 implementation of the above approach ` ` `  `INF ``=` `99999` `size ``=` `10` ` `  `def` `findMinimumSteps(mat, x, y, n): ` ` `  `    ``# dist[][] will be the output matrix  ` `    ``# that will finally have the shortest ` `    ``# distances between every pair of numbers ` `    ``dist ``=` `[[``0` `for` `i ``in` `range``(n)]  ` `               ``for` `i ``in` `range``(n)] ` `    ``i, j, k ``=` `0``, ``0``, ``0` ` `  `    ``# Initially same as mat ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``if` `(mat[i][j] ``=``=` `0``): ` `                ``dist[i][j] ``=` `INF ` `            ``else``: ` `                ``dist[i][j] ``=` `1` ` `  `            ``if` `(i ``=``=` `j): ` `                ``dist[i][j] ``=` `1` `         `  `    ``# Add all numbers one by one to the set ` `    ``# of intermediate numbers. Before start  ` `    ``# of an iteration, we have shortest distances  ` `    ``# between all pairs of numbers such that the  ` `    ``# shortest distances consider only the numbers  ` `    ``# in set {0, 1, 2, .. k-1} as intermediate  ` `    ``# numbers. After the end of an iteration, vertex  ` `    ``# no. k is added to the set of intermediate  ` `    ``# numbers and the set becomes {0, 1, 2, .. k} ` `    ``for` `k ``in` `range``(n): ` ` `  `        ``# Pick all numbers as source one by one ` `        ``for` `i ``in` `range``(n): ` ` `  `            ``# Pick all numbers as destination  ` `            ``# for the above picked source ` `            ``for` `j ``in` `range``(n): ` ` `  `                ``# If number k is on the shortest path from ` `                ``# i to j, then update the value of dist[i][j] ` `                ``if` `(dist[i][k] ``+` `dist[k][j] < dist[i][j]): ` `                    ``dist[i][j] ``=` `dist[i][k] ``+` `dist[k][j] ` ` `  `    ``# If no path ` `    ``if` `(dist[x][y] < INF): ` `        ``return` `dist[x][y] ` `    ``else``: ` `        ``return` `-``1` ` `  `# Driver Code ` `mat ``=` `[[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``1` `], ` `       ``[ ``0``, ``0``, ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``1``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `], ` `       ``[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``0``, ``1` `]] ` ` `  `x, y ``=` `2``, ``3` ` `  `print``(findMinimumSteps(mat, x, y, size)) ` ` `  `# This code is contributed by Mohit kumar 29 `

## C#

 `// C# implementation of the above approach  ` ` `  `using` `System; ` `class` `GFG  ` `{  ` `     `  `    ``static` `int` `INF=99999;  ` `     `  `    ``static` `int` `findMinimumSteps(``int` `[,]mat, ``int` `x, ``int` `y, ``int` `n)  ` `    ``{  ` `        ``// dist[][] will be the output matrix that  ` `        ``// will finally have the shortest  ` `        ``// distances between every pair of numbers  ` `        ``int` `i, j, k;  ` `        ``int` `[,] dist= ``new` `int``[n,n];  ` `     `  `        ``// Initially same as mat  ` `        ``for` `(i = 0; i < n; i++) {  ` `            ``for` `(j = 0; j < n; j++) {  ` `                ``if` `(mat[i,j] == 0)  ` `                    ``dist[i,j] = INF;  ` `                ``else` `                    ``dist[i,j] = 1;  ` `     `  `                ``if` `(i == j)  ` `                    ``dist[i,j] = 1;  ` `            ``}  ` `        ``}  ` `     `  `        ``// Add all numbers one by one to the set  ` `        ``// of intermediate numbers. Before start of  ` `        ``// an iteration, we have shortest distances  ` `        ``// between all pairs of numbers such that the  ` `        ``// shortest distances consider only the numbers  ` `        ``// in set {0, 1, 2, .. k-1} as intermediate numbers.  ` `        ``// After the end of an iteration, vertex no. k is  ` `        ``// added to the set of intermediate numbers and  ` `        ``// the set becomes {0, 1, 2, .. k}  ` `        ``for` `(k = 0; k < n; k++) {  ` `     `  `            ``// Pick all numbers as source one by one  ` `            ``for` `(i = 0; i < n; i++) {  ` `     `  `                ``// Pick all numbers as destination for the  ` `                ``// above picked source  ` `                ``for` `(j = 0; j < n; j++) {  ` `     `  `                    ``// If number k is on the shortest path from  ` `                    ``// i to j, then update the value of dist[i][j]  ` `                    ``if` `(dist[i,k] + dist[k,j] < dist[i,j])  ` `                        ``dist[i,j] = dist[i,k] + dist[k,j];  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// If no path  ` `        ``if` `(dist[x,y] < INF)  ` `            ``return` `dist[x,y];  ` `        ``else` `            ``return` `-1;  ` `    ``}  ` `     `  `    ``// Driver Code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `     `  `        ``int` `[,] mat = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },  ` `                        ``{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },  ` `                        ``{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } };  ` `     `  `        ``int` `x = 2, y = 3;  ` `        ``int` `size = mat.GetLength(0) ; ` `         `  `        ``Console.WriteLine( findMinimumSteps(mat, x, y, size));  ` `    ``}  ` `    ``// This code is contributed by Ryuga ` `}  `

Output:

```2
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.