算法：小蓝在一个n行 m列的方格图中玩一个游戏

1、题目描述

小蓝在一个 n 行 m 列的方格图中玩一个游戏。

开始时，小蓝站在方格图的左上角，即第 1 行第 1 列。

小蓝可以在方格图上走动，走动时，如果当前在第 r 行第 c 列，他不能走到行号比 r 小的行，也不能走到列号比 c 小的列。同时，他一步走的直线距离不超过 3。

例如，如果当前小蓝在第 3 行第 5 列，他下一步可以走到第 3 行第 6 列、第 3 行第 7 列、第 3行第 8 列、第 4 行第 5列、第 4 行第 6 列、第 4行第 7 列、第 5 行第 5 列、第 5 行第 6 列、第 6 行第 5 列之一。

小蓝最终要走到第 n 行第 m 列。

在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。

小蓝希望，从第 1行第 1 列走到第 n行第 m列后，总的权值和最大。请问最大是多少？

输入描述

输入的第一行包含两个整数 n, m表示图的大小。

接下来 n行，每行 m个整数，表示方格图中每个点的权值。

其中，1<=n<=100, -10^4<=权值<=10^4

输出描述

输出一个整数，表示最大权值和。

输入输出样例

示例 1

输入

3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

输出

15

运行限制

• 最大运行时间：1s
• 最大运行内存: 128M

2、问题：看过题之后，没什么思路，只会搞个嵌套循环，将输入的权值存入一个二维数组中，然后就看了算法库中别人的题解，看了也有些时间。

3、思路
经典的动态规划的思路，通过记事本的方式记录下来前面的位置的最大的权值，在后续计算的时候不需要重复计算，从而减少计算量。这道题的递推的方式是对当前（i，j）点进行判断时，通过对其前面的可以到达该点的8个点分别判断然后选出最大的到达该点的路径，之后进行存储，然后最终得出终点的最大权值。

package practice;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int[][] arr1 = new int[n + 1][m + 1];//存储每个点的权值
        int[][] arr2 = new int[n + 1][m + 1];//存储从起点到当前位置的最大的总权值
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                arr1[i][j] = scan.nextInt();
                if (i == 1 && j == 1) {
                    arr2[i][j] = arr1[i][j];//初始化 1，1 的位置
                } else {
                    arr2[i][j] = -10000;
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i == 1 && j == 1) {
                    continue;//结束当前所在循环当前次序，进行下一次循环
                }
                for (int k = 0; k < 3; k++) {
                    for (int h = 0; h < 3; h++) {
                        if (h == 0 && k == 0) {//对自身不判断
                            continue;
                        }
                        if (i - k > 0 && j - h > 0 && arr2[i - k][j - h] + arr1[i][j] > arr2[i][j]) {
                            arr2[i][j] = arr2[i - k][j - h] + arr1[i][j];
                        }
                    }
                }
            }
        }
        System.out.println(arr2[n][m]);
        scan.close();
    }
}

package practice;
import java.util.Scanner;
public class Main {    
public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int m = scan.nextInt();
    int[][] arr = new int[n + 1][m + 1];
    int a = 0;
    int[] x = new int[]{0, 0, 0, -1, -1, -1, -2, -2, -3};
    int[] y = new int[]{-3, -2, -1, -2, -1, 0, -1, 0, 0};
        for(int i = 1;i <=n;i++) {
        for (int j = 1; j <= m; j++) {
            arr[i][j] = scan.nextInt();
        }
    }
        for(int i = 1; i <=n;i++) {
        for (int j = 1; j <= m; j++) {
            a = Integer.MIN_VALUE;
            for (int k = 0; k < x.length; k++) {
                if (i + x[k] >= 1 && j + y[k] >= 1) {//求权值的最大值
                    a = Math.max(a, arr[i + x[k]][j + y[k]]);
                }
            }
            if (a != Integer.MIN_VALUE) {
                arr[i][j] += a;
            }
        }
    }
        System.out.println(arr[n][m]);
        scan.close();
    }
}

4、总结：尝试了一种新的算法，从而开阔了自己的思维，了解了整型类型的范围

在JDK中，整形类型是有范围的，最大值为Integer.MAX_VALUE，即2147483647，最小值为Integer.MIN_VALUE -2147483648。
Integer.MAX_VALUE + 1 = Integer.MIN_VALUE
Math.abs(Integer.MIN_VALUE) = Integer.MIN_VALUE （绝对值）
Long，short，byte的结论是相同的。