leetcode—6/13

1. 求根到葉子節點數字之和

給定一個二叉樹，它的每個節點都存放一個0—9的數字，每條從根到葉子節點的路徑都代表一個數字。
計算從根到葉子節點生成的所有數字之和

思路：有幾個葉子節點就有幾個數字，利用棧實現

• 利用棧實現，非遞歸

int sumNumbers(TreeNode* root) {
        int res = 0;
        stack<TreeNode*> s_node;
        stack<int> s_num;
        if(root == nullptr)
        {
            return 0;
        }
        s_node.push(root);
        s_num.push(0);
        while(!s_node.empty())
        {
            TreeNode* cur = s_node.top();
            s_node.pop();
            int curNum = s_num.top() * 10 + cur -> val;
            s_num.pop();
            if(cur -> left == nullptr && cur -> right == nullptr)
            {
                res += curNum;
            }
            if(cur -> left)
            {
                s_node.push(cur -> left);
                s_num.push(curNum);
            }
            if(cur -> right)
            {
                s_node.push(cur -> right);
                s_num.push(curNum);
            }
        }
        return res;
    }

• 遞歸

1. 先遍歷跟節點
2. 遍歷左子樹，把走當前路徑的數字帶到左子樹的求解中
3. 遍歷右子樹，把走當前路徑的數字帶到右子樹的求解中
4. 更新總的和

int sum = 0;
    int sumNumbers(TreeNode* root) {
        if(root == nullptr)
        {
            return sum;
        }
        addNum(root, 0);
        return sum;
    }
    void addNum(TreeNode* root, int temp)
    {
        if(root == nullptr)
        {
            return;
        }
        int cur = temp * 10 + root -> val;
        if(root -> left == nullptr && root -> right == nullptr)
        {
            sum += cur;
            return;
        }
        addNum(root -> left, cur);
        addNum(root -> right, cur);
    }

2. 被圍繞的區域

給定一個二維矩陣，包含’X’和’O’
找到所有被’X’圍繞的區域，並將這些區域裏所有的’O’用’X’填充
解釋：任何邊界上的’O’都不會被填充爲’X’，任何不在邊界上，或不與邊界上的’O’相連的’O’最終會被填充爲’X’

void solve(vector<vector<char>>& board) {
        if(board.size() == 0)
        {
            return;
        }
        int rows = board.size();
        int cols = board[0].size();
        for(int i = 0; i < rows; i++)
        {
            dfs(board, i, 0);
            dfs(board, i, cols - 1);
        }
        for(int j = 1; j < cols - 1; j++)
        {
            dfs(board, 0, j);
            dfs(board, rows -1, j);
        }
        for(int i = 0; i < rows; i++)
        {
            for(int j = 0; j < cols; j++)
            {
                if(board[i][j] == '1')
                {
                    board[i][j] = 'O';
                }
                else
                {
                    board[i][j] = 'X';
                }
            }
        }
    }
    void dfs(vector<vector<char>>& board, int i, int j)
    {
        if(i >= 0 && i < board.size() && j >= 0 && j < board[0].size() && board[i][j] == 'O')
        {
            board[i][j] = '1';
            dfs(board, i - 1, j);
            dfs(board, i + 1, j);
            dfs(board, i, j - 1);
            dfs(board, i, j + 1);
        }
    }