Question

问题

Jeff喜欢玩游戏，Gluttonous snake（诺基亚时代的老游戏）是他的最爱之一。然而，在玩过贪吃的蛇之后，他终于厌倦了原来的规则。

为了给这款旧游戏带来新挑战，杰夫推出了新规则：

地面是一个网格，有n行和m列（1 <= n，m <= 500）。
每个单元格包含一个值v（-1 vi 99999），如果v为-1，则该单元格被阻塞，≤≤和蛇不能通过，否则，在蛇访问这个单元格后，你可以获得v点。
蛇可以从这个地面左边缘的任何细胞开始，直到最后一直走在右边框的一个单元格停止。
在这次旅行中，蛇只能上/下/右，只能访问每个细胞一次。

特殊情况：

一个。即使在左边界和右边界，蛇也可以上下移动。

湾当蛇位于一列的顶部单元格时，它仍然可以上升，这需要玩家支付所有当前点数，然后蛇将被传送到该列的底部单元格，反之亦然。

在创造了这样一款新游戏之后，杰夫很困惑如何获得最高分。请帮他写一个程序来解决这个问题。

输入第一行包含两个整数n（行）和m（列），（1 <= n，m <= 500），由单个空格分隔。

接下来n行描述网格。每行包含m个整数vi（-1≤vi≤999999） vi = -1表示单元格被阻塞。

输出

输出您可以获得的最高分。如果蛇无法到达右侧，则输出-1。

限制

•每次测试的内存限制：256兆字节

•每次测试的时间限制：编译越好越好

我已经用下面给出的代码解决了问题，然后面试官改变了问题并且要求现在蛇总是必须在其路线中采取特定点，包括该特定点的路径仅在点上有效是（2,1）然后它必须始终在其路径中取3。而且我们必须找到最大总和？我无法在面试中做到这一点，请任何人帮助它，只提供这种类型的问题的链接。我应用dfs面试官告诉dfs在这个问题上是错误的，我无法弄清楚为什么它是错的，什么可以更好的算法找到答案

代码

 import java.util.Scanner;

public class worksApplication {
    private static int rows;
    private static int col;
    private static int[][] a;

    private static boolean[][] check;
    private static int max1;
    private static int max;

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        rows = sc.nextInt();
        col = sc.nextInt();

        a = new int[rows][col + 1];
        check = new boolean[rows][col];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < col + 1; j++) {
                if (j == col) {
                    a[i][j] = -1;
                } else
                    a[i][j] = sc.nextInt();
            }
        }
        for (int i = 0; i < rows; i++) {
            if (a[i][0] != -1) {
                check[i][0] = true;
                solve(i, 0, a[i][0]);
                check[i][0] = false;

                max1 = Math.max(max, max1);
            }
        }
        System.out.println(max1);
    }

    private static void solve(int i, int j, int sum) {
        // TODO Auto-generated method stub

        if (i - 1 == -1 && check[rows - 1][j] == false && a[rows - 1][j] != -1) {
            check[rows - 1][j] = true;
            solve(rows - 1, j, a[rows - 1][j]);
            check[rows - 1][j] = false;
        }
        if (i - 1 >= 0 && check[i - 1][j] == false && a[i - 1][j] != -1) {
            check[i - 1][j] = true;
            solve(i - 1, j, sum + a[i - 1][j]);
            check[i - 1][j] = false;
        }
        if (a[i][j + 1] != -1 && check[i][j + 1] == false) {
            check[i][j + 1] = true;
            solve(i, j + 1, sum + a[i][j + 1]);
            check[i][j + 1] = false;
        }
        if (i + 1 == rows && a[0][j] != -1 && check[0][j] == false) {
            check[0][j] = true;
            solve(0, j, a[0][j]);
            check[0][j] = false;
        }
        if (i + 1 < rows && a[i + 1][j] != -1 && check[i + 1][j] == false) {
            check[i + 1][j] = true;
            solve(i + 1, j, sum + a[i + 1][j]);
            check[i + 1][j] = false;
        }

        if (max < sum) {

            max = sum;
        }

    }

}

在网格中查找最大点，以便始终覆盖特定点

0 个答案: