thảo luận Leetcode mỗi ngày

var maxEqualRowsAfterFlips = function(matrix) {
    const m = new Map();
    let ans = 0;
    for (const r of matrix) {
        const s = (r[0] ? r.map(c => 1 - c) : r).join();
        const k = (m.get(s) ?? 0) + 1;
        m.set(s, k);
        ans = Math.max(ans, k);
    }
    return ans;
};

class Solution {
    func maxEqualRowsAfterFlips(_ matrix: [[Int]]) -> Int {
      var dict: [String: Int] = [:]
      for row in matrix {
        var pure = ""
        var flip = ""
        for c in row {
          pure.append("\(c)")
          flip.append(c == 0 ? "1" : "0")
        }

        dict[pure, default: 0] += 1
        dict[flip, default: 0] += 1
      }

      return dict.values.max() ?? 0
    }
}

class Solution {
    public int maxEqualRowsAfterFlips(int[][] matrix) {
        int cols = matrix[0].length;
        int max = 0;
        for (int[] row : matrix) {
            int[] flip = new int[cols];
            int count = 0;
            for (int i = 0; i < cols; i++) {
                flip[i] = 1 - row[i];
            }
            System.out.println(Arrays.toString(flip));
            for (int[] compare : matrix) {
                if (Arrays.equals(compare, row) || Arrays.equals(compare, flip)) count++;
            }
            max = Math.max(max, count);
        }
        return max;
    }
}

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        res = 0
        hm = defaultdict(int)
        for row in matrix:
            hm[tuple(row)] += 1
        for k in list(hm.keys()):
            flipped_row = tuple([(0 if i == 1 else 1) for i in list(k)])
            v = hm[k]
            res = max(res, v + hm[flipped_row])
        return res

public class Solution {
    public int MaxEqualRowsAfterFlips(int[][] matrix)
    {
        var dic = new Dictionary<string, int>();
        foreach (var arr in matrix)
        {
            var tmp = new StringBuilder();
            tmp.Append("0");
            for (int i = 1; i < arr.Length; i++)
            {
                tmp.Append(arr[i] == arr[0] ? "0" : "1");
            }
            var str = tmp.ToString();
            if (!dic.ContainsKey(str))
            {
                dic.Add(str, 1);
            }
            else
            {
                dic[str]++;
            }
        }

        return dic.Values.Max();
    }
}

class Solution {
    public int maxEqualRowsAfterFlips(int[][] matrix) {
        Map<String, Integer> patternFreq = new HashMap<>();

        for (int[] row : matrix) {
            StringBuilder pattern = new StringBuilder("");

            for (int col = 0; col < row.length; col++) {
                if (row[col] == row[0]) {
                    pattern.append("*");
                } else {
                    pattern.append("-");
                }
            }

            String p = pattern.toString();
            patternFreq.put(p, patternFreq.getOrDefault(p, 0) + 1);
        }

        int max = 0;
        for (int freq : patternFreq.values()) {
            max = Math.max(freq, max);
        }

        return max;
    }
}

class Solution:
    def maxEqualRowsAfterFlips(self, mat: List[List[int]]) -> int:
        d = defaultdict(int)
        for i, j in product(range(len(mat)), repeat=2):
            d[i] += (mat[j] == mat[i]) + all(a^b for a, b in zip(mat[i], mat[j]))
        return max(d.values())

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        res = 0
        hm = Counter(tuple(row) for row in matrix)

        for k in hm:
            flipped_row = tuple(i^1 for i in k)
            res = max(res, hm[k] + hm.get(flipped_row, 0))
        return res

class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>> const& mat) {
        unordered_map<string, int> counter;
        for (auto const& row : mat) {
            string a, b;
            for (auto e : row)
                a += e + '0', b += (1 - e) + '0';
            counter[a]++, counter[b]++;
        }
        int res = 1;
        for (auto it : counter) res = max(res, it.second);
        return res;
    }
};

func maxEqualRowsAfterFlips(matrix [][]int) int {
    m := make(map[string]int)

    for _, row := range matrix {
        var str strings.Builder
        str.Grow(len(row))

        shouldFlip := row[0] == 1

        for _, bit := range row {
            if shouldFlip {
                str.WriteByte(byte('0' + (1 - bit)))
            } else {
                str.WriteByte(byte('0' + bit))
            }
        }

        m[str.String()]++
    }

    maxCount := 0
    for _, count := range m {
        if count > maxCount {
            maxCount = count
        }
    }

    return maxCount
}

typedef bitset<300> bs;
class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
        unordered_map<bs, int> m;
        int ans = 0;
        for (auto& r : matrix) {
            bs k = 0;
            for (int i = 1, sz = r.size(); i < sz; i++) {
                if (r[i] ^ r[i-1]) {
                    k.flip(i-1);
                }
            }
            m[k]++;
            ans = max(ans, m[k]);
        }
        return ans;
    }
};

typedef bitset<300> bs;
class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
        unordered_map<bs, int> m;
        int ans = 0;
        for (auto& r : matrix) {
            bs k = 0;
            for (int i = 1, sz = r.size(); i < sz; i++) {
                k <<= 1;
                k |= r[i] == r[i-1] ? 1 : 0;
            }
            m[k]++;
            ans = max(ans, m[k]);
        }
        return ans;
    }
};

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        hash_table = {}
        for row in matrix:
            key_1 = tuple([i for i, value in enumerate(row) if value == 1])
            key_0 = tuple([i for i, value in enumerate(row) if value == 0])
            hash_table[key_1] = hash_table.get(key_1, 0) + 1
            hash_table[key_0] = hash_table.get(key_0, 0) + 1

        return max(hash_table.values())

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        counter = Counter()
        
        for row in matrix:
            key = tuple(x ^ row[0] for x in row)
            counter[key] += 1

        return max(counter.values())