129. 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.

For example,

    1
   / \
  2   3
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.

Return the sum = 12 + 13 = 25.

方法一：
最笨的方法，可以把所有路径存下来，然后逐一计算。如下：

class Solution {
public:
    int sumNumbers(TreeNode* root) {
        vector<vector<int>> res;
        vector<int> tempres;
        if (root == NULL) return 0;
        helper(root, res, tempres);
        int sum = 0;
        for (int i = 0; i < res.size(); i++) {
            int tempsum = 0;
            int len = res[i].size() - 1;
            double factor = pow(10.0, float(len));
            for (int j = 0; j <= len && factor >= 1; j++) {
                tempsum += res[i][j] * factor;
                factor = factor / 10;
            }
            sum += tempsum;
        }
        return sum;
    }
    void helper(TreeNode* root, vector<vector<int>>& res, vector<int>& tempres) {
        if (root == NULL) return;
        tempres.push_back(root->val);
        if (root->left == NULL && root->right == NULL) {
            res.push_back(tempres);
            tempres.pop_back();
            return;
        }
        if (root->left) {
            helper(root->left, res, tempres);
        }
        if (root->right) {
            helper(root->right, res, tempres);
        }
        tempres.pop_back();
        return;
    }
};

这里一开始，leetcode的测试用例最后一例显示答案错误。因为在当路径过长的时候，factor可能会越界，一开始用int就越界了，后来改用double就好了。

方法二： 简洁递归
其实从root到leaf， 每次都用现有的和乘以10加上新访问的节点值就可以了。
所以其实可以递归的很简洁：

class Solution {
public:
    int sumNumbers(TreeNode* root) {
        return helper(root, 0);
    }

    int helper(TreeNode* root, int prevSum) {
        if (root == NULL) return 0;
        prevSum = prevSum * 10 + root->val;
        if (root->left == NULL && root->right == NULL) return prevSum;
        else return helper(root->left, prevSum) + helper(root->right, prevSum);
    }
};

方法三：
in-place 操作，non-recursive。可以把previous sum存在每一个节点中。这样就可以很方便的往下传递。

class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if (root == NULL) return 0;
        int sum = 0;
        stack<TreeNode*> mystack;
        mystack.push(root);
        while (!mystack.empty()) {
            TreeNode* curr = mystack.top();
            mystack.pop();
            if (curr->left == NULL && curr->right == NULL) {
                sum += curr->val;
            }
            if (curr->left) {
                curr->left->val += curr->val * 10;
                mystack.push(curr->left);
            }
            if (curr->right) {
                curr->right->val += curr->val * 10;
                mystack.push(curr->right);
            }
        }
        return sum;
    }
};

方法四： 不改变原始数据的情况下non-recursive，只能用两个stack了。一个stack存储访问的节点，一个stack存储这个节点之前的sum.

class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if (root == NULL) return 0;
        int sum = 0;
        stack<TreeNode*> mystack;
        stack<int> prevSum;
        mystack.push(root);
        prevSum.push(0);
        while (!mystack.empty()) {
            TreeNode* curr = mystack.top();
            int psum = prevSum.top();
            mystack.pop();
            prevSum.pop();
            psum = psum * 10 + curr->val;
            if (curr->left == NULL && curr->right == NULL) {
                sum += psum;
            }
            if (curr->left) {
                mystack.push(curr->left);
                prevSum.push(psum);
            }
            if (curr->right) {
                mystack.push(curr->right);
                prevSum.push(psum);
            }
        }
        return sum;
    }
};

其实这题也可以用queue来做广度优先的讨论，无所谓，只要最后在找到每一个leaf的时候将正确的路径和加到总的sum里就行。不管是stack还是queue，只要同步push和pop之前的prevSum 和节点即可。