LeetCode 1582题解：二维矩阵中特殊位置的高效查找-代码聚汇网

LeetCode 1582题解：二维矩阵中特殊位置的高效查找

佚格麻瓜

1. 问题背景与需求解析

这道题目来自LeetCode第1582题，属于二维矩阵处理类问题。题目要求我们找出二进制矩阵中所有"特殊位置"的数量。所谓特殊位置，定义为一个矩阵元素值为1，并且该元素所在行和列的其他所有元素都为0。

这类问题在实际开发中其实非常常见。比如在图像处理中，我们可能需要识别图像中的孤立像素点；在关系型数据库的稀疏矩阵存储优化中，也需要快速定位这种"独一无二"的数据点。理解这类问题的解法，对培养程序员的基础矩阵操作能力很有帮助。

2. 核心算法思路分析

2.1 暴力解法与优化空间

最直观的解法当然是暴力遍历：对于矩阵中的每个1，都检查它所在的行和列是否全为0（除了它自己）。这种方法的时间复杂度是O(n^3)，对于n×n的矩阵来说，当n较大时效率会很低。

提示：在面试中，即使先提出暴力解法也是一个好的开始，但一定要主动分析其时间/空间复杂度，并思考优化方案。

2.2 预处理行和列信息

更聪明的做法是预先计算每行和每列的1的个数。具体步骤：

创建两个数组rows和cols，分别记录每行和每列中1的个数
第一次遍历矩阵填充rows和cols
第二次遍历矩阵，当遇到mat[i][j]==1时，检查rows[i]==1 && cols[j]==1

这种方法将时间复杂度降到了O(n^2)，因为只需要两次完整的矩阵遍历。空间复杂度是O(n)用于存储rows和cols数组。

2.3 进一步的空间优化

如果题目对空间复杂度有严格要求，我们还可以利用矩阵本身的第一行和第一列来存储统计信息。不过这种优化会使得代码可读性降低，在实际面试中除非特别要求，否则不建议优先采用。

3. 代码实现与详细解析

3.1 Python实现版本

python复制def numSpecial(mat):
    m, n = len(mat), len(mat[0])
    rows = [0] * m
    cols = [0] * n
    
    # 第一次遍历统计每行每列的1的个数
    for i in range(m):
        for j in range(n):
            if mat[i][j] == 1:
                rows[i] += 1
                cols[j] += 1
    
    # 第二次遍历检查特殊位置
    count = 0
    for i in range(m):
        for j in range(n):
            if mat[i][j] == 1 and rows[i] == 1 and cols[j] == 1:
                count += 1
                
    return count

3.2 Java实现版本

java复制class Solution {
    public int numSpecial(int[][] mat) {
        int m = mat.length, n = mat[0].length;
        int[] rows = new int[m];
        int[] cols = new int[n];
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 1) {
                    rows[i]++;
                    cols[j]++;
                }
            }
        }
        
        int count = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 1 && rows[i] == 1 && cols[j] == 1) {
                    count++;
                }
            }
        }
        
        return count;
    }
}

3.3 关键代码解析

初始化阶段：我们先获取矩阵的行数m和列数n，然后初始化两个计数数组rows和cols。
第一次遍历：这是统计阶段，我们遍历矩阵的每个元素，当遇到1时，就在对应的行计数和列计数中各加1。
第二次遍历：这是验证阶段，再次遍历矩阵，对于每个1，检查它所在行和列的计数是否都为1。如果是，则说明这是一个特殊位置。

注意：为什么第二次遍历不能合并到第一次中？因为我们需要完整的行和列统计信息后才能做出准确判断。

4. 复杂度分析与优化证明

4.1 时间复杂度

第一次遍历：O(m×n)
第二次遍历：O(m×n)
总时间复杂度：O(2×m×n) = O(m×n)

这是最优的时间复杂度，因为我们必须至少查看每个矩阵元素一次。

4.2 空间复杂度

rows数组：O(m)
cols数组：O(n)
总空间复杂度：O(m+n)

这在大多数情况下是可以接受的，特别是当矩阵很大时，相比O(m×n)的解法节省了大量空间。

4.3 算法正确性证明

算法的正确性基于以下观察：

一个位置(i,j)是特殊位置，当且仅当：
- mat[i][j] = 1
- 行i中所有其他元素为0 ⇒ rows[i] = 1
- 列j中所有其他元素为0 ⇒ cols[j] = 1
我们的统计方法准确记录了每行和每列中1的个数
因此，同时满足mat[i][j]==1、rows[i]==1和cols[j]==1的位置必定是特殊位置

5. 边界条件与测试案例

5.1 常见测试案例

最小矩阵：

python复制[[1]]  # 应返回1
[[0]]  # 应返回0

全0矩阵：

python复制[[0,0],[0,0]]  # 应返回0

全1矩阵：

python复制[[1,1],[1,1]]  # 应返回0

典型用例：

python复制[[1,0,0],[0,0,1],[1,0,0]]  # 应返回1

5.2 特殊边界情况

单行矩阵：
```
python复制[[1,0,1,0]]  # 应返回0
```

单列矩阵：

python复制[[1],[0],[1]]  # 应返回0

大型稀疏矩阵：

python复制# 100x100矩阵，只有(42,57)位置是1
# 应返回1

6. 常见错误与调试技巧

6.1 新手常见错误

边界条件处理不当：忘记处理1×1矩阵的情况，或者在单行/单列矩阵时出错。
索引混淆：在统计rows和cols时，容易把行和列的索引搞反，特别是在非方阵情况下。
过早优化：试图在第一次遍历时就判断特殊位置，这会导致错误，因为此时还没有完整的行和列统计信息。

6.2 调试建议

打印中间结果：在第一次遍历后打印rows和cols数组，确保统计正确。
小规模测试：先用小的测试案例手动计算预期结果，再与程序输出对比。
可视化矩阵：对于二维问题，将矩阵可视化打印出来有助于发现模式：
```
python复制for row in mat:
    print(row)
```

7. 实际应用场景延伸

虽然这个问题看起来是纯算法题，但其核心思想在实际开发中有广泛应用：

数据库索引优化：识别稀疏矩阵中的唯一键，类似于识别特殊位置。
图像处理：检测图像中的孤立像素或特定模式。
社交网络分析：在邻接矩阵中找出唯一的连接关系。
推荐系统：在用户-物品交互矩阵中找出独特的偏好。

理解这类矩阵处理问题的解法，可以帮助我们在面对实际业务中的类似数据结构时，快速找到高效的解决方案。

8. 算法变种与扩展思考

8.1 变种问题

特殊位置II：定义一个位置是特殊的，如果它是行中唯一的1，或者是列中唯一的1（不要求同时满足）。
k-特殊位置：定义一个位置是k-特殊的，如果它所在行和列的1的个数都正好是k。
加权特殊位置：矩阵元素不是0/1，而是任意数值，特殊位置定义为行和列中最大的元素。

8.2 性能优化挑战

对于非常大的稀疏矩阵（比如1M×1M但只有少量1），如何进一步优化？

只记录非零位置：使用字典或稀疏矩阵表示法，只存储1的位置。
并行计算：将矩阵分块，并行统计行和列的1的个数。
位运算优化：如果矩阵非常稀疏，可以用位图来表示行和列的状态。

9. 不同语言实现的注意事项

9.1 C++实现要点

cpp复制int numSpecial(vector<vector<int>>& mat) {
    int m = mat.size(), n = mat[0].size();
    vector<int> rows(m), cols(n);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j]) {
                rows[i]++;
                cols[j]++;
            }
        }
    }
    
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] && rows[i] == 1 && cols[j] == 1) {
                count++;
            }
        }
    }
    
    return count;
}

注意点：

使用vector而不是原生数组更安全
注意矩阵可能为空的情况
bool值在C++中可以直接用if(mat[i][j])判断

9.2 JavaScript实现要点

javascript复制function numSpecial(mat) {
    const m = mat.length, n = mat[0].length;
    const rows = new Array(m).fill(0);
    const cols = new Array(n).fill(0);
    
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (mat[i][j] === 1) {
                rows[i]++;
                cols[j]++;
            }
        }
    }
    
    let count = 0;
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (mat[i][j] === 1 && rows[i] === 1 && cols[j] === 1) {
                count++;
            }
        }
    }
    
    return count;
}