่ทฏๅพๆปๅ2 ๐๐๐๐ไธญ็ญ
่ฏพๅไฝไธ
้ฎ้ขๆ่ฟฐ
ๅๆ้พๆฅ๏ผ113. ่ทฏๅพๆปๅ II
็ปไฝ ไบๅๆ ็ๆ น่็น root ๅไธไธชๆดๆฐ็ฎๆ ๅ targetSum ๏ผๆพๅบๆๆไปๆ น่็นๅฐๅถๅญ่็น่ทฏๅพๆปๅ็ญไบ็ปๅฎ็ฎๆ ๅ็่ทฏๅพใ
ๅถๅญ่็นๆฏๆๆฒกๆๅญ่็น็่็นใ
็คบไพ 1๏ผ
่พๅ
ฅ๏ผroot = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
่พๅบ๏ผ[[5,4,11,2],[5,8,4,5]]
็คบไพ 2๏ผ
่พๅ
ฅ๏ผroot = [1,2,3], targetSum = 5
่พๅบ๏ผ[]
็คบไพ 3๏ผ
่พๅ
ฅ๏ผroot = [1,2], targetSum = 0
่พๅบ๏ผ[]
ๆ็คบ๏ผ
- ๆ ไธญ่็นๆปๆฐๅจ่ๅด
[0, 5000]ๅ -1000 <= Node.val <= 1000-1000 <= targetSum <= 1000
ไปฃ็ ๅฎ็ฐ
Java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
List<List<Integer>> res = new ArrayList();
List<Integer> tmp = new ArrayList();
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
if(root == null){
return res;
}
dfs(root, targetSum);
return res;
}
void dfs(TreeNode root, int targetSum){
if(root == null){
return;
}
tmp.add(root.val);
targetSum = targetSum - root.val;
if(root.left == null && root.right == null && targetSum == 0){
res.add(new ArrayList<>(tmp));
}
dfs(root.left, targetSum);
dfs(root.right, targetSum);
tmp.remove(tmp.size() - 1);
}
}
Python
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def pathSum(self, root, targetSum):
"""
:type root: TreeNode
:type targetSum: int
:rtype: List[List[int]]
"""
res = []
tmp = []
def dfs(root, targetSum):
if not root:
return
tmp.append(root.val)
targetSum = targetSum - root.val
if not root.left and not root.right and targetSum == 0:
res.append(list(tmp))
dfs(root.left, targetSum)
dfs(root.right, targetSum)
tmp.pop()
dfs(root, targetSum)
return res
C++
/**
* 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 {
public:
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
vector<vector<int>> res;
vector<int> tmp;
function<void(TreeNode*, int)> dfs = [&](TreeNode* root, int targetSum){
if (!root) {
return;
}
tmp.push_back(root->val);
targetSum = targetSum - root->val;
if (!root->left && !root->right && targetSum == 0) {
res.push_back(tmp);
}
dfs(root->left, targetSum);
dfs(root->right, targetSum);
tmp.pop_back();
};
dfs(root, targetSum);
return res;
}
};
Go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func pathSum(root *TreeNode, targetSum int) [][]int {
var res [][]int
var tmp []int
var dfs func(*TreeNode, int)
dfs = func(root *TreeNode, targetSum int) {
if root == nil {
return
}
tmp = append(tmp, root.Val)
targetSum = targetSum - root.Val
if root.Left == nil && root.Right == nil && targetSum == 0 {
res = append(res, append([]int{}, tmp...))
}
dfs(root.Left, targetSum)
dfs(root.Right, targetSum)
tmp = tmp[:len(tmp)-1]
}
dfs(root, targetSum)
return res
}