Find sum of all elements in a matrix except the elements in row and/or column of given cell?

Given a 2D matrix and a set of cell indexes e.g., an array of (i, j) where i indicates row and j column. For every given cell index (i, j), find sums of all matrix elements except the elements present in i’th row and/or j’th column.

Example:

mat[][]  = { {1, 1, 2}
             {3, 4, 6}
             {5, 3, 2} }
Array of Cell Indexes: {(0, 0), (1, 1), (0, 1)}
Output:  15, 10, 16

We strongly recommend you to minimize your browser and try this yourself first.

A Naive Solution is to one by once consider all given cell indexes. For every cell index (i, j), find the sum of matrix elements that are not present either at i’th row or at j’th column. Below is C++ implementation of the Naive approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include<bits/stdc++.h>
#define R 3
#define C 3
using namespace std;
  
// A structure to represent a cell index
struct Cell
    int r; // r is row, varies from 0 to R-1
    int c; // c is column, varies from 0 to C-1
};
  
// A simple solution to find sums for a given array of cell indexes
void printSums(int mat[][C], struct Cell arr[], int n)
{
    // Iterate through all cell indexes
    for (int i=0; i<n; i++)
    {
        int sum = 0, r = arr[i].r, c = arr[i].c;
  
        // Compute sum for current cell index
        for (int j=0; j<R; j++)
            for (int k=0; k<C; k++)
                if (j != r && k != c)
                    sum += mat[j][k];
        cout << sum << endl;
    }
}
  
// Driver program to test above
int main()
{
    int mat[][C] = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
    struct Cell arr[] = {{0, 0}, {1, 1}, {0, 1}};
    int n = sizeof(arr)/sizeof(arr[0]);
    printSums(mat, arr, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG 
{
  
    static int R = 3;
    static int C = 3;
  
    // A structure to represent a cell index
    static class Cell 
    {
  
        int r; // r is row, varies from 0 to R-1
        int c; // c is column, varies from 0 to C-1
  
        public Cell(int r, int c) 
        {
            this.r = r;
            this.c = c;
        }
  
    };
  
    // A simple solution to find sums for 
    // a given array of cell indexes
    static void printSums(int mat[][], Cell arr[], int n) 
    {
        // Iterate through all cell indexes
        for (int i = 0; i < n; i++) 
        {
            int sum = 0, r = arr[i].r, c = arr[i].c;
  
            // Compute sum for current cell index
            for (int j = 0; j < R; j++) 
            {
                for (int k = 0; k < C; k++)
                {
                    if (j != r && k != c) 
                    {
                        sum += mat[j][k];
                    }
                }
            }
            System.out.println(sum);
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int mat[][] = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
        Cell arr[] = {new Cell(0, 0), new Cell(1, 1), new Cell(0, 1)};
        int n = arr.length;
        printSums(mat, arr, n);
    }
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# A structure to represent a cell index 
class Cell: 
  
    def __init__(self, r, c):
        self.r = r # r is row, varies from 0 to R-1
        self.c = c # c is column, varies from 0 to C-1
  
# A simple solution to find sums 
# for a given array of cell indexes 
def printSums(mat, arr, n):
  
    # Iterate through all cell indexes 
    for i in range(0, n): 
      
        Sum = 0; r = arr[i].r; c = arr[i].c 
  
        # Compute sum for current cell index 
        for j in range(0, R): 
            for k in range(0, C): 
                if j != r and k != c: 
                    Sum += mat[j][k] 
        print(Sum
  
# Driver Code
if __name__ == "__main__":
  
    mat = [[1, 1, 2], [3, 4, 6], [5, 3, 2]]
    R = C = 3
    arr = [Cell(0, 0), Cell(1, 1), Cell(0, 1)] 
    n = len(arr)
    printSums(mat, arr, n) 
      
# This code is contributed by Rituraj Jain

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System; 
      
class GFG 
{
  
    static int R = 3;
    static int C = 3;
  
    // A structure to represent a cell index
    public class Cell 
    {
  
        public int r; // r is row, varies from 0 to R-1
        public int c; // c is column, varies from 0 to C-1
  
        public Cell(int r, int c) 
        {
            this.r = r;
            this.c = c;
        }
  
    };
  
    // A simple solution to find sums for 
    // a given array of cell indexes
    static void printSums(int [,]mat, Cell []arr, int n) 
    {
        // Iterate through all cell indexes
        for (int i = 0; i < n; i++) 
        {
            int sum = 0, r = arr[i].r, c = arr[i].c;
  
            // Compute sum for current cell index
            for (int j = 0; j < R; j++) 
            {
                for (int k = 0; k < C; k++)
                {
                    if (j != r && k != c) 
                    {
                        sum += mat[j,k];
                    }
                }
            }
            Console.WriteLine(sum);
        }
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int [,]mat = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
        Cell []arr = {new Cell(0, 0), new Cell(1, 1), new Cell(0, 1)};
        int n = arr.Length;
        printSums(mat, arr, n);
    }
}
  
/* This code is contributed by PrinciRaj1992 */

chevron_right


Output:

15
10
16

Time complexity of the above solution is O(n * R * C) where n is number of given cell indexes and R x C is matrix size.

An Efficient Solution can compute all sums in O(R x C + n) time. The idea is to precompute total sum, row and column sums before processing the given array of indexes. Below are details
1. Calculate sum of matrix, call it sum.
2. Calculate sum of individual rows and columns. (row[] and col[])
3. For a cell index (i, j), the desired sum will be “sum- row[i] – col[j] + arr[i][j]”

Below is the implementation of above idea.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// An efficient C++ program to compute sum for given array of cell indexes
#include<bits/stdc++.h>
#define R 3
#define C 3
using namespace std;
  
// A structure to represent a cell index
struct Cell
{
    int r; // r is row, varies from 0 to R-1
    int c; // c is column, varies from 0 to C-1
};
  
void printSums(int mat[][C], struct Cell arr[], int n)
{
    int sum = 0;
    int row[R] = {};
    int col[C] = {};
  
    // Compute sum of all elements, sum of every row and sum every column
    for (int i=0; i<R; i++)
    {
      for (int j=0; j<C; j++)
       {
             sum += mat[i][j];
             col[j] += mat[i][j];
             row[i] += mat[i][j];
       }
    }
  
    // Compute the desired sum for all given cell indexes
    for (int i=0; i<n; i++)
    {
        int ro = arr[i].r, co = arr[i].c;
        cout << sum - row[ro] - col[co] + mat[ro][co] << endl;
    }
}
  
// Driver program to test above function
int main()
{
    int mat[][C] = {{1, 1, 2}, {3, 4, 6}, {5, 3, 2}};
    struct Cell arr[] = {{0, 0}, {1, 1}, {0, 1}};
    int n = sizeof(arr)/sizeof(arr[0]);
    printSums(mat, arr, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// An efficient Java program to compute 
// sum for given array of cell indexes
class GFG
{
static int R = 3;
static int C = 3;
  
// A structure to represent a cell index
static class Cell
{
    int r; // r is row, varies from 0 to R-1
    int c; // c is column, varies from 0 to C-1
  
    public Cell(int r, int c) 
    {
        this.r = r;
        this.c = c;
    }     
};
  
static void printSums(int mat[][], 
                       Cell arr[], int n)
{
    int sum = 0;
    int []row = new int[R];
    int []col = new int[C];
  
    // Compute sum of all elements,
    // sum of every row and sum every column
    for (int i = 0; i < R; i++)
    {
        for (int j = 0; j < C; j++)
        {
                sum += mat[i][j];
                col[j] += mat[i][j];
                row[i] += mat[i][j];
        }
    }
  
    // Compute the desired sum
    // for all given cell indexes
    for (int i = 0; i < n; i++)
    {
        int ro = arr[i].r, co = arr[i].c;
        System.out.println(sum - row[ro] - col[co] + 
                                 mat[ro][co]);
    }
}
  
// Driver Code
public static void main(String[] args) 
{
    int mat[][] = {{1, 1, 2}, 
                   {3, 4, 6},
                   {5, 3, 2}};
    Cell arr[] = {new Cell(0, 0), 
                  new Cell(1, 1), 
                  new Cell(0, 1)};
    int n = arr.length;
    printSums(mat, arr, n);
}
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# A structure to represent a cell index
class Cell:
  
    def __init__(self, r, c):
        self.r = r # r is row, varies from 0 to R-1
        self.c = c # c is column, varies from 0 to C-1
  
# A simple solution to find sums 
# for a given array of cell indexes
def printSums(mat, arr, n):
  
    Sum = 0
    row, col = [0] * R, [0] * C
  
    # Compute sum of all elements,
    # sum of every row and sum every column
    for i in range(0, R):
        for j in range(0, C):
            Sum += mat[i][j]
            row[i] += mat[i][j]
            col[j] += mat[i][j]
  
    # Compute the desired sum 
    # for all given cell indexes
    for i in range(0, n):
        r0, c0 = arr[i].r, arr[i].c
        print(Sum - row[r0] - col[c0] + mat[r0][c0])
  
# Driver Code
if __name__ == "__main__":
  
    mat = [[1, 1, 2], [3, 4, 6], [5, 3, 2]]
    R = C = 3
    arr = [Cell(0, 0), Cell(1, 1), Cell(0, 1)]
    n = len(arr)
    printSums(mat, arr, n)
  
# This code is contributed by Rituraj Jain

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// An efficient C# program to compute 
// sum for given array of cell indexes
using System;
  
class GFG
{
static int R = 3;
static int C = 3;
  
// A structure to represent a cell index
public class Cell
{
    public int r; // r is row, varies from 0 to R-1
    public int c; // c is column, varies from 0 to C-1
  
    public Cell(int r, int c) 
    {
        this.r = r;
        this.c = c;
    }    
};
  
static void printSums(int [,]mat, 
                      Cell []arr, int n)
{
    int sum = 0;
    int []row = new int[R];
    int []col = new int[C];
  
    // Compute sum of all elements,
    // sum of every row and sum every column
    for (int i = 0; i < R; i++)
    {
        for (int j = 0; j < C; j++)
        {
            sum += mat[i, j];
            col[j] += mat[i, j];
            row[i] += mat[i, j];
        }
    }
  
    // Compute the desired sum
    // for all given cell indexes
    for (int i = 0; i < n; i++)
    {
        int ro = arr[i].r, co = arr[i].c;
        Console.WriteLine(sum - row[ro] - col[co] + 
                                mat[ro, co]);
    }
}
  
// Driver Code
public static void Main(String[] args) 
{
    int [,]mat = {{1, 1, 2}, 
                  {3, 4, 6},
                  {5, 3, 2}};
    Cell []arr = {new Cell(0, 0), 
                  new Cell(1, 1), 
                  new Cell(0, 1)};
    int n = arr.Length;
    printSums(mat, arr, n);
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

15
10
16

Time Complexity: O(R x C + n)
Auxiliary Space: O(R + C)

Thanks to Gaurav Ahirwar for suggesting this efficient solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.