leetcode112（路径总和）

路径总和

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root) return false;
        if(!root->left && !root->right && root->val == sum) return true;
        return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
    }
};



*/
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum){
        if(!root) return false;
        stack<TreeNode*> st{{root}};
        while(!st.empty()){
            TreeNode*t = st.top(); st.pop();
            if(!t->left && !t->right) {
                if (t->val == sum) return true;
            }
            if(t->right){
                t->right->val += t->val;
                st.push(t->right);
            }
            if(t->left){
                t->left->val += t->val;
                st.push(t->left);
            }
        }
    return false;
    }
};


*/python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        sum -= root.val
        if not root.left and not root.right:
            return sum==0
        return self.hasPathSum(root.left,sum) or self.hasPathSum(root.right,sum)
        
*/
  
class Solution:
    def hasPathSum(self,root,sum):
        if not root:
            return False
        de = [(root,sum-root.val),]
        while de:
            node, curr_sum = de.pop()
            if not node.left and not node.right and curr_sum == 0:
                return True
            if node.right:
                de.append((node.right,curr_sum-node.right.val))
            if node.left:
                de.append((node.left,curr_sum-node.left.val))
        return False