notes/OJ notes/pages/Leetcode Maxinum-subarray.md

# Leetcode Maxinum-subarray

#### 2022-06-09

---
##### Data stuctures:
#DS #array 
##### Algorithms:
#algorithm #Kadane_s_algorithm
##### Difficulty:
#leetcode #coding_problem #difficulty-easy
##### Links:
- [Link to problem](https://leetcode.com/problems/maximum-subarray/)
- [Analysis](https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d)
##### Related topics:
```expander
tag:#Kadane_s_algorithm 
```
 
- [[Kadane's Algorithm]]
- [[Leetcode Best-Time-To-Buy-And-Sell-Stock]]
- [[Leetcode Maximum-Difference-Between-Increasing-Elements]]
 


### Problem
Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return _its sum_.

A **subarray** is a **contiguous** part of an array.

#### Examples
Example 1:

```
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.
```

Example 2:

```
Input: nums = [1]
Output: 1
```

Example 3:

```
Input: nums = [5,4,-1,7,8]
Output: 23
```


#### Constraints

- 1 <= nums.length <= 105
- -104 <= nums[i] <= 104

### Solution

```cpp
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
      // Kadane's algorithm
      int local_max = 0;
      int global_max = INT_MIN;
      
      for (int i = 0; i < nums.size(); i++) {
        // if accumulated local max is smaller than nums,
        // we use the new one instead, and it must be the biggest.
        local_max = max(nums[i] + local_max, nums[i]);
        
        if (local_max > global_max) {
          // We take note when local_max achieves the peak.
          global_max = local_max;
        }
      }
      return global_max;
    }
};
```

### Thoughts

This is a [[Kadane's Algorithm]] problem, and the philosophy behind it id divide and conquer. 
local_max is the max accumulated number we've found, and global_max is the max local_max we've found.
```cpp
local_max = max(nums[i] + local_max, nums[i])
```
is the key to O(n) complexity.

> [!hint]
> Use the macro INT_MAX and INT_MIN to initialize variables that finds max / min var. #tip