# 연관 링크
- [문제 풀이 스케줄](https://github.com/orgs/DaleStudy/projects/6/views/5)
- [답안 코드 제출법](https://github.com/DaleStudy/leetcode-study/wiki/%EB%8B%B5%EC%95%88-%EC%A0%9C%EC%B6%9C-%EA%B0%80%EC%9D%B4%EB%93%9C)

# Problem
- 문제 링크 : https://leetcode.com/problems/maximum-subarray/description/
- 문제 이름 : Maximum Subarray
- 문제 번호 : 53
- 난이도 : Medium
- 카테고리 :

# 문제 설명


# 아이디어
- 어떤 방법으로 접근했는지 서술
- 포스 vs 최적화 아이디어 차이 등
- 잡도에 대한 고려

# ✅ 코드 (Solution)
## Brute force
```cpp
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> partialSum(nums.size()+1, 0);
        int res = nums[0];
        for(int i=0;i<nums.size();i++){
            partialSum[i+1] = partialSum[i]+nums[i];
        }

        for(int i=0;i<partialSum.size();i++){
            for(int j=0;j<i;j++){
                res = max(res, partialSum[i]-partialSum[j]);
            }
        }

        return res;
    }
};
```
- Brute Force
- o(n^2) -> TLE
## Kadane Algorithm - pass
```cpp
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int currentSum = nums[0];
        int maxSum = nums[0];
        
        for (int i = 1; i < nums.size(); ++i) {
            currentSum = max(nums[i], currentSum + nums[i]);
            maxSum = max(maxSum, currentSum);
        }
        
        return maxSum;
    }
};
```

- O(n)
- 다음 원소를 추가했을 때 더 좋아지면 연장, 아니면 새로 시작하며 계속 갱신

## Divide and conquer - pass
```cpp
class Solution {
public:
    int maxCrossingSum(vector<int>& nums, int left, int mid, int right) {
        int leftSum = INT_MIN, sum = 0;
        for (int i = mid; i >= left; i--) {
            sum += nums[i];
            leftSum = max(leftSum, sum);
        }

        int rightSum = INT_MIN;
        sum = 0;
        for (int i = mid + 1; i <= right; i++) {
            sum += nums[i];
            rightSum = max(rightSum, sum);
        }

        return leftSum + rightSum;
    }

    int maxSubArrayHelper(vector<int>& nums, int left, int right) {
        if (left == right)
            return nums[left];

        int mid = (left + right) / 2;

        int leftMax = maxSubArrayHelper(nums, left, mid);
        int rightMax = maxSubArrayHelper(nums, mid + 1, right);
        int crossMax = maxCrossingSum(nums, left, mid, right);

        return max({leftMax, rightMax, crossMax});
    }

    int maxSubArray(vector<int>& nums) {
        return maxSubArrayHelper(nums, 0, nums.size() - 1);
    }
};
```

- O(n log n)
- 참고용

# 최적화 포인트 (Optimality Discussion)
•	최적화한 이유와 원리
•	더 줄일 수 있는 여지는 있는가?
•	기존 방법 대비 얼마나 효율적이었는지

# 🧪 테스트 & 엣지 케이스

# 📚 관련 지식 복습

# 🔁 회고


