拯救雅典娜——倒序动态规划

题目：

 *黄金圣斗士拯救雅典娜，雅典娜在右下角
 * 每次只能往右边或者下面走，每个位置的值代表遭遇的事件，如果是负数则扣血
 * 如果是正数则回血，走到任何一个位置，血量都不能少于1，为了保证救出雅典娜，
 * 初始血量至少是多少？

sample data：
map[3][3]

 * -2 　-3　 3
 * -5　-10　1
 * 0 　30　-5

这明显是一道动态规划的题目，题目的意思是求dp[0][0]位置的最少血量，那么我们可以考虑倒着使用动态规划，从右下角雅典娜位置开始。

在右下角中，map[2][2]的数字如果是正数，那么dp[2][2]=1就能保证活着;如果是负数，那么dp[2][2]=-map[2][2]+1才能保证活着;

其余位置，最右边的列中，圣斗士只能往下，从而有dp[i][2]=Math.max[dp[i+1][2]-map[i][2],1);
最下一行，有dp[2][j]=Math.max[dp[2][j+1]-map[j][2],1);

最后中间的其他数，则是求右边和下边的dp数的最小值。
即dp[i][j] = Math.min(Math.max(dp[i][j + 1] - map[i][j], 1), Math.max(dp[i + 1][j] - map[i][j], 1));
下面写出代码：

github传送门

public class Pure2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] map = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                map[i][j] = in.nextInt();
            }
        }
        System.out.print(getMin(n, m, map));
    }

    public static int getMin(int n, int m, int[][] map) {
        if (map == null || n == 0 || m == 0) return 1;
        int dp[][] = new int[n][m];
        //反方向的动态规划
        dp[n - 1][m - 1] = Math.max(-map[n - 1][m - 1] + 1, 1);
        for (int i = n - 2; i >= 0; i--) {
            dp[i][m - 1] = Math.max(dp[i + 1][m - 1] - map[i][m - 1], 1);
        }
        for (int i = m - 2; i >= 0; i--) {
            dp[n - 1][i] = Math.max(dp[n - 1][i + 1] - map[n - 1][i], 1);
        }
        for (int i = n - 2; i >= 0; i--) {
            for (int j = n - 2; j >= 0; j--) {
                dp[i][j] = Math.min(Math.max(dp[i][j + 1] - map[i][j], 1), Math.max(dp[i + 1][j] - map[i][j], 1));
            }
        }
        return dp[0][0];
    }
}

完结