Leetcode 87 等价多米诺骨牌对的数量

1 题目

1128. 等价多米诺骨牌对的数量

给你一组多米诺骨牌 dominoes 。

形式上，dominoes[i] = [a, b] 与 dominoes[j] = [c, d] 等价 当且仅当 (a == c 且 b == d) 或者 (a == d 且 b == c) 。即一张骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌。

在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

示例 1：

输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
输出：1

示例 2：

输入：dominoes = [[1,2],[1,2],[1,1],[1,2],[2,2]]
输出：3

提示：

• 1 <= dominoes.length <= 4 * 104
• dominoes[i].length == 2
• 1 <= dominoes[i][j] <= 9

2 代码实现

我发现复习、总结真的很有必要。

之前明明做过的题单

分享丨【算法题单】常用数据结构（前缀和/栈/队列/堆/字典树/并查集/树状数组/线段树） - 讨论 - 力扣（LeetCode）

现在再回头看看发现依旧做得很艰难。尽管这个题目我当时是收藏了一下，也没有好好再看一遍，尽管这个题目已经是easy的了。

先贴一下代码

class Solution {
public:
    int numEquivDominoPairs(vector<vector<int>>& dominoes) {
        unordered_map<int ,int > countMap ;
        int result = 0 ;
        for (auto& dom : dominoes){
            int a = dom[0] , b = dom[1] ;
            int key = a < b ? (a * 10 + b) : (b * 10 + a );
            countMap[key] ++;
        }
        for (auto& pair : countMap){
            int k = pair.second;
            if (k >= 2){
                result += k * (k - 1 ) / 2 ;
            }
        }
        return result ;
    }
};

我想回避一下这个auto的语法，有点不太会用，也不好理解。

class Solution {
public:
    int numEquivDominoPairs(vector<vector<int>>& dominoes) {
        // key：规范化后的多米诺牌
        // value：该牌出现的次数
        unordered_map<int, int> countMap;

        int result = 0;

        // 遍历所有多米诺牌
        for (int i = 0; i < dominoes.size(); i++) {
            int a = dominoes[i][0];
            int b = dominoes[i][1];

            // 保证小的在前，大的在后
            int x = a < b ? a : b;
            int y = a > b ? a : b;

            // 生成唯一的 key（题目中 1 <= 数字 <= 9）
            int key = x * 10 + y;

            countMap[key]++;
        }

        // 统计等价多米诺牌对数（不用迭代器）
        for (int i = 0; i <= 99; i++) { // key最大是 9*10+9=99
            if (countMap[i] >= 2) {
                int cnt = countMap[i];
                result += cnt * (cnt - 1) / 2;
            }
        }

        return result;
    }
};

一张骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，大白话就是，数组里面的两个元素值相等。

然后首先是标准化处理，所有数组都按照大小排序，再用map统计值，采用组合数，最后加起来计数。

可以不用到迭代器因为题目里有说明dominoes[i].length == 2,最大是2。

目前cpp的语法不是很行，后续还要转js，先把这个朴素一点的思路弄明白，进阶的时候在用上语法糖吧。

可是这个99的限制会不会浪费很多，map能不能直接有一个size自己在循环的时候约束。

用 unordered_map（大小自适应）

unordered_map<int, int> countMap;
for (int i = 0; i < dominoes.size(); i++) {
    int x = min(dominoes[i][0], dominoes[i][1]);
    int y = max(dominoes[i][0], dominoes[i][1]);
    int key = x * 10 + y;
    countMap[key]++;
}

// 统计组合数
int result = 0;
for (const pair<int,int>& p : countMap) {
    int k = p.second;
    if (k >= 2) result += k * (k - 1) / 2;
}

想当然了。这下面是完全错误的，编译错误。

for (int i = 0; i <= countMap.size() i++) { 
    // key最大是 9*10+9=99 
    if (countMap[i] >= 2) { 
        int cnt = countMap[i]; 
        result += cnt * (cnt - 1) / 2; 
       } 
}    //这个写法不行？

关键问题

unordered_map<int,int> countMap; 并不是数组，它是哈希表 ，内部没有按整数下标顺序存储元素。

for (int i = 0; i <= countMap.size(); i++) { if (countMap[i] >= 2) ... }

• countMap.size() 返回的是 map 中元素的数量，比如 5 个不同的 key → size() = 5

• 你这里用 i 当作 key 去访问 countMap[i] ❌

  • 这样做会尝试访问 key = 0,1,2,3,4,5...

  • 很多 key 根本不存在，unordered_map 会自动创建默认值 0 → 结果错误

3 总结

哈希表的语法还需要学习，回头看看错题很有必要。

至少在这个题目里面知道要实现一个题目抽象的思路，注意训练，复盘，目前这些题目还没有很好笑接出来哈希表的解题框架。

有点难，大部分都是不求甚解，回头好好看看算法笔记。

(ง •_•)ง加油！！！！加油加油加油！！！