这个题虽然是中等，代码也不多，解法也有很多，但是特别高效的我也没找到。看到了很多双递归解法，确实巧妙。但是我觉得单递归+一次路径遍历效率上应该更高一点。
解法1：
把dfs所有的根节点到叶子节点路径列找到，然后单个路径使用滑动窗口，窗口路径和为sum则计数+1。
解法2：
dfs所有的节点，把每个节点值push进路径中(注意路径切换需要pop节点值)，以当前节点为末尾节点，向前遍历路径，找到路径和为sum的路径则计数加1.
代码实现起来，代码2比较好写些，我选了第2种，哈哈 
/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return int整型
     */
    int FindPath(TreeNode* root, int sum) {
        // write code here
        vector<int> path;
        return FindPathWithPath(root,sum, path);
    }
    
    int FindPathWithPath(TreeNode* root,int sum, vector<int> &path) {
        if(root == NULL){
            return 0;
        }
        int count = 0;
        int left = 0;
        int right = 0;
        int cur = sum;
        path.push_back(root->val);
        for(int i = path.size()-1;i>=0;i--){
            cur = cur - path[i];
            if(cur == 0){
                count++;
            }
        }          
        if(root->left != NULL){
            left = FindPathWithPath(root->left,sum,path);
            path.pop_back();
        }
        
        if(root->right != NULL){
            right = FindPathWithPath(root->right,sum,path);
            path.pop_back();
        }
        return left + right + count; 
    }
};