Remove unused C++ file Luogu_P_1075.cpp, which contained basic input structure without implemented logic.

Author: tkzzzzzz6

Luogu_P_1075.cpp

@@ -0,0 +1,21 @@
+class Solution {
+    public:
+        int subtractProductAndSum(int n) {
+            long long digit_sum = 0;
+            long long digit_multiply = 1;
+            int flag = 0;
+            while(n > 0){
+                int digit = n % 10;
+                if(digit == 0){
+                    flag = 1;
+                }
+                digit_sum += digit;
+                digit_multiply *= digit;
+                n /= 10;
+            }
+            if(flag == 1){
+                return -digit_sum;
+            }
+            return digit_multiply - digit_sum;
+        }
+    };

leetcode/Study Plan/1281. 整数的各位积和之差/1.cpp

@@ -0,0 +1,10 @@
+class Solution:
+    def subtractProductAndSum(self, n: int) -> int:
+        prod, s = 1,0
+        while n > 0:
+            prod *= n % 10
+            s += n % 10
+
+            n //= 10
+
+        return prod - s

leetcode/Study Plan/1281. 整数的各位积和之差/1.py

@@ -0,0 +1,7 @@
+class Solution {
+    public:
+        int countPartitions(vector<int>& nums) {
+            int sum = reduce(nums.begin(),nums.end());
+            return sum % 2 ? 0 : nums.size() - 1;
+        }
+    };

leetcode/Study Plan/3432. 统计元素和差值为偶数的分区方案/1.cpp

@@ -0,0 +1,7 @@
+class Solution {
+    public:
+        int countPartitions(vector<int>& nums) {
+			int sum = accumulate(nums.begin(),nums.end(),0);
+			return sum % 2 ? 0 : nums.size() - 1;
+        }
+    };

leetcode/Study Plan/3432. 统计元素和差值为偶数的分区方案/1.go

@@ -0,0 +1,6 @@
+class Solution {
+    public int countPartitions(int[] nums) {
+        int sum = Arrays.stream(nums).sum();
+        return sum % 2 != 0 ? 0 : nums.length - 1;       
+    }
+}

leetcode/Study Plan/3432. 统计元素和差值为偶数的分区方案/1.java

@@ -0,0 +1,3 @@
+class Solution:
+    def countPartitions(self, nums: List[int]) -> int:
+        return 0 if sum(nums) % 2 else len(nums) - 1

leetcode/Study Plan/3432. 统计元素和差值为偶数的分区方案/1.py

@@ -0,0 +1,279 @@
+# 3432. 统计元素和差值为偶数的分区方案 - 代码解释
+
+## 整体代码逻辑
+
+```cpp
+class Solution {
+    public:
+        int countPartitions(vector<int>& nums) {
+            int sum = accumulate(nums.begin(),nums.end(),0);
+            return sum % 2 ? 0 : nums.size() - 1;
+        }
+    };
+```
+
+### 代码功能
+这段代码用于统计将数组分成两部分，使得两部分元素和的差值为偶数的分区方案数。
+
+### 执行流程
+1. **第4行**：计算数组所有元素的和
+2. **第5行**：根据总和的奇偶性返回结果
+   - 如果总和是奇数 → 返回 0（无法找到差值为偶数的分区）
+   - 如果总和是偶数 → 返回 `nums.size() - 1`（有 n-1 个分割位置）
+
+---
+
+## `accumulate` 函数详解
+
+### 基本概念
+
+`accumulate` 是 C++ `<numeric>` 头文件中的函数，用于**累加计算**。它可以将一个范围内的所有元素按照指定操作进行累积。
+
+### 函数原型
+
+```cpp
+template<class InputIt, class T>
+T accumulate(InputIt first, InputIt last, T init);
+```
+
+### 参数说明
+
+1. **`first`**：起始迭代器，指向要累加的第一个元素
+2. **`last`**：结束迭代器，指向要累加的最后一个元素的下一个位置（不包含）
+3. **`init`**：初始值，累加的起始值
+
+### 工作原理
+
+`accumulate` 函数会：
+1. 从 `init` 开始
+2. 依次遍历 `[first, last)` 范围内的每个元素
+3. 将每个元素加到累加结果上
+4. 返回最终的累加结果
+
+**等价于**：
+```cpp
+T result = init;
+for (auto it = first; it != last; ++it) {
+    result = result + *it;  // 或者 result += *it;
+}
+return result;
+```
+
+---
+
+## 使用示例
+
+### 示例1：基本用法 - 计算数组和
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <numeric>  // 需要包含这个头文件
+
+int main() {
+    vector<int> nums = {1, 2, 3, 4, 5};
+    
+    // 计算数组所有元素的和
+    int sum = accumulate(nums.begin(), nums.end(), 0);
+    // 等价于：0 + 1 + 2 + 3 + 4 + 5 = 15
+    
+    cout << "数组和: " << sum << endl;  // 输出: 15
+    
+    return 0;
+}
+```
+
+**执行过程**：
+```
+初始值: 0
+0 + 1 = 1
+1 + 2 = 3
+3 + 3 = 6
+6 + 4 = 10
+10 + 5 = 15
+结果: 15
+```
+
+### 示例2：从非零初始值开始
+
+```cpp
+vector<int> nums = {10, 20, 30};
+
+// 从100开始累加
+int result = accumulate(nums.begin(), nums.end(), 100);
+// 等价于：100 + 10 + 20 + 30 = 160
+
+cout << result << endl;  // 输出: 160
+```
+
+### 示例3：计算乘积
+
+```cpp
+vector<int> nums = {2, 3, 4};
+
+// 计算乘积，初始值为1
+int product = accumulate(nums.begin(), nums.end(), 1, 
+                        [](int a, int b) { return a * b; });
+// 等价于：1 * 2 * 3 * 4 = 24
+
+cout << product << endl;  // 输出: 24
+```
+
+### 示例4：计算字符串连接
+
+```cpp
+vector<string> words = {"Hello", " ", "World"};
+
+string result = accumulate(words.begin(), words.end(), string(""));
+// 等价于："" + "Hello" + " " + "World" = "Hello World"
+
+cout << result << endl;  // 输出: Hello World
+```
+
+### 示例5：计算浮点数数组和
+
+```cpp
+vector<double> nums = {1.5, 2.5, 3.5};
+
+double sum = accumulate(nums.begin(), nums.end(), 0.0);
+// 注意：初始值要用 0.0 而不是 0，否则会丢失小数部分
+
+cout << sum << endl;  // 输出: 7.5
+```
+
+---
+
+## 代码中的使用
+
+### 原代码分析
+
+```cpp
+int sum = accumulate(nums.begin(), nums.end(), 0);
+```
+
+**含义**：
+- `nums.begin()`：指向数组第一个元素
+- `nums.end()`：指向数组最后一个元素的下一个位置
+- `0`：累加的初始值
+
+**等价的手动实现**：
+```cpp
+int sum = 0;
+for (int i = 0; i < nums.size(); i++) {
+    sum += nums[i];
+}
+```
+
+或者：
+```cpp
+int sum = 0;
+for (auto num : nums) {
+    sum += num;
+}
+```
+
+---
+
+## 完整示例：理解整个代码
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <numeric>
+using namespace std;
+
+class Solution {
+public:
+    int countPartitions(vector<int>& nums) {
+        // 计算数组所有元素的和
+        int sum = accumulate(nums.begin(), nums.end(), 0);
+        
+        // 如果总和是奇数，返回0；否则返回 n-1
+        return sum % 2 ? 0 : nums.size() - 1;
+    }
+};
+
+int main() {
+    Solution sol;
+    
+    // 示例1：总和为偶数
+    vector<int> nums1 = {1, 2, 3, 4};  // 总和 = 10（偶数）
+    cout << "数组: [1,2,3,4]" << endl;
+    cout << "总和: " << accumulate(nums1.begin(), nums1.end(), 0) << endl;
+    cout << "分区方案数: " << sol.countPartitions(nums1) << endl;
+    // 输出: 3（有3个分割位置：1|2,3,4 或 1,2|3,4 或 1,2,3|4）
+    
+    cout << endl;
+    
+    // 示例2：总和为奇数
+    vector<int> nums2 = {1, 2, 3};  // 总和 = 6（偶数）
+    cout << "数组: [1,2,3]" << endl;
+    cout << "总和: " << accumulate(nums2.begin(), nums2.end(), 0) << endl;
+    cout << "分区方案数: " << sol.countPartitions(nums2) << endl;
+    // 输出: 2（有2个分割位置）
+    
+    cout << endl;
+    
+    // 示例3：总和为奇数
+    vector<int> nums3 = {1, 2, 4};  // 总和 = 7（奇数）
+    cout << "数组: [1,2,4]" << endl;
+    cout << "总和: " << accumulate(nums3.begin(), nums3.end(), 0) << endl;
+    cout << "分区方案数: " << sol.countPartitions(nums3) << endl;
+    // 输出: 0（无法找到差值为偶数的分区）
+    
+    return 0;
+}
+```
+
+**运行结果**：
+```
+数组: [1,2,3,4]
+总和: 10
+分区方案数: 3
+
+数组: [1,2,3]
+总和: 6
+分区方案数: 2
+
+数组: [1,2,4]
+总和: 7
+分区方案数: 0
+```
+
+---
+
+## 注意事项
+
+### 1. 需要包含头文件
+```cpp
+#include <numeric>  // accumulate 函数需要这个头文件
+```
+
+### 2. 初始值类型很重要
+```cpp
+// 对于整数数组，用 0
+int sum = accumulate(nums.begin(), nums.end(), 0);
+
+// 对于浮点数数组，用 0.0
+double sum = accumulate(nums.begin(), nums.end(), 0.0);
+```
+
+### 3. 迭代器范围
+- `[begin, end)` 是**左闭右开**区间
+- `begin` 指向第一个元素
+- `end` 指向最后一个元素的下一个位置（不包含）
+
+### 4. 性能
+- `accumulate` 的时间复杂度是 O(n)，n 是元素个数
+- 比手动循环更简洁，但性能基本相同
+
+---
+
+## 总结
+
+1. **`accumulate` 函数**：用于累加计算，可以计算数组和、乘积等
+2. **基本用法**：`accumulate(开始位置, 结束位置, 初始值)`
+3. **代码中的使用**：计算数组所有元素的和
+4. **优势**：代码简洁，可读性好，避免手动循环
+
+

leetcode/Study Plan/3432. 统计元素和差值为偶数的分区方案/2.cpp

@@ -0,0 +1,33 @@
+class Solution:
+    def countPartitions(self, nums: List[int], k: int) -> int:
+        MOD = 1_000_000_007
+        n = len(nums)
+        min_q = deque()
+        max_q = deque()
+        f = [0]*(n+1)
+        f[0] = 1
+        sum_f = 0
+        left = 0
+
+        for i,x in enumerate(nums):
+            sum_f += f[i]
+
+            while min_q and nums[min_q[-1]] >= x:
+                min_q.pop()
+            min_q.append(i)
+
+            while max_q and nums[max_q[-1]] <= x:
+                max_q.pop()
+            max_q.append(i)
+
+            while nums[max_q[0]] - nums[min_q[0]] > k:
+                sum_f -= f[left]
+                left += 1
+                if min_q[0] < left:
+                    min_q.popleft()
+                if max_q[0] < left:
+                    max_q.popleft()
+
+            f[i+1] = sum_f % MOD
+
+        return f[n]