Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 14 Sep, 2022
Improve Article
Save Article

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 

Approach: This problem is a variant of the 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 <bits/stdc++.h>
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




# Python3 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
}

Javascript




<script>
 
// JavaScript implementation of the above approach  
    var INF=99999;
     
    function findMinimumSteps(mat , x , y , n)
    {
        // dist will be the output matrix that
        // will finally have the shortest
        // distances between every pair of numbers
        var i, j, k;
        var  dist= Array(n).fill().map(()=>Array(n).fill(0));
     
        // 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
     
        var  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 ] ];
     
        var x = 2, y = 3;
        var size=mat.length;
         
        document.write( findMinimumSteps(mat, x, y, size));
 
// This code contributed by Rajput-Ji
 
</script>

Output

2

Complexity Analysis:

  • Time Complexity: O(N3), as we are using nested loops to traverse N3 times.
  • Auxiliary Space: O(N2), as we are using extra space for the dist matrix.

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!