很模板的dfs、bfs，，但要熟练掌握

DFS

考虑进入下一层之前，提前判断是否进入，若是进入之后再判断容易造成太多分支以及调用函数时间，占据大量堆栈空间。而且书写代码容易混淆。
由于每次进入都判断了，所以最多进入50*50个格子，时间复杂度O（n * m）
但是bfs同样可以遍历到所有格子，只有合格才入队，所以队列数量并不多，使用bfs更好。

bool st[55][55];
class Solution {
public:
    int row, col, k;
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    int get_sum(int a, int b) {
        int s = 0;
        while (a) {
            s += a % 10;
            a /= 10;
        }
        while (b) {
            s += b % 10;
            b /= 10;
        }
        return s;
    }
    bool check(int x, int y) {
        if (x < 0 || x >= row  || y < 0 || y >= col ) return false;
        if (st[x][y]) return false;
        if (get_sum(x, y) > k) return false;
        return true;
    }
    int dfs(int r, int l) {
        st[r][l] = true;
        int ans = 1;
        for (int i = 0; i < 4; i ++ ) {
                int x = r + dx[i], y = l + dy[i];
                if (check(x, y)) ans += dfs(x, y);
            }
        return ans;
    }
    int movingCount(int threshold, int rows, int cols)
    {
        if (!rows || !cols) return 0;
        k = threshold;
        row = rows;
        col = cols;
        return dfs(0, 0);
    }
};

bfs

class Solution {
public:

    int get_sum(pair<int, int> p) {
        int s = 0;
        while (p.first) {
            s += p.first % 10;
            p.first /= 10;
        }
        while (p.second) {
            s += p.second % 10;
            p.second /= 10;
        }
        return s;
    }

    int movingCount(int threshold, int rows, int cols)
    {
        if (!rows || !cols) return 0;
        queue<pair<int,int>> q;
        vector<vector<bool>> st(rows, vector<bool>(cols, false));

        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

        int res = 0;
        q.push({0, 0});
        while (q.size()) {
            auto t = q.front();
            q.pop();
            if (st[t.first][t.second] || get_sum(t) > threshold) continue;
            res ++ ;
            st[t.first][t.second] = true;
            for (int i = 0; i < 4; i ++ ) {
                int x = t.first + dx[i], y = t.second + dy[i];
                if (x >= 0 && x < rows && y >= 0 && y < cols) q.push({x, y});
            }
        }

        return res;
    }
};