Minimum cells traversed to reach corner where every cell represents jumps

https://www.geeksforgeeks.org/minimum-cells-traversed-reach-corner-every-cell-represents-jumps/

Suppose A is at position (0, 0) of a 2-D grid containing ‘m’ rows and ‘n’ columns. His aim is to reach the bottom right point of this grid traveling through as minimum number of cells as possible.

Each cell of the grid contains a positive integer that defines the number of cells A can jump either in the right or the downward direction when he reaches that cell.

Find the minimum no of cells that need to be touched in order to reach bottom right corner.

Examples:

Input : 2 4 2
        5 3 8
        1 1 1
Output :
So following two paths exist to reach (2, 2) from (0, 0)
(0, 0) => (0, 2) => (2, 2) 
(0, 0) => (2, 0) => (2, 1) => (2, 2) 

Hence the output for this test case should be 3 

Following is a Breadth First Search(BFS) solution of the problem:

1. Think of this matrix as tree and (0, 0) as root and apply BFS using level order traversal.
2. Push the coordinates and no of jumps in a queue.
3. Pop the queue after every level of tree.
4. Add the value at cell to the coordinates while traversing right and downward direction.
5. Return no of cells touched while jumping when it reaches bottom right corner.

Time Complexity : O(n)

bool safe(int x, int y)

{

    if (x < R && y < C && x >= 0 && y >= 0)

        return true;

    return false;

}

  

// function to return minimum no of cells to reach

// bottom right cell.

int matrixJump(int M[R][C], int R1, int C1)

{

    queue<pair<int, pair<int, int> > > q;

  

    // push the no of cells and coordinates in a queue.

    q.push(make_pair(1, make_pair(R1, C1)));

  

    while (!q.empty()) {

        int x = q.front().second.first; // x coordinate

        int y = q.front().second.second; // y coordinate

        int no_of_cells = q.front().first; // no of cells

  

        q.pop();

  

        // when it reaches bottom right return no of cells

        if (x == R - 1 && y == C - 1)            

            return no_of_cells;

  

        int v = M[x][y];

  

        if (safe(x + v, y))

            q.push(make_pair(no_of_cells + 1, make_pair(x + v, y)));

  

        if (safe(x, y + v))

            q.push(make_pair(no_of_cells + 1, make_pair(x, y + v)));

    }

  

    // when destination cannot be reached

    return -1;

}




https://www.geeksforgeeks.org/minimum-cells-required-reach-destination-jumps-equal-cell-values/

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)

    static int minCells(int mat[][], int m, int n)

    {

        // to store min cells required to be

        // covered to reach a particular cell

        int dp[][] = new int[m][n];

        

        // initially no cells can be reached

        for (int i = 0; i < m; i++)

            for (int j = 0; j < n; j++)

                dp[i][j] = Integer.MAX_VALUE;

        

        // base case

        dp[0][0] = 1;

        

        // building up the dp[][] matrix

        for (int i = 0; i < m; i++) {

            for (int j = 0; j < n; j++) {

        

                // dp[i][j] != INT_MAX denotes that cell

                // (i, j) can be reached from cell (0, 0)

                // and the other half of the condition

                // finds the cell on the right that can

                // be reached from (i, j)

                if (dp[i][j] != Integer.MAX_VALUE && 

                   (j + mat[i][j]) < n && (dp[i][j] + 1)

                   < dp[i][j + mat[i][j]])

                    dp[i][j + mat[i][j]] = dp[i][j] + 1;

        

                // the other half of the condition finds

                // the cell right below that can be 

                // reached from (i, j)

                if (dp[i][j] != Integer.MAX_VALUE && 

                   (i + mat[i][j]) < m && (dp[i][j] + 1)

                   < dp[i + mat[i][j]][j])

                    dp[i + mat[i][j]][j] = dp[i][j] + 1;

            }

        }

        

        // it true then cell (m-1, n-1) can be reached

        // from cell (0, 0) and returns the minimum

        // number of cells covered

        if (dp[m - 1][n - 1] != Integer.MAX_VALUE)

            return dp[m - 1][n - 1];

        

        // cell (m-1, n-1) cannot be reached from

        // cell (0, 0)

        return -1;

    }