蓝桥杯真题 跳跃 C++、Java实现 动态规划小蓝在一个 n 行 m 列的方格图中玩一个游戏。 开始时，小蓝站在方格图的左上角，即第 1 行第 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⁴ ≤权值≤10⁴ 。

输出描述

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

输入输出样例

示例 1

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

输出
15

运行限制

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

代码（c++）

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<string>	
using namespace std;
int arr[110][110];//存储每个点的权值
int av[110][110];//存储从起点到当前位置的最大的总权值
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			cin >> arr[i][j];
			if(i==1&&j==1)av[1][1] = arr[1][1];//初始化1，1位置
			else av[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 && av[i - k][j - h] + arr[i][j] > av[i][j]) {//判断自身以外的前面的8个可以到达该位置的点
						av[i][j] = av[i - k][j - h] + arr[i][j];
					}
				}
			}
		}
	}
	cout << av[n][m] << endl;
	return 0;
}

代码（Java）

import java.util.Scanner;
public class Hello{
	public static void main(String[] args){
		int n,m;
		Scanner scan=new Scanner(System.in);
		n=scan.nextInt();
		m=scan.nextInt();
		int [][]arr=new int[n+1][m+1];//存储每个点的权值
		int [][]av=new int[n+1][m+1];//存储从起点到当前位置的最大的总权值
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				arr[i][j]=scan.nextInt();
				if(i==1&&j==1){
				av[i][j]=arr[i][j];//初始化1，1位置
				}
				else{
				av[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&&av[i-k][j-h]+arr[i][j]>av[i][j]){//判断自身以外的前面的8个可以到达该位置的点
						av[i][j]=av[i-k][j-h]+arr[i][j];
						}
					}
				}
			}
		}
		System.out.println(av[n][m]);
	}
}

思路

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