以等于单元格值的跳跃到达目的地所需的最小单元格

给定包含正整数的 amxn 矩阵 mat[][]。问题是通过遵循给定的约束从单元格 (0, 0) 到达单元格 (m-1, n-1)。从一个单元格 (i, j)，只有当移动需要矩阵边界内的单元格。
例如：给定 mat[1][1] = 4，那么只有当这些单元格存在于矩阵中时，才可以移动到单元格 mat[1][5] 和 mat[5][1]。遵循约束检查是否可以从 (0, 0) 到达单元格 (m-1, n-1)。 1如果可以达到，则打印移动过程中需要覆盖的最小单元格数，否则打印“-1”。
例子：

Input : mat[][] = { {2, 3, 2, 1, 4},
                    {3, 2, 5, 8, 2},
                    {1, 1, 2, 2, 1}  }
Output : 4
The movement and cells covered are as follows:
(0, 0)->(0, 2)
          |
        (2, 2)->(2, 4)

Input : mat[][] = { {2, 4, 2},
                {5, 3, 8},
            {1, 1, 1} }
Output : 3

算法：下面给出了一种动态规划方法：

下面是上述方法的实现：

C++

// C++ implementation to count minimum cells required
// to be covered to reach destination
#include 
 
using namespace std;
 
#define SIZE 100
 
// function to count minimum cells required
// to be covered to reach destination
int minCells(int mat[SIZE][SIZE], int m, int n)
{
    // to store min cells required to be
    // covered to reach a particular cell
    int dp[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] = INT_MAX;
 
    // 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] != INT_MAX && (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] != INT_MAX && (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] != INT_MAX)
        return dp[m - 1][n - 1];
 
    // cell (m-1, n-1) cannot be reached from
    // cell (0, 0)
    return -1;
}
 
// Driver program to test above
int main()
{
    int mat[SIZE][SIZE] = { { 2, 3, 2, 1, 4 },
                            { 3, 2, 5, 8, 2 },
                            { 1, 1, 2, 2, 1 } };
 
    int m = 3, n = 5;
    cout << "Minimum number of cells = "
         << minCells(mat, m, n);
 
    return 0;
}

Java

// Java implementation to count minimum
// cells required to be covered to reach
// destination
class MinCellsDestination
{
    static final int SIZE=100;
    
    // function to count minimum cells required
    // to be covered to reach destination
    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;
    }
     
    // Driver code
    public static void main(String args[])
    {
         int mat[][] = { { 2, 3, 2, 1, 4 },
                         { 3, 2, 5, 8, 2 },
                         { 1, 1, 2, 2, 1 }};
   
        int m = 3, n = 5;
        System.out.println("Minimum number of cells" +
                          " = " + minCells(mat, m, n));
    }
}
/* This code is contributed by Danish Kaleem */

Python3

# Python3 implementation to count minimum cells required
# to be covered to reach destination
SIZE=100
MAX=10000000
# function to count minimum cells required
# to be covered to reach destination
def minCells( mat,  m,  n):
    # to store min cells required to be
    # covered to reach a particular cell
    dp=[[MAX for i in range(n)]for i in range(m)]
   
    # initially no cells can be reached
     
    # base case
    dp[0][0] = 1
   
    # building up the dp[][] matrix
    for i in range(m):
        for j in range(n): 
            # dp[i][j] != 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] != MAX and
             (j + mat[i][j]) < n and
             (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] != MAX and (i + mat[i][j]) < m
                and (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] != MAX):
        return dp[m - 1][n - 1]
   
    # cell (m-1, n-1) cannot be reached from
    # cell (0, 0)
    return -1
   
# Driver program to test above
mat= [ [ 2, 3, 2, 1, 4 ],
       [ 3, 2, 5, 8, 2 ],
       [ 1, 1, 2, 2, 1 ]]
   
m = 3
n = 5
print("Minimum number of cells = ",
     minCells(mat, m, n))
#this code is contributed by sahilshelangia

C#

// C# implementation to count minimum
// cells required to be covered to reach
// destination
using System;
 
class GFG {
     
    //static int SIZE=100;
     
    // function to count minimum cells required
    // to be covered to reach destination
    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] = int.MaxValue;
     
        // 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] != int.MaxValue &&
                (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] != int.MaxValue &&
                (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] != int.MaxValue)
            return dp[m - 1,n - 1];
     
        // cell (m-1, n-1) cannot be reached from
        // cell (0, 0)
        return -1;
    }
     
    // Driver code
    public static void Main()
    {
        int [,]mat = { { 2, 3, 2, 1, 4 },
                       { 3, 2, 5, 8, 2 },
                       { 1, 1, 2, 2, 1 } };
 
        int m = 3, n = 5;
        Console.WriteLine("Minimum number of "
            + "cells = " + minCells(mat, m, n));
    }
}
 
// This code is contributed by anuj_67.

Javascript

// Javascript implementation to count minimum
// cells required to be covered to reach
// destination
 
let SIZE=100;
      
    // function to count minimum cells required
    // to be covered to reach destination
    function minCells(mat, m, n)
    {
        // to store min cells required to be
        // covered to reach a particular cell
        let dp = new Array(m);
         
        // Loop to create 2D array using 1D array
        for (var i = 0; i < dp.length; i++) {
            dp[i] = new Array(2);
        }
         
        // initially no cells can be reached
        for (let i = 0; i < m; i++)
            for (let j = 0; j < n; j++)
                dp[i][j] = Number.MAX_VALUE;
         
        // base case
        dp[0][0] = 1;
         
        // building up the dp[][] matrix
        for (let i = 0; i < m; i++) {
            for (let j = 0; j < n; j++) {
         
                // dp[i][j] != LET_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] != Number.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] != Number.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] != Number.MAX_VALUE)
            return dp[m - 1][n - 1];
         
        // cell (m-1, n-1) cannot be reached from
        // cell (0, 0)
        return -1;
    }
   
// driver function
 
        let mat = [[ 2, 3, 2, 1, 4 ],
                         [ 3, 2, 5, 8, 2 ],
                         [ 1, 1, 2, 2, 1 ]];
     
        let m = 3, n = 5;
        document.write("Minimum number of cells" +
                          " = " + minCells(mat, m, n));
   

输出：

Minimum number of cells = 4

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。