브러쉬 인터뷰 질문 - 가장 큰 하위 세그먼트와 연속

OJ 링크

• 루오 구 OJ P1115
• LEETCODE 최대-부분 배열

LEETCODE 코드

솔루션

이상 청소 선형

• 계산 프리픽스 및 인공 지능, 즉 A1 + A2 + ... + AI
• 최소 및 프리픽스를 계산 비스무트, 분 (A1, A2, ..., AI)
• 인공 지능은 최대 및 CI = AI-Bi를 최종 서브 세그먼트를 배치
• 또한 최소치를 기록하는 CI 일 수 가변 입술을 열고
• O의 시간 복잡도 (N)

typedef int ll;

class Solution {
public:
    ll maxSubArray(vector<int>& nums) {
        int sz = nums.size();
        if (!sz) {
            return 0;
        }

        ll prefix_sum = nums[0];
        ll min_prefix_sum = nums[0];
        ll res = nums[0];
        for(int i=1; i<sz; i++) {
            prefix_sum += nums[i];
            res = max(res, prefix_sum- min(min_prefix_sum, 0));
            min_prefix_sum = min(min_prefix_sum, prefix_sum);
        }

        return res;
    }
};

해결 방법 2

동적 프로그래밍

• 유지 관리는 최대의 하위 세그먼트와 CI의 인공 지능을 종료
• 또한 최소치를 기록하는 CI 일 수 가변 입술을 열고
• O의 시간 복잡도 (N)

typedef int ll;

class Solution {
public:
    ll maxSubArray(vector<int>& nums) {
        int sz = nums.size();
        if (sz == 0) {
            return 0;
        }

        ll res, current_max;
        res = current_max = nums[0];
        for (int i=1; i<sz; i++) {
            current_max = max(nums[i], current_max + nums[i]);
            res = max(res, current_max);
        }
        return res;
    }
};

해결 방법 3

분 치료 방법

• 각 세그먼트의 경우, 필요 유지
  • 왼쪽과 시작의에서 가장 큰 이하 세그먼트
  • 오른쪽에서 가장 큰 하위 세그먼트와 시작의
  • 그리고 가장 큰 이하 세그먼트
  • 합계
• O의 시간 복잡도 (N)

T(n) = 2T(n/2) + O(1) = 2*2T(n/2/2) + O(1) + O(1) = 2^tT(n/(2^t)) + tO(1) = 2^t + tO(1)
2^t = n
t = logn
T(n) = O(n + logn) = O(n)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        ll left_sum, right_sum, total_sum;
        return maxSubArray(nums, 0, nums.size() - 1, left_sum, right_sum, total_sum);
    }
private:
    // 每一段需要维护
    // 总和、左侧最大和、右侧最大和，最大子段和
    ll maxSubArray(vector<int>& nums, int L, int R, ll &left_sum, ll &right_sum, ll &total_sum) {
        if (L>R) {
            return 0;
        }
        if (L==R) {
            left_sum = right_sum = total_sum = nums[L];
            return nums[L];
        }
        int mid = L + R >> 1;
        ll left_left_sum, left_right_sum, left_total_sum;
        ll right_left_sum, right_right_sum, right_total_sum;
        ll left_max_sum = maxSubArray(nums, L, mid, left_left_sum, left_right_sum, left_total_sum);
        ll right_max_sum = maxSubArray(nums, mid+1, R, right_left_sum, right_right_sum, right_total_sum);

        left_sum = max(left_left_sum, left_total_sum + right_left_sum);
        right_sum = max(right_right_sum, right_total_sum + left_right_sum);
        total_sum = left_total_sum + right_total_sum;

        return max(max(left_max_sum, right_max_sum), left_right_sum + right_left_sum);
    }
};

네 들어

분 치료 방법

• 그러나 데이터 솔루션 III의 더미를 유지하지 않습니다
• 최대 교차 각 중간 서브 세그먼트 선형 스캔 시간을 찾는
• O의 시간 복잡도 (nlogn)

typedef int ll;

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        return maxSubArray(nums, 0, nums.size() - 1);
    }
private:
    // 每一段需要维护
    // 总和、左侧最大和、右侧最大和，最大子段和
    ll maxSubArray(vector<int>& nums, int L, int R) {
        if (L>R) {
            return 0;
        }
        if (L==R) {
            return nums[L];
        }

        int mid = L + R >> 1;
        ll left_max_sum = maxSubArray(nums, L, mid);
        ll right_max_sum = maxSubArray(nums, mid+1, R);
        ll res = max(left_max_sum, right_max_sum);

        ll tmp_left = nums[mid], rec_left = nums[mid];
        for (int i=mid-1; i>=L; i--) {
            tmp_left += nums[i];
            rec_left = max(tmp_left, rec_left);
        }

        ll tmp_right = nums[mid+1], rec_right = nums[mid+1];
        for (int i=mid+2; i<=R; i++) {
            tmp_right += nums[i];
            rec_right = max(tmp_right, rec_right);
        }

        res = max(res, rec_left + rec_right);

        return res;
    }
};

로스 OJ 밸리 시험

해결	사용하는 경우 (MS)	메모리 (MB)
一	149	1.87
두	(150)	1.79
세	(168)	2.19
네	(225)	1.82