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 

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

2


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

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.