Java 计算点上方和下方的行之和，以及点左侧和右侧的列之和

嘿，伙计们，我在做一个问题，我必须在一个N x M行的矩阵a中找到一个点，这样

点上方的行数之和等于行数之和

以这个例子为例

/**
 * A[0][0] = 2    A[0][1] = 7    A[0][2] =  5
 * A[1][0] = 3    A[1][1] = 1    A[1][2] =  1
 * A[2][0] = 2    A[2][1] = 1    A[2][2] = -7
 * A[3][0] = 0    A[3][1] = 2    A[3][2] =  1
 * A[4][0] = 1    A[4][1] = 6    A[4][2] =  8
 * @param matrix
 * @return
 */

在这个例子中，如果我们看点A[1][1]，可以说上面的行（sum=14）等于该点下面的行之和。 有人能帮我吗

到目前为止，我已经走到了这一步。但我知道这是一个糟糕的方法

public int solution(int[][] matrix) {
    int rows = matrix[0].length;
    int columns = matrix.length;
    int sumabove = 0;
    int sumbelow = 0;

    for( int i = 1; i < rows; i++  ) {
        for (int j = 0; j < columns; j++) {
            sumabove += matrix[i - 1][j];
            sumbelow += matrix[i + 1][j];
        }
    }
    return 0;
}

public int解决方案（int[]矩阵）{
int行=矩阵[0]。长度；
int columns=matrix.length；
int大于等于0；
小于等于0的整数；
对于（int i=1；i
这个想法是计算每行的总和（
int[]rowsSum
）和所有行的总和（
totalRowsSum
）。然后遍历行，比较前一行的总和（
currentSum
）和下一行的总和（
totalRowsSum-currentSum-rowsSum[i]
）


公共静态int解决方案（int[][]矩阵）
{
int foundRowNumber=-1；
int行=矩阵长度；
int columns=矩阵[0]。长度；
int[]rowsSum=新的int[行]；
int TOTALLOWSSUM=0；
对于（int i=0；i
我想说：
第一：得到整个矩阵的和

第二：除以2并存储在var中（mid）

第三：每次循环它向下一行，它将得到该行的和，并从总和中减去它，如果它小于剩余值，则继续，如果剩余值小于（中间值）然后，在中间，使用相同的概念开始检查另一个循环中的行和之前的列

类似这样的代码（伪代码）：

这样做是为了让你得到单元格而不是行，但是你可以根据自己的喜好改变它。
好的，我可以做一个解决方案。但我认为我把复杂性搞得一团糟。我应该在线性复杂度下做。无论如何，我的解决办法是

public class MainClass {
static int matrix[][] = {{2, 7, 5}, {3, 1, 1}, {2, 1, -7}, {0, 2, 1}, {1, 6, 8}};

public static void main(String[] args) {
    System.out.print(solution(matrix));
}

/**
 * A[0][0] = 2    A[0][1] = 7    A[0][2] =  5
 * A[1][0] = 3    A[1][1] = 1    A[1][2] =  1
 * A[2][0] = 2    A[2][1] = 1    A[2][2] = -7
 * A[3][0] = 0    A[3][1] = 2    A[3][2] =  1
 * A[4][0] = 1    A[4][1] = 6    A[4][2] =  8
 * @param matrix
 * @return
 */

public static int solution(int[][] matrix) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumRowsAbove = 0;
    int sumRowsBelow = 0;
    int sumColLeft = 0;
    int sumColRight = 0;

    int equilibrium = 0;

    for( int i = 0; i < rows; i++  ) {
        for (int j = 0; j < columns; j++) {
            sumRowsBelow = getSumRowsBelow(i);
            sumRowsAbove = getSumAbove(i);
            sumColLeft = getSumColumnLeft(j);
            sumColRight = getSumColumnRight(j);
            if(sumRowsAbove == sumRowsBelow && sumColLeft == sumColRight) {
                equilibrium++;
            }
            int x = 2;
            x+=2;
        }
    }
    return equilibrium;
}

public static int getSumRowsBelow(int rowNum) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for( int i = rowNum; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if((i+1) < rows){                   
                sumBelow += matrix[i + 1][j];
            }
        }
    }

    return sumBelow;
}

public static int getSumColumnRight(int column) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for (int j = column; j <= columns; j++) {
        for( int i = 0; i < rows; i++) {
            if((j+1) < columns){                    
                sumBelow += matrix[i][j + 1];
            }
        }
    }       
    return sumBelow;
}

public static int getSumColumnLeft(int column) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for (int j = column; j >= 0; j--) {
        for( int i = 0; i < rows; i++) {
            if((j-1) >= 0){                 
                sumBelow += matrix[i][j - 1];
            }
        }
    }       
    return sumBelow;
}

public static int getSumAbove(int rowNum) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for( int i = rowNum; i >= 0; i--) {
        for (int j = 0; j < columns; j++) {
            if((i-1) >= 0){                 
                sumBelow += matrix[i - 1][j];
            }
        }
    }

    return sumBelow;
}

public类MainClass{
静态整数矩阵[][]={{2,7,5}，{3,1,1}，{2,1，-7}，{0,2,1}，{1,6,8}；
公共静态void main（字符串[]args）{
系统输出打印（解决方案（矩阵））；
}
/**
*[0][0]=2A[0][1]=7A[0][2]=5
*[1][0]=3A[1][1]=1A[1][2]=1
*[2][0]=2A[2][1]=1A[2][2]=-7
*A[3][0]=0A[3][1]=2A[3][2]=1
*[4][0]=1A[4][1]=6A[4][2]=8
*@param矩阵
*@返回
*/
公共静态int解决方案（int[][]矩阵）{
int columns=矩阵[0]。长度；
int行=矩阵长度；
int-sumRowsAbove=0；
int sumRowsBelow=0；
int-sumColLeft=0；
int-sumColRight=0；
整数均衡=0；
对于（int i=0；i=0{
sum+=矩阵[i][j-1]；
}
}
}       
返回下表；
}
公共静态int getsumOver（int rowNum）{
int columns=矩阵[0]。长度；
int行=矩阵长度；
小于等于0的整数；
对于（int i=rowNum；i>=0；i--）{
对于（int j=0；j=0{
sum+=矩阵[i-1][j]；
}
}
}
返回下表；
}

}
这是一个关于查找点（平衡点）数量的协同性问题，即选定点上方行中元素的总和等于该点下方行的总和。而且，从选定点左侧开始的列的总和等于从该点右侧开始的列的总和
 您想要上面所有行的总和吗？或者只在上面的一行。问题很不清楚……为一个循环中的每一行计算
sum
（
for
），以及
totalrowsum
。然后在另一个循环中比较前面的行
sum
（它在每次迭代中增加
currentRowSum
）使用
totalRowsSum-sum
。那么您想要一个程序将矩阵分成2，这样顶部和底部的总和就相同了？在循环通过每个点时，我想要计算点上方的行总和和该点下方的行总和
int sum = matrix.sum();
int mid = sum/2;
int topsum = 0;
int botsum = sum; 
int counter=0;
bool fail = false;

while(topsum!=botsum && !fail) //either break when both top and bottom are same or if there is no middle gorund
{
  int rowsum; //use loop to get the sum of the row
  for(int i=0; i>colLength(); i++) rowsum=+ matrix[counter][i];
  topsum =+ rowsum;
  botsum=-rowsum;
  counter++;

  if(botsum>mid) //if you go over the middle
  {
    botsum=-rowsum; //take it back before last addition acction
    counter --; //go back to the last row;
    //loop
    //here you will start checking columns to get to the middle.
  }
}

public class MainClass {
static int matrix[][] = {{2, 7, 5}, {3, 1, 1}, {2, 1, -7}, {0, 2, 1}, {1, 6, 8}};

public static void main(String[] args) {
    System.out.print(solution(matrix));
}

/**
 * A[0][0] = 2    A[0][1] = 7    A[0][2] =  5
 * A[1][0] = 3    A[1][1] = 1    A[1][2] =  1
 * A[2][0] = 2    A[2][1] = 1    A[2][2] = -7
 * A[3][0] = 0    A[3][1] = 2    A[3][2] =  1
 * A[4][0] = 1    A[4][1] = 6    A[4][2] =  8
 * @param matrix
 * @return
 */

public static int solution(int[][] matrix) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumRowsAbove = 0;
    int sumRowsBelow = 0;
    int sumColLeft = 0;
    int sumColRight = 0;

    int equilibrium = 0;

    for( int i = 0; i < rows; i++  ) {
        for (int j = 0; j < columns; j++) {
            sumRowsBelow = getSumRowsBelow(i);
            sumRowsAbove = getSumAbove(i);
            sumColLeft = getSumColumnLeft(j);
            sumColRight = getSumColumnRight(j);
            if(sumRowsAbove == sumRowsBelow && sumColLeft == sumColRight) {
                equilibrium++;
            }
            int x = 2;
            x+=2;
        }
    }
    return equilibrium;
}

public static int getSumRowsBelow(int rowNum) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for( int i = rowNum; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if((i+1) < rows){                   
                sumBelow += matrix[i + 1][j];
            }
        }
    }

    return sumBelow;
}

public static int getSumColumnRight(int column) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for (int j = column; j <= columns; j++) {
        for( int i = 0; i < rows; i++) {
            if((j+1) < columns){                    
                sumBelow += matrix[i][j + 1];
            }
        }
    }       
    return sumBelow;
}

public static int getSumColumnLeft(int column) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for (int j = column; j >= 0; j--) {
        for( int i = 0; i < rows; i++) {
            if((j-1) >= 0){                 
                sumBelow += matrix[i][j - 1];
            }
        }
    }       
    return sumBelow;
}

public static int getSumAbove(int rowNum) {
    int columns = matrix[0].length;
    int rows = matrix.length;
    int sumBelow = 0;
    for( int i = rowNum; i >= 0; i--) {
        for (int j = 0; j < columns; j++) {
            if((i-1) >= 0){                 
                sumBelow += matrix[i - 1][j];
            }
        }
    }

    return sumBelow;
}