Count majority element in a matrix
Given a NxM matrix of integers containing duplicate elements. The task is to find the count of all majority occurring elements in the given matrix, where majority element are those whose frequency is greater than or equal to (N*M)/2.
Examples:
Input : mat[] = {{1, 1, 2},
{2, 3, 3},
{4, 3, 3}}
Output : 1
The majority elements is 3 and, its frequency is 4.
Input : mat[] = {{20, 20},
{40, 40}}
Output : 2
Approach:
- Traverse the matrix and use a map in C++ to store the frequency of elements of the matrix such that the key of map is the matrix element and value is its frequency in the matrix.
- Then, traverse the map to find the frequency of elements with a count variable to count majority elements and check if it is equal to or greater than (N*M)/2. If true, then increase the count.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define N 3 // Rows
#define M 3 // Columns
int majorityInMatrix( int arr[N][M])
{
unordered_map< int , int > mp;
for ( int i = 0; i < N; i++) {
for ( int j = 0; j < M; j++) {
mp[arr[i][j]]++;
}
}
int countMajority = 0;
for ( auto itr = mp.begin(); itr != mp.end(); itr++) {
if (itr->second >= ((N * M) / 2)) {
countMajority++;
}
}
return countMajority;
}
int main()
{
int mat[N][M] = { { 1, 2, 2 },
{ 1, 3, 2 },
{ 1, 2, 6 } };
cout << majorityInMatrix(mat) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int N = 3 ;
static int M = 3 ;
static int majorityInMatrix( int arr[][])
{
HashMap<Integer, Integer> mp =
new HashMap<Integer, Integer>();
for ( int i = 0 ; i < N; i++)
{
for ( int j = 0 ; j < M; j++)
{
if (mp.containsKey(arr[i][j]))
mp.put(arr[i][j], mp.get(arr[i][j]) + 1 );
else
mp.put(arr[i][j], 1 );
}
}
int countMajority = 0 ;
Iterator<HashMap.Entry<Integer, Integer>> itr =
mp.entrySet().iterator();
while (itr.hasNext())
{
HashMap.Entry<Integer, Integer> entry = itr.next();
if (entry.getValue() >= ((N * M) / 2 ))
{
countMajority++;
}
}
return countMajority;
}
public static void main (String[] args)
{
int mat[][] = { { 1 , 2 , 2 },
{ 1 , 3 , 2 },
{ 1 , 2 , 6 } };
System.out.println(majorityInMatrix(mat));
}
}
|
Python3
N = 3
M = 3
def majorityInMatrix(arr):
mp = {i: 0 for i in range ( 7 )}
for i in range ( len (arr)):
for j in range ( len (arr)):
mp[arr[i][j]] + = 1
countMajority = 0
for key, value in mp.items():
if (value > = ( int ((N * M) / 2 ))):
countMajority + = 1
return countMajority
if __name__ = = '__main__' :
mat = [[ 1 , 2 , 2 ],
[ 1 , 3 , 2 ],
[ 1 , 2 , 6 ]]
print (majorityInMatrix(mat))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int N = 3;
static int M = 3;
static int majorityInMatrix( int [ , ]arr)
{
Dictionary< int , int > mp =
new Dictionary< int , int >();
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < M; j++)
{
if (mp.ContainsKey(arr[i, j]))
mp[arr[i, j]]++;
else
mp[arr[i, j]] = 1;
}
}
int countMajority = 0;
Dictionary< int , int >.KeyCollection keyColl =
mp.Keys;
foreach ( int i in keyColl)
{
if ( mp[i] >= ((N * M) / 2))
{
countMajority++;
}
}
return countMajority;
}
public static void Main ()
{
int [, ] mat = { { 1, 2, 2 },
{ 1, 3, 2 },
{ 1, 2, 6 } };
Console.WriteLine(majorityInMatrix(mat));
}
}
|
Javascript
<script>
var N = 3;
var M = 3;
function majorityInMatrix(arr)
{
var mp = new Map();
for ( var i = 0; i < N; i++)
{
for ( var j = 0; j < M; j++)
{
if (mp.has(arr[i][j]))
{
mp.set(arr[i][j], mp.get(arr[i][j])+1)
}
else
mp.set(arr[i][j], 1);
}
}
var countMajority = 0;
mp.forEach((value, key) => {
if ( value >= (parseInt((N * M) / 2)))
{
countMajority++;
}
});
return countMajority;
}
var mat = [ [ 1, 2, 2 ],
[ 1, 3, 2 ],
[ 1, 2, 6 ]];
document.write(majorityInMatrix(mat));
</script>
|
Complexity Analysis:
- Time Complexity: O(N x M)
- Auxiliary Space: O(N X M)
Further Optimization :
We can use Moore’s voting algorithm to solve above problem in O(1) extra space. We can simply consider matrix elements as one dimensional array.
Last Updated :
06 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...