Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Medium
  • Last Updated : 06 Jul, 2021

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++




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



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



# 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
C#



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



<script>
// javascript implementation of the approach   
var R = 3;
    var C = 3;
 
    // A structure to represent a cell index
     class Cell
     {
         constructor(r, c)
         {
            this.r = r;
            this.c = c;
        }
 
    }
 
    // A simple solution to find sums for
    // a given array of cell indexes
    function printSums(mat,  arr , n) {
        // Iterate through all cell indexes
        for (i = 0; i < n; i++) {
            var sum = 0, r = arr[i].r, c = arr[i].c;
 
            // Compute sum for current cell index
            for (j = 0; j < R; j++) {
                for (k = 0; k < C; k++) {
                    if (j != r && k != c) {
                        sum += mat[j][k];
                    }
                }
            }
            document.write(sum+"<br/>");
        }
    }
 
    // Driver code   
        var mat = [ [ 1, 1, 2 ],
        [ 3, 4, 6 ],
        [ 5, 3, 2 ] ];
        var arr = [ new Cell(0, 0), new Cell(1, 1), new Cell(0, 1) ];
        var n = arr.length;
        printSums(mat, arr, n);
 
// This code is contributed by aashish1995
</script>
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++



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



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



# 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
C#



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



<script>
 
// An efficient Javascript program to compute
// sum for given array of cell indexes
 
var R = 3;
var C = 3;
 
// A structure to represent a cell index
class Cell
{
    // r is row, varies from 0 to R-1
    // c is column, varies from 0 to C-1
    constructor(r, c)
    {
        this.r = r;
        this.c = c;
    }    
};
 
function printSums(mat, arr, n)
{
    var sum = 0;
    var row = Array(R).fill(0);
    var col = Array(C).fill(0);
 
    // Compute sum of all elements,
    // sum of every row and sum every column
    for (var i = 0; i < R; i++)
    {
        for (var 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 (var i = 0; i < n; i++)
    {
        var ro = arr[i].r, co = arr[i].c;
        document.write(sum - row[ro] - col[co] +
                                mat[ro][co] + "<br>");
    }
}
 
// Driver Code
var mat = [[1, 1, 2],
              [3, 4, 6],
              [5, 3, 2]];
var arr = [new Cell(0, 0),
              new Cell(1, 1),
              new Cell(0, 1)];
var n = arr.length;
printSums(mat, arr, n);
 
 
</script>
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
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Next

Find a common element in all rows of a given row-wise sorted matrix
Recommended Articles
Page :
Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row
25, Feb 17
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Minimum row or column swaps required to make every pair of adjacent cell of a Binary Matrix distinct
07, Jan 21
Maximum of all distances to the nearest 1 cell from any 0 cell in a Binary matrix
04, May 20
Farthest cell from a given cell in a Matrix
22, Jan 21
Minimum moves taken to move coin of each cell to any one cell of Matrix
19, May 20
Minimum number of flips required such that the last cell of matrix can be reached from any other cell
18, Nov 20
Shortest path from a source cell to a destination cell of a Binary Matrix through cells consisting only of 1s
17, Mar 21
Check if a path exists for a cell valued 1 to reach the bottom right corner of a Matrix before any cell valued 2
07, Sep 20
Given a Boolean Matrix, find k such that all elements in k'th row are 0 and k'th column are 1.
24, Sep 15
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Construct a Matrix such that each cell consists of sum of adjacent elements of respective cells in given Matrix
11, Nov 20
Find all matrix elements which are minimum in their row and maximum in their column
23, Sep 20
Find a Square Matrix such that sum of elements in every row and column is K
09, Sep 19
Program to find the Sum of each Row and each Column of a Matrix
31, Oct 18
Number of shortest paths to reach every cell from bottom-left cell in the grid
14, Aug 19
Print all elements in sorted order from row and column wise sorted matrix
22, Oct 14
heapq in Python to print all elements in sorted order from row and column wise sorted matrix
07, Nov 17
Generate a matrix with each row and column of given sum
05, Feb 21
Find the original matrix when largest element in a row and a column are given
18, Apr 19
Find if a binary matrix exists with given row and column sums
11, Jun 19
Sum of matrix element where each elements is integer division of row and column
20, Feb 17
Sum of cost of all paths to reach a given cell in a Matrix
28, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox