leetcode --103、130

103. 二叉树的锯齿形层次遍历

题目描述

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

解题方法

队列，每层后面加一个NULL。

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector <int>> res;
        if (root == NULL)   return res;
        queue<TreeNode *>  q;
        q.push(root);   q.push(NULL);
        vector<int > v;
        bool flag = true;

        while ( !q.empty())
        {
            TreeNode * cur = q.front();     // 当前结点
            q.pop();
            if (cur != NULL)
            {
                v.push_back(cur->val);
                if (cur->left != NULL)  q.push(cur->left);
                if (cur->right != NULL) q.push(cur->right);
            }
            if (cur == NULL)                // 等于NULL，说明到了末尾
            {
                if (flag == true)
                    flag = false;
                else
                {
                    reverse(v.begin(), v.end());
                    flag = true;
                }
                res.push_back(v);
                q.push(NULL);   
                if (q.front() == NULL) // 如果是最后一层，如果还加NULL，那么会进入死循环
                    break;
                v.clear();      // 清零
            }
        }
        return res;
    }
};

130. 被围绕的区域

题目描述

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。

找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:

X X X X
X O O X
X X O X
X O X X
运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X
解释:

被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

解题方法

BFS，先将边界上为’O’的入队，并且将对应位置改变，目的是为了防止连通情况进入死循环，之后对每个队列元素BFS，同样需要改变对应位置元素。

连通情况指的是：
OOOO
OOOO
OOOO
OOOO

class Solution {
public:
    void solve(vector<vector<char>>& board) 
    {
        if(board.empty()) return;
        int m = board.size(), n = board[0].size();
        vector<vector<char>> res;
        for (int i = 0; i < m; i ++)            // 初始化 res
        {
            vector<char> c(n, 'X');
            res.push_back(c);
        }

        queue<pair<int, int>> q;
        for (int i = 0; i < m ; i ++)           // board的边界入队
        {
            if (board[i][0] == 'O')
            {
                q.push({i, 0});
                board[i][0] = 'a';
            }
            if (board[i][n-1] == 'O')
            {
                q.push({i, n-1});
                board[i][n-1] = 'a';
            }
                
        }

        for (int j = 0; j < n; j++ )
        {
            if (board[0][j] == 'O')
            {
                q.push({0, j});
                board[0][j] = 'a';
            }
                
            if (board[m-1][j] == 'O')
            {
                q.push({m-1, j});
                board[m-1][j] = 'a';
            }
        }
        
        int x_near[4] = {-1, 1, 0, 0};
        int y_near[4] = {0, 0, -1, 1};

        while (!q.empty())
        {
            pair<int, int> p = q.front();
            q.pop();
            res[p.first][p.second] = 'O';

            for (int c = 0; c < 4; c ++)
            {
                int xx = p.first + x_near[c];
                int yy = p.second + y_near[c];
                if (xx < 0 || xx >= m || yy < 0 || yy >= n || board[xx][yy] != 'O')
                    continue;
                q.push({xx, yy});
                board[xx][yy] = 'a';
            }
        }
        board = res;
    }
};