feat: add solutions to lc problems: No.2928,2929 (#1956)

* No.2928.Distribute Candies Among Children I
* No.2929.Distribute Candies Among Children II

Author: yanglbme

solution/2900-2999/2928.Distribute Candies Among Children I/README.md

@@ -41,34 +41,123 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：组合数学 + 容斥原理**
+
+根据题目描述，我们需要将 $n$ 个糖果分给 $3$ 个小孩，每个小孩分到的糖果数在 $[0, limit]$ 之间。
+
+这实际上等价于把 $n$ 个球放入 $3$ 个盒子中。由于盒子可以为空，我们可以再增加 $3$ 个虚拟球，然后再利用隔板法，即一共有 $n + 3$ 个球，我们在其中 $n + 3 - 1$ 个位置插入 $2$ 个隔板，从而将实际的 $n$ 个球分成 $3$ 组，并且允许盒子为空，因此初始方案数为 $C_{n + 2}^2$。
+
+我们需要在这些方案中，排除掉存在盒子分到的小球数超过 $limit$ 的方案。考虑其中有一个盒子分到的小球数超过 $limit$，那么剩下的球（包括虚拟球）最多有 $n + 3 - (limit + 1) = n - limit + 2$ 个，位置数为 $n - limit + 1$，因此方案数为 $C_{n - limit + 1}^2$。由于存在 $3$ 个盒子，因此这样的方案数为 $3 \times C_{n - limit + 1}^2$。这样子算，我们会多排除掉同时存在两个盒子分到的小球数超过 $limit$ 的方案，因此我们需要再加上这样的方案数，即 $3 \times C_{n - 2 \times limit}^2$。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def distributeCandies(self, n: int, limit: int) -> int:
+        if n > 3 * limit:
+            return 0
+        ans = comb(n + 2, 2)
+        if n > limit:
+            ans -= 3 * comb(n - limit + 1, 2)
+        if n - 2 >= 2 * limit:
+            ans += 3 * comb(n - 2 * limit, 2)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int distributeCandies(int n, int limit) {
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return (int) ans;
+    }
+
+    private long comb2(int n) {
+        return 1L * n * (n - 1) / 2;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int distributeCandies(int n, int limit) {
+        auto comb2 = [](int n) {
+            return 1LL * n * (n - 1) / 2;
+        };
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func distributeCandies(n int, limit int) int {
+	comb2 := func(n int) int {
+		return n * (n - 1) / 2
+	}
+	if n > 3*limit {
+		return 0
+	}
+	ans := comb2(n + 2)
+	if n > limit {
+		ans -= 3 * comb2(n-limit+1)
+	}
+	if n-2 >= 2*limit {
+		ans += 3 * comb2(n-2*limit)
+	}
+	return ans
+}
+```
 
+### **TypeScript**
+
+```ts
+function distributeCandies(n: number, limit: number): number {
+    const comb2 = (n: number) => (n * (n - 1)) / 2;
+    if (n > 3 * limit) {
+        return 0;
+    }
+    let ans = comb2(n + 2);
+    if (n > limit) {
+        ans -= 3 * comb2(n - limit + 1);
+    }
+    if (n - 2 >= 2 * limit) {
+        ans += 3 * comb2(n - 2 * limit);
+    }
+    return ans;
+}
 ```
 
 ### **...**

solution/2900-2999/2928.Distribute Candies Among Children I/README_EN.md

@@ -35,30 +35,119 @@
 
 ## Solutions
 
+**Solution 1: Combinatorial Mathematics + Principle of Inclusion-Exclusion**
+
+According to the problem description, we need to distribute $n$ candies to $3$ children, with each child receiving between $[0, limit]$ candies.
+
+This is equivalent to placing $n$ balls into $3$ boxes. Since the boxes can be empty, we can add $3$ virtual balls, and then use the method of inserting partitions, i.e., there are a total of $n + 3$ balls, and we insert $2$ partitions among the $n + 3 - 1$ positions, thus dividing the actual $n$ balls into $3$ groups, and allowing the boxes to be empty. Therefore, the initial number of schemes is $C_{n + 2}^2$.
+
+We need to exclude the schemes where the number of balls in a box exceeds $limit$. Consider that there is a box where the number of balls exceeds $limit$, then the remaining balls (including virtual balls) have at most $n + 3 - (limit + 1) = n - limit + 2$, and the number of positions is $n - limit + 1$, so the number of schemes is $C_{n - limit + 1}^2$. Since there are $3$ boxes, the number of such schemes is $3 \times C_{n - limit + 1}^2$. In this way, we will exclude too many schemes where the number of balls in two boxes exceeds $limit$ at the same time, so we need to add the number of such schemes, i.e., $3 \times C_{n - 2 \times limit}^2$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def distributeCandies(self, n: int, limit: int) -> int:
+        if n > 3 * limit:
+            return 0
+        ans = comb(n + 2, 2)
+        if n > limit:
+            ans -= 3 * comb(n - limit + 1, 2)
+        if n - 2 >= 2 * limit:
+            ans += 3 * comb(n - 2 * limit, 2)
+        return ans
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int distributeCandies(int n, int limit) {
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return (int) ans;
+    }
+
+    private long comb2(int n) {
+        return 1L * n * (n - 1) / 2;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int distributeCandies(int n, int limit) {
+        auto comb2 = [](int n) {
+            return 1LL * n * (n - 1) / 2;
+        };
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func distributeCandies(n int, limit int) int {
+	comb2 := func(n int) int {
+		return n * (n - 1) / 2
+	}
+	if n > 3*limit {
+		return 0
+	}
+	ans := comb2(n + 2)
+	if n > limit {
+		ans -= 3 * comb2(n-limit+1)
+	}
+	if n-2 >= 2*limit {
+		ans += 3 * comb2(n-2*limit)
+	}
+	return ans
+}
+```
 
+### **TypeScript**
+
+```ts
+function distributeCandies(n: number, limit: number): number {
+    const comb2 = (n: number) => (n * (n - 1)) / 2;
+    if (n > 3 * limit) {
+        return 0;
+    }
+    let ans = comb2(n + 2);
+    if (n > limit) {
+        ans -= 3 * comb2(n - limit + 1);
+    }
+    if (n - 2 >= 2 * limit) {
+        ans += 3 * comb2(n - 2 * limit);
+    }
+    return ans;
+}
 ```
 
 ### **...**

solution/2900-2999/2928.Distribute Candies Among Children I/Solution.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    int distributeCandies(int n, int limit) {
+        auto comb2 = [](int n) {
+            return 1LL * n * (n - 1) / 2;
+        };
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return ans;
+    }
+};

solution/2900-2999/2928.Distribute Candies Among Children I/Solution.go

@@ -0,0 +1,16 @@
+func distributeCandies(n int, limit int) int {
+	comb2 := func(n int) int {
+		return n * (n - 1) / 2
+	}
+	if n > 3*limit {
+		return 0
+	}
+	ans := comb2(n + 2)
+	if n > limit {
+		ans -= 3 * comb2(n-limit+1)
+	}
+	if n-2 >= 2*limit {
+		ans += 3 * comb2(n-2*limit)
+	}
+	return ans
+}

solution/2900-2999/2928.Distribute Candies Among Children I/Solution.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int distributeCandies(int n, int limit) {
+        if (n > 3 * limit) {
+            return 0;
+        }
+        long ans = comb2(n + 2);
+        if (n > limit) {
+            ans -= 3 * comb2(n - limit + 1);
+        }
+        if (n - 2 >= 2 * limit) {
+            ans += 3 * comb2(n - 2 * limit);
+        }
+        return (int) ans;
+    }
+
+    private long comb2(int n) {
+        return 1L * n * (n - 1) / 2;
+    }
+}

solution/2900-2999/2928.Distribute Candies Among Children I/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def distributeCandies(self, n: int, limit: int) -> int:
+        if n > 3 * limit:
+            return 0
+        ans = comb(n + 2, 2)
+        if n > limit:
+            ans -= 3 * comb(n - limit + 1, 2)
+        if n - 2 >= 2 * limit:
+            ans += 3 * comb(n - 2 * limit, 2)
+        return ans

solution/2900-2999/2928.Distribute Candies Among Children I/Solution.ts

@@ -0,0 +1,14 @@
+function distributeCandies(n: number, limit: number): number {
+    const comb2 = (n: number) => (n * (n - 1)) / 2;
+    if (n > 3 * limit) {
+        return 0;
+    }
+    let ans = comb2(n + 2);
+    if (n > limit) {
+        ans -= 3 * comb2(n - limit + 1);
+    }
+    if (n - 2 >= 2 * limit) {
+        ans += 3 * comb2(n - 2 * limit);
+    }
+    return ans;
+}