Рассчитайте сумму строк выше и ниже точки, а также сумму столбцов слева и справа a

Question

Эй, ребята, я задаю вопрос, где мне нужно найти точку в матрице A из N x M строк, такую ​​что

сумма строк выше точки равна сумме строки

Рассмотрим пример

/** 
* 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 
*/ 

в этом примере, если мы рассмотрим точку А [1] [1], может что строка выше (сумма = 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; 
} 

Answer 1

Идея заключается в том, чтобы вычислить сумму для каждой строки (int[] rowsSum) и суммы для всех строк (totalRowsSum). А затем перебирать строки, сравнивая сумму предыдущих строк (currentSum) с суммой следующих строк (totalRowsSum - currentSum - rowsSum[i]).

Code example.

public static int solution(int[][] matrix) 
{ 
    int foundRowNumber = -1; 
    int rows = matrix.length; 
    int columns = matrix[0].length; 
    int[] rowsSum = new int[rows]; 
    int totalRowsSum = 0; 
    for (int i = 0; i < rows; i++) 
    { 
     int rowSum = 0; 
     for (int j = 0; j < columns; j++) 
     { 
      rowSum += matrix[i][j]; 
     } 
     rowsSum[i] = rowSum; 
     totalRowsSum += rowSum; 
    } 
    int currentSum = 0; 
    for (int i = 0; i < rows; i ++) 
    { 
     if (currentSum == totalRowsSum - currentSum - rowsSum[i]) 
     { 
      foundRowNumber = i; 
      break; 
     } 
     currentSum += rowsSum[i]; 
    } 
    return foundRowNumber; 
} 

Answer 2

я бы сказал: первый: получить сумму всей матрицы

второй: делим на 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. 
    } 
} 

это было сделано так, что бы получить Вас в клетку и не грести, но вы можете изменить его по своему вкусу.

Answer 3

Хорошо, я смог сделать решение. Но я думаю, что я сделал беспорядок сложности. Я должен был делать линейную сложность. В любом случае мое решение

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; 
} 

} Это codility вопрос относительно найти количество точек (равновесия), такую ​​как сумма элементов в строках выше выбранной точки равна сумме строк ниже точки. А также сумма столбцов слева от выбранной точки равна сумме столбцов справа от точки.