Need Review

仅供记录

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        vector>ans;
        if (root == NULL) {
            return ans;
        }
        queueq1;
        q1.emplace(root);
        while (!q1.empty()) {

            vectorcur_ans;
            int size = q1.size();

            for (int i = 0; i < size; i++) {
                TreeNode* cur_root = q1.front();
                q1.pop();
                cur_ans.push_back(cur_root->val);
                if (cur_root->left) {
                    q1.emplace(cur_root->left);
                }
                if (cur_root->right) {
                    q1.emplace(cur_root->right);
                }
            }

            ans.push_back(cur_ans);
        }

        return ans;
    }
};

你被给定一个 m × n 的二维网格 rooms ，网格中有以下三种可能的初始化值：

-1 表示墙或是障碍物
0 表示一扇门
INF 无限表示一个空的房间。然后，我们用 231 - 1 = 2147483647 代表 INF。你可以认为通往门的距离总是小于 2147483647 的。
你要给每个空房间位上填上该房间到 最近门的距离 ，如果无法到达门，则填 INF 即可。

示例 1：

输入：rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
输出：[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]
示例 2：

输入：rooms = [[-1]]
输出：[[-1]]
示例 3：

输入：rooms = [[2147483647]]
输出：[[2147483647]]
示例 4：

输入：rooms = [[0]]
输出：[[0]]

提示：

m == rooms.length
n == rooms[i].length
1 <= m, n <= 250
rooms[i][j] 是 -1、0 或 231 - 1

 class Solution {
 private:
     const int DOOR = 0;
     const int WALL = -1;
     const int INF = 2147483647;

     int arround[4][2] = { {-1,0},{0,-1},{0,1},{1,0} };

 public:
     void wallsAndGates(vector>& rooms) {

         queue>door_queue;

         for (int i = 0; i < rooms.size(); i++) {
             for (int j = 0; j < rooms[i].size(); j++) {
                 if (rooms[i][j] == DOOR) {
                     door_queue.emplace(make_pair(i, j));
                 }
             }
         }

         while (!door_queue.empty()) {

             int x = door_queue.front().first;
             int y = door_queue.front().second;
             door_queue.pop();
             for (int i = 0; i < 4; i++) {
                 int cur_x = x + arround[i][0];
                 int cur_y = y + arround[i][1];
                 if (cur_x < 0 || cur_x >= rooms.size() || cur_y < 0 || cur_y >= rooms[0].size() || rooms[cur_x][cur_y] != INF) continue;

                 rooms[cur_x][cur_y] = rooms[x][y] + 1;
                 door_queue.emplace(make_pair(cur_x, cur_y));
             }

         }
     }
 };