蓝桥杯2021模拟赛 动态规划 dp 跳跃 JAVA实现

题目描述

蓝桥杯原题：题目链接

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

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

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

例如，如果当前小蓝在第 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, mn,m，表示图的大小。

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

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

输入输出样例
示例 1
输入

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

输出

15

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

题解

思路：
nums[][]保存读入的数据
dp[i][j]表示走到i行j列的最优解

可以走到dp[I][J]的关系图：
	 						 			   dp[i-3][j]
	 						  dp[i-2][j-1] dp[i-2][j]
				 dp[i-1][j-2] dp[i-1][j-1] dp[i-1][j]
	dp[i][j-3]   dp[i][j-2]   dp[i][j-1]   dp[i][j]
	
	 可得出递推公式(在上面这些值不包括dp[i][j] 里选出最大的值)
	 dp[i][j]= nums[i][j]+max(
	 				dp[i][j-1],dp[i][j-2],dp[i][j-3],
	 				dp[i-1][j-0],dp[i-1][j-1],dp[i-1][j-2],
	 				dp[i-2][j-0],dp[i-1][j-1],
	 				dp[i-3][j-0])

	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n=scanner.nextInt();
		int m=scanner.nextInt();
		int[][] nums = new int[n][m];
		//读取输入
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				nums[i][j] =scanner.nextInt();
			}
		}
		
		//在dp前面和左边多加几条 方便计算dp[i][j]  因为往上会有dp[i-3][j] dp[i][j-3]
		int[][] dp = new int[n+3][m+3];
		//为了不影响计算dp[i][j] 把整个dp都填充最小值
		for (int i = 0; i < dp.length; i++) {
			Arrays.fill(dp[i], Integer.MIN_VALUE);
		}
		//nums和dp的下标相差3  初始化只用给首个
		dp[3][3] = nums[0][0];
		
		for (int i = 3; i < dp.length; i++) {
			for (int j = 3; j < dp[0].length; j++) {
				//如果是刚才初始化过dp[3][3]就跳过
				if(i==3&&j==3) continue;
				
				/*
				 实现计算前面的max最大值 也就是前面思路max中的一大堆
				 这里不太美观 嫌麻烦的可以用递归或者dfs
				 * */
				int max = Integer.MIN_VALUE;
				for (int k = 0; k<=3; k++) {
					for (int k2 = 3-k; k2 >=0; k2--) {
						if (k==0 && k2==0) continue;
						max=Math.max(max,dp[i-k][j-k2]);
					}
				}
				//递推公式
				dp[i][j] = nums[i-3][j-3]+max;
				
			}
		}
		
		System.out.println(dp[n+2][m+2]);
	}