K-Concatenation Maximum Sum - Practice Coding Problems

K-Concatenation Maximum Sum - Problem

K-Concatenation Maximum Sum challenges you to find the maximum subarray sum in an array that has been repeated k times consecutively.

Given an integer array arr and an integer k, you need to:
1. Create a new array by repeating arr exactly k times
2. Find the maximum sum of any contiguous subarray in this concatenated array
3. Return the result modulo 10⁹ + 7

Example: If arr = [1, 2] and k = 3, the concatenated array becomes [1, 2, 1, 2, 1, 2]. The maximum subarray sum would be the sum of the entire array: 9.

Note: Empty subarrays are allowed (sum = 0), so the answer is never negative.

Input & Output

example_1.py — Basic Case

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

› Output: 9

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

example_2.py — Mixed Values

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

› Output: 2

💡 Note: The concatenated array is [1,-2,1,1,-2,1,1,-2,1,1,-2,1,1,-2,1]. The maximum subarray is [1,1] which appears multiple times, giving sum = 2.

example_3.py — All Negative

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

› Output: 0

💡 Note: All elements are negative, so the optimal strategy is to choose an empty subarray with sum 0.

Visualization

Tap to expand

Understanding the Visualization

Analyze Single Array

Use Kadane's algorithm to find max subarray, plus calculate best prefix and suffix sums

Check Double Concatenation

Find the maximum subarray in exactly 2 concatenated arrays to handle boundary-crossing cases

Optimize with Middle Repetitions

If the total array sum is positive and k > 2, add (k-2) complete arrays between the optimal suffix and prefix

Key Takeaway

🎯 Key Insight: The maximum subarray in k concatenations can span at most 2 complete arrays plus middle repetitions, allowing us to solve in O(n) time regardless of k value!

Time & Space Complexity

Time Complexity

⏱️

O((n*k)²)

We have n*k elements and check all O((n*k)²) subarrays

✓ Linear Growth

Space Complexity

O(n*k)

Store the entire concatenated array of size n*k

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁴ ≤ arr[i] ≤ 10⁴
1 ≤ k ≤ 10⁵
Answer must be returned modulo 10⁹ + 7

Asked in

G Google 23 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses Kadane's algorithm with mathematical insight: the maximum subarray in k concatenations spans at most 2 complete arrays plus middle repetitions. We calculate max prefix, suffix, and total sums, then intelligently combine them based on whether the total sum is positive. This achieves O(n) time complexity regardless of k value.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Subarrays)	O((n*k)²)	O(n*k)	Generate the full k-concatenated array and check all possible subarrays
Optimized Dynamic Programming	O(n)	O(1)	Use Kadane's algorithm with smart analysis of concatenation patterns

Brute Force (All Subarrays) — Algorithm Steps

Create concatenated array by repeating original array k times
Use nested loops to generate all possible subarrays
Calculate sum for each subarray and track maximum
Return maximum sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenate Array

Create the full k-repeated array

Check All Subarrays

Use nested loops to examine every contiguous subarray

Track Maximum

Keep track of the maximum sum found so far

Code -

solution.c — C

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

#define MOD 1000000007

int kConcatenationMaxSum(int* arr, int arrSize, int k) {
    // Create concatenated array
    int totalSize = arrSize * k;
    int* concatenated = malloc(totalSize * sizeof(int));
    
    for (int i = 0; i < k; i++) {
        for (int j = 0; j < arrSize; j++) {
            concatenated[i * arrSize + j] = arr[j];
        }
    }
    
    long long maxSum = 0;
    
    // Check all subarrays
    for (int i = 0; i < totalSize; i++) {
        long long currentSum = 0;
        for (int j = i; j < totalSize; j++) {
            currentSum += concatenated[j];
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    free(concatenated);
    return maxSum % MOD;
}

int main() {
    int arr[1000];
    int arrSize = 0;
    int num;
    char ch;
    
    while (scanf("%d%c", &num, &ch) == 2) {
        arr[arrSize++] = num;
        if (ch == '\n') break;
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", kConcatenationMaxSum(arr, arrSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((n*k)²)

We have n*k elements and check all O((n*k)²) subarrays

✓ Linear Growth

Space Complexity

O(n*k)

Store the entire concatenated array of size n*k

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁴ ≤ arr[i] ≤ 10⁴
1 ≤ k ≤ 10⁵
Answer must be returned modulo 10⁹ + 7

26.8K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler