feat: add solutions to lc problem: No.3299 (doocs#3564)

No.3299.Sum of Consecutive Subsequences

Author: yanglbme

solution/3200-3299/3299.Sum of Consecutive Subsequences/README.md

@@ -70,32 +70,172 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3299.Su
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：枚举贡献
+
+我们不妨统计每个元素 $\textit{nums}[i]$ 在多少个长度大于 $1$ 的连续子序列中出现，那么其个数乘以 $\textit{nums}[i]$ 就是 $\textit{nums}[i]$ 在所有长度大于 $1$ 的连续子序列中的贡献。我们将其累加，再加上所有元素的和，即为答案。
+
+我们可以先统计连续递增子序列对答案的贡献，再统计连续递减子序列对答案的贡献，最后再加上所有元素的和即可。
+
+在实现上，我们定义一个函数 $\textit{calc}(\textit{nums})$，其中 $\textit{nums}$ 是一个数组，返回 $\textit{nums}$ 所有长度大于 $1$ 的连续子序列的和。
+
+在函数中，我们可以使用两个数组 $\textit{left}$ 和 $\textit{right}$ 分别记录每个元素 $\textit{nums}[i]$ 的左侧以 $\textit{nums}[i] - 1$ 结尾的连续递增子序列的个数，以及右侧以 $\textit{nums}[i] + 1$ 开头的连续递增子序列的个数。这样，我们就可以在 $O(n)$ 的时间复杂度内计算出 $\textit{nums}$ 在所有长度大于 $1$ 的连续子序列中的贡献。
+
+在主函数中，我们首先调用 $\textit{calc}(\textit{nums})$ 计算出连续递增子序列对答案的贡献，然后将 $\textit{nums}$ 反转后再次调用 $\textit{calc}(\textit{nums})$ 计算出连续递减子序列对答案的贡献，最后再加上所有元素的和即为答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $\textit{nums}$ 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def getSum(self, nums: List[int]) -> int:
+        def calc(nums: List[int]) -> int:
+            n = len(nums)
+            left = [0] * n
+            right = [0] * n
+            cnt = Counter()
+            for i in range(1, n):
+                cnt[nums[i - 1]] += 1 + cnt[nums[i - 1] - 1]
+                left[i] = cnt[nums[i] - 1]
+            cnt = Counter()
+            for i in range(n - 2, -1, -1):
+                cnt[nums[i + 1]] += 1 + cnt[nums[i + 1] + 1]
+                right[i] = cnt[nums[i] + 1]
+            return sum((l + r + l * r) * x for l, r, x in zip(left, right, nums)) % mod
+
+        mod = 10**9 + 7
+        x = calc(nums)
+        nums.reverse()
+        y = calc(nums)
+        return (x + y + sum(nums)) % mod
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private final int mod = (int) 1e9 + 7;
+
+    public int getSum(int[] nums) {
+        long x = calc(nums);
+        for (int i = 0, j = nums.length - 1; i < j; ++i, --j) {
+            int t = nums[i];
+            nums[i] = nums[j];
+            nums[j] = t;
+        }
+        long y = calc(nums);
+        long s = Arrays.stream(nums).asLongStream().sum();
+        return (int) ((x + y + s) % mod);
+    }
+
+    private long calc(int[] nums) {
+        int n = nums.length;
+        long[] left = new long[n];
+        long[] right = new long[n];
+        Map<Integer, Long> cnt = new HashMap<>();
+        for (int i = 1; i < n; ++i) {
+            cnt.merge(nums[i - 1], 1 + cnt.getOrDefault(nums[i - 1] - 1, 0L), Long::sum);
+            left[i] = cnt.getOrDefault(nums[i] - 1, 0L);
+        }
+        cnt.clear();
+        for (int i = n - 2; i >= 0; --i) {
+            cnt.merge(nums[i + 1], 1 + cnt.getOrDefault(nums[i + 1] + 1, 0L), Long::sum);
+            right[i] = cnt.getOrDefault(nums[i] + 1, 0L);
+        }
+        long ans = 0;
+        for (int i = 0; i < n; ++i) {
+            ans = (ans + (left[i] + right[i] + left[i] * right[i] % mod) * nums[i] % mod) % mod;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int getSum(vector<int>& nums) {
+        using ll = long long;
+        const int mod = 1e9 + 7;
+        auto calc = [&](const vector<int>& nums) -> ll {
+            int n = nums.size();
+            vector<ll> left(n), right(n);
+            unordered_map<int, ll> cnt;
+
+            for (int i = 1; i < n; ++i) {
+                cnt[nums[i - 1]] += 1 + cnt[nums[i - 1] - 1];
+                left[i] = cnt[nums[i] - 1];
+            }
+
+            cnt.clear();
+
+            for (int i = n - 2; i >= 0; --i) {
+                cnt[nums[i + 1]] += 1 + cnt[nums[i + 1] + 1];
+                right[i] = cnt[nums[i] + 1];
+            }
+
+            ll ans = 0;
+            for (int i = 0; i < n; ++i) {
+                ans = (ans + (left[i] + right[i] + left[i] * right[i] % mod) * nums[i] % mod) % mod;
+            }
+            return ans;
+        };
+
+        ll x = calc(nums);
+        reverse(nums.begin(), nums.end());
+        ll y = calc(nums);
+        ll s = accumulate(nums.begin(), nums.end(), 0LL);
+        return static_cast<int>((x + y + s) % mod);
+    }
+};
 ```
 
 #### Go
 
 ```go
-
+func getSum(nums []int) int {
+	const mod = 1e9 + 7
+
+	calc := func(nums []int) int64 {
+		n := len(nums)
+		left := make([]int64, n)
+		right := make([]int64, n)
+		cnt := make(map[int]int64)
+
+		for i := 1; i < n; i++ {
+			cnt[nums[i-1]] += 1 + cnt[nums[i-1]-1]
+			left[i] = cnt[nums[i]-1]
+		}
+
+		cnt = make(map[int]int64)
+
+		for i := n - 2; i >= 0; i-- {
+			cnt[nums[i+1]] += 1 + cnt[nums[i+1]+1]
+			right[i] = cnt[nums[i]+1]
+		}
+
+		var ans int64
+		for i, x := range nums {
+			ans = (ans + (left[i]+right[i]+(left[i]*right[i]%mod))*int64(x)%mod) % mod
+		}
+		return ans
+	}
+
+	x := calc(nums)
+	for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
+		nums[i], nums[j] = nums[j], nums[i]
+	}
+	y := calc(nums)
+	s := int64(0)
+	for _, num := range nums {
+		s += int64(num)
+	}
+	return int((x + y + s) % mod)
+}
 ```
 
 <!-- tabs:end -->

solution/3200-3299/3299.Sum of Consecutive Subsequences/README_EN.md

@@ -70,32 +70,172 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3299.Su
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Enumeration of Contributions
+
+Let us count how many times each element $\textit{nums}[i]$ appears in a continuous subsequence of length greater than 1. Then, multiplying this count by $\textit{nums}[i]$ gives the contribution of $\textit{nums}[i]$ in all continuous subsequences of length greater than 1. We sum these contributions, and adding the sum of all elements, we get the answer.
+
+We can first compute the contribution of strictly increasing subsequences, then the contribution of strictly decreasing subsequences, and finally add the sum of all elements.
+
+To implement this, we define a function $\textit{calc}(\textit{nums})$, where $\textit{nums}$ is an array. This function returns the sum of all continuous subsequences of length greater than 1 in $\textit{nums}$.
+
+In the function, we can use two arrays, $\textit{left}$ and $\textit{right}$, to record the number of strictly increasing subsequences ending with $\textit{nums}[i] - 1$ on the left of each element $\textit{nums}[i]$, and the number of strictly increasing subsequences starting with $\textit{nums}[i] + 1$ on the right of each element $\textit{nums}[i]$. In this way, we can calculate the contribution of $\textit{nums}$ in all continuous subsequences of length greater than 1 in $O(n)$ time complexity.
+
+In the main function, we first call $\textit{calc}(\textit{nums})$ to compute the contribution of strictly increasing subsequences, then reverse $\textit{nums}$ and call $\textit{calc}(\textit{nums})$ again to compute the contribution of strictly decreasing subsequences. Finally, adding the sum of all elements gives the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def getSum(self, nums: List[int]) -> int:
+        def calc(nums: List[int]) -> int:
+            n = len(nums)
+            left = [0] * n
+            right = [0] * n
+            cnt = Counter()
+            for i in range(1, n):
+                cnt[nums[i - 1]] += 1 + cnt[nums[i - 1] - 1]
+                left[i] = cnt[nums[i] - 1]
+            cnt = Counter()
+            for i in range(n - 2, -1, -1):
+                cnt[nums[i + 1]] += 1 + cnt[nums[i + 1] + 1]
+                right[i] = cnt[nums[i] + 1]
+            return sum((l + r + l * r) * x for l, r, x in zip(left, right, nums)) % mod
+
+        mod = 10**9 + 7
+        x = calc(nums)
+        nums.reverse()
+        y = calc(nums)
+        return (x + y + sum(nums)) % mod
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private final int mod = (int) 1e9 + 7;
+
+    public int getSum(int[] nums) {
+        long x = calc(nums);
+        for (int i = 0, j = nums.length - 1; i < j; ++i, --j) {
+            int t = nums[i];
+            nums[i] = nums[j];
+            nums[j] = t;
+        }
+        long y = calc(nums);
+        long s = Arrays.stream(nums).asLongStream().sum();
+        return (int) ((x + y + s) % mod);
+    }
+
+    private long calc(int[] nums) {
+        int n = nums.length;
+        long[] left = new long[n];
+        long[] right = new long[n];
+        Map<Integer, Long> cnt = new HashMap<>();
+        for (int i = 1; i < n; ++i) {
+            cnt.merge(nums[i - 1], 1 + cnt.getOrDefault(nums[i - 1] - 1, 0L), Long::sum);
+            left[i] = cnt.getOrDefault(nums[i] - 1, 0L);
+        }
+        cnt.clear();
+        for (int i = n - 2; i >= 0; --i) {
+            cnt.merge(nums[i + 1], 1 + cnt.getOrDefault(nums[i + 1] + 1, 0L), Long::sum);
+            right[i] = cnt.getOrDefault(nums[i] + 1, 0L);
+        }
+        long ans = 0;
+        for (int i = 0; i < n; ++i) {
+            ans = (ans + (left[i] + right[i] + left[i] * right[i] % mod) * nums[i] % mod) % mod;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int getSum(vector<int>& nums) {
+        using ll = long long;
+        const int mod = 1e9 + 7;
+        auto calc = [&](const vector<int>& nums) -> ll {
+            int n = nums.size();
+            vector<ll> left(n), right(n);
+            unordered_map<int, ll> cnt;
+
+            for (int i = 1; i < n; ++i) {
+                cnt[nums[i - 1]] += 1 + cnt[nums[i - 1] - 1];
+                left[i] = cnt[nums[i] - 1];
+            }
+
+            cnt.clear();
+
+            for (int i = n - 2; i >= 0; --i) {
+                cnt[nums[i + 1]] += 1 + cnt[nums[i + 1] + 1];
+                right[i] = cnt[nums[i] + 1];
+            }
+
+            ll ans = 0;
+            for (int i = 0; i < n; ++i) {
+                ans = (ans + (left[i] + right[i] + left[i] * right[i] % mod) * nums[i] % mod) % mod;
+            }
+            return ans;
+        };
+
+        ll x = calc(nums);
+        reverse(nums.begin(), nums.end());
+        ll y = calc(nums);
+        ll s = accumulate(nums.begin(), nums.end(), 0LL);
+        return static_cast<int>((x + y + s) % mod);
+    }
+};
 ```
 
 #### Go
 
 ```go
-
+func getSum(nums []int) int {
+	const mod = 1e9 + 7
+
+	calc := func(nums []int) int64 {
+		n := len(nums)
+		left := make([]int64, n)
+		right := make([]int64, n)
+		cnt := make(map[int]int64)
+
+		for i := 1; i < n; i++ {
+			cnt[nums[i-1]] += 1 + cnt[nums[i-1]-1]
+			left[i] = cnt[nums[i]-1]
+		}
+
+		cnt = make(map[int]int64)
+
+		for i := n - 2; i >= 0; i-- {
+			cnt[nums[i+1]] += 1 + cnt[nums[i+1]+1]
+			right[i] = cnt[nums[i]+1]
+		}
+
+		var ans int64
+		for i, x := range nums {
+			ans = (ans + (left[i]+right[i]+(left[i]*right[i]%mod))*int64(x)%mod) % mod
+		}
+		return ans
+	}
+
+	x := calc(nums)
+	for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
+		nums[i], nums[j] = nums[j], nums[i]
+	}
+	y := calc(nums)
+	s := int64(0)
+	for _, num := range nums {
+		s += int64(num)
+	}
+	return int((x + y + s) % mod)
+}
 ```
 
 <!-- tabs:end -->

solution/3200-3299/3299.Sum of Consecutive Subsequences/Solution.cpp

@@ -0,0 +1,36 @@
+class Solution {
+public:
+    int getSum(vector<int>& nums) {
+        using ll = long long;
+        const int mod = 1e9 + 7;
+        auto calc = [&](const vector<int>& nums) -> ll {
+            int n = nums.size();
+            vector<ll> left(n), right(n);
+            unordered_map<int, ll> cnt;
+
+            for (int i = 1; i < n; ++i) {
+                cnt[nums[i - 1]] += 1 + cnt[nums[i - 1] - 1];
+                left[i] = cnt[nums[i] - 1];
+            }
+
+            cnt.clear();
+
+            for (int i = n - 2; i >= 0; --i) {
+                cnt[nums[i + 1]] += 1 + cnt[nums[i + 1] + 1];
+                right[i] = cnt[nums[i] + 1];
+            }
+
+            ll ans = 0;
+            for (int i = 0; i < n; ++i) {
+                ans = (ans + (left[i] + right[i] + left[i] * right[i] % mod) * nums[i] % mod) % mod;
+            }
+            return ans;
+        };
+
+        ll x = calc(nums);
+        reverse(nums.begin(), nums.end());
+        ll y = calc(nums);
+        ll s = accumulate(nums.begin(), nums.end(), 0LL);
+        return static_cast<int>((x + y + s) % mod);
+    }
+};