洛谷P1025 :方格取数

[NOIP2001 提高组] 数的划分 - 洛谷

题面：

设有 N×NN×N 的方格图 (N≤9)(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 00。如下图所示（见样例）:

某人从图的左上角的 A 点出发，可以向下行走，也可以向右走，直到到达右下角的 B 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 0）。
此人从 A 点到 B 点共走两次，试找出 2 条这样的路径，使得取得的数之和为最大。

输入格式

输入的第一行为一个整数 NN（表示 N×NN×N 的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的 00 表示输入结束。

输出格式

只需输出一个整数，表示 2 条路径上取得的最大的和。

输入输出样例

输入 #1

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

输出 #1

67

说明/提示

数据范围：1≤N≤91≤N≤9。

思路：

        1，分两步dp，获取完后手动修改，每次都获取当前迷宫下的最大值(已证明错误)

当方格为

0   4   3

5   5   5

4   2   0        第一次dp时，会选择  下（5，a[1][0] ）,右（5, a[1][1]），右(5,a[1][2])，下(end,a[2][2])

第二次就只能拿第一行的 (4 :a[0][1]) 和 （3: a[0][2] ） ，

和为： 5 + 5 + 5 + 4 + 3 == 22

而无法达成最优解的：

路径1： 4（右）,5（下）,5（右）,0(end）

路径2： 5（下），4（下），2（右），0（end）了

4 + 5 + 5 + 5 + 4 + 2==25

由此证明，在这个有后效性的dp中，单次行走的最佳路径，不能代表同时行走的最佳的两次路径

        2，同时行走，一次走两条路线

代码

import java.util.Scanner;

public class Main {
    static  Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
 
        int n = sc.nextInt();
        int[][] w = new int[20][20];
        int[][][] f = new int[20][20][20];

        int a, b, c;
        while (sc.hasNextInt() ) {
            a=sc.nextInt();
            b=sc.nextInt();
            c=sc.nextInt();
            w[a][b] = c;
        }

        for (int k = 2; k <= n + n; k++) {
            for (int i1 = 1; i1 <= n; i1++) {
                for (int i2 = 1; i2 <= n; i2++) {
                    int j1 = k - i1, j2 = k - i2;
                    if (j1 >= 1 && j1 <= n && j2 >= 1 && j2 <= n) {
                        int t = w[i1][j1];
                        if (i1 != i2) t += w[i2][j2];
                        int x = f[k][i1][i2];
                        x = Math.max(x, f[k - 1][i1 - 1][i2 - 1] + t);
                        x = Math.max(x, f[k - 1][i1 - 1][i2] + t);
                        x = Math.max(x, f[k - 1][i1][i2 - 1] + t);
                        x = Math.max(x, f[k - 1][i1][i2] + t);
                        f[k][i1][i2] = x;
                    }
                }
            }
        }

        System.out.println(f[n + n][n][n]);
    }
}