Path Sum II

1. 问题
   

   Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

   For example:
   Given the below binary tree and sum = 22,

                 5
                / \
               4   8
              /   / \
             11  13  4
            /  \    / \
           7    2  5   1
   

   return
   

   [
      [5,4,11,2],
      [5,8,4,5]
   ] 
   

2. 解答
   

   /**
    * Definition for a binary tree node.
    * struct TreeNode {
    *     int val;
    *     TreeNode *left;
    *     TreeNode *right;
    *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    * };
    */
   class Solution1 {
   public:
       vector<vector<int>> pathSum(TreeNode* root, int sum) {
    
            vector<int> a;
            path(root,sum,a);
          
           return res;
       }
       void path(TreeNode *root,int sum,vector<int> a)
       {
            if(root)
           {
          // if(root==NULL) return res;
             if(root->left==NULL && root->right==NULL && sum==root->val)
             {
                 a.push_back(root->val);
                 res.push_back(a);
                 //a.clear();
             }
            else
             {
               a.push_back(root->val);
               path(root->left,sum-root->val,a);
               path(root->right,sum-root->val,a);
             }
           }
       }
   public:
      vector<vector<int>> res;
   };
   
   class Solution2 {
   public:
       vector<vector<int>> pathSum(TreeNode* root, int sum) {
    
           // vector<int> a;
            path(root,sum);
          
           return res;
       }
       void path(TreeNode *root,int sum)
       {
            if(root)
           {
          // if(root==NULL) return res;
             if(root->left==NULL && root->right==NULL && sum==root->val)
             {
                 a.push_back(root->val);
                 res.push_back(a);
                 return ;
                 //a.clear();
             }
            else
             {
                  a.push_back(root->val);
                  
                 if(root->left)
                 {
                      
                   path(root->left,sum-root->val);
                   a.pop_back();
                      
                 }
                  
                if(root->right)
                {
                   path(root->right,sum-root->val);
                   a.pop_back();
                }
             }
           }
       }
   public:
      vector<vector<int>> res;
      vector<int> a;
   };
   
   class Solution {
   public:
       Solution():a(1000){}
       vector<vector<int>> pathSum(TreeNode* root, int sum) {
    
            path(root,sum,0);
          
           return res;
       }
       void path(TreeNode *root,int sum,int n)
       {
           if(root==NULL) return ;
            if(root)
           {
              a[n]=root->val;
              n++;
              
             if(root->left==NULL && root->right==NULL && sum==root->val)
             {
                 vector<int> temp(a.begin(),a.begin()+n);
                 res.push_back(temp);
                 return ;
             }
            else
             {
        
                   path(root->left,sum-root->val,n);
        
                   path(root->right,sum-root->val,n);
    
             }
           }
       }
   public:
      vector<vector<int>> res;
      vector<int> a;
   };