Count total ways to reach destination from source in an undirected Graph - GeeksforGeeks

03 Jun, 2021
Given an undirected graph, a source vertex ‘s’ and a destination vertex ‘d’, the task is to count the total paths from the given ‘s’ to ‘d’.
Examples 
Input: s = 1, d = 4  
Output: 2 Explanation: Below are the 2 paths from 1 to 4 1 -> 3 -> 4 1 -> 2 -> 3 -> 4
Input: s = 3, d = 9 
Output: 6 Explanation: Below are the 6 paths from 3 to 9 3 -> 2 -> 1 -> 7 -> 6 -> 5 -> 10 -> 9 3 -> 2 -> 1 -> 7 -> 6 -> 10 -> 9 3 -> 2 -> 1 -> 7 -> 8 -> 9 3 -> 4 -> 2 -> 1 -> 7 -> 6 -> 5 -> 10 -> 9 3 -> 4 -> 2 -> 1 -> 7 -> 6 -> 10 -> 9 3 -> 4 -> 2 -> 1 -> 7 -> 8 -> 9  
Approach: The idea is to do Depth First Traversal of a given undirected graph.  
Start the traversal from the source.
Keep storing the visited vertices in an array saying ‘visited[]’.
If we reach the destination vertex, increment the count by ‘1’.
The important thing is to mark current vertices in visited[] as visited so that the traversal doesn’t go in cycles.
Below is the implementation of the above approach: 
C++
Java
Python 3
C#
Javascript
// C++ program to count total number of// ways to reach destination in a graph#include <iostream>using namespace std; // Utility Function to count total waysint countWays(int mtrx[][11], int vrtx,              int i, int dest, bool visited[]){    // Base condition    // When reach to the destination    if (i == dest) {         return 1;    }    int total = 0;    for (int j = 0; j < vrtx; j++) {        if (mtrx[i][j] == 1 && !visited[j]) {             // Make vertex visited            visited[j] = true;             // Recursive function, for count ways            total += countWays(mtrx, vrtx,                               j, dest, visited);             // Backtracking            // Make vertex unvisited            visited[j] = false;        }    }     // Return total ways    return total;} // Function to count total ways// to reach destinationint totalWays(int mtrx[][11], int vrtx,              int src, int dest){    bool visited[vrtx];     // Loop to make all vertex unvisited,    // Initially    for (int i = 0; i < vrtx; i++) {        visited[i] = false;    }     // Make source visited    visited[src] = true;     return countWays(mtrx, vrtx, src, dest,                     visited);} int main(){    int vrtx = 11;    int mtrx[11][11] = {        { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },        { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 },        { 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 },        { 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 },        { 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },        { 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }    };     int src = 3;    int dest = 9;     // Print total ways    cout << totalWays(mtrx, vrtx, src - 1,                      dest - 1);     return 0;}
// Java program to count total number of// ways to reach destination in a graphclass GFG{  // Utility Function to count total waysstatic int countWays(int mtrx[][], int vrtx,              int i, int dest, boolean visited[]){    // Base condition    // When reach to the destination    if (i == dest) {          return 1;    }    int total = 0;    for (int j = 0; j < vrtx; j++) {        if (mtrx[i][j] == 1 && !visited[j]) {              // Make vertex visited            visited[j] = true;              // Recursive function, for count ways            total += countWays(mtrx, vrtx,                               j, dest, visited);              // Backtracking            // Make vertex unvisited            visited[j] = false;        }    }      // Return total ways    return total;}  // Function to count total ways// to reach destinationstatic int totalWays(int mtrx[][], int vrtx,              int src, int dest){    boolean []visited = new boolean[vrtx];      // Loop to make all vertex unvisited,    // Initially    for (int i = 0; i < vrtx; i++) {        visited[i] = false;    }      // Make source visited    visited[src] = true;      return countWays(mtrx, vrtx, src, dest,                     visited);}  public static void main(String[] args){    int vrtx = 11;    int mtrx[][] = {        { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },        { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 },        { 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 },        { 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 },        { 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },        { 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }    };      int src = 3;    int dest = 9;      // Print total ways    System.out.print(totalWays(mtrx, vrtx, src - 1,                      dest - 1));  }} // This code contributed by Rajput-Ji
# Python 3 program to count total number of# ways to reach destination in a graph # Utility Function to count total waysdef countWays(mtrx, vrtx, i, dest, visited):         # Base condition    # When reach to the destination    if (i == dest):        return 1             total = 0    for j in range(vrtx):        if (mtrx[i][j] == 1 and not visited[j]):             # Make vertex visited            visited[j] = True;             # Recursive function, for count ways            total += countWays(mtrx, vrtx, j, dest, visited);             # Backtracking            # Make vertex unvisited            visited[j] = False;     # Return total ways    return total # Function to count total ways# to reach destinationdef totalWays(mtrx, vrtx, src, dest):    visited = [False]*vrtx     # Loop to make all vertex unvisited,    # Initially    for i in range(vrtx):        visited[i] = False     # Make source visited    visited[src] = True;     return countWays(mtrx, vrtx, src, dest,visited) # Driver functionvrtx = 11mtrx = [        [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],        [ 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],        [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 ],        [ 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],        [ 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]    ] src = 3dest = 9 # Print total waysprint(totalWays(mtrx, vrtx, src - 1,dest - 1)) # This code is contributed by atul kumar shrivastava
// C# program to count total number of// ways to reach destination in a graphusing System; class GFG{   // Utility Function to count total waysstatic int countWays(int[,] mtrx, int vrtx,              int i, int dest, bool[] visited){    // Base condition    // When reach to the destination    if (i == dest) {           return 1;    }    int total = 0;    for (int j = 0; j < vrtx; j++) {        if (mtrx[i,j] == 1 && !visited[j]) {               // Make vertex visited            visited[j] = true;               // Recursive function, for count ways            total += countWays(mtrx, vrtx,                               j, dest, visited);               // Backtracking            // Make vertex unvisited            visited[j] = false;        }    }       // Return total ways    return total;}   // Function to count total ways// to reach destinationstatic int totalWays(int[,] mtrx, int vrtx,              int src, int dest){    bool[]visited = new bool[vrtx];       // Loop to make all vertex unvisited,    // Initially    for (int i = 0; i < vrtx; i++) {        visited[i] = false;    }       // Make source visited    visited[src] = true;       return countWays(mtrx, vrtx, src, dest,                     visited);}   public static void Main(){    int vrtx = 11;    int[,] mtrx = {        { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 },        { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 },        { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 },        { 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 },        { 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 },        { 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },        { 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 },        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 }    };       int src = 3;    int dest = 9;       // Print total ways    Console.Write(totalWays(mtrx, vrtx, src - 1,                      dest - 1));   }}
<script>// Javascript program to count total number of// ways to reach destination in a graph // Utility Function to count total waysfunction countWays(mtrx,vrtx,i,dest,visited){    // Base condition    // When reach to the destination    if (i == dest) {            return 1;    }    let total = 0;    for (let j = 0; j < vrtx; j++) {        if (mtrx[i][j] == 1 && !visited[j]) {                // Make vertex visited            visited[j] = true;                // Recursive function, for count ways            total += countWays(mtrx, vrtx,                               j, dest, visited);                // Backtracking            // Make vertex unvisited            visited[j] = false;        }    }        // Return total ways    return total;} // Function to count total ways// to reach destinationfunction totalWays(mtrx,vrtx,src,dest){    let visited = new Array(vrtx);        // Loop to make all vertex unvisited,    // Initially    for (let i = 0; i < vrtx; i++) {        visited[i] = false;    }        // Make source visited    visited[src] = true;        return countWays(mtrx, vrtx, src, dest,                     visited);} let vrtx = 11;let mtrx=[        [ 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],        [ 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],        [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],        [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 ],        [ 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],        [ 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 ],        [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ]    ];     let src = 3;let dest = 9;// Print total waysdocument.write(totalWays(mtrx, vrtx, src - 1,                      dest - 1));// This code is contributed by avanitrachhadiya2155</script>
6
 
Performance Analysis:  
Time Complexity: In the above approach, for a given vertex, we check all vertices, so the time complexity is O(N*N) where N is no of vertices. 
Auxiliary Space Complexity: In the above approach, we are using a visited array of size N where N is the number of vertices, so Auxiliary space complexity is O(N).
 
Atul_kumar_Shrivastava
Rajput-Ji
ukasp
Akanksha_Rai
avanitrachhadiya2155
Algorithms-Graph Traversals
DFS
Backtracking
Graph
Recursion
Recursion
DFS
Graph
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Difference between Backtracking and Branch-N-Bound technique
Minimum Cost Path in a directed graph via given set of intermediate nodes
Tug of War
N-Queen Problem | Local Search using Hill climbing with random neighbour
Generate all possible combinations of K numbers that sums to N
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5