feat: add solutions to lc problem: No.2019 (doocs#1462)

No.2019.The Score of Students Solving Math Expression

Author: yanglbme

solution/1300-1399/1388.Pizza With 3n Slices/README.md

@@ -57,7 +57,14 @@
 
 **方法一：动态规划**
 
-我们可以将这个问题转化为：在一个环形数组中，选择其中 $n$ 个不相邻的数，使得这 $n$ 个数的和最大。
+我们可以将这个问题转化为：在一个长度为 $3n$ 的环形数组中，选择其中 $n$ 个不相邻的数，使得这 $n$ 个数的和最大。
+
+证明如下：
+
+-   当 $n = 1$ 时，我们可以选择数组中的任意一个数。
+-   当 $n \gt 1$ 时，那么一定存在一个数，使得它的某一侧有两个连续的数没有被选择，而另一侧至少有一个数没有被选择。因此，我们可以将这个数和它两侧的数一起从数组中删除，然后剩下的 $3(n - 1)$ 个数构成一个新的环形数组。问题规模缩小成了在长度为 $3(n - 1)$ 的环形数组中选择 $n - 1$ 个不相邻的数，使得这 $n - 1$ 个数的和最大。
+
+因此，我们需要求解的问题可以转化为：在一个长度为 $3n$ 的环形数组中，选择其中 $n$ 个不相邻的数，使得这 $n$ 个数的和最大。
 
 环形数组中，如果选择了第一个数，那么最后一个数就不能选择，如果选择了最后一个数，那么第一个数就不能选择，因此我们可以将环形数组拆成两个数组，一个是去掉第一个数的，一个是去掉最后一个数的，然后分别求解这两个数组的最大值，最后取两个最大值中的较大值即可。
 

solution/2000-2099/2019.The Score of Students Solving Math Expression/README.md

@@ -74,22 +74,318 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划（区间 DP）**
+
+我们先设计一个函数 $cal(s)$，用于计算一个合法的只含有个位数数字的数学表达式的结果。那么正确答案就是 $x = cal(s)$。
+
+我们记字符串 $s$ 的长度为 $n$，那么 $s$ 中的数字个数为 $m = \frac{n+1}{2}$。
+
+我们定义 $f[i][j]$ 表示选择 $s$ 中的第 $i$ 个数字到第 $j$ 个数字（下标从 $0$ 开始）这一段数字，计算出的结果可能的取值。初始时 $f[i][i]$ 表示选择第 $i$ 个数字，结果只能是这个数字本身，即 $f[i][i] = \{s[i \times 2]\}$（即第 $i$ 个数字映射到字符串 $s$ 中的下标为 $i \times 2$ 的字符）。
+
+接下来，我们从大到小枚举 $i$，然后从小到大枚举 $j$，我们需要求出区间 $[i, j]$ 所有数字运算的结果可能的取值。我们在区间 $[i, j]$ 中枚举分界点 $k$，那么 $f[i][j]$ 可以由 $f[i][k]$ 和 $f[k+1][j]$ 通过运算符 $s[k \times 2 + 1]$ 得到。因此我们可以得到如下状态转移方程：
+
+$$
+f[i][j] = \begin{cases}
+\{s[i \times 2]\}, & i = j \\
+\bigcup\limits_{k=i}^{j-1} \{f[i][k] \otimes f[k+1][j]\}, & i < j
+\end{cases}
+$$
+
+其中 $\otimes$ 表示运算符，即 $s[k \times 2 + 1]$。
+
+那么字符串 $s$ 所有数字运算的结果可能的取值就是 $f[0][m-1]$。
+
+最后，我们统计答案。我们用一个数组 $cnt$ 统计答案数组 $answers$ 中每个答案出现的次数。如果答案等于 $x$，那么这个学生得到 $5$ 分，否则如果答案在 $f[0][m-1]$ 中，那么这个学生得到 $2$ 分。遍历 $cnt$，统计答案即可。
+
+时间复杂度 $O(n^3 \times M^2)$，空间复杂度 $O(n^2 \times M^2)$。其中 $M$ 是答案可能的最大值，而 $n$ 是字符串 $s$ 的长度中数字的个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def scoreOfStudents(self, s: str, answers: List[int]) -> int:
+        def cal(s: str) -> int:
+            res, pre = 0, int(s[0])
+            for i in range(1, n, 2):
+                if s[i] == "*":
+                    pre *= int(s[i + 1])
+                else:
+                    res += pre
+                    pre = int(s[i + 1])
+            res += pre
+            return res
+
+        n = len(s)
+        x = cal(s)
+        m = (n + 1) >> 1
+        f = [[set() for _ in range(m)] for _ in range(m)]
+        for i in range(m):
+            f[i][i] = {int(s[i << 1])}
+        for i in range(m - 1, -1, -1):
+            for j in range(i, m):
+                for k in range(i, j):
+                    for l in f[i][k]:
+                        for r in f[k + 1][j]:
+                            if s[k << 1 | 1] == "+" and l + r <= 1000:
+                                f[i][j].add(l + r)
+                            elif s[k << 1 | 1] == "*" and l * r <= 1000:
+                                f[i][j].add(l * r)
+        cnt = Counter(answers)
+        ans = cnt[x] * 5
+        for k, v in cnt.items():
+            if k != x and k in f[0][m - 1]:
+                ans += v << 1
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int scoreOfStudents(String s, int[] answers) {
+        int n = s.length();
+        int x = cal(s);
+        int m = (n + 1) >> 1;
+        Set<Integer>[][] f = new Set[m][m];
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < m; ++j) {
+                f[i][j] = new HashSet<>();
+            }
+            f[i][i].add(s.charAt(i << 1) - '0');
+        }
+        for (int i = m - 1; i >= 0; --i) {
+            for (int j = i; j < m; ++j) {
+                for (int k = i; k < j; ++k) {
+                    for (int l : f[i][k]) {
+                        for (int r : f[k + 1][j]) {
+                            char op = s.charAt(k << 1 | 1);
+                            if (op == '+' && l + r <= 1000) {
+                                f[i][j].add(l + r);
+                            } else if (op == '*' && l * r <= 1000) {
+                                f[i][j].add(l * r);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        int[] cnt = new int[1001];
+        for (int ans : answers) {
+            ++cnt[ans];
+        }
+        int ans = 5 * cnt[x];
+        for (int i = 0; i <= 1000; ++i) {
+            if (i != x && f[0][m - 1].contains(i)) {
+                ans += 2 * cnt[i];
+            }
+        }
+        return ans;
+    }
+
+    private int cal(String s) {
+        int res = 0, pre = s.charAt(0) - '0';
+        for (int i = 1; i < s.length(); i += 2) {
+            char op = s.charAt(i);
+            int cur = s.charAt(i + 1) - '0';
+            if (op == '*') {
+                pre *= cur;
+            } else {
+                res += pre;
+                pre = cur;
+            }
+        }
+        res += pre;
+        return res;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int scoreOfStudents(string s, vector<int>& answers) {
+        int n = s.size();
+        int x = cal(s);
+        int m = (n + 1) >> 1;
+        unordered_set<int> f[m][m];
+        for (int i = 0; i < m; ++i) {
+            f[i][i] = {s[i * 2] - '0'};
+        }
+        for (int i = m - 1; ~i; --i) {
+            for (int j = i; j < m; ++j) {
+                for (int k = i; k < j; ++k) {
+                    for (int l : f[i][k]) {
+                        for (int r : f[k + 1][j]) {
+                            char op = s[k << 1 | 1];
+                            if (op == '+' && l + r <= 1000) {
+                                f[i][j].insert(l + r);
+                            } else if (op == '*' && l * r <= 1000) {
+                                f[i][j].insert(l * r);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        int cnt[1001]{};
+        for (int t : answers) {
+            ++cnt[t];
+        }
+        int ans = 5 * cnt[x];
+        for (int i = 0; i <= 1000; ++i) {
+            if (i != x && f[0][m - 1].count(i)) {
+                ans += cnt[i] << 1;
+            }
+        }
+        return ans;
+    }
+
+    int cal(string& s) {
+        int res = 0;
+        int pre = s[0] - '0';
+        for (int i = 1; i < s.size(); i += 2) {
+            int cur = s[i + 1] - '0';
+            if (s[i] == '*') {
+                pre *= cur;
+            } else {
+                res += pre;
+                pre = cur;
+            }
+        }
+        res += pre;
+        return res;
+    }
+};
+```
+
+### **Go**
+
+```go
+func scoreOfStudents(s string, answers []int) int {
+	n := len(s)
+	x := cal(s)
+	m := (n + 1) >> 1
+	f := make([][]map[int]bool, m)
+	for i := range f {
+		f[i] = make([]map[int]bool, m)
+		for j := range f[i] {
+			f[i][j] = make(map[int]bool)
+		}
+		f[i][i][int(s[i<<1]-'0')] = true
+	}
+	for i := m - 1; i >= 0; i-- {
+		for j := i; j < m; j++ {
+			for k := i; k < j; k++ {
+				for l := range f[i][k] {
+					for r := range f[k+1][j] {
+						op := s[k<<1|1]
+						if op == '+' && l+r <= 1000 {
+							f[i][j][l+r] = true
+						} else if op == '*' && l*r <= 1000 {
+							f[i][j][l*r] = true
+						}
+					}
+				}
+			}
+		}
+	}
+	cnt := [1001]int{}
+	for _, v := range answers {
+		cnt[v]++
+	}
+	ans := cnt[x] * 5
+	for k, v := range cnt {
+		if k != x && f[0][m-1][k] {
+			ans += v << 1
+		}
+	}
+	return ans
+}
+
+func cal(s string) int {
+	res, pre := 0, int(s[0]-'0')
+	for i := 1; i < len(s); i += 2 {
+		cur := int(s[i+1] - '0')
+		if s[i] == '+' {
+			res += pre
+			pre = cur
+		} else {
+			pre *= cur
+		}
+	}
+	res += pre
+	return res
+}
+```
 
+### **TypeScript**
+
+```ts
+function scoreOfStudents(s: string, answers: number[]): number {
+    const n = s.length;
+    const cal = (s: string): number => {
+        let res = 0;
+        let pre = s.charCodeAt(0) - '0'.charCodeAt(0);
+        for (let i = 1; i < s.length; i += 2) {
+            const cur = s.charCodeAt(i + 1) - '0'.charCodeAt(0);
+            if (s[i] === '+') {
+                res += pre;
+                pre = cur;
+            } else {
+                pre *= cur;
+            }
+        }
+        res += pre;
+        return res;
+    };
+    const x = cal(s);
+    const m = (n + 1) >> 1;
+    const f: Set<number>[][] = Array(m)
+        .fill(0)
+        .map(() =>
+            Array(m)
+                .fill(0)
+                .map(() => new Set()),
+        );
+    for (let i = 0; i < m; ++i) {
+        f[i][i].add(s[i << 1].charCodeAt(0) - '0'.charCodeAt(0));
+    }
+    for (let i = m - 1; i >= 0; --i) {
+        for (let j = i; j < m; ++j) {
+            for (let k = i; k < j; ++k) {
+                for (const l of f[i][k]) {
+                    for (const r of f[k + 1][j]) {
+                        const op = s[(k << 1) + 1];
+                        if (op === '+' && l + r <= 1000) {
+                            f[i][j].add(l + r);
+                        } else if (op === '*' && l * r <= 1000) {
+                            f[i][j].add(l * r);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const cnt: number[] = Array(1001).fill(0);
+    for (const v of answers) {
+        ++cnt[v];
+    }
+    let ans = cnt[x] * 5;
+    for (let i = 0; i <= 1000; ++i) {
+        if (i !== x && f[0][m - 1].has(i)) {
+            ans += cnt[i] << 1;
+        }
+    }
+    return ans;
+}
 ```
 
 ### **...**