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

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 = 4Output :1 3 6 10 1 2 3 4 1 1 1 1Input :N = 5, M = 2Output :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 progarm 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; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java progarm to find number of shortest paths ` `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 ` |

*chevron_right*

*filter_none*

## C#

// C# progarm 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
[tabbyending]
**Output :**

1 5 1 4 1 3 1 2 1 1

**Time complexity:** O(N × M)

## Recommended Posts:

- Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row
- Minimum cells traversed to reach corner where every cell represents jumps
- Minimum cells required to reach destination with jumps equal to cell values
- Find the minimum number of moves needed to move from one cell of matrix to another
- Number of shortest paths in an unweighted and directed graph
- Final cell position in the matrix
- Distance of nearest cell having 1 in a binary matrix
- Find if a 2-D array is completely traversed or not by following the cell values
- Unique paths in a Grid with Obstacles
- Find sum of all elements in a matrix except the elements in row and/or column of given cell?
- Unique paths covering every non-obstacle block exactly once in a grid
- Shortest paths from all vertices to a destination
- Shortest distance between two cells in a matrix or grid
- Johnson's algorithm for All-pairs shortest paths
- Printing Paths in Dijkstra's Shortest Path Algorithm

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.