## 113. Path Sum II

Given the `root` of a binary tree and an integer `targetSum`, return all root-to-leaf paths where each path's sum equals `targetSum`.

A leaf is a node with no children.

Example 1:

```Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
Output: [[5,4,11,2],[5,8,4,5]]
```

Example 2:

```Input: root = [1,2,3], targetSum = 5
Output: []
```

Example 3:

```Input: root = [1,2], targetSum = 0
Output: []
```

Constraints:

• The number of nodes in the tree is in the range `[0, 5000]`.
• `-1000 <= Node.val <= 1000`
• `-1000 <= targetSum <= 1000`

## Rust Solution

``````struct Solution;
use rustgym_util::*;

trait Preorder {
fn preorder(&self, target: i32, path: &mut Vec<i32>, all: &mut Vec<Vec<i32>>);
}

fn preorder(&self, target: i32, path: &mut Vec<i32>, all: &mut Vec<Vec<i32>>) {
if let Some(node) = self {
let node = node.borrow();
let val = node.val;
path.push(val);
if node.left.is_none() && node.right.is_none() {
if val == target {
all.push(path.to_vec());
}
} else {
node.left.preorder(target - val, path, all);
node.right.preorder(target - val, path, all);
}
path.pop();
}
}
}

impl Solution {
fn path_sum(root: TreeLink, sum: i32) -> Vec<Vec<i32>> {
let mut res = vec![];
let mut path = vec![];
root.preorder(sum, &mut path, &mut res);
res
}
}

#[test]
fn test() {
let root = tree!(
5,
tree!(4, tree!(11, tree!(7), tree!(2)), None),
tree!(8, tree!(13), tree!(4, tree!(5), tree!(1)))
);
let sum = 22;
let res = vec_vec_i32![[5, 4, 11, 2], [5, 8, 4, 5]];
assert_eq!(Solution::path_sum(root, sum), res);
}
``````

Having problems with this solution? Click here to submit an issue on github.