Open In App

Number of shortest paths to reach every cell from bottom-left cell in the grid

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given two number N and M. The task is to find the number of shortest paths to reach the cell(i, j) in the grid of size N × M when the moves started from the bottom-left corner
Note: cell(i, j) represents the ith row and jth column in the grid
Below image shows some of the shortest paths to reach cell(1, 4) in 4 × 4 grid 
 

Examples : 
 

Input : N = 3, M = 4 
Output : 1 3 6 10 
         1 2 3 4 
         1 1 1 1  

Input : N = 5, M = 2 
Output : 1 5 
         1 4 
         1 3 
         1 2 
         1 1 

 

Approach : An efficient approach is to compute the grid starting from the bottom-left corner. 

  • The number of shortest paths to reach cell(n, i) is 1, where, 1 < = i < = M
  • The number of shortest paths to reach cell(i, 1) is 1, where, 1 < = i < = N
  • The number of shortest paths to reach cell(i, j) are the sum the number of shortest paths of cell(i-1, j) and (i, j+1), where, 1 < = j < = M and 1 < = i < = N

Below is the implementation of the above approach : 
 

C++




// CPP program to find number of shortest paths
#include <bits/stdc++.h>
using namespace std;
 
// Function to find number of shortest paths
void NumberOfShortestPaths(int n, int m)
{
    int a[n][m];
 
    for (int i = 0; i < n; i++)
        memset(a[i], 0, sizeof(a[i]));
 
    // Compute the grid starting from
    // the bottom-left corner
    for (int i = n - 1; i >= 0; i--) {
        for (int j = 0; j < m; j++) {
            if (j == 0 or i == n - 1)
                a[i][j] = 1;
            else
                a[i][j] = a[i][j - 1] + a[i + 1][j];
        }
    }
 
    // Print the grid
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
}
 
// Driver code
int main()
{
    int n = 5, m = 2;
 
    // Function call
    NumberOfShortestPaths(n, m);
 
    return 0;
}


Java




// Java program to find number of shortest paths
import java.io.*;
class GFG
{
 
// Function to find number of shortest paths
static void NumberOfShortestPaths(int n, int m)
{
    int [][]a = new int[n][m];
 
    // Compute the grid starting from
    // the bottom-left corner
    for (int i = n - 1; i >= 0; i--)
    {
        for (int j = 0; j < m; j++)
        {
            if (j == 0 || i == n - 1)
                a[i][j] = 1;
            else
                a[i][j] = a[i][j - 1] + a[i + 1][j];
        }
    }
 
    // Print the grid
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            System.out.print(a[i][j] + " ");
        }
        System.out.println();
    }
}
 
// Driver code
public static void main(String[] args)
{
    int n = 5, m = 2;
 
    // Function call
    NumberOfShortestPaths(n, m);
}
}
 
// This code is contributed by Princi Singh


Python3




# Python 3 program to find
# number of shortest paths
 
# Function to find number of shortest paths
def NumberOfShortestPaths(n, m):
    a = [[0 for i in range(m)]
            for j in range(n)]
 
    for i in range(n):
        for j in range(m):
            a[i][j] = 0
 
    # Compute the grid starting from
    # the bottom-left corner
    i = n - 1
    while(i >= 0):
        for j in range(m):
            if (j == 0 or i == n - 1):
                a[i][j] = 1
            else:
                a[i][j] = a[i][j - 1] + \
                          a[i + 1][j]
 
        i -= 1
 
    # Print the grid
    for i in range(n):
        for j in range(m):
            print(a[i][j], end = " ")
        print("\n", end = "")
 
# Driver code
if __name__ == '__main__':
    n = 5
    m = 2
 
    # Function call
    NumberOfShortestPaths(n, m)
     
# This code is contributed by
# Surendra_Gangwar


C#




// C# program to find number of shortest paths
using System;
 
class GFG
{
 
// Function to find number of shortest paths
static void NumberOfShortestPaths(int n, int m)
{
    int [,]a = new int[n, m];
 
    // Compute the grid starting from
    // the bottom-left corner
    for (int i = n - 1; i >= 0; i--)
    {
        for (int j = 0; j < m; j++)
        {
            if (j == 0 || i == n - 1)
                a[i, j] = 1;
            else
                a[i, j] = a[i, j - 1] + a[i + 1, j];
        }
    }
 
    // Print the grid
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            Console.Write(a[i, j] + " ");
        }
        Console.Write("\n");
    }
}
 
// Driver code
public static void Main(String[] args)
{
    int n = 5, m = 2;
 
    // Function call
    NumberOfShortestPaths(n, m);
}
}
 
// This code is contributed by PrinciRaj1992


Javascript




<script>
// javascript program to find number of shortest paths   
// Function to find number of shortest paths
    function NumberOfShortestPaths(n , m) {
        var a = Array(n).fill().map(() => Array(m).fill(0));
 
        // Compute the grid starting from
        // the bottom-left corner
        for (var i = n - 1; i >= 0; i--) {
            for (j = 0; j < m; j++) {
                if (j == 0 || i == n - 1)
                    a[i][j] = 1;
                else
                    a[i][j] = a[i][j - 1] + a[i + 1][j];
            }
        }
 
        // Print the grid
        for (var i = 0; i < n; i++) {
            for (j = 0; j < m; j++) {
                document.write(a[i][j] + " ");
            }
            document.write("<br/>");
        }
    }
 
    // Driver code
        var n = 5, m = 2;
 
        // Function call
        NumberOfShortestPaths(n, m);
 
// This code is contributed by gauravrajput1
</script>


Output

1 5 
1 4 
1 3 
1 2 
1 1 

Time complexity: O(N × M), where N is number of rows and M is number of columns of the grid.
Auxiliary Space: O(N × M), where N is number of rows and M is number of columns of the grid.



Last Updated : 15 Dec, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads