diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md
index e191eabc..9b59e66d 100644
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@@ -138,8 +138,12 @@ public:
                 */
                 if (nums[i] + nums[left] + nums[right] > 0) {
                     right--;
+                    // 当前元素不合适了，可以去重
+                    while (left < right && nums[right] == nums[right + 1]) right--;
                 } else if (nums[i] + nums[left] + nums[right] < 0) {
                     left++;
+                    // 不合适，去重
+                    while (left < right && nums[left] == nums[left - 1]) left++;
                 } else {
                     result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                     // 去重逻辑应该放在找到一个三元组之后
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
index bad258c1..c6c55d50 100644
--- a/problems/0018.四数之和.md
+++ b/problems/0018.四数之和.md
@@ -91,9 +91,13 @@ public:
                     // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                     if (nums[k] + nums[i] > target - (nums[left] + nums[right])) {
                         right--;
+                        // 当前元素不合适了，可以去重
+                        while (left < right && nums[right] == nums[right + 1]) right--;
                     // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                     } else if (nums[k] + nums[i]  < target - (nums[left] + nums[right])) {
                         left++;
+                        // 不合适，去重
+                        while (left < right && nums[left] == nums[left - 1]) left++;
                     } else {
                         result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                         // 去重逻辑应该放在找到一个四元组之后
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index a884b278..5db36687 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -747,11 +747,132 @@ let pathSum = function(root, targetSum) {
 };
 ```
 
+## TypeScript
+
+> 0112.路径总和
+
+**递归法：**
+
+```typescript
+function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
+    function recur(node: TreeNode, sum: number): boolean {
+        console.log(sum);
+        if (
+            node.left === null &&
+            node.right === null &&
+            sum === 0
+        ) return true;
+        if (node.left !== null) {
+            sum -= node.left.val;
+            if (recur(node.left, sum) === true) return true;
+            sum += node.left.val;
+        }
+        if (node.right !== null) {
+            sum -= node.right.val;
+            if (recur(node.right, sum) === true) return true;
+            sum += node.right.val;
+        }
+        return false;
+    }
+    if (root === null) return false;
+    return recur(root, targetSum - root.val);
+};
+```
+
+**递归法（精简版）：**
+
+```typescript
+function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
+    if (root === null) return false;
+    targetSum -= root.val;
+    if (
+        root.left === null &&
+        root.right === null &&
+        targetSum === 0
+    ) return true;
+    return hasPathSum(root.left, targetSum) ||
+        hasPathSum(root.right, targetSum);
+};
+```
+
+**迭代法：**
+
+```typescript
+function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
+    type Pair = {
+        node: TreeNode, // 当前节点
+        sum: number // 根节点到当前节点的路径数值总和
+    }
+
+    const helperStack: Pair[] = [];
+    if (root !== null) helperStack.push({ node: root, sum: root.val });
+    let tempPair: Pair;
+    while (helperStack.length > 0) {
+        tempPair = helperStack.pop()!;
+        if (
+            tempPair.node.left === null &&
+            tempPair.node.right === null &&
+            tempPair.sum === targetSum
+        ) return true;
+        if (tempPair.node.right !== null) {
+            helperStack.push({
+                node: tempPair.node.right,
+                sum: tempPair.sum + tempPair.node.right.val
+            });
+        }
+        if (tempPair.node.left !== null) {
+            helperStack.push({
+                node: tempPair.node.left,
+                sum: tempPair.sum + tempPair.node.left.val
+            });
+        }
+    }
+    return false;
+};
+```
+
+> 0112.路径总和 ii
+
+**递归法：**
+
+```typescript
+function pathSum(root: TreeNode | null, targetSum: number): number[][] {
+    function recur(node: TreeNode, sumGap: number, routeArr: number[]): void {
+        if (
+            node.left === null &&
+            node.right === null &&
+            sumGap === 0
+        ) resArr.push([...routeArr]);
+        if (node.left !== null) {
+            sumGap -= node.left.val;
+            routeArr.push(node.left.val);
+            recur(node.left, sumGap, routeArr);
+            sumGap += node.left.val;
+            routeArr.pop();
+        }
+        if (node.right !== null) {
+            sumGap -= node.right.val;
+            routeArr.push(node.right.val);
+            recur(node.right, sumGap, routeArr);
+            sumGap += node.right.val;
+            routeArr.pop();
+        }
+    }
+    const resArr: number[][] = [];
+    if (root === null) return resArr;
+    const routeArr: number[] = [];
+    routeArr.push(root.val);
+    recur(root, targetSum - root.val, routeArr);
+    return resArr;
+};
+```
+
 ## Swift
 
 0112.路径总和
 
 **递归**
+
 ```swift
 func hasPathSum(_ root: TreeNode?, _ targetSum: Int) -> Bool {
     guard let root = root else {
diff --git a/problems/前序/广州互联网公司总结.md b/problems/前序/广州互联网公司总结.md
index 1cf0da36..e83fcd2b 100644
--- a/problems/前序/广州互联网公司总结.md
+++ b/problems/前序/广州互联网公司总结.md
@@ -14,6 +14,7 @@
 ## 一线互联网
 
 * 微信（总部） 有点难进！
+* 字节跳动（广州）
 
 ## 二线
 * 网易（总部）主要是游戏