Thanks a lot for helping Harry Potter in finding the Sorcerer's Stone of Immortality in October. Did we not tell you that it was just an online game ? uhhh! now here is the real onsite task for Harry. You are given a magrid S ( a magic grid ) having R rows and C columns. Each cell in this magrid has either a Hungarian horntail dragon that our intrepid hero has to defeat, or a flask of magic potion that his teacher Snape has left for him. A dragon at a cell (i,j) takes away |S[i][j]| strength points from him, and a potion at a cell (i,j) increases Harry's strength by S[i][j]. If his strength drops to 0 or less at any point during his journey, Harry dies, and no magical stone can revive him.
Harry starts from the top-left corner cell (1,1) and the Sorcerer's Stone is in the bottom-right corner cell (R,C). From a cell (i,j), Harry can only move either one cell down or right i.e., to cell (i+1,j) or cell (i,j+1) and he can not move outside the magrid. Harry has used magic before starting his journey to determine which cell contains what, but lacks the basic simple mathematical skill to determine what minimum strength he needs to start with to collect the Sorcerer's Stone. Please help him once again.
Input (STDIN):
The first line contains the number of test cases T. T cases follow. Each test case consists of R C in the first line followed by the description of the grid in R lines, each containing C integers. Rows are numbered 1 to R from top to bottom and columns are numbered 1 to C from left to right. Cells with S[i][j] < 0 contain dragons, others contain magic potions.
Output (STDOUT):
Output T lines, one for each case containing the minimum strength Harry should start with from the cell (1,1) to have a positive strength through out his journey to the cell (R,C).
Constraints:
1 ≤ T ≤ 5
2 ≤ R, C ≤ 500
-10^3 ≤ S[i][j] ≤ 10^3
S[1][1] = S[R][C] = 0
Sample Input:
3
2 3
0 1 -3
1 -2 0
2 2
0 1
2 0
3 4
0 -2 -3 1
-1 4 0 -2
1 -2 -3 0
Sample Output:
2
1
2
Explanation:
Case 1 : If Harry starts with strength = 1 at cell (1,1), he cannot maintain a positive strength in any possible path. He needs at least strength = 2 initially.
Case 2 : Note that to start from (1,1) he needs at least strength = 1.
题意：
给你一副图,问你从图左上点走到右下点，所需要的最小初始分数，因为每走到一点就要加上改点的值，且你要保证在中途每点上你的分数的值至少为1，你的走路方式只能往右走或下走。
思路：
一开始想用DFS，好吧，打完后超时，不知道哪位小伙伴能用DFS加剪枝做出答案，求分享。其次看到如此简单的走路方式，想必他也是头铁（滑稽），想到可以用dp,但并不是从起点开始算，而是逆向思维，从终点开始算。
因为假设dp[i][j]会保存每一点到终点的最小需求分数，那么这个分数dp[i][j] = 至少1分 or min（dp[i+1][j],dp[i][j+1])-a[i][j] .可知我们要先算出dp[i+1][j]和dp[i][j+1]才行。即逆向dp
正向dp不行，因为这样只能算出从起点到终点最大或最小分数
AC代码：
| Time | 230ms |
|---|---|
| Memory | 18432kB |
| Length | 945 |
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
int t;
scanf("%d",&t);
int a[505][505],dp[505][505];
while( t-- )
{
int n,m;
scanf("%d%d",&n,&m);
for( int i=0; i<n; i++ )
for( int j=0; j<m; j++ )
scanf("%d",&a[i][j]);
dp[n-1][m-1] = 1;
for( int i=n-1; i>=0; i-- )
{
for( int j=m-1; j>=0; j-- )
{
if( j==m-1 && i!=n-1 )
{
dp[i][j] = max( 1,dp[i+1][j] - a[i][j] );
}
else if( i==n-1 && j!=m-1 )
{
dp[i][j] = max( 1, dp[i][j+1] - a[i][j] ) ;
}
else if( j!=m-1 && i!=n-1 )
{
dp[i][j] = max( 1,min(dp[i][j+1],dp[i+1][j])-a[i][j]);
}
}
}
printf("%d\n",dp[0][0]);
}
return 0;
}