> For the complete documentation index, see [llms.txt](https://anton-veselskyi.gitbook.io/codding-problems-solutions/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://anton-veselskyi.gitbook.io/codding-problems-solutions/leetcode/easy/sum-of-root-to-leaf-binary-numbers.md).

# Sum of Root To Leaf Binary Numbers

## [Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers)

You are given the `root` of a binary tree where each node has a value `0` or `1`.  Each root-to-leaf path represents a binary number starting with the most significant bit.  For example, if the path is `0 -> 1 -> 1 -> 0 -> 1`, then this could represent `01101` in binary, which is `13`.

For all leaves in the tree, consider the numbers represented by the path from the root to that leaf.

Return *the sum of these numbers*. The answer is **guaranteed** to fit in a **32-bits** integer.

**Example 1:** ![](https://assets.leetcode.com/uploads/2019/04/04/sum-of-root-to-leaf-binary-numbers.png)

```

Input: root = [1,0,1,0,1,0,1]
Output: 22
Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
```

**Example 2:**

```

Input: root = [0]
Output: 0
```

**Example 3:**

```

Input: root = [1]
Output: 1
```

**Example 4:**

```

Input: root = [1,1]
Output: 3
```

**Constraints:**

* The number of nodes in the tree is in the range `[1, 1000]`.
* `Node.val` is `0` or `1`.

## Solutions

### 🧠 Cpp

```cpp
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution
{
    //list of binary represented
    static list<list<int>> getAllNumbers(TreeNode* root)
    {
        if(!root)
            return {};
        //if leaf
        if(!root->left && !root->right)
            return list<list<int>>{{root->val}};

        list<list<int>> res;
        auto process_leaf = [&](TreeNode* leaf)
        {
            if(leaf)
            for(auto num : getAllNumbers(leaf))
            {
                num.push_front(root->val);
                res.push_back(num);
            }
        };

        process_leaf(root->left);
        process_leaf(root->right);

        return res;
    }

public:
    int sumRootToLeaf(TreeNode* root)
    {
        int res = 0;
        for(auto num : getAllNumbers(root))
        {
            string binary_string;
            for(int bit : num)
                binary_string.push_back(to_string(bit)[0]);
            res += std::stoi(binary_string, nullptr, 2);
        }
        return res;
    }
};
```