给定amxn矩阵mat [] []包含正整数。问题是要遵循给定的约束，从像元(0，0)到达像元(m-1，n-1)。从一个单元格(i，j)，只有在移动到以下位置时，才能“精确”移动“ mat [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 sahilshelangiaC#
// 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.PHP
输出：
Minimum number of cells = 4
时间复杂度：O(m * n)
辅助空间：O(m * n)