> For the complete documentation index, see [llms.txt](https://soumyajit4419.gitbook.io/ds-algo/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://soumyajit4419.gitbook.io/ds-algo/sub-array-problems/8.-maximum-absolute-sum-of-any-subarray.md).

# 4. Maximum Absolute Sum of Any Subarray

You are given an integer array `nums`. The **absolute sum** of a subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is `abs(numsl + numsl+1 + ... + numsr-1 + numsr)`.

Return *the **maximum** absolute sum of any **(possibly empty)** subarray of* `nums`.

Note that `abs(x)` is defined as follows:

* If `x` is a negative integer, then `abs(x) = -x`.
* If `x` is a non-negative integer, then `abs(x) = x`.

**Example 1:**

```
Input: nums = [1,-3,2,3,-4]
Output: 5
Explanation: The subarray [2,3] has absolute sum = abs(2+3) = abs(5) = 5.
```

**Example 2:**

```
Input: nums = [2,-5,1,-4,3,-2]
Output: 8
Explanation: The subarray [-5,1,-4] has absolute sum = abs(-5+1-4) = abs(-8) = 8.
```

## Solution: (Using Kadane's  Algorithm)

**Approach:**\
**Finding the max Sum possible**\
**Finding the min sum possible**\
**Checking the max.**

```cpp
class Solution
{
public:
    int maxAbsoluteSum(vector<int> &nums)
    {

        int s = 0;
        int maxSum = INT_MIN;
        int minSum = INT_MAX;

        //Finding the max sum subarray
        for (int i = 0; i < nums.size(); i++)
        {
            s += nums[i];
            if (s > maxSum)
            {
                maxSum = s;
            }

            if (s < 0)
            {
                s = 0;
            }
        }

        //Finding the min sum subarray
        s = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            s += nums[i];
            if (s < minSum)
            {
                minSum = s;
            }

            if (s > 0)
            {
                s = 0;
            }
        }

        return max(maxSum, abs(minSum));
    }
};
```

**Time Complexity: O(n)**