<p>You are given an <code>m x n</code> binary matrix <code>matrix</code>.</p>

<p>You can choose any number of columns in the matrix and flip every cell in that column (i.e., Change the value of the cell from <code>0</code> to <code>1</code> or vice versa).</p>

<p>Return <em>the maximum number of rows that have all values equal after some number of flips</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> matrix = [[0,1],[1,1]]
<strong>Output:</strong> 1
<strong>Explanation:</strong> After flipping no values, 1 row has all values equal.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> matrix = [[0,1],[1,0]]
<strong>Output:</strong> 2
<strong>Explanation:</strong> After flipping values in the first column, both rows have equal values.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> matrix = [[0,0,0],[0,0,1],[1,1,0]]
<strong>Output:</strong> 2
<strong>Explanation:</strong> After flipping values in the first two columns, the last two rows have equal values.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == matrix.length</code></li>
	<li><code>n == matrix[i].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 300</code></li>
	<li><code>matrix[i][j]</code> is either&nbsp;<code>0</code> or <code>1</code>.</li>
</ul>

class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>>& mat) {
        int m=mat.size(),n=mat[0].size();
        unordered_map<string,int>mpp;
        for(int i=0;i<m;i++) {
            string st,ts;
            for(int j=0;j<n;j++) {
                st.push_back(mat[i][j]+'0');
                ts.push_back((1^mat[i][j])+'0');
            }
            mpp[st]++;
            mpp[ts]++;
        }
        int mi=0;
        for(auto x : mpp) {
            mi=max(mi,x.second);
        }
        return mi;
    }
    /*int getValues(vector<vector<int>>& mat) {
        int m=mat.size(),n=mat[0].size(),mi=INT_MIN,res=0;
        for(int i=0;i<m;i++) {
            int vl=mat[i][0],cnt=0;
            for(int j=0;j<n;j++) {
                if(vl==mat[i][j]) { 
                    cnt+=1;
                }
            }
            if(cnt==n) {
                res+=1;
            }     
            mi=max(mi,res);
        }
        return mi;
    }
    int maxEqualRowsAfterFlips(vector<vector<int>>& mat) {
        int m=mat.size(),n=mat[0].size();
        int j=0,mi=getValues(mat);
        while(j<n) {
            if(mat[0][j]==0) {
                for(int i=0;i<m;i++) {
                    mat[i][j]=!mat[i][j];
                }
                mi=max(mi,getValues(mat));
            }
            j++;
        }
        j=0;
        while(j<n) {
            for(int i=0;i<m;i++) {
                mat[i][j]=!mat[i][j];
            }
            mi=max(mi,getValues(mat));
            j++;
        }
        return mi;
    }*/
};
83900