K consecutive maxSum

// given an array, find n consecutive number which forms the largest sum.
#include "header.h"
using namespace std;

int maxConsecutive(vector<int>& array, int n) {
  if(n <= 0) return 0;
  vector<int> dp(array.size(), 0);
  dp[0] = array[0];
  for(int i = 1; i < array.size(); ++i) {
    dp[i] += dp[i-1] + array[i];
  }
  int maxSum = INT_MIN;
  for(int i = 0; i + n < array.size(); i++) {
      maxSum = max(maxSum, dp[i + n] - dp[i]);
  }
  if(n > array.size()) return dp[array.size() - 1];
  return maxSum;
}

// given an array and a number n, find 3 non-overlap n consecutive numbers which makes the largest sum.
// 1, 3, 7, 7, 2, 1, 1, 4, 8, 8, 6, 1, 1, 9
// 1, 3, (7 7), 2, 1, 1, (4 8), (8, 6), 1, 1, 9
// seems like we can use divide and conquer here.
void maxSum(vector<int>& array, int pos, int currSum, int& maxSumValue, int k, int n) {
  if(k < 0 || pos > array.size()) return;
  if(k == 0) {
    maxSumValue = max(maxSumValue, currSum);
    return;
  }
  for(int i = pos; i + k * n < array.size(); ++i) {
      for(int j = i; j < i + n; ++j) currSum += array[j];
      maxSum(array, i + n, currSum, maxSumValue, k - 1, n);
      for(int j = i; j < i + n; ++j) currSum -= array[j];
  }
}
// maybe think about dynamic programming?


int maxSum(vector<int>& array, int n) {
  if(array.size() < n * 3) return 0;
  int maxSumValue = INT_MIN;
  int currSum = 0;
  int pos = 0;
  maxSum(array, pos, currSum, maxSumValue, 3, n);
  return maxSumValue;
}

int main(void) {
  vector<int> nums{1, 3, 7, 7, 2, 1, 1, 4, 8, 8, 6, 1, 1, 9};
  cout << maxSum(nums, 2) << endl;
}

A bit  update for first question and DP method for second question

// consecutive largest sum.
int kConsecutiveSum(vector<int>& nums, int k) {
  int n = nums.size();
  vector<int> dp(n, 0); dp[0] = nums[0];
  for(int i = 1; i < n; ++i) {
    dp[i] = nums[i] + dp[i-1];
  }
  if(k >= n) return dp[n-1];
  int largestSum = dp[k-1];
  for(int j = k + 1; j < n; ++j) {
      largestSum = max(largestSum, dp[j- 1] - dp[j - k - 1]);
  }
  return largestSum;
}

// K consecutive largest sum.
int kConsecutiveSumII(vector<int>& nums, int k, int n) {
  int size = nums.size();
  vector<int> dp(n, 0); dp[0] = nums[0];
  for(int i = 1; i < nums.size(); ++i) {
    dp[i] = dp[i-1] + nums[i];
  }
  if(k * n >= nums.size()) return dp[nums.size() - 1];
  vector<int> pre(n, 0);
  for(int i = 1; i <= k; ++i) {
    vector<int> curr(n, 0);
    for(int j = i * n; j < nums.size(); ++j) {
      if(j == i * n) curr[j] = dp[j-1];
      else dp[j] = max(dp[j - 1], dp[j - 1] - sum[j - n - 1] + prev[j - n]);
    }
  }
  return dp[nums.size() - 1];
}