leetcode算法题--网格照明

原题链接：https://leetcode-cn.com/problems/grid-illumination/

方法一：

在n=1000000000时会超时，使用hash map替换

class Solution {
public:
    vector<int> gridIllumination(int n, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        vector<int> res;
        for (auto &q : queries) {
            if(isLightAndClose(lamps, q)) {
                res.emplace_back(1);
            } else {
                res.emplace_back(0);
            }
        }
        return res;
    }

    bool isLightAndClose(vector<vector<int>>& lamps, vector<int>& q) {
        bool flag = false;
        vector<int> dlt;
        int n = lamps.size();
        for (int i = n - 1; i >= 0; --i) {
            vector<int> l = lamps[i];
            if (q[0] == l[0] || q[1] == l[1] || q[0] - q[1] == l[0] - l[1] || q[0] + q[1] == l[0] + l[1]) {
                flag = true;
                int x = l[0] - q[0], y = l[1] - q[1];
                if (x >= -1 && x <= 1 && y >= -1 && y <= 1) {
                    dlt.emplace_back(i);
                }
            }
        }
        for (auto &d : dlt) {
            lamps.erase(lamps.begin() + d);
        }
        return flag;
    }
};

方法二：

class Solution {
public:
    vector<int> gridIllumination(int n, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        vector<int> res;
        auto hash_p = [](const pair<int, int> &p) -> size_t {
            static hash<long long> hash_ll;
            return hash_ll(p.first + (static_cast<long long>(p.second) << 32));
        };
        unordered_set<pair<int, int>, decltype(hash_p)> la(0, hash_p);
        unordered_map<int, int> row, col, dia, adia;
        for (auto &l : lamps) {
            if (la.count({l[0], l[1]})) continue;
            la.insert({l[0], l[1]});
            row[l[0]]++;
            col[l[1]]++;
            dia[l[0] - l[1]]++;
            adia[l[0] + l[1]]++;
        }
        for (auto &q : queries) {
            if (row.count(q[0]) && row[q[0]] > 0 
            || col.count(q[1]) && col[q[1]] > 0 
            || dia.count(q[0] - q[1]) && dia[q[0] - q[1]] > 0 
            || adia.count(q[0] + q[1]) && adia[q[0] + q[1]] > 0) {
                res.emplace_back(1);
                for (int x = q[0] - 1; x <= q[0] + 1; x++) {
                    for (int y = q[1] - 1; y <= q[1] + 1; y++) {
                        if (x < 0 || y < 0 || x >= n || y >= n ) continue;
                        if (la.count({x, y})) {
                            la.erase({x, y});
                            row[x]--;
                            col[y]--;
                            dia[x - y]--;
                            adia[x + y]--;
                        }
                    }
                }
            } else {
                res.emplace_back(0);
            }
        }
        return res;
    }
};