Print unique rows in a given Binary matrix - GeeksforGeeks

19 Apr, 2022
Given a binary matrix, print all unique rows of the given matrix. 
Example: 
Input:
        {0, 1, 0, 0, 1}
        {1, 0, 1, 1, 0}
        {0, 1, 0, 0, 1}
        {1, 1, 1, 0, 0}
Output:
    0 1 0 0 1 
    1 0 1 1 0 
    1 1 1 0 0 
Explanation: 
The rows are r1={0, 1, 0, 0, 1}, 
r2={1, 0, 1, 1, 0}, r3={0, 1, 0, 0, 1}, 
r4={1, 1, 1, 0, 0}, As r1 = r3, remove r3
and print the other rows.

Input:
        {0, 1, 0}
        {1, 0, 1}
        {0, 1, 0}
Output:
   0 1 0
   1 0 1
Explanation: 
The rows are r1={0, 1, 0}, 
r2={1, 0, 1}, r3={0, 1, 0} As r1 = r3,
remove r3 and print the other rows.
Method 1: This method explains the simple approach towards solving the above problem. 
Approach: A simple approach would be to check each row with all processed rows. Print the first row. Now, starting from the second row, for each row, compare the row with already processed rows. If the row matches with any of the processed rows, skip it else print it.
Algorithm: 
Traverse the matrix row-wiseFor each row check if there is any similar row less than the current index.If any two rows are similar then do not print the row.Else print the row.
Traverse the matrix row-wise
For each row check if there is any similar row less than the current index.
If any two rows are similar then do not print the row.
Else print the row.
Implementation: 
C++
Java
Python3
C#
Javascript
// Given a binary matrix of M X N of integers,// you need to return only unique rows of binary array#include <bits/stdc++.h>using namespace std;#define ROW 4#define COL 5 // The main function that prints// all unique rows in a given matrix.void findUniqueRows(int M[ROW][COL]){    //Traverse through the matrix    for(int i=0; i<ROW; i++)    {        int flag=0;                 //check if there is similar column        //is already printed, i.e if i and        //jth column match.        for(int j=0; j<i; j++)        {            flag=1;                         for(int k=0; k<=COL; k++)            if(M[i][k]!=M[j][k])                flag=0;                         if(flag==1)            break;        }                 //if no row is similar        if(flag==0)        {            //print the row            for(int j=0; j<COL; j++)                cout<<M[i][j]<<" ";            cout<<endl;        }    }} // Driver Codeint main(){    int M[ROW][COL] = {{0, 1, 0, 0, 1},                       {1, 0, 1, 1, 0},                       {0, 1, 0, 0, 1},                       {1, 0, 1, 0, 0}};     findUniqueRows(M);     return 0;}
// Given a binary matrix of M X N// of integers, you need to return// only unique rows of binary array class GFG{     static int ROW = 4;static int COL = 5; // Function that prints all// unique rows in a given matrix.static void findUniqueRows(int M[][]){         // Traverse through the matrix    for(int i = 0; i < ROW; i++)    {        int flag = 0;                 // Check if there is similar column        // is already printed, i.e if i and        // jth column match.        for(int j = 0; j < i; j++)        {            flag = 1;             for(int k = 0; k < COL; k++)                if (M[i][k] != M[j][k])                    flag = 0;             if (flag == 1)                break;        }         // If no row is similar        if (flag == 0)        {                         // Print the row            for(int j = 0; j < COL; j++)                System.out.print(M[i][j] + " ");             System.out.println();        }    }} // Driver Codepublic static void main(String[] args){    int M[][] = { { 0, 1, 0, 0, 1 },                  { 1, 0, 1, 1, 0 },                  { 0, 1, 0, 0, 1 },                  { 1, 0, 1, 0, 0 } };     findUniqueRows(M);}} // This code is contributed by mark_85
# Given a binary matrix of M X N of# integers, you need to return only# unique rows of binary arrayROW = 4COL = 5 # The main function that prints# all unique rows in a given matrix.def findUniqueRows(M):         # Traverse through the matrix    for i in range(ROW):        flag = 0         # Check if there is similar column        # is already printed, i.e if i and        # jth column match.        for j in range(i):            flag = 1             for k in range(COL):                if (M[i][k] != M[j][k]):                    flag = 0             if (flag == 1):                break         # If no row is similar        if (flag == 0):                         # Print the row            for j in range(COL):                print(M[i][j], end = " ")                             print()    # Driver Codeif __name__ == '__main__':         M = [ [ 0, 1, 0, 0, 1 ],          [ 1, 0, 1, 1, 0 ],          [ 0, 1, 0, 0, 1 ],          [ 1, 0, 1, 0, 0 ] ]     findUniqueRows(M) # This code is contributed by mohit kumar 29
// Given a binary matrix of M X N // of integers, you need to return// only unique rows of binary array  using System; class GFG{     static int ROW = 4;static int COL = 5;   // Function that prints all // unique rows in a given matrix.static void findUniqueRows(int[,] M){         // Traverse through the matrix    for(int i = 0; i < ROW; i++)    {        int flag = 0;                   // Check if there is similar column        // is already printed, i.e if i and        // jth column match.        for(int j = 0; j < i; j++)         {            flag = 1;                         for(int k = 0; k < COL; k++)                if (M[i, k] != M[j, k])                    flag = 0;               if (flag == 1)                break;        }           // If no row is similar        if (flag == 0)        {                         // Print the row            for(int j = 0; j < COL; j++)                Console.Write(M[i, j] + " ");               Console.WriteLine();        }    }} // Driver codestatic void Main(){    int[,] M = { { 0, 1, 0, 0, 1 },                 { 1, 0, 1, 1, 0 },                 { 0, 1, 0, 0, 1 },                 { 1, 0, 1, 0, 0 } };         findUniqueRows(M);}} // This code is contributed by divyeshrabadiya07
<script>// Given a binary matrix of M X N// of integers, you need to return// only unique rows of binary array         let ROW = 4;    let COL = 5;         // Function that prints all// unique rows in a given matrix.    function findUniqueRows(M)    {        // Traverse through the matrix    for(let i = 0; i < ROW; i++)    {        let flag = 0;                   // Check if there is similar column        // is already printed, i.e if i and        // jth column match.        for(let j = 0; j < i; j++)        {            flag = 1;               for(let k = 0; k < COL; k++)                if (M[i][k] != M[j][k])                    flag = 0;               if (flag == 1)                break;        }           // If no row is similar        if (flag == 0)        {                           // Print the row            for(let j = 0; j < COL; j++)                document.write(M[i][j] + " ");               document.write("<br>");        }    }    }         // Driver Code    let M = [ [ 0, 1, 0, 0, 1 ],          [ 1, 0, 1, 1, 0 ],          [ 0, 1, 0, 0, 1 ],          [ 1, 0, 1, 0, 0 ] ]       findUniqueRows(M)         // This code is contributed by unknown2108</script>
Output: 
0 1 0 0 1 
1 0 1 1 0 
1 0 1 0 0
Complexity Analysis: 
Time complexity: O( ROW^2 x COL ). So for every row check if there is any other similar row. So the time complexity is O( ROW^2 x COL ).
Auxiliary Space: O(1). As no extra space is required.
Method 2: This method uses Binary Search Tree to solve the above operation. The Binary Search Tree is a node-based binary tree data structure which has the following properties: 
The left subtree of a node contains only nodes with keys lesser than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
The left and right subtree each must also be a binary search tree.
There must be no duplicate nodes.
The above properties of Binary Search Tree provide ordering among keys so that the operations like search, minimum and maximum can be done fast. If there is no order, then we may have to compare every key to search a given key.
Approach: The process must begin from finding the decimal equivalent of each row and inserting them into a BST. As we know, each node of the BST will contain two fields, one field for the decimal value, other for row number. One must not insert a node if it is duplicated. Finally, traverse the BST and print the corresponding rows.
Algorithm: 
Create a BST in which no duplicate elements can be stored. Create a function to convert a row into decimal and to convert the decimal value into binary array.Traverse through the matrix and insert the row into the BST.Traverse the BST (inorder traversal) and convert the decimal into binary array and print it.
Create a BST in which no duplicate elements can be stored. Create a function to convert a row into decimal and to convert the decimal value into binary array.
Traverse through the matrix and insert the row into the BST.
Traverse the BST (inorder traversal) and convert the decimal into binary array and print it.
Implementation: 
C++14
Java
C#
Python3
Javascript
// Given a binary matrix of M X N of integers,// you need to return only unique rows of binary array#include <bits/stdc++.h>using namespace std;#define ROW 4#define COL 5 class BST{    int data;    BST *left, *right;     public:         // Default constructor.    BST();         // Parameterized constructor.    BST(int);         // Insert function.    BST* Insert(BST *, int);         // Inorder traversal.    void Inorder(BST *);}; //convert array to decimalint convert(int arr[]){    int sum=0;         for(int i=0; i<COL; i++)    {        sum+=pow(2,i)*arr[i];    }    return sum;} //print the column represented as integersvoid print(int p){    for(int i=0; i<COL; i++)    {        cout<<p%2<<" ";        p/=2;    }    cout<<endl;}  // Default Constructor definition.BST :: BST() : data(0), left(NULL), right(NULL){} // Parameterized Constructor definition.BST :: BST(int value){    data = value;    left = right = NULL;} // Insert function definition.BST* BST :: Insert(BST *root, int value){    if(!root)    {        // Insert the first node, if root is NULL.        return new BST(value);    }         //if the value is present    if(value == root->data)     return root;     // Insert data.    if(value > root->data)    {        // Insert right node data, if the 'value'        // to be inserted is greater than 'root' node data.                 // Process right nodes.        root->right = Insert(root->right, value);    }    else    {        // Insert left node data, if the 'value'        // to be inserted is greater than 'root' node data.                 // Process left nodes.        root->left = Insert(root->left, value);    }         // Return 'root' node, after insertion.    return root;} // Inorder traversal function.// This gives data in sorted order.void BST :: Inorder(BST *root){    if(!root)    {        return;    }    Inorder(root->left);    print( root->data );    Inorder(root->right);}  // The main function that prints// all unique rows in a given matrix.void findUniqueRows(int M[ROW][COL]){         BST b, *root = NULL;         //Traverse through the matrix    for(int i=0; i<ROW; i++)    {        //insert the row into BST        root=b.Insert(root,convert(M[i]));    }              //print    b.Inorder(root);     } // Driver Codeint main(){    int M[ROW][COL] = {{0, 1, 0, 0, 1},                       {1, 0, 1, 1, 0},                       {0, 1, 0, 0, 1},                       {1, 0, 1, 0, 0}};     findUniqueRows(M);     return 0;}
// Given a binary matrix of M X N of integers,// you need to return only unique rows of binary arrayimport java.util.*; class GFG{  static class BST {    int data;    BST left,right;    BST(int v){      this.data = v;      this.left = this.right = null;    }  }  final  static int ROW = 4;  final  static int COL = 5;  // convert array to decimal  static int convert(int arr[])  {    int sum = 0;     for(int i = 0; i < COL; i++)    {      sum += Math.pow(2,i)*arr[i];    }    return sum;  }   // print the column represented as integers  static void print(int p)  {    for(int i = 0; i < COL; i++)    {      System.out.print(p%2+" ");      p /= 2;    }    System.out.println();  }     // Insert function definition.  static BST Insert(BST root, int value)  {    if(root == null)    {      // Insert the first node, if root is null.      return new BST(value);    }     //if the value is present    if(value == root.data)      return root;     // Insert data.    if(value > root.data)    {      // Insert right node data, if the 'value'      // to be inserted is greater than 'root' node data.       // Process right nodes.      root.right = Insert(root.right, value);    }    else    {      // Insert left node data, if the 'value'      // to be inserted is greater than 'root' node data.       // Process left nodes.      root.left = Insert(root.left, value);    }     // Return 'root' node, after insertion.    return root;  }   // Inorder traversal function.  // This gives data in sorted order.  static void Inorder(BST root)  {    if(root == null)    {      return;    }    Inorder(root.left);    print( root.data );    Inorder(root.right);  }   // The main function that prints  // all unique rows in a given matrix.  static void findUniqueRows(int M[][])  {     BST b, root = null;     // Traverse through the matrix    for(int i = 0; i < ROW; i++)    {      // insert the row into BST      root=Insert(root, convert(M[i]));    }      //print    Inorder(root);   }   // Driver Code  public static void main(String[] args)  {    int M[][] = {{0, 1, 0, 0, 1},                 {1, 0, 1, 1, 0},                 {0, 1, 0, 0, 1},                 {1, 0, 1, 0, 0}};     findUniqueRows(M);  }} // This code is contributed by Rajput-Ji
// Given a binary matrix of M X N of integers,// you need to return only unique rows of binary arrayusing System;using System.Collections.Generic; public class GFG{  public class BST {    public int data;    public BST left,right;    public BST(int v){      this.data = v;      this.left = this.right = null;    }  }  readonly  static int ROW = 4;  readonly  static int COL = 5;     // convert array to decimal  static int convert(int []arr)  {    int sum = 0;     for(int i = 0; i < COL; i++)    {      sum += (int)Math.Pow(2,i)*arr[i];    }    return sum;  }   // print the column represented as integers  static void print(int p)  {    for(int i = 0; i < COL; i++)    {      Console.Write(p%2+" ");      p /= 2;    }    Console.WriteLine();  }     // Insert function definition.  static BST Insert(BST root, int value)  {    if(root == null)    {      // Insert the first node, if root is null.      return new BST(value);    }     // if the value is present    if(value == root.data)      return root;     // Insert data.    if(value > root.data)    {      // Insert right node data, if the 'value'      // to be inserted is greater than 'root' node data.       // Process right nodes.      root.right = Insert(root.right, value);    }    else    {      // Insert left node data, if the 'value'      // to be inserted is greater than 'root' node data.       // Process left nodes.      root.left = Insert(root.left, value);    }     // Return 'root' node, after insertion.    return root;  }   // Inorder traversal function.  // This gives data in sorted order.  static void Inorder(BST root)  {    if(root == null)    {      return;    }    Inorder(root.left);    print( root.data );    Inorder(root.right);  } public static int[] GetRow(int[,] matrix, int row)  {    var rowLength = matrix.GetLength(1);    var rowVector = new int[rowLength];     for (var i = 0; i < rowLength; i++)      rowVector[i] = matrix[row, i];     return rowVector;  }  // The main function that prints  // all unique rows in a given matrix.  static void findUniqueRows(int [,]M)  {     BST b, root = null;     // Traverse through the matrix    for(int i = 0; i < ROW; i++)    {      // insert the row into BST        int[] row = GetRow(M,i);      root=Insert(root, convert(row));    }      //print    Inorder(root);   }   // Driver Code  public static void Main(String[] args)  {    int [,]M = {{0, 1, 0, 0, 1},                 {1, 0, 1, 1, 0},                 {0, 1, 0, 0, 1},                 {1, 0, 1, 0, 0}};     findUniqueRows(M);  }} // This code contributed by Rajput-Ji
# Given a binary matrix of M X N of integers,# you need to return only unique rows of binary arrayROW = 4COL = 5 # print the column represented as integersdef Print(p):     for i in range(COL):        print(p % 2 ,end = " ")        p = int(p//2)    print("") class BST:     def __init__(self,data):        self.data = data        self.left = None        self.right = None     # Insert function definition.    def Insert(self,root, value):         if(not root):            # Insert the first node, if root is NULL.            return BST(value)                 #if the value is present        if(value == root.data):            return root             # Insert data.        if(value > root.data):            # Insert right node data, if the 'value'            # to be inserted is greater than 'root' node data.                         # Process right nodes.            root.right = self.Insert(root.right, value)        else:            # Insert left node data, if the 'value'            # to be inserted is greater than 'root' node data.                         # Process left nodes.            root.left = self.Insert(root.left, value)                 # Return 'root' node, after insertion.        return root     # Inorder traversal function.    # This gives data in sorted order.    def Inorder(self,root):        if(not root):            return        self.Inorder(root.left);        Print( root.data );        self.Inorder(root.right) # convert array to decimaldef convert(arr):    sum=0         for i in range(COL):        sum+=pow(2,i)*arr[i]    return sum  # The main function that prints# all unique rows in a given matrix.def findUniqueRows(M):         b,root =BST(0),None         #Traverse through the matrix    for i in range(ROW):        #insert the row into BST        root = b.Insert(root,convert(M[i]))         #print    b.Inorder(root) # Driver CodeM = [[0, 1, 0, 0, 1],     [1, 0, 1, 1, 0],     [0, 1, 0, 0, 1],     [1, 0, 1, 0, 0]] findUniqueRows(M) # This code is contributed by shinjanpatra
<script> // Given a binary matrix of M X N of integers,// you need to return only unique rows of binary arrayvar ROW = 4var COL = 5 class BST{     constructor(data)    {        this.data = data;        this.left = null;        this.right = null;    }     // Insert function definition.    Insert(root, value)    {        if(!root)        {            // Insert the first node, if root is NULL.            return new BST(value);        }                 //if the value is present        if(value == root.data)         return root;             // Insert data.        if(value > root.data)        {            // Insert right node data, if the 'value'            // to be inserted is greater than 'root' node data.                         // Process right nodes.            root.right = this.Insert(root.right, value);        }        else        {            // Insert left node data, if the 'value'            // to be inserted is greater than 'root' node data.                         // Process left nodes.            root.left = this.Insert(root.left, value);        }                 // Return 'root' node, after insertion.        return root;    }     // Inorder traversal function.    // This gives data in sorted order.    Inorder(root)    {        if(!root)        {            return;        }        this.Inorder(root.left);        print( root.data );        this.Inorder(root.right);    }}; // convert array to decimalfunction convert(arr){    var sum=0;         for(var i=0; i<COL; i++)    {        sum+=Math.pow(2,i)*arr[i];    }    return sum;} // print the column represented as integersfunction print(p){    for(var i=0; i<COL; i++)    {        document.write(p%2 + " ");        p=parseInt(p/2);    }    document.write("<br>");} // The main function that prints// all unique rows in a given matrix.function findUniqueRows(M){         var b =new BST(0),root = null;         //Traverse through the matrix    for(var i=0; i<ROW; i++)    {        //insert the row into BST        root=b.Insert(root,convert(M[i]));    }              //print    b.Inorder(root);     } // Driver Codevar M = [[0, 1, 0, 0, 1],                   [1, 0, 1, 1, 0],                   [0, 1, 0, 0, 1],                   [1, 0, 1, 0, 0]];findUniqueRows(M); // This code is contributed by rutvik_56.</script>
Output: 
1 0 1 0 0 
1 0 1 1 0 
0 1 0 0 1
Complexity Analysis: 
Time complexity: O( ROW x COL + ROW x log( ROW ) ). To traverse the matrix time complexity is O( ROW x COL) and to insert them into BST time complexity is O(log ROW) for each row. So overall time complexity is O( ROW x COL + ROW x log( ROW ) )
Auxiliary Space: O( ROW ). To store the BST O(ROW) space is needed.
Method 3: This method uses Trie data structure to solve the above problem. Trie is an efficient information retrieval data structure. Using Trie, search complexities can be brought to an optimal limit (key length). If we store keys in the binary search tree, a well-balanced BST will need time proportional to M * log N, where M is maximum string length and N is the number of keys in the tree. Using Trie, we can search the key in O(M) time. However, the penalty is on Trie storage requirements.Note: This method will lead to Integer Overflow if the number of columns is large. 
Approach: Since the matrix is boolean, a variant of Trie data structure can be used where each node will be having two children one for 0 and other for 1. Insert each row in the Trie. If the row is already there, don’t print the row. If the row is not there in Trie, insert it in Trie and print it.
Algorithm: 
Create a Trie where rows can be stored.Traverse through the matrix and insert the row into the Trie.Trie cannot store duplicate entries so the duplicates will be removedTraverse the Trie and print the rows.
Create a Trie where rows can be stored.
Traverse through the matrix and insert the row into the Trie.
Trie cannot store duplicate entries so the duplicates will be removed
Traverse the Trie and print the rows.
Implementation: 
C++
C
// Given a binary matrix of M X N of integers,// you need to return only unique rows of binary array#include <bits/stdc++.h>using namespace std;#define ROW 4#define COL 5 // A Trie nodeclass Node{    public:    bool isEndOfCol;    Node *child[2]; // Only two children needed for 0 and 1} ;  // A utility function to allocate memory// for a new Trie nodeNode* newNode(){    Node* temp = new Node();    temp->isEndOfCol = 0;    temp->child[0] = temp->child[1] = NULL;    return temp;} // Inserts a new matrix row to Trie.// If row is already present,// then returns 0, otherwise insets the row and// return 1bool insert(Node** root, int (*M)[COL],                int row, int col ){    // base case    if (*root == NULL)        *root = newNode();     // Recur if there are more entries in this row    if (col < COL)        return insert (&((*root)->child[M[row][col]]),                                        M, row, col + 1);     else // If all entries of this row are processed    {        // unique row found, return 1        if (!((*root)->isEndOfCol))            return (*root)->isEndOfCol = 1;         // duplicate row found, return 0        return 0;    }} // A utility function to print a rowvoid printRow(int(*M)[COL], int row){    int i;    for(i = 0; i < COL; ++i)        cout << M[row][i] << " ";    cout << endl;} // The main function that prints// all unique rows in a given matrix.void findUniqueRows(int (*M)[COL]){    Node* root = NULL; // create an empty Trie    int i;     // Iterate through all rows    for (i = 0; i < ROW; ++i)             // insert row to TRIE        if (insert(&root, M, i, 0))                     // unique row found, print it            printRow(M, i);} // Driver Codeint main(){    int M[ROW][COL] = {{0, 1, 0, 0, 1},                       {1, 0, 1, 1, 0},                       {0, 1, 0, 0, 1},                       {1, 0, 1, 0, 0}};     findUniqueRows(M);     return 0;} // This code is contributed by rathbhupendra
//Given a binary matrix of M X N of integers, you need to return only unique rows of binary array#include <stdio.h>#include <stdlib.h>#include <stdbool.h> #define ROW 4#define COL 5 // A Trie nodetypedef struct Node{    bool isEndOfCol;    struct Node *child[2]; // Only two children needed for 0 and 1} Node;  // A utility function to allocate memory for a new Trie nodeNode* newNode(){    Node* temp = (Node *)malloc( sizeof( Node ) );    temp->isEndOfCol = 0;    temp->child[0] = temp->child[1] = NULL;    return temp;} // Inserts a new matrix row to Trie.  If row is already// present, then returns 0, otherwise insets the row and// return 1bool insert( Node** root, int (*M)[COL], int row, int col ){    // base case    if ( *root == NULL )        *root = newNode();     // Recur if there are more entries in this row    if ( col < COL )        return insert ( &( (*root)->child[ M[row][col] ] ), M, row, col+1 );     else // If all entries of this row are processed    {        // unique row found, return 1        if ( !( (*root)->isEndOfCol ) )            return (*root)->isEndOfCol = 1;         // duplicate row found, return 0        return 0;    }} // A utility function to print a rowvoid printRow( int (*M)[COL], int row ){    int i;    for( i = 0; i < COL; ++i )        printf( "%d ", M[row][i] );    printf("\n");} // The main function that prints all unique rows in a// given matrix.void findUniqueRows( int (*M)[COL] ){    Node* root = NULL; // create an empty Trie    int i;     // Iterate through all rows    for ( i = 0; i < ROW; ++i )        // insert row to TRIE        if ( insert(&root, M, i, 0) )            // unique row found, print it            printRow( M, i );} // Driver program to test above functionsint main(){    int M[ROW][COL] = {{0, 1, 0, 0, 1},        {1, 0, 1, 1, 0},        {0, 1, 0, 0, 1},        {1, 0, 1, 0, 0}    };     findUniqueRows( M );     return 0;}
Output: 
0 1 0 0 1 
1 0 1 1 0 
1 0 1 0 0
Complexity Analysis: 
Time complexity: O( ROW x COL ). To traverse the matrix and insert in the trie the time complexity is O( ROW x COL). This method has better time complexity. Also, the relative order of rows is maintained while printing but it takes a toll on space.
Auxiliary Space: O( ROW x COL ). To store the Trie O(ROW x COL) space complexity is needed.
Method 4: This method uses HashSet data structure to solve the above problem. The HashSet class implements the Set interface, backed by a hash table which is actually a HashMap instance. No guarantee is made as to the iteration order of the set which means that the class does not guarantee the constant order of elements over time. This class permits the null element. The class offers constant time performance for the basic operations like add, remove, contains and size assuming the hash function disperses the elements properly among the buckets. 
Approach: In this method convert the whole row into a single String and then if check it is already present in the HashSet or not. If the row is present then we will leave it otherwise we will print unique row and add it to HashSet.
Algorithm: 
Create a HashSet where rows can be stored as a String.Traverse through the matrix and insert the row as String into the HashSet.HashSet cannot store duplicate entries so the duplicates will be removedTraverse the HashSet and print the rows.
Create a HashSet where rows can be stored as a String.
Traverse through the matrix and insert the row as String into the HashSet.
HashSet cannot store duplicate entries so the duplicates will be removed
Traverse the HashSet and print the rows.
Implementation: 
C++
Java
Python3
C#
Javascript
// C++ code to print unique row in a// given binary matrix#include<bits/stdc++.h>using namespace std; void printArray(int arr[][5], int row,                              int col){    unordered_set<string> uset;         for(int i = 0; i < row; i++)    {        string s = "";                 for(int j = 0; j < col; j++)            s += to_string(arr[i][j]);                 if(uset.count(s) == 0)        {            uset.insert(s);            cout << s << endl;                     }    }} // Driver codeint main(){    int arr[][5] = {{0, 1, 0, 0, 1},                    {1, 0, 1, 1, 0},                    {0, 1, 0, 0, 1},                    {1, 1, 1, 0, 0}};         printArray(arr, 4, 5);} // This code is contributed by// rathbhupendra
// Java code to print unique row in a// given binary matriximport java.util.HashSet; public class GFG {     public static void printArray(int arr[][],                               int row,int col)    {                 HashSet<String> set = new HashSet<String>();                 for(int i = 0; i < row; i++)        {            String s = "";                         for(int j = 0; j < col; j++)                s += String.valueOf(arr[i][j]);                         if(!set.contains(s)) {                set.add(s);                System.out.println(s);                             }        }    }         // Driver code    public static void main(String[] args) {                 int arr[][] = { {0, 1, 0, 0, 1},                        {1, 0, 1, 1, 0},                        {0, 1, 0, 0, 1},                        {1, 1, 1, 0, 0} };                 printArray(arr, 4, 5);    }}
# Python3 code to print unique row in a# given binary matrix def printArray(matrix):     rowCount = len(matrix)    if rowCount == 0:        return     columnCount = len(matrix[0])    if columnCount == 0:        return     row_output_format = " ".join(["%s"] * columnCount)     printed = {}     for row in matrix:        routput = row_output_format % tuple(row)        if routput not in printed:            printed[routput] = True            print(routput) # Driver Codemat = [[0, 1, 0, 0, 1],       [1, 0, 1, 1, 0],       [0, 1, 0, 0, 1],       [1, 1, 1, 0, 0]] printArray(mat) # This code is contributed by myronwalker
using System;using System.Collections.Generic; // c# code to print unique row in a // given binary matrix public class GFG{     public static void printArray(int[][] arr, int row, int col)    {         HashSet<string> set = new HashSet<string>();         for (int i = 0; i < row; i++)        {            string s = "";             for (int j = 0; j < col; j++)            {                s += arr[i][j].ToString();            }             if (!set.Contains(s))            {                set.Add(s);                Console.WriteLine(s);             }        }    }     // Driver code    public static void Main(string[] args)    {         int[][] arr = new int[][]        {            new int[] {0, 1, 0, 0, 1},            new int[] {1, 0, 1, 1, 0},            new int[] {0, 1, 0, 0, 1},            new int[] {1, 1, 1, 0, 0}        };         printArray(arr, 4, 5);    }} // This code is contributed by Shrikant13
<script>// Javascript code to print unique row in a// given binary matrix function printArray(arr,row,col){    let set = new Set();    for(let i = 0; i < row; i++)        {            let s = "";                          for(let j = 0; j < col; j++)                s += (arr[i][j]).toString();                          if(!set.has(s)) {                set.add(s);                document.write(s+"<br>");                              }        }} // Driver codelet arr = [[0, 1, 0, 0, 1],                        [1, 0, 1, 1, 0],                        [0, 1, 0, 0, 1],                        [1, 1, 1, 0, 0]];printArray(arr, 4, 5); // This code is contributed by avanitrachhadiya2155</script>
Output: 
01001
10110
11100
Complexity Analysis: 
Time complexity: O( ROW x COL ). To traverse the matrix and insert in the HashSet the time complexity is O( ROW x COL)
Auxiliary Space: O( ROW ). To store the HashSet O(ROW x COL) space complexity is needed.
Thanks, Anshuman Kaushik for suggesting this method.
YouTubeGeeksforGeeks507K subscribersPrint unique rows in a given boolean matrix | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 14:56•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=GixyVinjtFk" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
 
 
Anshuman Kaushik
shrikanth13
rathbhupendra
myronwalker
andrew1234
mohit kumar 29
sujitmeshram
divyeshrabadiya07
unknown2108
avanitrachhadiya2155
rutvik_56
Rajput-Ji
shinjanpatra
Amazon
Trie
Zoho
Advanced Data Structure
Matrix
Zoho
Amazon
Matrix
Trie
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Decision Tree Introduction with example
Ordered Set and GNU C++ PBDS
Red-Black Tree | Set 2 (Insert)
Disjoint Set Data Structures
Binary Indexed Tree or Fenwick Tree
Matrix Chain Multiplication | DP-8
Program to find largest element in an array
Rat in a Maze | Backtracking-2
Sudoku | Backtracking-7
Find the number of islands | Set 1 (Using DFS)