【2022刷题】跳跃

引言

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

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

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

例如，如果当前小蓝在第 33 行第 55 列，他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。

小蓝最终要走到第 nn 行第 mm 列。

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

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

输入描述

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

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

其中，1 <=n <=100，-10⁴<=权值 <=10⁴。

输出描述

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

输入输出样例

示例 1

输入

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

输出

15

---

解题思路

要求走到第 n行第 m 列后，总的权值和最大。而小蓝可以在方格图上走动，走动时，如果当前在第 r 行第 c 列，他不能走到行号比 r 小的行，也不能走到列号比 c 小的列。同时，他一步走的直线距离不超过 3。所以：

• 到第 n行第 m 列只可能从第 n行第 m-1 列，第 n行第 m-2 列，第 n行第 m-3 列，第 n-1行第 m 列，第 n-2行第 m 列，第 n-3行第 m 列.第 n-1行第 m -2列，第 n-1行第 m-1 列，第 n-2行第 m-1 列走到。
• 故求走到第 n行第 m 列后，总的权值和最大，只需要考虑之前走过的位置中的最大值+第 n行第 m 列的权值即可。
• 符合这种情况就可以用动态规划来解决，其初始状态dp[1][1] = g[1][1]
• 状态转移方程如下：

dp[n][m] = Max{dp[n][m-1],dp[n][m-2],dp[n][m-3],dp[n-1][m],dp[n-2][m],dp[n-3][m],dp[n-1][m-1],dp[n-1][m-2],dp[n-2][m-1]}+g[n][m];
（g为矩阵的权值 dp为第n行m列的最大权值）

代码部分

import java.util.*;
import java.io.*;


public class Main {
	static int dp[][] = new int[1000][1000];
	static int g[][] = new int[1000][1000];
	public static void main(String[] args) throws  IOException {
    	//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	Scanner scan = new Scanner(System.in);
    	int n = scan.nextInt(),m = scan.nextInt();
    	ArrayList<Integer> max = new ArrayList<Integer>();//用来比较大小
    	for(int i = 0;i<1000;i++) {//给数组赋初值
    		Arrays.fill(dp[i], 0);
        	Arrays.fill(g[i], 0);
    	}
    	scan.nextLine();
    	for(int i = 1;i<=n;i++) {//存权值
    		for(int j = 1;j<=m;j++) {
    			g[i][j] = scan.nextInt();
    		}
    		scan.nextLine();
    	}
    	for(int i = 1;i<=n;i++) {
    		for(int j = 1;j<=m;j++) {
    			max.clear();//每次清空
    			if(j>1) {//防止数组越界
    				max.add(dp[i][j-1]);
    				if(j>2) {
    					max.add(dp[i][j-2]);
    					if(j>3) {
        					max.add(dp[i][j-3]);
        				}
    				}
    			}
    			if(i>1) {
    				max.add(dp[i-1][j]);
    				if(i>2) {
    					max.add(dp[i-2][j]);
    					if(i>3) {
        					max.add(dp[i-3][j]);
        				}
    				}
    			}
    			if(i>1&&j>1) {
    				max.add(dp[i-1][j-1]);
    			}
    			if(i>1&&j>2) {
    				max.add(dp[i-1][j-2]);
    			}
    			if(i>2&&j>1) {
    				max.add(dp[i-2][j-1]);
    			}
    			max.sort(null);
    			if(max.size()!=0) {
    				dp[i][j] = max.get(max.size()-1)+g[i][j];
    			}else {
    				dp[i][j] = g[i][j];
    			}
    			
    		}
    	}
    	System.out.println(dp[n][m]);//输出结果
    	scan.close();
    	//br.close();
    }


}