LeetCode解题报告—— Sum Root to Leaf Numbers & Surrounded Regions & Single Number II

1. Sum Root to Leaf Numbers

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

Note: A leaf is a node with no children.

Example:

Input: [1,2,3]
    1
   / \
  2   3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2:

Input: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

思路：本来想用递归解决这个问题，结果在传参时出现了一个很典型的错误，结果还是点来了discussion，瞬间清朗很多，果然大佬就是大佬。

public int sumNumbers(TreeNode root) {
    return sum(root, 0);
}

public int sum(TreeNode n, int s){
    if (n == null) return 0;
    if (n.right == null && n.left == null) return s*10 + n.val;　　// 叶节点的情形
    return sum(n.left, s*10 + n.val) + sum(n.right, s*10 + n.val);　　// 不是叶节点的情形
}

感觉对于树有关的题目，很多都可以用递归来解决，因为在处理完了根节点后，对于它的左子节点和右子节点的处理流程和根节点差不多，关键是着其中参数的变化。

2. Surrounded Regions

Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region.

Example:

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

思路：类似于围棋一样，基本思路是先将整个矩阵中没有围住的 O (也就是临接边界的) 置为 * ，再将被围住的(其余的) O 置为 X ，再将 * 置回 O 即可，需要注意的是在第一步寻找没有被围住的 O 时，需要用到DFS或者BFS来搜索。

public void solve(char[][] board) {
    if (board.length == 0 || board[0].length == 0)
        return;
    if (board.length < 2 || board[0].length < 2)
        return;
    int m = board.length, n = board[0].length;
    //Any 'O' connected to a boundary can't be turned to 'X', so ...
    //Start from first and last column, turn 'O' to '*'.
    for (int i = 0; i < m; i++) {
        if (board[i][0] == 'O')
            boundaryDFS(board, i, 0);
        if (board[i][n-1] == 'O')
            boundaryDFS(board, i, n-1);
    }
    //Start from first and last row, turn '0' to '*'
    for (int j = 0; j < n; j++) {
        if (board[0][j] == 'O')
            boundaryDFS(board, 0, j);
        if (board[m-1][j] == 'O')
            boundaryDFS(board, m-1, j);
    }
    //post-prcessing, turn 'O' to 'X', '*' back to 'O', keep 'X' intact.
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'O')
                board[i][j] = 'X';
            else if (board[i][j] == '*')
                board[i][j] = 'O';
        }
    }
}
//Use DFS algo to turn internal however boundary-connected 'O' to '*';
private void boundaryDFS(char[][] board, int i, int j) {
    if (i < 0 || i > board.length - 1 || j <0 || j > board[0].length - 1)
        return;
    if (board[i][j] == 'O')　　// 感觉这个判断条件可以省略
        board[i][j] = '*';
    if (i > 1 && board[i-1][j] == 'O')  // 向四个相邻的方向DFS，DFS是递归，BFS是队列。上
        boundaryDFS(board, i-1, j);
    if (i < board.length - 2 && board[i+1][j] == 'O')　　// 下
        boundaryDFS(board, i+1, j);
    if (j > 1 && board[i][j-1] == 'O')　　// 左
        boundaryDFS(board, i, j-1);
    if (j < board[i].length - 2 && board[i][j+1] == 'O' )　　// 右
        boundaryDFS(board, i, j+1);
}

注意的是上面往四个方向DFS时的if判断条件，这里用 length-2 而不是 length-1 是为了避免过深的DFS而导致的stackOverflow。

3. Single Number II

Given a non-empty array of integers, every element appears three times except for one, which appears exactly once. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

Example 1:

Input: [2,2,3,2]
Output: 3

Example 2:

Input: [0,1,0,1,0,1,99]
Output: 99

思路：本来为是比较简单的一题，结果还是各种恪手，算法这玩意儿，真的是好难学(┬＿┬)。看了一下discuss，主要是利用位运算符，既然题目要求在线性时间内完成，即扫描一遍整个数组就能得出结果。

public int singleNumber(int[] nums) {
    int ans = 0;
    for(int i = 0; i < 32; i++) {　　// 从低位到高位处理
        int sum = 0;
        for(int j = 0; j < nums.length; j++) {
            if(((nums[j] >> i) & 1) == 1) {
                sum++;
                sum %= 3;　　// 这里可以扩展
            }
        }
        if(sum != 0) {
            ans |= sum << i;　　// 确定每个位置最终是0还是1后，还原值
        }
    }
    return ans;
}

选择了discuss中最容易理解的一个，主要思想就是将整数转化成32位的二进制来考虑，因为数组中的元素要么出现了3次要么出现了一次，所以任何一位上的数字(0或者1)出现的总次数是3的倍数或者3的倍数加1，所以统计总共每个位置上出现的1的个数即可，如果到了次数3就置为0，这样统计下来，那些出现次数为3的数每个二进制位置上都是0，只要出现一次的数字的二进制位留在了最后处理结果上。