Question

我必须在给定的2d数组（n，m）中找到最大和路径，其值为0到99999. 0表示墙。我们从阵列的左下侧开始，必须到达右上方的单元格（0，m-1）。你可以上/下/右，可以访问每个单元格一次。下面是没有任何块的代码。我的问题是我无法从左下角移动到右上角单元格。我还创建了左数组（主数组的最左边），这样我就可以从最好的值开始。抱歉我不是程序员:)。

代码

 public static int  maxvalue(int [][]field,int[] left)
 {
      for(int i=field.length-1;i>0 && left[i]!=-1;i--)
      {

           System.out.println( "Startpos "+i+" 0");
           int distance =max(i,0,field,0,field.length-1);
           if(distance>maxvalue)
               maxvalue=distance;
      }
     return maxvalue;
 }
 public static int  max(int r, int c,int [][]field ,int destR, int destC)
 {

       if(r>destR|| c>destC)
           return 0;
      if(r==0 && c==field[0].length)
     return  field[r][c];
      int sum1=max(r-1,c,field,destR,destC); // up
      System.out.println(sum1);
      int sum2= max(r+1,c,field,destR,destC);          //down
      int sum3=  max(r,c+1,field,destR,destC);         //right
      return field[r][c]+Math.max(sum1, Math.max(sum2, sum3));
 }

样品

输入

0 1 2 3

2 0 2 4

3 3 0 3

4 2 1 2

输出

25

如何解决这个问题？如果所有路径都被阻止，则打印No Solution。

Answer 1

您是否首先尝试自己解决？

看起来有点工作但并非不可能。

我将使用3个int变量：xPosition，yPosition和Sum;

继续并优先测试xPosition + 1，yPosition-1的值，然后测试其余的值（因为你想要达到xPosition == array.length - 1 && yPosition == 0。）如果你找到0，测试其他可能性并排除你已经过的人。

每次找到好路径时，请将单元格的值添加到总和中。

一旦被阻止，请将其重置为0.

Answer 2

对于数组中的每个元素，您必须找到相邻元素的最大值，并检查边界条件。我希望这段代码可以帮到你。

public class StackOverFlow {

public static void main(String[] args) {

    Scanner in = new Scanner(System.in);

    int n = in.nextInt();
    int m = in.nextInt();
    Integer [][] array = new Integer[n][m];
    boolean [][] visited = new boolean[n][m];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            array[i][j] = in.nextInt();
        }
    }

    int i = n-1, j =0;
    visited[i][j] = true;
    int sum = array[i][j];
    while(true)
    {

        int max = -1;
        int maxi = 0, maxj = 0;
        if(i-1 >= 0 && i-1<= n-1 && j>=0 && j<= m-1 && array[i-1][j] != null && array[i-1][j]>max && !visited[i-1][j])
        {
            max = array[i-1][j];
            maxi = i-1;
            maxj=j;
        }
        if(i+1 >= 0 && i+1<= n-1 && j>=0 && j<= m-1 &&array[i+1][j] != null  && array[i+1][j]>max && !visited[i+1][j])
        {
            max = array[i+1][j];
            maxi = i+1;
            maxj=j;
        }

        if(i >= 0 && i<= n-1 && j-1>=0 && j-1<= m-1 && array[i][j-1] != null  && array[i][j-1]>max && !visited[i][j-1])
        {
            max = array[i][j-1];
            maxi = i;
            maxj=j-1;
        }

        if(i >= 0 && i<= n-1 && j+1>=0 && j+1<= m-1 && array[i][j+1] != null  && array[i][j+1]>max && !visited[i][j+1])
        {
            max = array[i][j+1];
            maxi = i;
            maxj=j+1;
        }

        i = maxi;
        j = maxj;
        visited[i][j] = true;
        sum += max;

        if(i == 0 && j == m-1)
            break;
    }
    System.out.println(sum);

}
}

找到从左下角到右上角单元格的最大总和路径

2 个答案: