题目描述
设有N×N 的方格图(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 0。如下图所示（见样例）:
A
0 0 0 0 0 0 0 0
0 0 13 0 0 6 0 0
0 0 0 0 7 0 0 0
0 0 0 14 0 0 0 0
0 21 0 0 0 4 0 0
0 0 15 0 0 0 0 0
0 14 0 0 0 0 0 0
0 0 0 0 0 0 0 0
B
某人从图的左上角的 A 点出发，可以向下行走，也可以向右走，直到到达右下角的 B 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 0）。
此人从 A 点到 B 点共走两次，试找出 2 条这样的路径，使得取得的数之和为最大。
输入格式
输入的第一行为一个整数 N（表示N×N 的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的 0 表示输入结束。
输出格式
只需输出一个整数，表示 2 条路径上取得的最大的和。
输入输出样例
输入：
8
2 3 13
2 6 6
3 5 7
4 4 14
5 2 21
5 6 4
6 3 15
7 2 14
0 0 0
输出：
67
最开始看到这一题以为只是简单的动态规划，跑两遍就算结束了，但仔细想想好像又不太对劲，动态规划我似乎要到最后才可以知道他的一条路径上的元素到底是什么？所以不可取，后来想DFS或许可以，毕竟这一题给的数据并不是一整个矩阵的数据，而是一个一个的，我计算出他给出每一组数据到终点b的最大值，结果发现好像还是走不通，没办法去看了一下大佬的思路，好吧，还是动态规划，不过并不是平常的一维，二维，而是四维，草，就TM离谱，长见识了。
这边先写一下四维动规的公式
dp[x][y][i][j] = max(max(dp[x-1][y][i-1][j], dp[x-1][y][i][j-1]),max(dp[x][y-1][i-1][j], dp[x][y-1][i][j-1]))
思路大致是在这样的，假设两人同时开始走，遍历两个人所走方格的所有的可能搭配，然后输出最后的值就好了，dp[x][y][i][j]表示当前第一个人走到坐标为（x, y）的格子，第二个人走到（i，j）的格子时的最大值，比较麻烦的是要处理边界问题，这里是借用别人的代码，他直接选择扩大数组大小来解决这个问题,而走到重复点时只要加上一个数组元素就可以了，不重复加俩，这段代码也存在一个问题，x+y和i+j的值并不相等时dp的值没有什么意义。
//四维
import java.io.IOException;
import java.util.Scanner;
public class grid_access_1 {
public static void main(String[] args) throws IOException {
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int[][] arr = new int[num+3][num+3];
int x, y, z;
x = in.nextInt();
y = in.nextInt();
z = in.nextInt();
while (x != 0 && y != 0 && z !=0){
arr[x][y] = z;
x = in.nextInt();
y = in.nextInt();
z = in.nextInt();
}
int[][][][] dp = new int[num+3][num+3][num+3][num+3];
for (int i = 1; i <= num; i++){
for (int j = 1;j <= num;j++){
for (int k = 1; k <= num; k++){
for (int t = 1;t <= num; t++){
dp[i][j][k][t] = Math.max(
Math.max(dp[i-1][j][k-1][t], dp[i-1][j][k][t-1]),
Math.max(dp[i][j-1][k-1][t], dp[i][j-1][k][t-1])
);
if (i == k && j == t){
dp[i][j][k][t] += arr[i][j];
}else {
dp[i][j][k][t] += arr[i][j] + arr[k][t];
}
}
}
}
}
System.out.println(dp[num][num][num][num]);
}
}
承接上文，你可以选择用个if语句，当i+j != k+t时直接跳出来避免一些不必要的计算，当然你也可以试着别的方法，我们观察四维dp的四个值分别时两个角色的横纵坐标，两个角色走的长度相同才具有意义，那么我们可以用一个三维dp去代替这个四维dp，三维dp的三个值分别表示走的长度，一个角色的横/纵坐标，另一个角色的横/纵坐标，dp公式如下。
dp[l][i][j] = max(max(dp[l-1][i-1][j-1], dp[l-1][i][j]), max(dp[l-1][i-1][j], dp[l-1][i][j-1]))
通过寻找四维数组中四个值之间的关系，从而利用三个值代表四个值，实现了数据的降维,同时避免了不必要的计算，下面给出我自己的代码，其中关于数组越界问题，我选择写了两个函数解决，一旦数组可能越界，就返回0值，否则返回正常值。
import java.util.Scanner;
public class grid_access_4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[][] arr = new int[num][num];
int x, y, z;
x = scanner.nextInt();
y = scanner.nextInt();
z = scanner.nextInt();
while (x != 0 && y != 0 && z != 0){
arr[x-1][y-1] = z;
x = scanner.nextInt();
y = scanner.nextInt();
z = scanner.nextInt();
}
//l代表走的次数，i代表横坐标，j代表第二个人横坐标
int[][][] dp = new int[num*2][num][num];
for (int l = 0;l < num*2;l++){
for (int i = 0;i < num && i <= l;i++){
if ((l-i) >= num)continue;
for (int j = 0;j < num && j <= l;j++){
if ((l-j) >= num) continue;
if (l == 0){dp[l][i][j] = arr[0][0];}
else {
dp[l][i][j] = Math.max(
Math.max(get_dpvalue(l-1, i-1, j-1, dp), get_dpvalue(l-1, i, j, dp)),
Math.max(get_dpvalue(l-1, i-1, j, dp), get_dpvalue(l-1, i, j-1, dp))
);
if (i == j){
dp[l][i][j] += get_arrvalue(l-i, i, arr);
}else {
dp[l][i][j] += get_arrvalue(l-i, i, arr) + get_arrvalue(l-j, j, arr);
}
}
}
}
}
System.out.println(dp[num*2-2][num-1][num-1]);
}
static int get_dpvalue(int l,int i,int j, int[][][] dp){
if (l < 0 || i < 0 || j < 0){return 0;}
else return dp[l][i][j];
}
static int get_arrvalue(int i, int j, int[][] arr){
if (i < 0 || j < 0) return 0;
else return arr[i][j];
}
}
从上面代码中我们很容易就可以看出，这个动态规划解法公式只依赖上一层的结果，那么我们就可以进一步将其降维。
import java.util.Scanner;
public class grid_access_5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int[][] arr = new int[num][num];
int x, y, z;
x = scanner.nextInt();
y = scanner.nextInt();
z = scanner.nextInt();
while (x != 0 && y != 0 && z != 0){
arr[x-1][y-1] = z;
x = scanner.nextInt();
y = scanner.nextInt();
z = scanner.nextInt();
}
int[][] dp = new int[num][num];
for (int l = 0;l < num*2-1;l++){
//这里因为每一次更新数据都需要用到前面坐标的数据，所以采用倒序进行获取
for (int i = num-1;i >= 0;i--){
if ((l-i) >= num || i > l)continue;
for (int j = num-1;j >= 0;j--){
if ((l-j) >= num || j > l)continue;
if (l == 0){dp[i][j] = arr[0][0];continue;}
dp[i][j] = Math.max(
Math.max(get_dpvalue(i-1, j-1, dp), get_dpvalue(i, j, dp)),
Math.max(get_dpvalue(i-1, j, dp), get_dpvalue(i, j-1, dp))
);
if (i == j){
dp[i][j] += get_arrvalue(l-i, i, arr);
}else {
dp[i][j] += get_arrvalue(l-i, i, arr) + get_arrvalue(l-j, j, arr);
}
}
}
}
System.out.println(dp[num-1][num-1]);
}
static int get_dpvalue(int i,int j, int[][] dp){
if (i < 0 || j < 0){return 0;}
else return dp[i][j];
}
static int get_arrvalue(int i, int j, int[][] arr){
if (i < 0 || j < 0) return 0;
else return arr[i][j];
}
}
从一个四维的数组，一步步降维降低到二维，怎么说呢，挺奇妙的，当然这一题也有其他解法，dfs也是可以走通的，不过我还没有去试试，我的代码中也有一些不规范的地方，还需要修改。
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
