feat: add solutions to lc problem: No.1325

No.1325.Delete Leaves With a Given Value

Author: yanglbme

solution/0500-0599/0555.Split Concatenated Strings/Solution.py

@@ -3,7 +3,7 @@ def splitLoopedString(self, strs: List[str]) -> str:
         strs = [s[::-1] if s[::-1] > s else s for s in strs]
         ans = ''.join(strs)
         for i, s in enumerate(strs):
-            t = ''.join(strs[i + 1:]) + ''.join(strs[: i])
+            t = ''.join(strs[i + 1 :]) + ''.join(strs[:i])
             for j in range(len(s)):
                 a = s[j:]
                 b = s[:j]

solution/0800-0899/0831.Masking Personal Information/Solution.py

@@ -2,7 +2,7 @@ class Solution:
     def maskPII(self, s: str) -> str:
         if s[0].isalpha():
             s = s.lower()
-            return s[0] + '*****' + s[s.find('@') - 1:]
+            return s[0] + '*****' + s[s.find('@') - 1 :]
         s = ''.join(c for c in s if c.isdigit())
         cnt = len(s) - 10
         suf = '***-***-' + s[-4:]

solution/0800-0899/0833.Find And Replace in String/Solution.py

@@ -1,9 +1,11 @@
 class Solution:
-    def findReplaceString(self, s: str, indices: List[int], sources: List[str], targets: List[str]) -> str:
+    def findReplaceString(
+        self, s: str, indices: List[int], sources: List[str], targets: List[str]
+    ) -> str:
         n = len(s)
         d = [-1] * n
         for i, (j, source) in enumerate(zip(indices, sources)):
-            if s[j: j + len(source)] == source:
+            if s[j : j + len(source)] == source:
                 d[j] = i
         ans = []
         i = 0

solution/1100-1199/1125.Smallest Sufficient Team/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def smallestSufficientTeam(self, req_skills: List[str], people: List[List[str]]) -> List[int]:
+    def smallestSufficientTeam(
+        self, req_skills: List[str], people: List[List[str]]
+    ) -> List[int]:
         @cache
         def dfs(i, state):
             if i == n:

solution/1200-1299/1223.Dice Roll Simulation/Solution.py

@@ -10,6 +10,6 @@ def dfs(i, j, x):
                     ans += dfs(i + 1, k, 1)
                 elif x < rollMax[j - 1]:
                     ans += dfs(i + 1, j, x + 1)
-            return ans % (10 ** 9 + 7)
+            return ans % (10**9 + 7)
 
         return dfs(0, 0, 0)

solution/1200-1299/1229.Meeting Scheduler/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def minAvailableDuration(self, slots1: List[List[int]], slots2: List[List[int]], duration: int) -> List[int]:
+    def minAvailableDuration(
+        self, slots1: List[List[int]], slots2: List[List[int]], duration: int
+    ) -> List[int]:
         slots1.sort()
         slots2.sort()
         m, n = len(slots1), len(slots2)

solution/1200-1299/1253.Reconstruct a 2-Row Binary Matrix/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:
+    def reconstructMatrix(
+        self, upper: int, lower: int, colsum: List[int]
+    ) -> List[List[int]]:
         n = len(colsum)
         ans = [[0] * n for _ in range(2)]
         for j, v in enumerate(colsum):

solution/1200-1299/1255.Maximum Score Words Formed by Letters/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def maxScoreWords(self, words: List[str], letters: List[str], score: List[int]) -> int:
+    def maxScoreWords(
+        self, words: List[str], letters: List[str], score: List[int]
+    ) -> int:
         cnt = Counter(letters)
         n = len(words)
         ans = 0

solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.py

@@ -5,7 +5,6 @@
 #         self.left = left
 #         self.right = right
 class FindElements:
-
     def __init__(self, root: Optional[TreeNode]):
         def dfs(root):
             self.vis.add(root.val)

solution/1300-1399/1325.Delete Leaves With a Given Value/README.md

@@ -67,7 +67,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-后序遍历，遇到叶子节点值为 target 的时候，将叶子节点置为 null。此过程使用一个父节点来完成。
+**方法一：递归**
+
+我们先判断 $root$ 节点是否为空，若为空，则返回空。
+
+否则，递归地处理 $root$ 的左右子树，即调用 `root.left = removeLeafNodes(root.left, target)` 和 `root.right = removeLeafNodes(root.right, target)`。
+
+然后判断 $root$ 节点是否为叶子节点，即判断 $root.left$ 和 $root.right$ 是否为空，且 $root.val$ 是否等于 $target$。若是，则返回空，否则返回 $root$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。
 
 <!-- tabs:start -->
 
@@ -86,20 +94,13 @@ class Solution:
     def removeLeafNodes(
         self, root: Optional[TreeNode], target: int
     ) -> Optional[TreeNode]:
-        def dfs(root, prev):
-            if root is None:
-                return
-            dfs(root.left, root)
-            dfs(root.right, root)
-            if root.left is None and root.right is None and root.val == target:
-                if prev.left == root:
-                    prev.left = None
-                else:
-                    prev.right = None
-
-        p = TreeNode(val=0, left=root)
-        dfs(root, p)
-        return p.left
+        if root is None:
+            return None
+        root.left = self.removeLeafNodes(root.left, target)
+        root.right = self.removeLeafNodes(root.right, target)
+        if root.left is None and root.right is None and root.val == target:
+            return None
+        return root
 ```
 
 ### **Java**
@@ -124,24 +125,15 @@ class Solution:
  */
 class Solution {
     public TreeNode removeLeafNodes(TreeNode root, int target) {
-        TreeNode p = new TreeNode(0, root, null);
-        dfs(root, p, target);
-        return p.left;
-    }
-
-    private void dfs(TreeNode root, TreeNode prev, int target) {
         if (root == null) {
-            return;
+            return null;
         }
-        dfs(root.left, root, target);
-        dfs(root.right, root, target);
+        root.left = removeLeafNodes(root.left, target);
+        root.right = removeLeafNodes(root.right, target);
         if (root.left == null && root.right == null && root.val == target) {
-            if (prev.left == root) {
-                prev.left = null;
-            } else {
-                prev.right = null;
-            }
+            return null;
         }
+        return root;
     }
 }
 ```
@@ -163,21 +155,15 @@ class Solution {
 class Solution {
 public:
     TreeNode* removeLeafNodes(TreeNode* root, int target) {
-        TreeNode* p = new TreeNode(0, root, nullptr);
-        dfs(root, p, target);
-        return p->left;
-    }
-
-    void dfs(TreeNode* root, TreeNode* prev, int target) {
-        if (!root) return;
-        dfs(root->left, root, target);
-        dfs(root->right, root, target);
+        if (!root) {
+            return nullptr;
+        }
+        root->left = removeLeafNodes(root->left, target);
+        root->right = removeLeafNodes(root->right, target);
         if (!root->left && !root->right && root->val == target) {
-            if (prev->left == root)
-                prev->left = nullptr;
-            else
-                prev->right = nullptr;
+            return nullptr;
         }
+        return root;
     }
 };
 ```
@@ -194,24 +180,48 @@ public:
  * }
  */
 func removeLeafNodes(root *TreeNode, target int) *TreeNode {
-	p := &TreeNode{0, root, nil}
-	var dfs func(root, prev *TreeNode)
-	dfs = func(root, prev *TreeNode) {
-		if root == nil {
-			return
-		}
-		dfs(root.Left, root)
-		dfs(root.Right, root)
-		if root.Left == nil && root.Right == nil && root.Val == target {
-			if prev.Left == root {
-				prev.Left = nil
-			} else {
-				prev.Right = nil
-			}
-		}
+	if root == nil {
+		return nil
 	}
-	dfs(root, p)
-	return p.Left
+	root.Left = removeLeafNodes(root.Left, target)
+	root.Right = removeLeafNodes(root.Right, target)
+	if root.Left == nil && root.Right == nil && root.Val == target {
+		return nil
+	}
+	return root
+}
+```
+
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function removeLeafNodes(
+    root: TreeNode | null,
+    target: number,
+): TreeNode | null {
+    if (!root) {
+        return null;
+    }
+    root.left = removeLeafNodes(root.left, target);
+    root.right = removeLeafNodes(root.right, target);
+    if (!root.left && !root.right && root.val == target) {
+        return null;
+    }
+    return root;
 }
 ```