补充了几道LCP题

lcp/LCP 07. 传递信息/README.md

@@ -47,22 +47,42 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划**
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def numWays(self, n: int, relation: List[List[int]], k: int) -> int:
+        dp = [[0] * n for _ in range(k + 1)]
+        dp[0][0] = 1
+        for i in range(1, k + 1):
+            for a, b in relation:
+                dp[i][b] += dp[i - 1][a]
+        return dp[-1][-1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int numWays(int n, int[][] relation, int k) {
+        int[][] dp = new int[k + 1][n];
+        dp[0][0] = 1;
+        for (int i = 1; i <= k; i++) {
+            for (int[] r : relation) {
+                dp[i][r[1]] += dp[i - 1][r[0]];
+            }
+        }
+        return dp[k][n - 1];
+    }
+}
 ```
 
 ### **...**

lcp/LCP 07. 传递信息/Solution.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int numWays(int n, int[][] relation, int k) {
+        int[][] dp = new int[k + 1][n];
+        dp[0][0] = 1;
+        for (int i = 1; i <= k; i++) {
+            for (int[] r : relation) {
+                dp[i][r[1]] += dp[i - 1][r[0]];
+            }
+        }
+        return dp[k][n - 1];
+    }
+}

lcp/LCP 07. 传递信息/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def numWays(self, n: int, relation: List[List[int]], k: int) -> int:
+        dp = [[0] * n for _ in range(k + 1)]
+        dp[0][0] = 1
+        for i in range(1, k + 1):
+            for a, b in relation:
+                dp[i][b] += dp[i - 1][a]
+        return dp[-1][-1]
+

lcp/LCP 08. 剧情触发时间/README.md

@@ -61,22 +61,76 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：前缀和 + 二分查找**
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def getTriggerTime(self, increase: List[List[int]], requirements: List[List[int]]) -> List[int]:
+        increase.insert(0, [0, 0, 0])
+        m, n = len(increase), len(requirements)
+        for i in range(1, m):
+            for j in range(3):
+                increase[i][j] += increase[i - 1][j]
+        ans = [-1] * n
+        for i, req in enumerate(requirements):
+            left, right = 0, m
+            while left < right:
+                mid = (left + right) >> 1
+                if all(a >= b for a, b in zip(increase[mid], req)):
+                    ans[i] = mid
+                    right = mid
+                else:
+                    left = mid + 1
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int[] getTriggerTime(int[][] increase, int[][] requirements) {
+        int m = increase.length, n = requirements.length;
+        int[][] s = new int[m + 1][3];
+        for (int j = 0; j < 3; ++j) {
+            for (int i = 0; i < m; ++i) {
+                s[i + 1][j] = s[i][j] + increase[i][j];
+            }
+        }
+
+        int[] ans = new int[n];
+        Arrays.fill(ans, -1);
+        for (int i = 0; i < n; ++i) {
+            int left = 0, right = m + 1;
+            while (left < right) {
+                int mid = (left + right) >> 1;
+                if (check(s[mid], requirements[i])) {
+                    ans[i] = mid;
+                    right = mid;
+                } else {
+                    left = mid + 1;
+                }
+            }
+        }
+        return ans;
+    }
+
+    private boolean check(int[] a, int[] b) {
+        for (int i = 0; i < 3; ++i) {
+            if (a[i] < b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
 ```
 
 ### **...**

lcp/LCP 08. 剧情触发时间/Solution.java

@@ -0,0 +1,36 @@
+class Solution {
+    public int[] getTriggerTime(int[][] increase, int[][] requirements) {
+        int m = increase.length, n = requirements.length;
+        int[][] s = new int[m + 1][3];
+        for (int j = 0; j < 3; ++j) {
+            for (int i = 0; i < m; ++i) {
+                s[i + 1][j] = s[i][j] + increase[i][j];
+            }
+        }
+
+        int[] ans = new int[n];
+        Arrays.fill(ans, -1);
+        for (int i = 0; i < n; ++i) {
+            int left = 0, right = m + 1;
+            while (left < right) {
+                int mid = (left + right) >> 1;
+                if (check(s[mid], requirements[i])) {
+                    ans[i] = mid;
+                    right = mid;
+                } else {
+                    left = mid + 1;
+                }
+            }
+        }
+        return ans;
+    }
+
+    private boolean check(int[] a, int[] b) {
+        for (int i = 0; i < 3; ++i) {
+            if (a[i] < b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

lcp/LCP 08. 剧情触发时间/Solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def getTriggerTime(self, increase: List[List[int]], requirements: List[List[int]]) -> List[int]:
+        increase.insert(0, [0, 0, 0])
+        m, n = len(increase), len(requirements)
+        for i in range(1, m):
+            for j in range(3):
+                increase[i][j] += increase[i - 1][j]
+        ans = [-1] * n
+        for i, req in enumerate(requirements):
+            left, right = 0, m
+            while left < right:
+                mid = (left + right) >> 1
+                if all(a >= b for a, b in zip(increase[mid], req)):
+                    ans[i] = mid
+                    right = mid
+                else:
+                    left = mid + 1
+        return ans

lcp/LCP 11. 期望个数统计/Solution.java

@@ -0,0 +1,9 @@
+class Solution {
+    public int expectNumber(int[] scores) {
+        Set<Integer> s = new HashSet<>();
+        for (int v : scores) {
+            s.add(v);
+        }
+        return s.size();
+    }
+}

lcp/LCP 11. 期望个数统计/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+   def expectNumber(self, scores: List[int]) -> int:
+        return len(set(scores))

lcp/LCP 34. 二叉树染色/README.md

@@ -40,15 +40,75 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def maxValue(self, root: TreeNode, k: int) -> int:
+        def dfs(root):
+            ans = [0] * (k + 1)
+            if root is None:
+                return ans
+            l, r = dfs(root.left), dfs(root.right)
+            for i in range(k):
+                for j in range(k - i):
+                    ans[i + j + 1] = max(ans[i + j + 1], l[i] + r[j] + root.val)
+            for i in range(k + 1):
+                for j in range(k + 1):
+                    ans[0] = max(ans[0], l[i] + r[j])
+            return ans
+
+        return max(dfs(root))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int maxValue(TreeNode root, int k) {
+        int[] t = dfs(root, k);
+        int ans = 0;
+        for (int v : t) {
+            ans = Math.max(ans, v);
+        }
+        return ans;
+    }
+
+    private int[] dfs(TreeNode root, int k) {
+        int[] ans = new int[k + 1];
+        if (root == null) {
+            return ans;
+        }
+        int[] l = dfs(root.left, k);
+        int[] r = dfs(root.right, k);
+        for (int i = 0; i < k; ++i) {
+            for (int j = 0; j < k - i; ++j) {
+                ans[i + j + 1] = Math.max(ans[i + j + 1], l[i] + r[j] + root.val);
+            }
+        }
+        for (int i = 0; i <= k; ++i) {
+            for (int j = 0; j <= k; ++j) {
+                ans[0] = Math.max(ans[0], l[i] + r[j]);
+            }
+        }
+        return ans;
+    }
+}
 ```
 
 ### **...**

lcp/LCP 34. 二叉树染色/Solution.java

@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int maxValue(TreeNode root, int k) {
+        int[] t = dfs(root, k);
+        int ans = 0;
+        for (int v : t) {
+            ans = Math.max(ans, v);
+        }
+        return ans;
+    }
+
+    private int[] dfs(TreeNode root, int k) {
+        int[] ans = new int[k + 1];
+        if (root == null) {
+            return ans;
+        }
+        int[] l = dfs(root.left, k);
+        int[] r = dfs(root.right, k);
+        for (int i = 0; i < k; ++i) {
+            for (int j = 0; j < k - i; ++j) {
+                ans[i + j + 1] = Math.max(ans[i + j + 1], l[i] + r[j] + root.val);
+            }
+        }
+        for (int i = 0; i <= k; ++i) {
+            for (int j = 0; j <= k; ++j) {
+                ans[0] = Math.max(ans[0], l[i] + r[j]);
+            }
+        }
+        return ans;
+    }
+}

lcp/LCP 34. 二叉树染色/Solution.py

@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def maxValue(self, root: TreeNode, k: int) -> int:
+        def dfs(root):
+            ans = [0] * (k + 1)
+            if root is None:
+                return ans
+            l, r = dfs(root.left), dfs(root.right)
+            for i in range(k):
+                for j in range(k - i):
+                    ans[i + j + 1] = max(ans[i + j + 1], l[i] + r[j] + root.val)
+            for i in range(k + 1):
+                for j in range(k + 1):
+                    ans[0] = max(ans[0], l[i] + r[j])
+            return ans
+
+        return max(dfs(root))