K-Concatenation Maximum Sum

K-Concatenation Maximum Sum - Problem

Given an integer array arr and an integer k, modify the array by repeating it k times.

For example, if arr = [1, 2] and k = 3 then the modified array will be [1, 2, 1, 2, 1, 2].

Return the maximum sub-array sum in the modified array. Note that the length of the sub-array can be 0 and its sum in that case is 0.

As the answer can be very large, return the answer modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Positive Array

$ Input: arr = [1,2], k = 3

› Output: 9

💡 Note: The concatenated array is [1,2,1,2,1,2]. The maximum subarray sum is 1+2+1+2+1+2 = 9 (taking the entire array).

Example 2 — Mixed Values

$ Input: arr = [1,-2,1], k = 5

› Output: 2

💡 Note: The maximum subarray sum in a single array is max(1, -2, 1, 1-2, -2+1, 1-2+1) = 1. Since total sum is 0, we don't benefit from repetitions.

Example 3 — Single Element

$ Input: arr = [-1], k = 2

› Output: 0

💡 Note: All elements are negative, so the maximum subarray sum is 0 (empty subarray).

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ k ≤ 10⁵
-10⁴ ≤ arr[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12

The key insight is that instead of generating the full k-concatenated array, we can analyze three patterns: maximum subarray within single array, maximum prefix+suffix across boundaries, and benefits from middle repetitions when total sum is positive. The optimal approach uses pattern analysis achieving Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Generate Full Array

⏱️ Time: O(n × k) Space: O(n × k)

Generate the complete concatenated array of size n*k, then use Kadane's algorithm to find maximum subarray sum. Simple but inefficient for large k values.

Optimized - Pattern Analysis

⏱️ Time: O(n) Space: O(1)

Instead of creating the full array, we analyze three key patterns: maximum subarray in single array, maximum prefix + suffix combination, and contribution of full array sum when k > 2.

Brute Force - Generate Full Array — Algorithm Steps

Step 1: Create array by repeating arr k times
Step 2: Apply Kadane's algorithm on the full array
Step 3: Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenate

Repeat array k times to create full array

Kadane's Algorithm

Find maximum subarray sum using classic approach

Result

Return maximum sum modulo 10^9 + 7

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007L

long long max_ll(long long a, long long b) {
    return a > b ? a : b;
}

long long solution(int* arr, int arrSize, int k) {
    if (arr == NULL || arrSize == 0 || k == 0) {
        return 0;
    }
    
    // Create concatenated array
    int concatSize = arrSize * k;
    int* concat = malloc(concatSize * sizeof(int));
    
    for (int i = 0; i < k; i++) {
        for (int j = 0; j < arrSize; j++) {
            concat[i * arrSize + j] = arr[j];
        }
    }
    
    // Apply Kadane's algorithm
    long long maxSum = 0;
    long long currentSum = 0;
    
    for (int i = 0; i < concatSize; i++) {
        currentSum = max_ll(0, currentSum + concat[i]);
        maxSum = max_ll(maxSum, currentSum);
    }
    
    free(concat);
    return maxSum % MOD;
}

int main() {
    char line[100000];
    
    // Parse array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Remove [ ]
    int len = strlen(line);
    memmove(line, line + 1, len - 1);
    line[len - 2] = '\0';
    
    int arr[10000];
    int arrSize = 0;
    
    if (strlen(line) > 0) {
        char* token = strtok(line, ",");
        while (token != NULL) {
            // Trim spaces
            while (*token == ' ') token++;
            arr[arrSize++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    // Parse k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    long long result = solution(arr, arrSize, k);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Creating concatenated array takes O(n×k) and Kadane's algorithm runs on array of size n×k

✓ Linear Growth

Space Complexity

O(n × k)

Need to store the concatenated array of size n×k

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate Full Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler