Unique Pairs in a 2D Matrix Summing to Target

Given a rectangular integer matrix matrix whose values are globally unique and an integer target, return the number of unordered pairs of values whose sum is target.
Each pair must use two different cells. Count a value pair once regardless of order.

Function
countPairs(matrix: int[][], target: int) → int

Examples
Example 1
matrix = [[1,5],[7,-1]]
target = 6
return = 2
The unordered pairs are (1, 5) and (-1, 7).
Example 2
matrix = [[1,2],[3,4]]
target = 5
return = 2
The pairs are (1, 4) and (2, 3).
Example 3
matrix = [[4]]
target = 8
return = 0
The one value cannot be paired with its own cell.

Constraints
1 <= matrix.length, matrix[i].length.
The matrix is rectangular and contains at most 100000 cells.
-10^9 <= matrix[i][j], target <= 10^9.
All matrix values are distinct.

Here's the reduction. Values are globally distinct, so every value appears in exactly one cell. That means you never worry about duplicates or about reusing a cell, except one case: a value pairing with itself when target equals twice the value. Since values are unique, that self-pair is impossible with only one copy, so the set check handles it by checking the complement before inserting the current value. Loop over every cell, compute target minus value, and if it's in the set, increment the count. Then add the value to the set. Time is O(n) over at most 100000 cells, space is O(n). The common pitfall is writing nested loops over rows and columns, which is O(n^2) and times out. The other trap is counting each pair twice. Checking before inserting avoids that. If you freeze on the OA, StealthCoder can hand you this approach live, but the pattern is short enough to memorize.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.