diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README.md b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README.md
index 04f0b028b3b80..906040595261d 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README.md	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README.md	
@@ -70,11 +70,10 @@ class Solution:
         ans = s if len(cnt) == k else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
-            s += nums[i]
             cnt[nums[i - k]] -= 1
-            s -= nums[i - k]
             if cnt[nums[i - k]] == 0:
-                del cnt[nums[i - k]]
+                cnt.pop(nums[i - k])
+            s += nums[i] - nums[i - k]
             if len(cnt) == k:
                 ans = max(ans, s)
         return ans
@@ -93,11 +92,10 @@ class Solution {
         long ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums[i], 1, Integer::sum);
-            s += nums[i];
             if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
                 cnt.remove(nums[i - k]);
             }
-            s -= nums[i - k];
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = Math.max(ans, s);
             }
@@ -116,18 +114,16 @@ public:
         unordered_map<int, ll> cnt;
         ll s = 0;
         for (int i = 0; i < k; ++i) {
-            cnt[nums[i]]++;
+            ++cnt[nums[i]];
             s += nums[i];
         }
         ll ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
-            cnt[nums[i]]++;
-            s += nums[i];
-            cnt[nums[i - k]]--;
-            s -= nums[i - k];
-            if (cnt[nums[i - k]] == 0) {
+            ++cnt[nums[i]];
+            if (--cnt[nums[i - k]] == 0) {
                 cnt.erase(nums[i - k]);
             }
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = max(ans, s);
             }
@@ -151,12 +147,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
 	}
 	for i := k; i < n; i++ {
 		cnt[nums[i]]++
-		s += int64(nums[i])
 		cnt[nums[i-k]]--
-		s -= int64(nums[i-k])
 		if cnt[nums[i-k]] == 0 {
 			delete(cnt, nums[i-k])
 		}
+		s += int64(nums[i] - nums[i-k])
 		if len(cnt) == k && ans < s {
 			ans = s
 		}
@@ -177,12 +172,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
     let ans = cnt.size === k ? s : 0;
     for (let i = k; i < n; ++i) {
         cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
-        s += nums[i];
         cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
-        s -= nums[i - k];
         if (cnt.get(nums[i - k]) === 0) {
             cnt.delete(nums[i - k]);
         }
+        s += nums[i] - nums[i - k];
         if (cnt.size === k) {
             ans = Math.max(ans, s);
         }
@@ -191,6 +185,48 @@ function maximumSubarraySum(nums: number[], k: number): number {
 }
 ```
 
+```cs
+public class Solution {
+    public long MaximumSubarraySum(int[] nums, int k) {
+        int n = nums.Length;
+        Dictionary<int, int> cnt = new Dictionary<int, int>(k);
+        long s = 0;
+
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+
+        long ans = cnt.Count == k ? s : 0;
+
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (--cnt[nums[i - k]] == 0) {
+                cnt.Remove(nums[i - k]);
+            }
+
+            s += nums[i] - nums[i - k];
+
+            if (cnt.Count == k) {
+                ans = Math.Max(ans, s);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README_EN.md b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README_EN.md
index 68755aee68a01..f233b6a16b0bf 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README_EN.md	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/README_EN.md	
@@ -68,11 +68,10 @@ class Solution:
         ans = s if len(cnt) == k else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
-            s += nums[i]
             cnt[nums[i - k]] -= 1
-            s -= nums[i - k]
             if cnt[nums[i - k]] == 0:
-                del cnt[nums[i - k]]
+                cnt.pop(nums[i - k])
+            s += nums[i] - nums[i - k]
             if len(cnt) == k:
                 ans = max(ans, s)
         return ans
@@ -91,11 +90,10 @@ class Solution {
         long ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums[i], 1, Integer::sum);
-            s += nums[i];
             if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
                 cnt.remove(nums[i - k]);
             }
-            s -= nums[i - k];
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = Math.max(ans, s);
             }
@@ -114,18 +112,16 @@ public:
         unordered_map<int, ll> cnt;
         ll s = 0;
         for (int i = 0; i < k; ++i) {
-            cnt[nums[i]]++;
+            ++cnt[nums[i]];
             s += nums[i];
         }
         ll ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
-            cnt[nums[i]]++;
-            s += nums[i];
-            cnt[nums[i - k]]--;
-            s -= nums[i - k];
-            if (cnt[nums[i - k]] == 0) {
+            ++cnt[nums[i]];
+            if (--cnt[nums[i - k]] == 0) {
                 cnt.erase(nums[i - k]);
             }
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = max(ans, s);
             }
@@ -149,12 +145,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
 	}
 	for i := k; i < n; i++ {
 		cnt[nums[i]]++
-		s += int64(nums[i])
 		cnt[nums[i-k]]--
-		s -= int64(nums[i-k])
 		if cnt[nums[i-k]] == 0 {
 			delete(cnt, nums[i-k])
 		}
+		s += int64(nums[i] - nums[i-k])
 		if len(cnt) == k && ans < s {
 			ans = s
 		}
@@ -175,12 +170,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
     let ans = cnt.size === k ? s : 0;
     for (let i = k; i < n; ++i) {
         cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
-        s += nums[i];
         cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
-        s -= nums[i - k];
         if (cnt.get(nums[i - k]) === 0) {
             cnt.delete(nums[i - k]);
         }
+        s += nums[i] - nums[i - k];
         if (cnt.size === k) {
             ans = Math.max(ans, s);
         }
@@ -189,6 +183,48 @@ function maximumSubarraySum(nums: number[], k: number): number {
 }
 ```
 
+```cs
+public class Solution {
+    public long MaximumSubarraySum(int[] nums, int k) {
+        int n = nums.Length;
+        Dictionary<int, int> cnt = new Dictionary<int, int>(k);
+        long s = 0;
+
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+
+        long ans = cnt.Count == k ? s : 0;
+
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (--cnt[nums[i - k]] == 0) {
+                cnt.Remove(nums[i - k]);
+            }
+
+            s += nums[i] - nums[i - k];
+
+            if (cnt.Count == k) {
+                ans = Math.Max(ans, s);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cpp b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cpp
index 5103bc82a519b..77b4b51665ccd 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cpp	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cpp	
@@ -6,18 +6,16 @@ class Solution {
         unordered_map<int, ll> cnt;
         ll s = 0;
         for (int i = 0; i < k; ++i) {
-            cnt[nums[i]]++;
+            ++cnt[nums[i]];
             s += nums[i];
         }
         ll ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
-            cnt[nums[i]]++;
-            s += nums[i];
-            cnt[nums[i - k]]--;
-            s -= nums[i - k];
-            if (cnt[nums[i - k]] == 0) {
+            ++cnt[nums[i]];
+            if (--cnt[nums[i - k]] == 0) {
                 cnt.erase(nums[i - k]);
             }
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = max(ans, s);
             }
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cs b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cs
new file mode 100644
index 0000000000000..dc1e7539f53ca
--- /dev/null
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.cs	
@@ -0,0 +1,39 @@
+public class Solution {
+    public long MaximumSubarraySum(int[] nums, int k) {
+        int n = nums.Length;
+        Dictionary<int, int> cnt = new Dictionary<int, int>(k);
+        long s = 0;
+        
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+        
+        long ans = cnt.Count == k ? s : 0;
+        
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (--cnt[nums[i - k]] == 0) {
+                cnt.Remove(nums[i - k]);
+            }
+            
+            s += nums[i] - nums[i - k];
+            
+            if (cnt.Count == k) {
+                ans = Math.Max(ans, s);
+            }
+        }
+        
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.go b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.go
index 41ec230004187..e34c9de933904 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.go	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.go	
@@ -11,12 +11,11 @@ func maximumSubarraySum(nums []int, k int) (ans int64) {
 	}
 	for i := k; i < n; i++ {
 		cnt[nums[i]]++
-		s += int64(nums[i])
 		cnt[nums[i-k]]--
-		s -= int64(nums[i-k])
 		if cnt[nums[i-k]] == 0 {
 			delete(cnt, nums[i-k])
 		}
+		s += int64(nums[i] - nums[i-k])
 		if len(cnt) == k && ans < s {
 			ans = s
 		}
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.java b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.java
index 16583a400cc06..329f289ee7246 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.java	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.java	
@@ -10,11 +10,10 @@ public long maximumSubarraySum(int[] nums, int k) {
         long ans = cnt.size() == k ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums[i], 1, Integer::sum);
-            s += nums[i];
             if (cnt.merge(nums[i - k], -1, Integer::sum) == 0) {
                 cnt.remove(nums[i - k]);
             }
-            s -= nums[i - k];
+            s += nums[i] - nums[i - k];
             if (cnt.size() == k) {
                 ans = Math.max(ans, s);
             }
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.py b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.py
index d7ff1461926f6..a840885368599 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.py	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.py	
@@ -5,11 +5,10 @@ def maximumSubarraySum(self, nums: List[int], k: int) -> int:
         ans = s if len(cnt) == k else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
-            s += nums[i]
             cnt[nums[i - k]] -= 1
-            s -= nums[i - k]
             if cnt[nums[i - k]] == 0:
-                del cnt[nums[i - k]]
+                cnt.pop(nums[i - k])
+            s += nums[i] - nums[i - k]
             if len(cnt) == k:
                 ans = max(ans, s)
         return ans
diff --git a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.ts b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.ts
index 0b2a4ca8f3c72..790dbbbd961e3 100644
--- a/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.ts	
+++ b/solution/2400-2499/2461.Maximum Sum of Distinct Subarrays With Length K/Solution.ts	
@@ -9,12 +9,11 @@ function maximumSubarraySum(nums: number[], k: number): number {
     let ans = cnt.size === k ? s : 0;
     for (let i = k; i < n; ++i) {
         cnt.set(nums[i], (cnt.get(nums[i]) ?? 0) + 1);
-        s += nums[i];
         cnt.set(nums[i - k], cnt.get(nums[i - k])! - 1);
-        s -= nums[i - k];
         if (cnt.get(nums[i - k]) === 0) {
             cnt.delete(nums[i - k]);
         }
+        s += nums[i] - nums[i - k];
         if (cnt.size === k) {
             ans = Math.max(ans, s);
         }
diff --git a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README.md b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README.md
index e4bdbdbbf4d33..622203696ac45 100644
--- a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README.md	
+++ b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README.md	
@@ -69,9 +69,7 @@ class Solution:
     def maxSum(self, nums: List[int], m: int, k: int) -> int:
         cnt = Counter(nums[:k])
         s = sum(nums[:k])
-        ans = 0
-        if len(cnt) >= m:
-            ans = s
+        ans = s if len(cnt) >= m else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
             cnt[nums[i - k]] -= 1
@@ -93,10 +91,7 @@ class Solution {
             cnt.merge(nums.get(i), 1, Integer::sum);
             s += nums.get(i);
         }
-        long ans = 0;
-        if (cnt.size() >= m) {
-            ans = s;
-        }
+        long ans = cnt.size() >= m ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums.get(i), 1, Integer::sum);
             if (cnt.merge(nums.get(i - k), -1, Integer::sum) == 0) {
@@ -191,6 +186,51 @@ function maxSum(nums: number[], m: number, k: number): number {
 }
 ```
 
+```cs
+public class Solution {
+    public long MaxSum(IList<int> nums, int m, int k) {
+        Dictionary<int, int> cnt = new Dictionary<int, int>();
+        int n = nums.Count;
+        long s = 0;
+
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+
+        long ans = cnt.Count >= m ? s : 0;
+
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (cnt.ContainsKey(nums[i - k])) {
+                cnt[nums[i - k]]--;
+                if (cnt[nums[i - k]] == 0) {
+                    cnt.Remove(nums[i - k]);
+                }
+            }
+
+            s += nums[i] - nums[i - k];
+
+            if (cnt.Count >= m) {
+                ans = Math.Max(ans, s);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->
diff --git a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README_EN.md b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README_EN.md
index 1b3cd7de8f1c7..3c01f8393ad8f 100644
--- a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README_EN.md	
+++ b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/README_EN.md	
@@ -65,9 +65,7 @@ class Solution:
     def maxSum(self, nums: List[int], m: int, k: int) -> int:
         cnt = Counter(nums[:k])
         s = sum(nums[:k])
-        ans = 0
-        if len(cnt) >= m:
-            ans = s
+        ans = s if len(cnt) >= m else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
             cnt[nums[i - k]] -= 1
@@ -89,10 +87,7 @@ class Solution {
             cnt.merge(nums.get(i), 1, Integer::sum);
             s += nums.get(i);
         }
-        long ans = 0;
-        if (cnt.size() >= m) {
-            ans = s;
-        }
+        long ans = cnt.size() >= m ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums.get(i), 1, Integer::sum);
             if (cnt.merge(nums.get(i - k), -1, Integer::sum) == 0) {
@@ -187,6 +182,51 @@ function maxSum(nums: number[], m: number, k: number): number {
 }
 ```
 
+```cs
+public class Solution {
+    public long MaxSum(IList<int> nums, int m, int k) {
+        Dictionary<int, int> cnt = new Dictionary<int, int>();
+        int n = nums.Count;
+        long s = 0;
+
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+
+        long ans = cnt.Count >= m ? s : 0;
+
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (cnt.ContainsKey(nums[i - k])) {
+                cnt[nums[i - k]]--;
+                if (cnt[nums[i - k]] == 0) {
+                    cnt.Remove(nums[i - k]);
+                }
+            }
+
+            s += nums[i] - nums[i - k];
+
+            if (cnt.Count >= m) {
+                ans = Math.Max(ans, s);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->
diff --git a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.cs b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.cs
new file mode 100644
index 0000000000000..5a139c8ae55ec
--- /dev/null
+++ b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.cs	
@@ -0,0 +1,42 @@
+public class Solution {
+    public long MaxSum(IList<int> nums, int m, int k) {
+        Dictionary<int, int> cnt = new Dictionary<int, int>();
+        int n = nums.Count;
+        long s = 0;
+        
+        for (int i = 0; i < k; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            s += nums[i];
+        }
+        
+        long ans = cnt.Count >= m ? s : 0;
+        
+        for (int i = k; i < n; ++i) {
+            if (!cnt.ContainsKey(nums[i])) {
+                cnt[nums[i]] = 1;
+            }
+            else {
+                cnt[nums[i]]++;
+            }
+            if (cnt.ContainsKey(nums[i - k])) {
+                cnt[nums[i - k]]--;
+                if (cnt[nums[i - k]] == 0) {
+                    cnt.Remove(nums[i - k]);
+                }
+            }
+            
+            s += nums[i] - nums[i - k];
+            
+            if (cnt.Count >= m) {
+                ans = Math.Max(ans, s);
+            }
+        }
+        
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.java b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.java
index f2464efd2aa54..16cda4b8d8c8a 100644
--- a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.java	
+++ b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.java	
@@ -7,10 +7,7 @@ public long maxSum(List<Integer> nums, int m, int k) {
             cnt.merge(nums.get(i), 1, Integer::sum);
             s += nums.get(i);
         }
-        long ans = 0;
-        if (cnt.size() >= m) {
-            ans = s;
-        }
+        long ans = cnt.size() >= m ? s : 0;
         for (int i = k; i < n; ++i) {
             cnt.merge(nums.get(i), 1, Integer::sum);
             if (cnt.merge(nums.get(i - k), -1, Integer::sum) == 0) {
diff --git a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.py b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.py
index c45a872a9ecaf..4eafc3443648a 100644
--- a/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.py	
+++ b/solution/2800-2899/2841.Maximum Sum of Almost Unique Subarray/Solution.py	
@@ -2,9 +2,7 @@ class Solution:
     def maxSum(self, nums: List[int], m: int, k: int) -> int:
         cnt = Counter(nums[:k])
         s = sum(nums[:k])
-        ans = 0
-        if len(cnt) >= m:
-            ans = s
+        ans = s if len(cnt) >= m else 0
         for i in range(k, len(nums)):
             cnt[nums[i]] += 1
             cnt[nums[i - k]] -= 1