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
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.
Implementation:
#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 implementation of the approach import java.io.*;
public 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 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# 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 */ |
<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> |
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.
Auxiliary Space: O(1)
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.
- Calculate sum of matrix, call it sum.
- Calculate sum of individual rows and columns. (row[] and col[])
- 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.
// 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;
} |
// An efficient Java program to compute // sum for given array of cell indexes import java.io.*;
public 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 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 |
// 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 |
<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> |
15 10 16
Time Complexity: O(R x C + n)
Auxiliary Space: O(R + C)
Thanks to Gaurav Ahirwar for suggesting this efficient solution.