<p>Given the <code>root</code> of a binary tree and an integer <code>targetSum</code>, return <em>the number of paths where the sum of the values&nbsp;along the path equals</em>&nbsp;<code>targetSum</code>.</p>

<p>The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/pathsum3-1-tree.jpg" style="width: 450px; height: 386px;" />
<pre>
<strong>Input:</strong> root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
<strong>Output:</strong> 3
<strong>Explanation:</strong> The paths that sum to 8 are shown.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
<strong>Output:</strong> 3
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the tree is in the range <code>[0, 1000]</code>.</li>
	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
	<li><code>-1000 &lt;= targetSum &lt;= 1000</code></li>
</ul>

/**
 * 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:

  void check(TreeNode* node, long long sum, int c,vector<int>&v4,int &h){
      
      if(node==NULL){
            return;
        }
     
      sum=sum+node->val;
      v4.push_back(node->val);
      
      if( sum ==c)
      {
          h++;
          
         
         
         
          
          
      }
      
      
      
     
     check(node->left,sum,c,v4,h);
     check(node->right,sum,c,v4,h);
      v4.pop_back();
      

       
   }
   int pathSum(TreeNode* root, int targetSum) {
        //vector<vector<int>> v3;
        if(root==nullptr){
            return (0);
        }
       
        
        int h=0;
        
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            
            
            int si=q.size();
            for(int i=0;i<si;i++){
                TreeNode* node=q.front();
                long long s=0;
                
                q.pop();
       
            
            vector<int>v4;
            check( node,s,targetSum,v4,h);
                v4.clear();
            
            if(node->left){
                q.push(node->left);
            }
                if(node-> right){
                q.push(node->right);
            }
                
            }
            
            
        }
        
        return(h);
            
       
    }
};
50034