From 2d2bfce98f15d8547f7f72d01b12c9d418a39f17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=94=90=E6=A0=91=E6=A3=AE?= <14021051@buaa.edu.cn>
Date: Mon, 19 Nov 2018 10:39:46 +0800
Subject: [PATCH] Create 437. Path Sum III.md

---
 437. Path Sum III.md | 104 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 437. Path Sum III.md

diff --git a/437. Path Sum III.md b/437. Path Sum III.md
new file mode 100644
index 0000000..bff17a6
--- /dev/null
+++ b/437. Path Sum III.md	
@@ -0,0 +1,104 @@
+# [437. Path Sum III](https://leetcode.com/problems/path-sum-iii/description/)
+# 思路
+求二叉树中路径和等于sum的路径条数，这个路径不一定是从根开始以叶子结束，只要求从上到下就行。
+## 思路一
+最简单的思路，如果这条路径要求必须从根开始，那么这题只需要遍历一遍二叉树就行了。  
+因此我们考虑遍历一遍二叉树，遍历到节点node时，就将node作为根节点调用从根开始的路径和函数。则算法具体步骤如下:
+* 递归遍历root这课树，假设现在遍历到了节点node，运行rootpathSum(node, sum)；
+* rootpathSum(node, sum)计算了所有从node开始的路径的和等于sum的路径条数；
+* 同时用一个全局变量res对结果进行累加。
+
+运用了两次递归，复杂度有点高。
+实际跑出来只击败了30%多...    
+时间复杂度O(n*n)
+
+## 思路二
+思路一递归中还包含递归，因此时间复杂度比较高。  
+其实我们在先序遍历到某个节点node时，从根到此节点路径(设为out)上所有节点都应见过了，
+那么我们就应该知道路径out上有多少满足条件且以node结束的子路径了。out定义成一个数组，里面存放了从root到node这条路径的所有节点，再用curSum记录out里面所有
+元素的和，每次都要检查out里面是否存在满足条件且以node结束的子路径（一个for循环）。   
+相对于思路一来说，思路二把思路一的递归改成了循环，运行时间有所下降(击败了80%的人)但是时间复杂度依然是O(n*n)
+
+## 思路三*
+不难发现思路二中的每次for循环包含了大量的重复运算，我们可以考虑用空间换时间的思想去掉这些不必要的重复计算。   
+大致思想还是同思路二，不过不用out数组记录root到node的所有节点，而是用一个hash表mp记录root到(当前)所有节点的每个路径和的个数，这样的话mp[curSum - sum]
+就是满足条件的且以node结束的路径条数。    
+例如，若root到node的值分别是：1、2、3、-3，则4个从root开始的路径和分别为1、3、6、3，那么此时就有`mp[1] = 1`、`mp[3]=2`、`mp[6]=1`。
+若sum=2，则此时得到的满足条件的且以node结束的路径条数就为`mp[curSum - sum] = mp[3 - 2] = 1`。    
+此时击败了99%的人，时间复杂度为O(n)
+
+# C++
+## 思路一
+``` C++
+class Solution {
+private:
+    int res = 0;
+    int rootpathSum(TreeNode *root, int sum){ // 计算从根开始的路径和等于sum的路径条数
+        if(!root) return 0;
+        int tmp = 0;
+        if(root -> val == sum) tmp++;
+        tmp += rootpathSum(root -> left, sum - root -> val);
+        tmp += rootpathSum(root -> right, sum - root -> val);
+        return tmp;
+    }
+    void sum_rootpathSum(TreeNode* root, int sum){ // 遍历一遍树，将所有的rootpathSum相加
+        if(!root) return;
+        res += rootpathSum(root, sum);
+        sum_rootpathSum(root -> left, sum);
+        sum_rootpathSum(root -> right, sum);
+    }
+public:
+    int pathSum(TreeNode* root, int sum) {
+        sum_rootpathSum(root, sum);
+        return res;
+    }
+};
+```
+## 思路二
+``` C++
+class Solution {
+private:
+    int res = 0;
+    void helper(TreeNode* node, int sum, int curSum, vector<TreeNode*>& out) {
+        if (!node) return;
+        curSum += node->val;
+        out.push_back(node);
+        if (curSum == sum) ++res;
+        int t = curSum;
+        for (int i = 0; i < out.size() - 1; i++) { // 循环判断以node为结束的子路径中是否有满足条件的
+            t -= out[i]->val;
+            if (t == sum) res++;
+        }
+        helper(node->left, sum, curSum, out);
+        helper(node->right, sum, curSum, out);
+        out.pop_back();
+    }
+public:
+    int pathSum(TreeNode* root, int sum) {
+        vector<TreeNode*> out;
+        helper(root, sum, 0, out);
+        return res;
+    }
+};
+```
+## 思路三
+``` C++
+class Solution {
+private:
+    int helper(TreeNode* node, int sum, int curSum, unordered_map<int, int>& mp) {
+        if (!node) return 0;
+        curSum += node->val;
+        int res = mp[curSum - sum]; // 以node为结束的路径和等于sum的路径条数
+        mp[curSum]++; // mp记录root到(当前)所有节点的路径和的个数
+        res += helper(node->left, sum, curSum, mp) + helper(node->right, sum, curSum, mp);
+        mp[curSum]--;
+        return res;
+    }
+public:
+    int pathSum(TreeNode* root, int sum) {
+        unordered_map<int, int>mp;
+        mp[0] = 1; 
+        return helper(root, sum, 0, mp);
+    }
+};
+```