Minimum Average Difference - Leetcode Solution

The Minimum Average Difference problem on LeetCode involves finding the minimum possible difference between the average of two groups of integers, given an array of integers. Here is a detailed solution to this problem:

Approach:

The brute force approach to solve this problem would involve taking all possible combinations of two sets and then taking their averages, computing the difference and then finding the minimum difference among all the combinations. However, the time complexity of this approach would be O(n^2 * 2^n), which is not efficient enough to pass the LeetCode test cases.

One better approach is to use dynamic programming to keep track of all possible sums that can be obtained from subsets of the array. This can be done using a 2D boolean array dp[i][j]. Here, dp[i][j] represents whether a sum j can be obtained using the first i elements of the array. The base case for this DP is dp[0][0] = true, as we can obtain a sum of 0 using an empty set.

Once we have computed all possible sums for subsets of the array, we can iterate over all possible sums half of the total sum of array to 0 and check if this sum can be obtained using the first n/2 elements of the array. If so, we compute the difference between this sum and the remaining half and update our answer if this difference is lesser than the current minimum difference.

Solution:

Here is the Python code for the minimum average difference problem on LeetCode:

class Solution:
    def minimumAverageDifference(self, nums: List[int]) -> float:
        n = len(nums)
        total = sum(nums)
        dp = [[False]*(total+1) for _ in range(n+1)]
        dp[0][0] = True
        for i in range(1, n+1):
            for j in range(total+1):
                if j-nums[i-1] >= 0 and dp[i-1][j-nums[i-1]]:
                    dp[i][j] = True
                if dp[i-1][j]:
                    dp[i][j] = True
        ans = float('inf')
        for i in range(total//2, -1, -1):
            if dp[n][i]:
                ans = min(ans, total-2*i)
        return ans/2

Time Complexity:

The time complexity of this solution is O(n * total), where total is the sum of the elements in nums, since we are iterating over n * total elements for the DP, and then iterating once more over values of i from total//2 to 0.

Space Complexity:

The space complexity of this solution is O(n * total), since we are using a 2D array of size (n+1) * (total+1) for the DP.

1