feat: add solutions to lc problems: No.1735,2600~2603

* No.1735.Count Ways to Make Array With Product
* No.2600.K Items With the Maximum Sum
* No.2601.Prime Subtraction Operation
* No.2602.Minimum Operations to Make All Array Elements Equal
* No.2603.Collect Coins in a Tree

Author: yanglbme

solution/0100-0199/0125.Valid Palindrome/README.md

@@ -310,7 +310,7 @@ func verify(ch byte) bool {
 
 ### **PHP**
 
-```php 
+```php
 class Solution {
     /**
      * @param String $s

solution/0100-0199/0125.Valid Palindrome/README_EN.md

@@ -298,7 +298,7 @@ func verify(ch byte) bool {
 
 ### **PHP**
 
-```php 
+```php
 class Solution {
     /**
      * @param String $s

solution/0100-0199/0188.Best Time to Buy and Sell Stock IV/README_EN.md

@@ -6,7 +6,7 @@
 
 <p>You are given an integer array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer <code>k</code>.</p>
 
-<p>Find the maximum profit you can achieve. You may complete at most <code>k</code> transactions.</p>
+<p>Find the maximum profit you can achieve. You may complete at most <code>k</code> transactions: i.e. you may buy at most <code>k</code> times and sell at most <code>k</code> times.</p>
 
 <p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
 

solution/0200-0299/0211.Design Add and Search Words Data Structure/README_EN.md

@@ -42,7 +42,7 @@ wordDictionary.search("b.."); // return True
 	<li><code>1 &lt;= word.length &lt;= 25</code></li>
 	<li><code>word</code> in <code>addWord</code> consists of lowercase English letters.</li>
 	<li><code>word</code> in <code>search</code> consist of <code>&#39;.&#39;</code> or lowercase English letters.</li>
-	<li>There will be at most <code>3</code> dots in <code>word</code> for <code>search</code> queries.</li>
+	<li>There will be at most <code>2</code> dots in <code>word</code> for <code>search</code> queries.</li>
 	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>addWord</code> and <code>search</code>.</li>
 </ul>
 

solution/1700-1799/1735.Count Ways to Make Array With Product/README.md

@@ -50,15 +50,237 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+N = 10020
+MOD = 10**9 + 7
+f = [1] * N
+g = [1] * N
+p = defaultdict(list)
+for i in range(1, N):
+    f[i] = f[i - 1] * i % MOD
+    g[i] = pow(f[i], MOD - 2, MOD)
+    x = i
+    j = 2
+    while j <= x // j:
+        if x % j == 0:
+            cnt = 0
+            while x % j == 0:
+                cnt += 1
+                x //= j
+            p[i].append(cnt)
+        j += 1
+    if x > 1:
+        p[i].append(1)
 
+
+def comb(n, k):
+    return f[n] * g[k] * g[n - k] % MOD
+
+
+class Solution:
+    def waysToFillArray(self, queries: List[List[int]]) -> List[int]:
+        ans = []
+        for n, k in queries:
+            t = 1
+            for x in p[k]:
+                t = t * comb(x + n - 1, n - 1) % MOD
+            ans.append(t)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private static final int N = 10020;
+    private static final int MOD = (int) 1e9 + 7;
+    private static final long[] F = new long[N];
+    private static final long[] G = new long[N];
+    private static final List<Integer>[] P = new List[N];
+
+    static {
+        F[0] = 1;
+        G[0] = 1;
+        Arrays.setAll(P, k -> new ArrayList<>());
+        for (int i = 1; i < N; ++i) {
+            F[i] = F[i - 1] * i % MOD;
+            G[i] = qmi(F[i], MOD - 2, MOD);
+            int x = i;
+            for (int j = 2; j <= x / j; ++j) {
+                if (x % j == 0) {
+                    int cnt = 0;
+                    while (x % j == 0) {
+                        ++cnt;
+                        x /= j;
+                    }
+                    P[i].add(cnt);
+                }
+            }
+            if (x > 1) {
+                P[i].add(1);
+            }
+        }
+    }
+
+    public static long qmi(long a, long k, long p) {
+        long res = 1;
+        while (k != 0) {
+            if ((k & 1) == 1) {
+                res = res * a % p;
+            }
+            k >>= 1;
+            a = a * a % p;
+        }
+        return res;
+    }
+
+    public static long comb(int n, int k) {
+        return (F[n] * G[k] % MOD) * G[n - k] % MOD;
+    }
+
+
+    public int[] waysToFillArray(int[][] queries) {
+        int m = queries.length;
+        int[] ans = new int[m];
+        for (int i = 0; i < m; ++i) {
+            int n = queries[i][0], k = queries[i][1];
+            long t = 1;
+            for (int x : P[k]) {
+                t = t * comb(x + n - 1, n - 1) % MOD;
+            }
+            ans[i] = (int) t;
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+int N = 10020;
+int MOD = 1e9 + 7;
+long f[10020];
+long g[10020];
+vector<int> p[10020];
+
+long qmi(long a, long k, long p) {
+    long res = 1;
+    while (k != 0) {
+        if ((k & 1) == 1) {
+            res = res * a % p;
+        }
+        k >>= 1;
+        a = a * a % p;
+    }
+    return res;
+}
+
+int init = []() {
+    f[0] = 1;
+    g[0] = 1;
+    for (int i = 1; i < N; ++i) {
+        f[i] = f[i - 1] * i % MOD;
+        g[i] = qmi(f[i], MOD - 2, MOD);
+        int x = i;
+        for (int j = 2; j <= x / j; ++j) {
+            if (x % j == 0) {
+                int cnt = 0;
+                while (x % j == 0) {
+                    ++cnt;
+                    x /= j;
+                }
+                p[i].push_back(cnt);
+            }
+        }
+        if (x > 1) {
+            p[i].push_back(1);
+        }
+    }
+    return 0;
+}();
+
+int comb(int n, int k) {
+    return (f[n] * g[k] % MOD) * g[n - k] % MOD;
+}
+
+class Solution {
+public:
+    vector<int> waysToFillArray(vector<vector<int>>& queries) {
+        vector<int> ans;
+        for (auto& q : queries) {
+            int n = q[0], k = q[1];
+            long long t = 1;
+            for (int x : p[k]) {
+                t = t * comb(x + n - 1, n - 1) % MOD;
+            }
+            ans.push_back(t);
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+const n = 1e4 + 20
+const mod = 1e9 + 7
+
+var f = make([]int, n)
+var g = make([]int, n)
+var p = make([][]int, n)
+
+func qmi(a, k, p int) int {
+	res := 1
+	for k != 0 {
+		if k&1 == 1 {
+			res = res * a % p
+		}
+		k >>= 1
+		a = a * a % p
+	}
+	return res
+}
+
+func init() {
+	f[0], g[0] = 1, 1
+	for i := 1; i < n; i++ {
+		f[i] = f[i-1] * i % mod
+		g[i] = qmi(f[i], mod-2, mod)
+		x := i
+		for j := 2; j <= x/j; j++ {
+			if x%j == 0 {
+				cnt := 0
+				for x%j == 0 {
+					cnt++
+					x /= j
+				}
+				p[i] = append(p[i], cnt)
+			}
+		}
+		if x > 1 {
+			p[i] = append(p[i], 1)
+		}
+	}
+}
+
+func comb(n, k int) int {
+	return (f[n] * g[k] % mod) * g[n-k] % mod
+}
 
+func waysToFillArray(queries [][]int) (ans []int) {
+	for _, q := range queries {
+		n, k := q[0], q[1]
+		t := 1
+		for _, x := range p[k] {
+			t = t * comb(x+n-1, n-1) % mod
+		}
+		ans = append(ans, t)
+	}
+	return
+}
 ```
 
 ### **...**