feat: add solutions to lc problem: No.1652

No.1652.Defuse the Bomb

Author: yanglbme

lcci/17.09.Get Kth Magic Number/README.md

@@ -25,9 +25,9 @@
 
 **方法二：动态规划**
 
-定义数组 `dp`，其中 `dp[i]` 表示第 $i$ 个数，答案即为 `dp[k]`。
+定义数组 $dp$，其中 $dp[i]$ 表示第 $i$ 个数，答案即为 $dp[k]$。
 
-定义三个指针 `p3`, `p5`, `p7`，表示下一个数是当前指针指向的数乘以对应的质因数，初始值都为 $1$。
+定义三个指针 $p_3$, $p_5$, $p_7$，表示下一个数是当前指针指向的数乘以对应的质因数，初始值都为 $1$。
 
 当 $2\le i \le k$ 时，令 $dp[i] = \min(dp[p_3\times 3], dp[p_5]\times 5, dp[p_7]\times 7)$，然后分别比较 $dp[i]$ 和 $dp[p_3]\times 3, dp[p_5]\times 5, dp[p_7]\times 7$，如果相等，则将对应的指针加 $1$。
 

solution/1600-1699/1652.Defuse the Bomb/README.md

@@ -61,7 +61,37 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-数组下标取模，累加求每一项即可。
+**方法一：模拟**
+
+定义答案数组 `ans`，长度为 $n$，初始时所有元素都为 $0$。根据题意，若 $k$ 为 $0$，直接返回 `ans`。
+
+否则，遍历每个位置 $i$：
+
+若 $k$ 为正数，那么 $i$ 位置的值为 $i$ 位置后 $k$ 个位置的值之和，即：
+
+$$
+ans[i] = \sum_{j=i+1}^{i+k} code[j\mod{n}]
+$$
+
+若 $k$ 为负数，那么 $i$ 位置的值为 $i$ 位置前 $|k|$ 个位置的值之和，即：
+
+$$
+ans[i] = \sum_{j=i+k}^{i-1} code[(j+n)\mod{n}]
+$$
+
+时间复杂度 $O(n\times|k|)$，忽略答案的空间消耗，空间复杂度 $O(1)$。
+
+**方法二：前缀和**
+
+在方法一中，对于每个位置 $i$，都需要遍历 $k$ 个位置，有很多重复计算的操作。我们可以利用前缀和来优化。
+
+我们将 `code` 数组复制一份（可以不用执行复制操作，直接通过循环遍历取模实现），得到两倍长度的数组，对其求前缀和，得到长度为 $2\times n + 1$ 的前缀和数组 $s$。
+
+若 $k$ 为正数，那么 $i$ 位置的值为 $i$ 位置后 $k$ 个位置的值之和，即 $ans[i] = s[i + k + 1] - s[i + 1]$。
+
+若 $k$ 为负数，那么 $i$ 位置的值为 $i$ 位置前 $|k|$ 个位置的值之和，即 $ans[i] = s[i + n] - s[i + k + n]$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `code` 数组的长度。
 
 <!-- tabs:start -->
 
@@ -73,17 +103,33 @@
 class Solution:
     def decrypt(self, code: List[int], k: int) -> List[int]:
         n = len(code)
-        res = [0] * n
+        ans = [0] * n
         if k == 0:
-            return res
+            return ans
         for i in range(n):
             if k > 0:
                 for j in range(i + 1, i + k + 1):
-                    res[i] += code[j % n]
+                    ans[i] += code[j % n]
             else:
                 for j in range(i + k, i):
-                    res[i] += code[(j + n) % n]
-        return res
+                    ans[i] += code[(j + n) % n]
+        return ans
+```
+
+```python
+class Solution:
+    def decrypt(self, code: List[int], k: int) -> List[int]:
+        n = len(code)
+        ans = [0] * n
+        if k == 0:
+            return ans
+        s = list(accumulate(code + code, initial=0))
+        for i in range(n):
+            if k > 0:
+                ans[i] = s[i + k + 1] - s[i + 1]
+            else:
+                ans[i] = s[i + n] - s[i + k + n]
+        return ans
 ```
 
 ### **Java**
@@ -94,24 +140,148 @@ class Solution:
 class Solution {
     public int[] decrypt(int[] code, int k) {
         int n = code.length;
-        int[] res = new int[n];
-        if (k == 0) return res;
+        int[] ans = new int[n];
+        if (k == 0) {
+            return ans;
+        }
         for (int i = 0; i < n; ++i) {
             if (k > 0) {
-                for (int j = i + 1; j <= i + k; ++j) {
-                    res[i] += code[j % n];
+                for (int j = i + 1; j < i + k + 1; ++j) {
+                    ans[i] += code[j % n];
                 }
             } else {
-                for (int j = i + k; j <= i - 1; ++j) {
-                    res[i] += code[(j + n) % n];
+                for (int j = i + k; j < i; ++j) {
+                    ans[i] += code[(j + n) % n];
                 }
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+```java
+class Solution {
+    public int[] decrypt(int[] code, int k) {
+        int n = code.length;
+        int[] ans = new int[n];
+        if (k == 0) {
+            return ans;
+        }
+        int[] s = new int[n << 1 | 1];
+        for (int i = 0; i < n << 1; ++i) {
+            s[i + 1] = s[i] + code[i % n];
+        }
+        for (int i = 0; i < n; ++i) {
+            if (k > 0) {
+                ans[i] = s[i + k + 1] - s[i + 1];
+            } else {
+                ans[i] = s[i + n] - s[i + k + n];
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> decrypt(vector<int>& code, int k) {
+        int n = code.size();
+        vector<int> ans(n);
+        if (k == 0) {
+            return ans;
+        }
+        for (int i = 0; i < n; ++i) {
+            if (k > 0) {
+                for (int j = i + 1; j < i + k + 1; ++j) {
+                    ans[i] += code[j % n];
+                }
+            } else {
+                for (int j = i + k; j < i; ++j) {
+                    ans[i] += code[(j + n) % n];
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> decrypt(vector<int>& code, int k) {
+        int n = code.size();
+        vector<int> ans(n);
+        if (k == 0) {
+            return ans;
+        }
+        vector<int> s(n << 1 | 1);
+        for (int i = 0; i < n << 1; ++i) {
+            s[i + 1] = s[i] + code[i % n];
+        }
+        for (int i = 0; i < n; ++i) {
+            if (k > 0) {
+                ans[i] = s[i + k + 1] - s[i + 1];
+            } else {
+                ans[i] = s[i + n] - s[i + k + n];
+            }
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func decrypt(code []int, k int) []int {
+	n := len(code)
+	ans := make([]int, n)
+	if k == 0 {
+		return ans
+	}
+	for i := 0; i < n; i++ {
+		if k > 0 {
+			for j := i + 1; j < i+k+1; j++ {
+				ans[i] += code[j%n]
+			}
+		} else {
+			for j := i + k; j < i; j++ {
+				ans[i] += code[(j+n)%n]
+			}
+		}
+	}
+	return ans
+}
+```
+
+```go
+func decrypt(code []int, k int) []int {
+	n := len(code)
+	ans := make([]int, n)
+	if k == 0 {
+		return ans
+	}
+	s := make([]int, n<<1|1)
+	for i := 0; i < n<<1; i++ {
+		s[i+1] = s[i] + code[i%n]
+	}
+	for i := range code {
+		if k > 0 {
+			ans[i] = s[i+k+1] - s[i+1]
+		} else {
+			ans[i] = s[i+n] - s[i+k+n]
+		}
+	}
+	return ans
+}
+```
+
 ### **...**
 
 ```