Algorithm java中2D数组的最大路径，任意单元格开始

我想打印在二维阵列上移动时可以累积的最大值，直到离开二维边为止
注意用户可以向右移动，也可以移动到2D阵列上的按钮。
例如

因此，我编写如下代码

public static int find(int[][] A) {
    int[][] solution = new int[A.length][A.length];

    solution[0][0] = A[0][0];
    // fill the first row
    for (int i = 1; i < A.length; i++) {
        solution[0][i] = A[0][i] + solution[0][i - 1];
    }

    // fill the first column
    for (int i = 1; i < A.length; i++) {
        
        solution[i][0] = A[i][0] + solution[i - 1][0];
    }

    // path will be either from top or left, choose which ever is maximum
    int temp=0;
    for (int i = 1; i < A.length; i++) {
        for (int j = 1; j < A.length; j++) {
           // if ((A[i][j]+ Math.max(solution[i - 1][j], solution[i][j - 1])) >A[i][j] )
            solution[i][j] = A[i][j]
                    + Math.max(solution[i - 1][j], solution[i][j - 1]);
                //  else solution[i][j] = A[i][j];
                    
        }
    }
    int temp1 = 0;
    int temp2 =0;
    for(int i=0; i< A.length; i++){
       // System.out.println(" temp1= "+temp1);
        if(solution[i][A.length-1] > temp1) temp1= solution[i][A.length-1];
        //System.out.println(" temp1= "+temp1);
        if(solution[A.length-1][i] > temp2) temp2= solution[A.length-1][i];
       // System.out.println(" temp2= "+temp2);
    }
    for(int i=0; i< A.length; i++){
        for (int j=0; j< A.length;j++){
            System.out.print(solution[i][j]+"\t");
        }
         System.out.println(" ");
    }
    return Math.max(temp1,temp2);
    
}

公共静态int-find（int[]A）{
int[][]解决方案=新int[A.length][A.length]；
溶液[0][0]=A[0][0]；
//填写第一行
for（int i=1；iA[i][j]）
解[i][j]=A[i][j]
+max（解[i-1][j]，解[i][j-1]）；
//else解[i][j]=A[i][j]；
}
}
int temp1=0；
int temp2=0；
for（int i=0；itemp1）temp1=溶液[i][A.length-1]；
//System.out.println（“temp1=“+temp1”）；
如果（溶液[A.length-1][i]>temp2）temp2=溶液[A.length-1][i]；
//System.out.println（“temp2=“+temp2”）；
}
for（int i=0；i

但是它给了我592作为输出，并且不知道代码中的问题在哪里。

编辑：
好像我的代码和你的一样…
不管怎样，我得到了547英镑。
最大值为

解决方案[A.length-1][A.length-1]

---

原始答案：
下面是我使用javascript（547）得到的信息——我相信您可以将其“翻译”为您选择的语言：

var输入阵列=[
[-45,  87, -43, -12,   3, -39, -61, -19],
[ 97, -64,  79, -75,  19,  97,  80,  12],
[-24, -62,  46,  97, -75, -45,  92,  69],
[ 87, -31,  74,  33, -49,   1,  27,  95],
[ 13, -82, -19,  14, -76,  95,  64, -33],
[-25,  45, -61,  90, -90,  43,  32,  96],
[-27,  38,  77, -42,  36,  71,  32,  30],
[ 27, -52, -66, -78, -42,  66,  69, -11]
];
log（JSON.stringify（inputArray））；
var maxArray=[]；
对于（var i=0；i，问题是在二维数组上移动时可以累积的最大值，因此最大和的路径可以从任意位置开始，也可以从任意位置结束。
您应该在每个位置保持最大化结果
（i，j）
。每个位置的最大值可以是以下三个位置之一：


位置本身的值：
A[i][j]


该值+当您从顶部到达时的最大值：
d[i-1][j]+A[i][j]


当你从左边来时，这个值+到目前为止的最大值：
d[i][j-1]+A[i][j]



你必须在这三个中取最大值

代码：

公共静态int-find（int[]A）{
int R=A.长度；
int C=A[0]。长度；
int[][]d=新int[R+1][C+1]；
int res=整数的最小值；
对于（int i=1；我非常感谢！我如何才能将其更改为递归函数？
public static int find(int[][] A) {
     int R = A.length;
     int C = A[0].length;
     int[][] d = new int[R+1][C+1];
     int res = Integer.MIN_VALUE;
     for ( int i = 1; i <= R; i++ ) {
       for ( int j = 1; j <= C; j++ ) {
          d[i][j] = Math.max( A[i-1][j-1], Math.max(d[i][j-1] + A[i-1][j-1], d[i-1][j] + A[i-1][j-1]));
          res = Math.max( res, d[i][j]);
       }
     }
     return res;
   }