Program to find longest equivalent sublist after K increments in Python

The longest equivalent sublist after K increments is the longest contiguous portion of a list where we can make all elements equal by performing at most K increment operations. This problem uses a sliding window technique on a sorted array to find the optimal solution.

Given a list nums and integer k, we need to find the maximum length of a sublist where all elements can be made equal using at most k increment operations on individual elements.

Problem Example

Consider this input scenario where we can increment 9 once and 6 four times to get the sublist [10, 10, 10] with length 3 ?

Input: nums = [3, 5, 9, 6, 10, 7], k = 6
Output: 3

Algorithm Approach

The solution involves sorting the array and using a sliding window approach:

• Sort the array to group similar values together
• Use two pointers (left and right) to maintain a sliding window
• Calculate increments needed to make all elements equal to the maximum in current window
• Expand or shrink window based on whether increments exceed K

Implementation

Example 1: Basic Case

Here's how to find the longest sublist that can be made equivalent using at most K increments ?

def longest_equal_sublist_after_k_increments(nums, k):
    nums.sort()
    left = 0
    total = 0
    max_len = 0

    for right in range(len(nums)):
        total += nums[right]
        
        # Check if increments needed exceed k
        while nums[right] * (right - left + 1) - total > k:
            total -= nums[left]
            left += 1
        
        max_len = max(max_len, right - left + 1)
    
    return max_len

# Sample input
numbers = [1, 2, 4]
k = 5
result = longest_equal_sublist_after_k_increments(numbers, k)
print("Longest equivalent sublist length after K increments:", result)

Longest equivalent sublist length after K increments: 3

Example 2: Limited Increments

This example shows a case where the increment limit restricts the sublist length ?

def longest_equal_sublist_after_k_increments(nums, k):
    nums.sort()
    left = 0
    total = 0
    max_length = 0

    for right in range(len(nums)):
        total += nums[right]
        
        # Shrink window if increments needed exceed k
        while nums[right] * (right - left + 1) - total > k:
            total -= nums[left]
            left += 1

        max_length = max(max_length, right - left + 1)

    return max_length

# Sample input with limited increments
numbers = [3, 9, 6]
k = 2
result = longest_equal_sublist_after_k_increments(numbers, k)
print("Longest equivalent sublist length after K increments:", result)

Longest equivalent sublist length after K increments: 1

How It Works

The algorithm calculates the cost to make all elements in the current window equal to the maximum element. The formula nums[right] * window_size - total gives the total increments needed. If this exceeds K, we shrink the window from the left.

Time Complexity

The time complexity is O(n log n) due to sorting, where n is the length of the input array. The sliding window traversal is O(n), making sorting the bottleneck.

Conclusion

This sliding window approach efficiently finds the longest sublist that can be made equivalent with K increments. The key insight is sorting first and then calculating increment costs for contiguous windows.