feat: update solutions to lc problems: No.1255,2022

* No.1255.Maximum Score Words Formed by Letters
* No.2022.Convert 1D Array Into 2D Array

Author: yanglbme

solution/1200-1299/1255.Maximum Score Words Formed by Letters/README.md

@@ -67,9 +67,13 @@
 
 **方法一：二进制枚举**
 
-对于给定的单词集合，我们可以使用二进制枚举的方法，枚举出所有的单词组合，然后判断每个单词组合是否满足题目要求，如果满足则计算其得分，最后取得分最大的单词组合。
+我们注意到题目的数据范围不大，因此对于给定的单词表，我们可以使用二进制枚举的方法，枚举出所有的单词组合，然后判断每个单词组合是否满足题目要求，如果满足则计算其得分，最后取得分最大的单词组合。
 
-具体地，我们可以使用二进制的每一位来表示单词集合中的每一个单词是否被选中，如果第 $i$ 位为 $1$，则表示第 $i$ 个单词被选中，否则表示第 $i$ 个单词没有被选中。对于每一个二进制数，我们可以使用位运算来判断其对应的单词是否被选中。
+我们首先用哈希表或数组 $cnt$ 记录字母表 $letters$ 中每个字母出现的次数。
+
+接下来，我们使用二进制枚举的方法，枚举出所有的单词组合。二进制的每一位表示单词表中的每一个单词是否被选中，如果第 $i$ 位为 $1$，则表示第 $i$ 个单词被选中，否则表示第 $i$ 个单词没有被选中。
+
+然后我们统计当前单词组合中每个字母出现的次数，记录在哈希表或数组 $cur$ 中。如果 $cur$ 中的每个字母的出现次数都不大于 $cnt$ 中的对应字母的出现次数，则说明当前单词组合满足题目要求，我们计算当前单词组合的得分，取得分最大的单词组合。
 
 时间复杂度 $(2^n \times n \times M)$，空间复杂度 $O(C)$。其中 $n$ 和 $M$ 分别为单词集合中单词的个数和单词的最大长度；而 $C$ 为字母表中字母的个数，本题中 $C=26$。
 

solution/2000-2099/2022.Convert 1D Array Into 2D Array/README.md

@@ -65,9 +65,13 @@ original 中只有 1 个元素。
 
 <!-- 这里可写通用的实现逻辑 -->
 
-在该题当中，想要成功转换为二维数组，**元素不能少也不能多**，所以需要先做一次长度判断，不对等的情况下直接退出。
+**方法一：模拟**
 
-在数量正确时，则按照给出的规格，将 `original` 分割成小数组，放入返回数组当中。
+根据题目描述，我们知道，要想构造出一个 $m$ 行 $n$ 列的二维数组，需要满足 $m \times n$ 等于原数组的长度。如果不满足，直接返回空数组即可。
+
+如果满足，我们可以按照题目描述的过程，将原数组中的元素依次放入二维数组中即可。
+
+时间复杂度 $O(m \times n)$，其中 $m$ 和 $n$ 分别为二维数组的行数和列数。忽略答案的空间消耗，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -110,8 +114,10 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
-        if (m * n != original.size()) return {};
-        vector<vector<int>> ans(m, vector<int>(n, 0));
+        if (m * n != original.size()) {
+            return {};
+        }
+        vector<vector<int>> ans(m, vector<int>(n));
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
                 ans[i][j] = original[i * n + j];
@@ -125,15 +131,14 @@ public:
 ### **Go**
 
 ```go
-func construct2DArray(original []int, m int, n int) [][]int {
+func construct2DArray(original []int, m int, n int) (ans [][]int) {
 	if m*n != len(original) {
 		return [][]int{}
 	}
-	var ans [][]int
 	for i := 0; i < m*n; i += n {
 		ans = append(ans, original[i:i+n])
 	}
-	return ans
+	return
 }
 ```
 
@@ -147,17 +152,14 @@ func construct2DArray(original []int, m int, n int) [][]int {
  * @return {number[][]}
  */
 var construct2DArray = function (original, m, n) {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 };
 ```
 
@@ -169,17 +171,14 @@ function construct2DArray(
     m: number,
     n: number,
 ): number[][] {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans: number[][] = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 }
 ```
 

solution/2000-2099/2022.Convert 1D Array Into 2D Array/README_EN.md

@@ -87,8 +87,10 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
-        if (m * n != original.size()) return {};
-        vector<vector<int>> ans(m, vector<int>(n, 0));
+        if (m * n != original.size()) {
+            return {};
+        }
+        vector<vector<int>> ans(m, vector<int>(n));
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
                 ans[i][j] = original[i * n + j];
@@ -102,15 +104,14 @@ public:
 ### **Go**
 
 ```go
-func construct2DArray(original []int, m int, n int) [][]int {
+func construct2DArray(original []int, m int, n int) (ans [][]int) {
 	if m*n != len(original) {
 		return [][]int{}
 	}
-	var ans [][]int
 	for i := 0; i < m*n; i += n {
 		ans = append(ans, original[i:i+n])
 	}
-	return ans
+	return
 }
 ```
 
@@ -124,17 +125,14 @@ func construct2DArray(original []int, m int, n int) [][]int {
  * @return {number[][]}
  */
 var construct2DArray = function (original, m, n) {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 };
 ```
 
@@ -146,17 +144,14 @@ function construct2DArray(
     m: number,
     n: number,
 ): number[][] {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans: number[][] = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 }
 ```
 

solution/2000-2099/2022.Convert 1D Array Into 2D Array/Solution.cpp

@@ -1,8 +1,10 @@
 class Solution {
 public:
     vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
-        if (m * n != original.size()) return {};
-        vector<vector<int>> ans(m, vector<int>(n, 0));
+        if (m * n != original.size()) {
+            return {};
+        }
+        vector<vector<int>> ans(m, vector<int>(n));
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
                 ans[i][j] = original[i * n + j];

solution/2000-2099/2022.Convert 1D Array Into 2D Array/Solution.go

@@ -1,10 +1,9 @@
-func construct2DArray(original []int, m int, n int) [][]int {
+func construct2DArray(original []int, m int, n int) (ans [][]int) {
 	if m*n != len(original) {
 		return [][]int{}
 	}
-	var ans [][]int
 	for i := 0; i < m*n; i += n {
 		ans = append(ans, original[i:i+n])
 	}
-	return ans
+	return
 }

solution/2000-2099/2022.Convert 1D Array Into 2D Array/Solution.js

@@ -5,15 +5,12 @@
  * @return {number[][]}
  */
 var construct2DArray = function (original, m, n) {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 };

solution/2000-2099/2022.Convert 1D Array Into 2D Array/Solution.ts

@@ -3,15 +3,12 @@ function construct2DArray(
     m: number,
     n: number,
 ): number[][] {
-    const result = [];
-
-    if (original.length != m * n) {
-        return result;
+    if (m * n != original.length) {
+        return [];
     }
-
-    for (let i = 0; i < m; i++) {
-        result.push(original.slice(i * n, i * n + n));
+    const ans: number[][] = [];
+    for (let i = 0; i < m * n; i += n) {
+        ans.push(original.slice(i, i + n));
     }
-
-    return result;
+    return ans;
 }