Time Complexity: O(m * n), where m is the number of rows and n is the number of columns in the grid. This is because we are filling up a 2D DP array of size m x n, and each cell takes constant time to compute.

Space Complexity: O(m * n), due to the storage of the DP array which keeps track of the number of unique paths to each cell in the grid.

Tabulation Approach

Algorithm

Declare a dp[] array of size [m][n], where m and n represent the number of rows and columns of the grid, respectively. The dp[i][j] stores the total number of ways to reach from the start (0,0) to the cell (i,j).
Set the base case: As per the recursive approach, dp[0][0] is 1, indicating there is only one way to reach the starting position. So, initialize dp[0][0] = 1.
Use two nested loops to fill the dp array iteratively. The outer loop iterates through rows (i from 0 to m-1), and the inner loop iterates through columns (j from 0 to n-1).
For each cell dp[i][j], calculate the number of ways to reach it from the top (dp[i-1][j]) and from the left (dp[i][j-1]). Add the values of dp[i-1][j] and dp[i][j-1] to get the total number of ways to reach dp[i][j].
As the question asks for the total number of ways, update dp[i][j] as the sum of dp[i-1][j] (ways from above) and dp[i][j-1] (ways from left).
Once all cells are processed, the last element dp[m-1][n-1] will contain the total number of ways to reach the destination (bottom-right corner) of the grid. Return this value as the result after the bottom-up computation.

Code