diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/README.md b/solution/3000-3099/3026.Maximum Good Subarray Sum/README.md
index c233338be4ff6..95a73d74a5c3b 100644
--- a/solution/3000-3099/3026.Maximum Good Subarray Sum/README.md	
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/README.md	
@@ -55,19 +55,137 @@
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def maximumSubarraySum(self, nums: List[int], k: int) -> int:
+        p = {}
+        r = float('-inf')
+        p[nums[0]] = 0
+        s = 0
+        n = len(nums)
+        for i in range(n):
+            s += nums[i]
+            if nums[i] - k in p:
+                r = max(r, s - p[nums[i] - k])
+            if nums[i] + k in p:
+                r = max(r, s - p[nums[i] + k])
+            if i + 1 == n:
+                break
+            if nums[i + 1] not in p or p[nums[i + 1]] > s:
+                p[nums[i + 1]] = s
+        return r if r != float('-inf') else 0
 ```
 
 ```java
-
+class Solution {
+    public long maximumSubarraySum(int[] nums, int k) {
+        HashMap<Integer, Long> p = new HashMap<>();
+        long r = Long.MIN_VALUE;
+        p.put(nums[0], 0L);
+        long s = 0;
+        int n = nums.length;
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            if (p.containsKey(nums[i] - k)) {
+                r = Math.max(r, s - p.get(nums[i] - k));
+            }
+            if (p.containsKey(nums[i] + k)) {
+                r = Math.max(r, s - p.get(nums[i] + k));
+            }
+            if (i + 1 == n) break;
+            if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
+                p.put(nums[i + 1], s);
+            }
+        }
+        return r == Long.MIN_VALUE ? 0 : r;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    long long maximumSubarraySum(vector<int>& nums, int k) {
+        unordered_map<int, long long> p;
+        long long r = LONG_LONG_MIN;
+        p[nums[0]] = 0;
+        long long s = 0;
+        const int n = nums.size();
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            auto t = p.find(nums[i] - k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            t = p.find(nums[i] + k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            if (i + 1 == n)
+            	break;
+            t = p.find(nums[i + 1]);
+            if (t == p.end() || t->second > s) {
+                p[nums[i + 1]] = s;
+            }
+        }
+        return r == LONG_LONG_MIN ? 0 : r;
+    }
+};
 ```
 
 ```go
+func maximumSubarraySum(nums []int, k int) int64 {
+    p := make(map[int]int64)
+    var r int64 = math.MinInt64
+    p[nums[0]] = 0
+    var s int64 = 0
+    n := len(nums)
+    for i := 0; ; i++ {
+        s += int64(nums[i])
+        if t, ok := p[nums[i]-k]; ok {
+            r = max(r, s-t)
+        }
+        if t, ok := p[nums[i]+k]; ok {
+            r = max(r, s-t)
+        }
+        if i+1 == n {
+            break
+        }
+        if t, ok := p[nums[i+1]]; !ok || t > s {
+            p[nums[i+1]] = s
+        }
+    }
+    if r == math.MinInt64 {
+        return 0
+    }
+    return r
+}
+```
 
+```ts
+function maximumSubarraySum(nums: number[], k: number): number {
+    const p: Map<number, number> = new Map();
+    let r: number = Number.MIN_SAFE_INTEGER;
+    p.set(nums[0], 0);
+    let s: number = 0;
+    const n: number = nums.length;
+    for (let i = 0; ; ++i) {
+        s += nums[i];
+        let t: number | undefined = p.get(nums[i] - k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        t = p.get(nums[i] + k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        if (i + 1 === n) break;
+        t = p.get(nums[i + 1]);
+        if (t === undefined || t > s) {
+            p.set(nums[i + 1], s);
+        }
+    }
+    return r === Number.MIN_SAFE_INTEGER ? 0 : r;
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/README_EN.md b/solution/3000-3099/3026.Maximum Good Subarray Sum/README_EN.md
index a2badbc513003..1c5215ad610d8 100644
--- a/solution/3000-3099/3026.Maximum Good Subarray Sum/README_EN.md	
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/README_EN.md	
@@ -51,19 +51,137 @@
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def maximumSubarraySum(self, nums: List[int], k: int) -> int:
+        p = {}
+        r = float('-inf')
+        p[nums[0]] = 0
+        s = 0
+        n = len(nums)
+        for i in range(n):
+            s += nums[i]
+            if nums[i] - k in p:
+                r = max(r, s - p[nums[i] - k])
+            if nums[i] + k in p:
+                r = max(r, s - p[nums[i] + k])
+            if i + 1 == n:
+                break
+            if nums[i + 1] not in p or p[nums[i + 1]] > s:
+                p[nums[i + 1]] = s
+        return r if r != float('-inf') else 0
 ```
 
 ```java
-
+class Solution {
+    public long maximumSubarraySum(int[] nums, int k) {
+        HashMap<Integer, Long> p = new HashMap<>();
+        long r = Long.MIN_VALUE;
+        p.put(nums[0], 0L);
+        long s = 0;
+        int n = nums.length;
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            if (p.containsKey(nums[i] - k)) {
+                r = Math.max(r, s - p.get(nums[i] - k));
+            }
+            if (p.containsKey(nums[i] + k)) {
+                r = Math.max(r, s - p.get(nums[i] + k));
+            }
+            if (i + 1 == n) break;
+            if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
+                p.put(nums[i + 1], s);
+            }
+        }
+        return r == Long.MIN_VALUE ? 0 : r;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    long long maximumSubarraySum(vector<int>& nums, int k) {
+        unordered_map<int, long long> p;
+        long long r = LONG_LONG_MIN;
+        p[nums[0]] = 0;
+        long long s = 0;
+        const int n = nums.size();
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            auto t = p.find(nums[i] - k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            t = p.find(nums[i] + k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            if (i + 1 == n)
+            	break;
+            t = p.find(nums[i + 1]);
+            if (t == p.end() || t->second > s) {
+                p[nums[i + 1]] = s;
+            }
+        }
+        return r == LONG_LONG_MIN ? 0 : r;
+    }
+};
 ```
 
 ```go
+func maximumSubarraySum(nums []int, k int) int64 {
+    p := make(map[int]int64)
+    var r int64 = math.MinInt64
+    p[nums[0]] = 0
+    var s int64 = 0
+    n := len(nums)
+    for i := 0; ; i++ {
+        s += int64(nums[i])
+        if t, ok := p[nums[i]-k]; ok {
+            r = max(r, s-t)
+        }
+        if t, ok := p[nums[i]+k]; ok {
+            r = max(r, s-t)
+        }
+        if i+1 == n {
+            break
+        }
+        if t, ok := p[nums[i+1]]; !ok || t > s {
+            p[nums[i+1]] = s
+        }
+    }
+    if r == math.MinInt64 {
+        return 0
+    }
+    return r
+}
+```
 
+```ts
+function maximumSubarraySum(nums: number[], k: number): number {
+    const p: Map<number, number> = new Map();
+    let r: number = Number.MIN_SAFE_INTEGER;
+    p.set(nums[0], 0);
+    let s: number = 0;
+    const n: number = nums.length;
+    for (let i = 0; ; ++i) {
+        s += nums[i];
+        let t: number | undefined = p.get(nums[i] - k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        t = p.get(nums[i] + k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        if (i + 1 === n) break;
+        t = p.get(nums[i + 1]);
+        if (t === undefined || t > s) {
+            p.set(nums[i + 1], s);
+        }
+    }
+    return r === Number.MIN_SAFE_INTEGER ? 0 : r;
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.cpp b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.cpp
new file mode 100644
index 0000000000000..c002641010a70
--- /dev/null
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.cpp	
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    long long maximumSubarraySum(vector<int>& nums, int k) {
+        unordered_map<int, long long> p;
+        long long r = LONG_LONG_MIN;
+        p[nums[0]] = 0;
+        long long s = 0;
+        const int n = nums.size();
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            auto t = p.find(nums[i] - k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            t = p.find(nums[i] + k);
+            if (t != p.end()) {
+                r = max(r, s - t->second);
+            }
+            if (i + 1 == n)
+                break;
+            t = p.find(nums[i + 1]);
+            if (t == p.end() || t->second > s) {
+                p[nums[i + 1]] = s;
+            }
+        }
+        return r == LONG_LONG_MIN ? 0 : r;
+    }
+};
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.go b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.go
new file mode 100644
index 0000000000000..b14d02d611e87
--- /dev/null
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.go	
@@ -0,0 +1,26 @@
+func maximumSubarraySum(nums []int, k int) int64 {
+    p := make(map[int]int64)
+    var r int64 = math.MinInt64
+    p[nums[0]] = 0
+    var s int64 = 0
+    n := len(nums)
+    for i := 0; ; i++ {
+        s += int64(nums[i])
+        if t, ok := p[nums[i]-k]; ok {
+            r = max(r, s-t)
+        }
+        if t, ok := p[nums[i]+k]; ok {
+            r = max(r, s-t)
+        }
+        if i+1 == n {
+            break
+        }
+        if t, ok := p[nums[i+1]]; !ok || t > s {
+            p[nums[i+1]] = s
+        }
+    }
+    if r == math.MinInt64 {
+        return 0
+    }
+    return r
+}
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.java b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.java
new file mode 100644
index 0000000000000..4eeb6c8e0d2a9
--- /dev/null
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public long maximumSubarraySum(int[] nums, int k) {
+        HashMap<Integer, Long> p = new HashMap<>();
+        long r = Long.MIN_VALUE;
+        p.put(nums[0], 0L);
+        long s = 0;
+        int n = nums.length;
+        for (int i = 0;; ++i) {
+            s += nums[i];
+            if (p.containsKey(nums[i] - k)) {
+                r = Math.max(r, s - p.get(nums[i] - k));
+            }
+            if (p.containsKey(nums[i] + k)) {
+                r = Math.max(r, s - p.get(nums[i] + k));
+            }
+            if (i + 1 == n) break;
+            if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
+                p.put(nums[i + 1], s);
+            }
+        }
+        return r == Long.MIN_VALUE ? 0 : r;
+    }
+}
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.py b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.py
new file mode 100644
index 0000000000000..10a5950f11e26
--- /dev/null
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.py	
@@ -0,0 +1,18 @@
+class Solution:
+    def maximumSubarraySum(self, nums: List[int], k: int) -> int:
+        p = {}
+        r = float('-inf')
+        p[nums[0]] = 0
+        s = 0
+        n = len(nums)
+        for i in range(n):
+            s += nums[i]
+            if nums[i] - k in p:
+                r = max(r, s - p[nums[i] - k])
+            if nums[i] + k in p:
+                r = max(r, s - p[nums[i] + k])
+            if i + 1 == n:
+                break
+            if nums[i + 1] not in p or p[nums[i + 1]] > s:
+                p[nums[i + 1]] = s
+        return r if r != float('-inf') else 0
diff --git a/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.ts b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.ts
new file mode 100644
index 0000000000000..a7b50bf7dcec9
--- /dev/null
+++ b/solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.ts	
@@ -0,0 +1,24 @@
+function maximumSubarraySum(nums: number[], k: number): number {
+    const p: Map<number, number> = new Map();
+    let r: number = Number.MIN_SAFE_INTEGER;
+    p.set(nums[0], 0);
+    let s: number = 0;
+    const n: number = nums.length;
+    for (let i = 0; ; ++i) {
+        s += nums[i];
+        let t: number | undefined = p.get(nums[i] - k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        t = p.get(nums[i] + k);
+        if (t !== undefined) {
+            r = Math.max(r, s - t);
+        }
+        if (i + 1 === n) break;
+        t = p.get(nums[i + 1]);
+        if (t === undefined || t > s) {
+            p.set(nums[i + 1], s);
+        }
+    }
+    return r === Number.MIN_SAFE_INTEGER ? 0 : r;
+}