2661. 找出叠涂元素 : 常规哈希表运用题

news2024/11/18 19:27:39

题目描述

这是 LeetCode 上的 「2661. 找出叠涂元素」 ，难度为 「中等」。

Tag : 「模拟」、「哈希表」、「计数」

给你一个下标从开始的整数数组 arr 和一个的整数矩阵 mat。

arr 和 mat 都包含范围内的所有整数。

从下标开始遍历 arr 中的每个下标 i ，并将包含整数 arr[i] 的 mat 单元格涂色。

请你找出 arr 中在 mat 的某一行或某一列上都被涂色且下标最小的元素，并返回其下标。

示例 1： alt

输入：arr = [1,3,4,2], mat = [[1,4],[2,3]]

输出：2

解释：遍历如上图所示，arr[2] 在矩阵中的第一行或第二列上都被涂色。

示例 2： alt

image explanation for example 2

输入：arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]

输出：3

解释：遍历如上图所示，arr[3] 在矩阵中的第二列上都被涂色。

提示：

arr 中的所有整数互不相同
mat 中的所有整数互不相同

哈希表

利用 mat 的数值各不相同，先使用「哈希表」对 mat 进行转存，以为键，为值，方便后续快速查询某个值所在位置。

创建数组 c1 和 c2，分别记录某行某列有多少单元格被涂色，如 c1[x] = a 代表第行被涂色单元格数量为个，c2[y] = b 代表第列被涂色单元格数量为个。

遍历所有的，查询到的所在位置后，更新 c1 和 c2，若某行或某列被完全涂色，返回当前下标。

Java 代码：

class Solution {
    public int firstCompleteIndex(int[] arr, int[][] mat) {
        int n = mat.length, m = mat[0].length;
        Map<Integer, int[]> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                map.put(mat[i][j], new int[]{i, j});
            }
        }
        int[] c1 = new int[n], c2 = new int[m];
        for (int i = 0; i < n * m; i++) {
            int[] info = map.get(arr[i]);
            int x = info[0], y = info[1];
            if (++c1[x] == m || ++c2[y] == n) return i;
        }
        return -1; // never
    }
}

C++ 代码：

class Solution {
public:
    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size();
        unordered_map<int, pair<int, int>> map;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                map[mat[i][j]] = make_pair(i, j);
            }
        }
        vector<int> c1(n), c2(m);
        for (int i = 0; i < n * m; i++) {
            pair<int, int> info = map[arr[i]];
            int x = info.first, y = info.second;
            if (++c1[x] == m || ++c2[y] == n) return i;
        }
        return -1; // never
    }
};

Python 代码：

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        n, m = len(mat), len(mat[0])
        mapping = {mat[i][j]: (i, j) for i in range(n) for j in range(m)}
        c1, c2 = [0] * n, [0] * m
        for i in range(n * m):
            x, y = mapping[arr[i]]
            c1[x], c2[y] = c1[x] + 1, c2[y] + 1
            if c1[x] == m or c2[y] == n: return i
        return -1  # never

TypeScript 代码：

function firstCompleteIndex(arr: number[], mat: number[][]): number {
    const n = mat.length, m = mat[0].length;
    const map: { [key: number]: [number, number] } = {};
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < m; j++) {
            map[mat[i][j]] = [i, j];
        }
    }
    const c1 = new Array(n).fill(0), c2 = new Array(m).fill(0);
    for (let i = 0; i < n * m; i++) {
        const [x, y] = map[arr[i]];
        if (++c1[x] == m || ++c2[y] === n) return i;
    }
    return -1; // never
};