diff --git "a/topic02/submit/LC222_\346\261\252\347\220\233\347\250\213.cpp" "b/topic02/submit/LC222_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..bc87842ea7e922c8dfa2c17ebb8d2ebf5869873e
--- /dev/null
+++ "b/topic02/submit/LC222_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,63 @@
+/**
+ * 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:
+    int countNodes(TreeNode* root)
+    {
+        if (root == nullptr)
+            return 0;
+        
+        if (root->left  == nullptr)
+            return 1;
+
+        int layer = 0;
+        int max_layer = std::log2(5*pow(10,4) + 1);
+        TreeNode* last_node = root;
+
+        while(layer <= max_layer)
+        {
+            layer++;
+            if(last_node->left != nullptr)
+                last_node = last_node->left;
+            else
+                break;
+        }
+        
+        int loop = std::pow(2, layer-1);
+        for (int i = 0; i < loop; i++)
+        {
+            last_node = root;
+            int mask = (1<<layer-1) - 1 - i; // eg: layer=4, action:111 110 101 100 ... (1-left,0-right), last layer num = 8
+            for (int j = 0; j < (layer-1); j++)
+            {
+                if((mask >> (layer-2-j)) & 0x1 == 1)
+                {
+                    if (last_node->left == nullptr)
+                       return i + pow(2,layer-1) - 1;
+                    else
+                        last_node = last_node->left;
+                }
+                else
+                {
+                    if (last_node->right == nullptr)
+                       return i + pow(2,layer-1) - 1;
+                    else
+                        last_node = last_node->right;
+                }
+            }   
+        }
+
+        return pow(2,layer) - 1;
+    }
+};
diff --git "a/topic02/submit/LC2616_\346\261\252\347\220\233\347\250\213.cpp" "b/topic02/submit/LC2616_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..2adb7cdcf0544b10d5a9ff8cc702b12fd515fe69
--- /dev/null
+++ "b/topic02/submit/LC2616_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int minimizeMax(vector<int>& nums, int p) {
+        if (p == 0) return 0;
+
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+
+        auto check = [&](int LIM) {
+            int cnt = 0, total = 0;
+            for (int i = 0; i + 1 < n; i++) {
+                if (nums[i + 1] - nums[i] <= LIM) cnt++;
+                else {
+                    total += (cnt + 1) / 2;
+                    cnt = 0;
+                }
+            }
+            total += (cnt + 1) / 2;
+            return total >= p;
+        };
+
+        int head = 0, tail = nums[n - 1] - nums[0];
+        while (head < tail) {
+            int mid = (head + tail) >> 1;
+            if (check(mid)) tail = mid;
+            else head = mid + 1;
+        }
+        return head;
+    }
+};
diff --git "a/topic02/submit/LC875_\346\261\252\347\220\233\347\250\213.cpp" "b/topic02/submit/LC875_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..32673428d2c9b4d570423f8e4b71f45c60ecc877
--- /dev/null
+++ "b/topic02/submit/LC875_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    int minEatingSpeed(vector<int>& piles, int h) {
+        auto max_it=max_element(piles.begin(),piles.end());
+        int left=0;
+        int right=*max_it;
+        while(left+1<right){
+            int mid=left+(right-left)/2;
+            int sum=0;
+            for(int i=0;i<piles.size();i++){
+                if(piles[i]<=mid){
+                    sum++;
+                    continue;
+                }
+                sum += (piles[i] + mid - 1) / mid;
+                //提前退出
+                if (sum > h) {
+                    break;
+                }
+                // int tem=piles[i];
+                // while(tem>0){
+                //     tem-=mid;
+                //     sum++;
+                // }
+            }
+            if(sum<=h)
+                right=mid;
+            else 
+                left=mid;
+        }
+        return right;
+    }
+};
diff --git "a/topic03/submit/LC53_\346\261\252\347\220\233\347\250\213.cpp" "b/topic03/submit/LC53_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..02b04f24b2242d559d4f22672236e22aa5e50026
--- /dev/null
+++ "b/topic03/submit/LC53_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int sum = 0, result = INT_MIN;
+        for(int i = 0; i < nums.size(); i++){
+            sum += nums[i];
+            if(sum > result){
+                result = sum;
+            }
+
+            if(sum < 0){
+                sum = 0;
+            }
+        }
+        return result;
+    }
+};
diff --git "a/topic03/submit/LC560_\346\261\252\347\220\233\347\250\213.cpp" "b/topic03/submit/LC560_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..be47417c99289b8a818d8d99878349da82ebacf6
--- /dev/null
+++ "b/topic03/submit/LC560_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int subarraySum(vector<int>& nums, int k) {
+        int sum = 0, ans = 0;
+        unordered_map<int,int> mp;
+        mp[0] = 1;
+        for(int i: nums){
+            sum += i;
+            if(mp.find(sum-k) != mp.end()) ans += mp[sum-k];
+            mp[sum] ++;
+        }
+        return ans;
+    }
+};
diff --git "a/topic04/submit/LC1376_\346\261\252\347\220\233\347\250\213.cpp" "b/topic04/submit/LC1376_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..3ff1eced86043eb9c3c977d3834fb5c3b485ab85
--- /dev/null
+++ "b/topic04/submit/LC1376_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,20 @@
+class Solution {
+public:
+
+    vector<vector<int>> son;
+    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
+        son = vector<vector<int>> (n);
+        for (int i = 0; i < n; i ++){
+            if (i != headID){
+                son[manager[i]].push_back(i);
+            }
+        }
+        return dfs(headID, informTime);
+    }
+
+    int dfs(int u, vector<int>& informTime){
+        int res = 0;
+        for (auto s : son[u]) res = max(res, dfs(s, informTime));
+        return res + informTime[u];
+    }
+};
diff --git "a/topic04/submit/LC310_\346\261\252\347\220\233\347\250\213.cpp" "b/topic04/submit/LC310_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..4b54bdfc26bb5ecd5e61a5b5605820f65e362f87
--- /dev/null
+++ "b/topic04/submit/LC310_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,64 @@
+class Solution {
+public:
+
+    vector<vector<int>> g;
+    vector<int> d1, d2, p1, up;
+
+    void dfs1(int u, int father) {
+
+        d1[u] = d2[u] = 0;
+        for(int j: g[u]) {
+
+            if(j == father) continue;
+            dfs1(j, u);
+
+            int d = d1[j] + 1;
+            if(d >= d1[u]) {
+                d2[u] = d1[u];
+                d1[u] = d;
+                p1[u] = j;
+            }else if (d >= d2[u]){
+                d2[u] = d;
+            }
+        }
+    }
+
+    void dfs2(int u, int father){
+        for(int j: g[u]) {
+            if(j == father) continue;
+            if(j == p1[u]) {
+                up[j] = max(up[u], d2[u]) + 1;
+            }else{
+                up[j] = max(up[u], d1[u]) + 1;
+            }
+            dfs2(j, u);
+        }
+    }
+
+    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
+
+        g.resize(n);
+        d1 = d2 = p1 = up = vector<int>(n);
+
+        for (auto &e: edges) {
+            int a = e[0], b = e[1];
+            g[a].push_back(b);
+            g[b].push_back(a);
+        }
+        vector<int> res;
+        dfs1(0, -1);
+        dfs2(0, -1);
+
+        int min_heigh = n + 1;
+        for(int i = 0; i < n; ++i){
+
+            min_heigh = min(min_heigh, max(d1[i], up[i]));
+        }
+        for(int i = 0; i < n; ++i){
+
+            if(max(d1[i], up[i]) == min_heigh) res.push_back(i);
+        }
+
+        return res;
+    }
+};
diff --git "a/topic04/submit/LC687_\346\261\252\347\220\233\347\250\213.cpp" "b/topic04/submit/LC687_\346\261\252\347\220\233\347\250\213.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..4d7a953bfba192ec45a1be585b0cf0ba578561c7
--- /dev/null
+++ "b/topic04/submit/LC687_\346\261\252\347\220\233\347\250\213.cpp"
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int ans = 0;
+    int longestUnivaluePath(TreeNode* root) {
+        dfs(root, -1);
+        return ans;
+    }
+
+    int dfs(TreeNode* root, int val) {
+        if (root == nullptr) return 0;
+        int left = dfs(root->left, root->val), right = dfs(root->right, root->val);
+        ans = max(ans, left + right);
+        return root->val == val ? max(left, right) + 1 : 0;
+    }
+};