方法一：双重递归
    遇到问题：数据溢出，将int类型改为long类型

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     TreeNode *left;
    6.  *     TreeNode *right;
    7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
    8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
    10.  * };
    11.  */
    12. class Solution {
    13. public:
    14.     int result=0;
    15.     int pathSum(TreeNode* root, long targetSum) {
    16.         if(root==NULL){
    17.             return 0;
    18.         }
    19.         hasPathSum(root,targetSum);
    20.         pathSum(root->left,targetSum);
    21.         pathSum(root->right,targetSum);
    22.         return result;
    23.     }
    24.     void hasPathSum(TreeNode* root, long targetSum) {
    25.         if(root==NULL){
    26.             return;
    27.         }
    28.         if(targetSum==root->val){
    29.             result=result+1;
    30.         }
    31.         hasPathSum(root->left,targetSum-root->val);
    32.         hasPathSum(root->right,targetSum-root->val);
    33.     }
    34. };

    方法二：将节点root前面所以的父节点的val累加起来（rootsum），以该累加的值减去目标路径长度，若在哈希表中可以查找到该值出现的次数（count）即为有count条路径，并将rootsum存入哈希表之中，同时在后序遍历时，因为路径是由上往下的方向，在子节点进行返回时，为了不让后面的子节点印象前面的父节点，我们对哈希表中rootsum的出现次数进行一个减减的操作

    1. class Solution {
    2. public:
    3.     unordered_map<long,int>presum;
    4.     int result=0;
    5.     int pathSum(TreeNode* root, int targetSum) {
    6.         if(!root){
    7.             return 0;
    8.         }
    9.         presum[0]=1;
    10.         dfs(root,targetSum,0);
    11.         return result;
    12.     }
    13.     void dfs(TreeNode* root, int targetSum, long rootsum)
    14.     {
    15.         if(root==NULL){
    16.             return;
    17.         }
    18.         rootsum+=root->val;
    19.         if(presum.count(rootsum-targetSum)){
    20.             result+=presum[rootsum-targetSum];
    21.         }
    22.         presum[rootsum]+=1;
    23.         dfs(root->left,targetSum,rootsum);
    24.         dfs(root->right,targetSum,rootsum);
    25.         presum[rootsum]--;
    26.     }
    27. };