<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 {
    std::array<uint32_t, 10> makeKey(const std::vector<int>& row) const noexcept {
        std::array<uint32_t, 10> ret{};
        int invert = (row[0] == 0);

        for (int c=0; c < row.size(); ++c)
            ret[c/32] |= ((row[c]^invert) << (c%32));
        return ret;
    }
    struct Key1072Hash {
        std::size_t operator()(const std::array<uint32_t, 10>& x) const
        {
            return x[0];
        }
    };
public:
    int maxEqualRowsAfterFlips(const vector<vector<int>>& matrix) {
        const int NumRows = matrix.size();
        const int NumCols = matrix[0].size();
        int maxCount = 0;
        std::unordered_map<std::array<uint32_t,10>, int, Key1072Hash> countsByKey;
        for (int r=0; r < NumRows; ++r)
        {
            auto [it, wasInserted] = countsByKey.try_emplace(makeKey(matrix[r]), 1);
            if (!wasInserted) // already exists
                it->second++;
            maxCount = std::max(maxCount, it->second);
        }
        return maxCount;
    }
};
66700