675. Cut Off Trees for Golf Event

// Potential improvements:
// 1. we can use vector<int> { h, x, y } to replace Element, sorting vector is to compare elements one by one.
// 2. use 2-d bool vector<vector<bool>> to replace unordered_set.

class Element {
public:
    int x, y, h;
    Element(int x, int y, int h) {
        this->x = x;
        this->y = y;
        this->h = h;
    }
};
class Solution {
public:
    int m;
    int n;
    int cutOffTree(vector<vector<int>>& forest) {
        m = forest.size();  if (m == ) return ;
        n = forest[].size();   if (n == ) return ;
        vector<Element> v;
        for (int i = ; i < m; i++)
            for (int j = ; j < n; j++)
                if (forest[i][j] > )
                    v.emplace_back(i, j, forest[i][j]);
        auto comp = [](const Element& a, const Element& b) { return a.h < b.h; };
        v.emplace_back(, , );
        sort(v.begin(), v.end(), comp);

        int res = ;
        for (int i = ; i < v.size()  - ; i++) {
            int t = helper(forest, v[i], v[i+]);
            if (t < )  return t;
            res += t;
        }
        return res;
    }
    int helper(vector<vector<int>>& forest, const Element& a, const Element& b) {
        const int dirs[] = { -, , , , - };
        // (x,y) is small enough, so x*n+y won't overflow. otherwise we have to use long,
        // and be careful x*n+y will overflow, we may use (long)x*n+y instead.
        unordered_set<int> s;
        queue<pair<int,int>> q;
        q.push({a.x, a.y});
        s.insert(a.x * n + a.y);
        int lv = ;
        while (!q.empty()) {
            int qsz = q.size();
            for (int i = ; i < qsz; i++) {
                auto cur = q.front();
                q.pop();
                if (cur.first == b.x && cur.second == b.y)
                    return lv;
                for (int i = ; i < ; i++) {
                    int nx = cur.first + dirs[i];
                    int ny = cur.second + dirs[i+];
                    pair<int,int> np = {nx,ny};
                    if (nx >=  && nx < m && ny >=  && ny < n &&
                        forest[nx][ny] >  &&
                        s.find(nx * n + ny) == s.end()) {
                        q.push(np);
                        s.insert(nx * n + ny);
                    }
                }
            }
            lv++;
        }
        return -;
    }
};

huge perf improve from 1000+ ms to 300 ms:

use 2-d bool vector<vector<bool>> to replace unordered_set

class Element {
public:
    int x, y, h;
    Element(int x, int y, int h) {
        this->x = x;
        this->y = y;
        this->h = h;
    }
};
class Solution {
public:
    int m;
    int n;
    int cutOffTree(vector<vector<int>>& forest) {
        m = forest.size();  if (m == ) return ;
        n = forest[].size();   if (n == ) return ;
        vector<Element> v;
        for (int i = ; i < m; i++)
            for (int j = ; j < n; j++)
                if (forest[i][j] > )
                    v.emplace_back(i, j, forest[i][j]);
        auto comp = [](const Element& a, const Element& b) { return a.h < b.h; };
        v.emplace_back(, , );
        sort(v.begin(), v.end(), comp);

        int res = ;
        for (int i = ; i < v.size()  - ; i++) {
            int t = helper(forest, v[i], v[i+]);
            if (t < )  return t;
            res += t;
        }
        return res;
    }
    int helper(vector<vector<int>>& forest, const Element& a, const Element& b) {
        const int dirs[] = { -, , , , - };
        // (x,y) is small enough, so x*n+y won't overflow. otherwise we have to use long,
        // and be careful x*n+y will overflow, we may use (long)x*n+y instead.
        vector<vector<bool>> s(m, vector<bool>(n));
        queue<pair<int,int>> q;
        q.emplace(a.x, a.y);
        s[a.x][a.y] = true;
        int lv = ;
        while (!q.empty()) {
            int qsz = q.size();
            for (int i = ; i < qsz; i++) {
                auto cur = q.front();
                q.pop();
                if (cur.first == b.x && cur.second == b.y)
                    return lv;
                for (int i = ; i < ; i++) {
                    int nx = cur.first + dirs[i];
                    int ny = cur.second + dirs[i+];
                    pair<int,int> np = {nx,ny};
                    if (nx >=  && nx < m && ny >=  && ny < n &&
                        forest[nx][ny] >  &&
                        !s[nx][ny]) {
                        q.push(np);
                        s[nx][ny] = true;
                    }
                }
            }
            lv++;
        }
        return -;
    }
};