All vertex pairs connected with exactly k edges in a graph

Given a directed graph represented as an adjacency matrix and an integer ‘k’, the task is to find all the vertex pairs that are connected with exactly ‘k’ edges.
Also, find the number of ways in which the two vertices can be linked in exactly k edges.

Examples :

Input : k = 3 and graph :
0 1 0 0 0 
0 0 1 0 0 
0 0 0 1 1 
1 0 0 0 0 
0 0 1 0 0 
Output :
1 -> 4 in 1 way(s)
1 -> 5 in 1 way(s)
2 -> 1 in 1 way(s)
2 -> 3 in 1 way(s)
3 -> 2 in 1 way(s)
3 -> 4 in 1 way(s)
3 -> 5 in 1 way(s)
4 -> 3 in 1 way(s)
5 -> 1 in 1 way(s)
5 -> 3 in 1 way(s)

Input : k = 2 and graph :
0 0 0 
1 0 1 
0 1 0 
Output :
2 -> 2 in 1 way(s)
3 -> 1 in 1 way(s)
3 -> 3 in 1 way(s)

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

Approach :

We will multiply the adjacency matrix with itself ‘k’ number of times.
In the resultant matrix, res[i][j] will be the number of ways in which vertex ‘j’ can be reached from vertex ‘i’ covering exactly ‘k’ edges.

Below is the implementation of the above approach :

Java

// Java implementation of the approach 
public class KPaths { 
  
    // Function to multiply two square matrices 
    static int[][] multiplyMatrices(int[][] arr1, int[][] arr2) 
    { 
        int order = arr1.length; 
        int[][] ans = new int[order][order]; 
        for (int i = 0; i < order; i++) { 
            for (int j = 0; j < order; j++) { 
                for (int k = 0; k < order; k++) { 
                    ans[i][j] += arr1[i][k] * arr2[k][j]; 
                } 
            } 
        } 
        return ans; 
    } 
  
    // Function to find all the pairs that 
    // can be connected with exactly 'k' edges 
    static void solve(int[][] arr, int k) 
    { 
        int[][] res = new int[arr.length][arr[0].length]; 
  
        // copying arr to res, 
        // which is the result for k=1 
        for (int i = 0; i < res.length; i++) 
            for (int j = 0; j < res.length; j++) 
                res[i][j] = arr[i][j]; 
  
        // multiplying arr with itself 
        // the required number of times 
        for (int i = 2; i <= k; i++) 
            res = multiplyMatrices(res, arr); 
  
        for (int i = 0; i < res.length; i++) 
            for (int j = 0; j < res.length; j++) 
  
                // if there is a path between 'i' 
                // and 'j' in exactly 'k' edges 
                if (res[i][j] > 0) 
                    System.out.println(i + " -> " + j + " in " + res[i][j] + " way(s)"); 
    } 
  
    // Driver code 
    public static void main(String[] args) 
    { 
        int[][] arr = new int[5][5]; 
        arr[0][1] = 1; 
        arr[1][2] = 1; 
        arr[2][3] = 1; 
        arr[2][4] = 1; 
        arr[3][0] = 1; 
        arr[4][2] = 1; 
        int k = 3; 
        solve(arr, k); 
    } 
} 

C#

// C# implementation of the approach 
using System; 
  
class KPaths 
{  
  
// Function to multiply two square matrices  
static int[,] multiplyMatrices(int[,] arr1,  
                               int[,] arr2)  
{  
    int order = arr1.GetLength(0);  
    int[,] ans = new int[order, order];  
    for (int i = 0; i < order; i++)  
    {  
        for (int j = 0; j < order; j++)  
        {  
            for (int k = 0; k < order; k++)  
            {  
                ans[i, j] += arr1[i, k] *  
                             arr2[k, j];  
            }  
        }  
    }  
    return ans;  
}  
  
// Function to find all the pairs that  
// can be connected with exactly 'k' edges  
static void solve(int[,] arr, int k)  
{  
    int[,] res = new int[arr.GetLength(0), 
                         arr.GetLength(1)];  
  
    // copying arr to res,  
    // which is the result for k = 1  
    for (int i = 0; i < res.GetLength(0); i++)  
        for (int j = 0; j < res.GetLength(1); j++)  
            res[i, j] = arr[i, j];  
  
    // multiplying arr with itself  
    // the required number of times  
    for (int i = 2; i <= k; i++)  
        res = multiplyMatrices(res, arr);  
  
    for (int i = 0; i < res.GetLength(0); i++)  
        for (int j = 0; j < res.GetLength(1); j++)  
  
            // if there is a path between 'i'  
            // and 'j' in exactly 'k' edges  
            if (res[i,j] > 0)  
                Console.WriteLine(i + " -> " + j + " in " + 
                                    res[i, j] + " way(s)");  
}  
  
// Driver code  
public static void Main(String[] args)  
{  
    int[,] arr = new int[5, 5];  
    arr[0, 1] = 1;  
    arr[1, 2] = 1;  
    arr[2, 3] = 1;  
    arr[2, 4] = 1;  
    arr[3, 0] = 1;  
    arr[4, 2] = 1;  
    int k = 3;  
    solve(arr, k);  
}  
}  
  
// This code is contributed by Rajput-Ji 

Output:

0 -> 3 in 1 way(s)
0 -> 4 in 1 way(s)
1 -> 0 in 1 way(s)
1 -> 2 in 1 way(s)
2 -> 1 in 1 way(s)
2 -> 3 in 1 way(s)
2 -> 4 in 1 way(s)
3 -> 2 in 1 way(s)
4 -> 0 in 1 way(s)
4 -> 2 in 1 way(s)

The time complexity of the above code can be reduced for large values of k by using matrix exponentitation. The complexity can be changed from O(n^3 * k) to O(n^3 * log k)

Java

class KPaths { 
  
    // Function to multiply two square matrices 
    static int[][] multiplyMatrices(int[][] arr1, int[][] arr2) 
    { 
        int order = arr1.length; 
        int[][] ans = new int[order][order]; 
        for (int i = 0; i < order; i++) { 
            for (int j = 0; j < order; j++) { 
                for (int k = 0; k < order; k++) { 
                    ans[i][j] += arr1[i][k] * arr2[k][j]; 
                } 
            } 
        } 
        return ans; 
    } 
  
    // Function to find all the pairs that 
    // can be connected with exactly 'k' edges 
    static void solve(int[][] arr, int k) 
    { 
        int[][] res = new int[arr.length][arr[0].length]; 
  
        res = power(arr, k, arr[0].length); 
        for (int i = 0; i < res.length; i++) 
            for (int j = 0; j < res.length; j++) 
  
                // if there is a path between 'i' 
                // and 'j' in exactly 'k' edges 
                if (res[i][j] > 0) 
                    System.out.println(i + " -> " + j + " in " + res[i][j] + " way(s)"); 
    } 
  
    static int[][] power(int x[][], int y, int n) 
    { 
        // MATRIX EXPONENTIATION 
        // Initialize result 
        int res[][] = identity(n); 
  
        while (y > 0) { 
  
            if ((y & 1) == 1) 
                res = multiplyMatrices(res, x); 
  
            // y must be even now 
            // y = y / 2 
            y = y >> 1; 
            x = multiplyMatrices(x, x); 
        } 
        return res; 
    } 
    static int[][] identity(int n) 
    { 
        // returns identity matrix of order n 
        int r[][] = new int[n][n]; 
        for (int i = 0; i < n; i++) 
            r[i][i] = 1; 
  
        return r; 
    } 
  
    // Driver code 
    public static void main(String[] args) 
    { 
        int[][] arr = new int[5][5]; 
        arr[0][1] = 1; 
        arr[1][2] = 1; 
        arr[2][3] = 1; 
        arr[2][4] = 1; 
        arr[3][0] = 1; 
        arr[4][2] = 1; 
        int k = 3; 
        solve(arr, k); 
    } 
} 

C#

// C# implementation of the above approach:  
using System; 
  
class KPaths  
{ 
  
    // Function to multiply two square matrices 
    static int[,] multiplyMatrices(int[,] arr1,  
                                   int[,] arr2) 
    { 
        int order = arr1.GetLength(0); 
        int[,] ans = new int[order,order]; 
        for (int i = 0; i < order; i++)  
        { 
            for (int j = 0; j < order; j++) 
            { 
                for (int k = 0; k < order; k++)  
                { 
                    ans[i, j] += arr1[i, k] *  
                                 arr2[k, j]; 
                } 
            } 
        } 
        return ans; 
    } 
  
    // Function to find all the pairs that 
    // can be connected with exactly 'k' edges 
    static void solve(int[,] arr, int k) 
    { 
        int[,] res = new int[arr.GetLength(0), 
                             arr.GetLength(1)]; 
  
        res = power(arr, k, arr.GetLength(0)); 
        for (int i = 0; i < res.GetLength(0); i++) 
            for (int j = 0; j < res.GetLength(1); j++) 
  
                // if there is a path between 'i' 
                // and 'j' in exactly 'k' edges 
                if (res[i, j] > 0) 
                    Console.WriteLine(i + " -> " + j +   
                      " in " + res[i, j] + " way(s)"); 
    } 
  
    static int[,] power(int [,]x, int y, int n) 
    { 
          
        // MATRIX EXPONENTIATION 
        // Initialize result 
        int [,]res = identity(n); 
  
        while (y > 0) 
        { 
  
            if ((y & 1) == 1) 
                res = multiplyMatrices(res, x); 
  
            // y must be even now 
            // y = y / 2 
            y = y >> 1; 
            x = multiplyMatrices(x, x); 
        } 
        return res; 
    } 
      
    static int[,] identity(int n) 
    { 
        // returns identity matrix of order n 
        int [,]r = new int[n, n]; 
        for (int i = 0; i < n; i++) 
            r[i, i] = 1; 
  
        return r; 
    } 
  
    // Driver code 
    public static void Main(String[] args) 
    { 
        int[,] arr = new int[5, 5]; 
        arr[0, 1] = 1; 
        arr[1, 2] = 1; 
        arr[2, 3] = 1; 
        arr[2, 4] = 1; 
        arr[3, 0] = 1; 
        arr[4, 2] = 1; 
        int k = 3; 
        solve(arr, k); 
    } 
} 
  
// This code is contributed by PrinciRaj1992  

My Personal Notes

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

Java

C#

Java

C#

Recommended Posts: