Codility MinAbsSum

Question

I tried this Codility test: MinAbsSum. https://codility.com/programmers/lessons/17-dynamic_programming/min_abs_sum/

I solved the problem by searching the whole tree of possibilities. The results were OK, however, my solution failed due to timeout for large input. In other words the time complexity was not as good as expected. My solution is O(nlogn), something normal with trees. But this coding test was in the section "Dynamic Programming", and there must be some way to improve it. I tried with summing the whole set first and then using this information, but always there is something missing in my solution. Does anybody have an idea on how to improve my solution using DP?

#include 
using namespace std;

int sum(vector& A, size_t i, int s)
{
   if (i == A.size())     
      return s;

   int tmpl = s + A[i];
   int tmpr = s - A[i];
   return min (abs(sum(A, i+1, tmpl)), abs(sum(A, i+1, tmpr)));
}

int solution(vector &A) {
   return sum(A, 0, 0);   
}

user_9892209 · Answer

I could not solve it. But here's the official answer.

Quoting it:

Notice that the range of numbers is quite small (maximum 100). Hence, there must be a lot of duplicated numbers. Let count[i] denote the number of occurrences of the value i. We can process all occurrences of the same value at once. First we calculate values count[i] Then we create array dp such that:

dp[j] = −1 if we cannot get the sum j,

dp[j] >= 0 if we can get sum j.

Initially, dp[j] = -1 for all of j (except dp[0] = 0). Then we scan through all the values a appearing in A; we consider all a such that count[a]>0. For every such a we update dp that dp[j] denotes how many values a remain (maximally) after achieving sum j. Note that if the previous value at dp[j] >= 0 then we can set dp[j] = count[a] as no value a is needed to obtain the sum j. Otherwise we must obtain sum j-a first and then use a number a to get sum j. In such a situation dp[j] = dp[j-a]-1. Using this algorithm, we can mark all the sum values and choose the best one (closest to half of S, the sum of abs of A).
def MinAbsSum(A):
    N = len(A)
    M = 0
    for i in range(N):
        A[i] = abs(A[i])
        M = max(A[i], M)
    S = sum(A)
    count = [0] * (M + 1)
    for i in range(N):
        count[A[i]] += 1
    dp = [-1] * (S + 1)
    dp[0] = 0
    for a in range(1, M + 1):
        if count[a] > 0:
            for j in range(S):
                if dp[j] >= 0:
                    dp[j] = count[a]
                elif (j >= a and dp[j - a] > 0):
                    dp[j] = dp[j - a] - 1
    result = S
    for i in range(S // 2 + 1):
        if dp[i] >= 0:
            result = min(result, S - 2 * i)
    return result

(note that since the final iteration only considers sums up until S // 2 + 1, we can save some space and time by only creating a DP Cache up until that value as well)

The Java answer provided by fladam returns wrong result for input [2, 3, 2, 2, 3], although it gets 100% score.

Java Solution

import java.util.Arrays;

public class MinAbsSum{
    static int[] dp;

    public static void main(String args[]) {
        int[] array = {1, 5,  2, -2};

        System.out.println(findMinAbsSum(array));
    }
    
    public static int findMinAbsSum(int[] A) {
        int arrayLength = A.length;
        int M = 0;
        for (int i = 0; i < arrayLength; i++) {
            A[i] = Math.abs(A[i]);
            M = Math.max(A[i], M);
        }
        
        int S = sum(A);
        dp = new int[S + 1];
        int[] count = new int[M + 1];
        for (int i = 0; i < arrayLength; i++) {
            count[A[i]] += 1;
        }
        Arrays.fill(dp, -1);
        dp[0] = 0;
        for (int i = 1; i < M + 1; i++) {
            if (count[i] > 0) {
                for(int j = 0; j < S; j++) {
                    if (dp[j] >= 0) {
                        dp[j] = count[i];
                    } else if (j >= i && dp[j - i] > 0) {
                        dp[j] = dp[j - i] - 1;
                    }
                }
            }
        }
        int result = S;
        for (int i = 0; i < Math.floor(S / 2) + 1; i++) {
            if (dp[i] >= 0) {
                result = Math.min(result, S - 2 * i);
            }
        }
        return result;
    }

    public static int sum(int[] array) {
        int sum = 0;
        for(int i : array) {
            sum += i;
        }

        return sum;
    }
}

user_2057127 · Answer

This solution (in Java) scored 100% for both (correctness and performance)

public int solution(int[] a){
    if (a.length == 0) return 0;
    if (a.length == 1) return a[0];
    int sum = 0;
    for (int i=0;i Math.abs(2*localSum - sum))
                minLocalSum = localSum;
            localSum += Math.abs(a[i]);
            indices[placeIndex++] = i;
        }else{
            if (localSum == half)
                return Math.abs(2*half - sum);

            if (Math.abs(2*minLocalSum-sum) > Math.abs(2*localSum - sum))
                minLocalSum = localSum;
            if (placeIndex > 1) {
                localSum -= Math.abs(a[indices[placeIndex--]]);
                i = indices[placeIndex];
            }
        }
    }
    return (Math.abs(2*minLocalSum - sum));

}

this solution treats all elements like they are positive numbers and it's looking to reach as close as it can to the sum of all elements divided by 2 (in that case we know that the sum of all other elements will be the same delta far from the half too -> abs sum will be minimum possible ). it does so by starting with the first element and successively adding others to the "local" sum (and recording indices of elements in the sum) until it reaches sum of x >= sumAll/2. if that x is equal to sumAll/2 we have an optimal solution. if not, we go step back in the indices array and continue picking other element where last iteration in that position ended. the result will be a "local" sum having abs((sumAll - sum) - sum) closest to 0;

fixed solution:

public static int solution(int[] a){
    if (a.length == 0) return 0;
    if (a.length == 1) return a[0];
    int sum = 0;
    for (int i=0;i= 0;i+=2){
        arr[i] = a[a.length/2+i/2];
        arr[i+1] = a[a.length/2-i/2-1];
    }
    if (a.length % 2 > 0) arr[a.length-1] = a[a.length-1];
    else{
        arr[a.length-2] = a[0];
        arr[a.length-1] = a[a.length-1];
    }
    return arr;
}

private static int findSum(int[] arr, int sum){
    int[] indices = new int[arr.length];
    indices[0] = 0;
    double half = Double.valueOf(sum)/2;
    int localSum = Math.abs(arr[0]);
    int minLocalSum = Integer.MAX_VALUE;
    int placeIndex = 1;
    for (int i=1;i Math.abs(2*localSum - sum))
            minLocalSum = localSum;

        if (localSum 1) {
                localSum -= Math.abs(arr[indices[--placeIndex]]);
                i = indices[placeIndex];
            }
        }
    }

    return Math.abs(2*minLocalSum - sum);
}

user_9959070 · Answer

The following is a rendering of the official answer in C++ (scoring 100% in task, correctness, and performance):

#include 
#include 
#include 
using namespace std;

int solution(vector &A) {
    // write your code in C++14 (g++ 6.2.0)
    const int N = A.size();
    int M = 0;
    for (int i=0; i counts(M+1, 0);
    for (int i=0; i dp(S+1, -1);
    dp[0] = 0;
    for (int a=1; a 0) {
            for (int j=0; j= 0) {
                    dp[j] = counts[a];
                } else if ((j >= a) && (dp[j-a] > 0)) {
                    dp[j] = dp[j-a]-1;
                }
            }
        }
    }
    int result = S;
    for (int i =0; i<(S/2+1); i++) {
        if (dp[i] >= 0) {
            result = min(result, S-2*i);
        }
    }
    return result;
}

user_2682142 · Answer

I would like to provide the algorithm and then my implementation in C++. Idea is more or less the same as the official codility solution with some constant optimisation added.

Calculate the maximum absolute element of the inputs.
Calculate the absolute sum of the inputs.
Count the number of occurrence of each number in the inputs. Store the results in a vector hash.
Go through each input.
For each input, goes through all possible sums of any number of inputs. It is a slight constant optimisation to go only up to half of the possible sums.
For each sum that has been made before, set the occurrence count of the current input.
Check for each potential sum equal to or greater than the current input whether this input has already been used before. Update the values at the current sum accordingly. We do not need to check for potential sums less than the current input in this iteration, since it is evident that it has not been used before.
The above nested loop will fill in each possible sum with a value greater than -1.
Go through this possible sum hash again to look for the closest sum to half that is possible to make. Eventually, the min abs sum will be the difference of this from the half multiplied by two as the difference will be added up in both groups as the difference from the median.

The runtime complexity of this algorithm is O(N * max(abs(A)) ^ 2), or simply O(N * M ^ 2). That is because the outer loop is iterating M times and the inner loop is iterating sum times. The sum is basically N * M in worst case. Therefore, it is O(M * N * M).

The space complexity of this solution is O(N * M) because we allocate a hash of N items for the counts and a hash of S items for the sums. S is N * M again.

int solution(vector &A)                                                    
{                                                                               
  int M = 0, S = 0;                                                             
  for (const int e : A) { M = max(abs(e), M); S += abs(e); }                    
  vector counts(M + 1, 0);                                                 
  for (const int e : A) { ++counts[abs(e)]; }                                   
  vector sums(S + 1, -1);                                                  
  sums[0] = 0;                                                                  
  for (int ci = 1; ci < counts.size(); ++ci) {                                  
    if (!counts[ci]) continue;                                                  
    for (int si = 0; si < S / 2 + 1; ++si) {                                    
      if (sums[si] >= 0) sums[si] = counts[ci];                                 
      else if (si >= ci and sums[si - ci] > 0) sums[si] = sums[si - ci] - 1;    
    }                                                                           
  }                                                                             
                                                                                
  int min_abs_sum = S;                                                          
  for (int i = S / 2; i >= 0; --i) if (sums[i] >= 0) return S - 2 * i;          
  return min_abs_sum;                                                           
}

user_8938079 · Answer

Let me add my 50 cent, how to come up with the score 100% solution.

For me it was hard to understand the ultimate solution, proposed earlier in this thread. So I started with warm-up solution with score 63%, because its O(NxNxM), and because it doesn't use the fact that M is quite small value, and there are many duplicates in big arrays

here the key part is to understand how array isSumPossible is filled and interpreted:

how to fill array isSumPossible using numbers in input array:

if isSumPossible[sum] >= 0, i.e. sum is already possible, even without current number, then let's set it's value to 1 - count of current number, that is left unused for this sum, it'll go to our "reserve", so we can use it later for greater sums.
```
        if (isSumPossible[sum] >= 0) {
            isSumPossible[sum] = 1;
        }
```
if isSumPossible[sum] <= 0, i.e. sum is considered not yet possible, with all input numbers considered previously, then let's check maybe smaller sum sum - number is already considered as possible, and we have in "reserve" our current number (isSumPossible[sum - number] == 1), then do following
```
else if (sum >= number && isSumPossible[sum - number] == 1) {
            isSumPossible[sum] = 0;
}
```

here isSumPossible[sum] = 0 means that we have used number in composing sum and it's now considered as possible (>=0), but we have no number in "reserve", because we've used it ( =0)

how to interpret filled array isSumPossible after considering all numbers in input array:

if isSumPossible[sum] >= 0 then the sum is possible, i.e. it can be reached by summation of some numbers in given array
if isSumPossible[sum] < 0 then the sum can't be reached by summation of any numbers in given array

The more simple thing here is to understand why we are searching sums only in interval [0, maxSum/2]: because if find a possible sum, that is very close to maxSum/2, ideal case here if we've found possible sum = maxSum/2, if so, then it's obvious, that we can somehow use the rest numbers in input array to make another maxSum/2, but now with negative sign, so as a result of annihilation we'll get solution = 0, because maxSum/2 + (-1)maxSum/2 = 0. But 0 the best case solution, not always reachable. But we, nevertheless, should seek for the minimal delta = ((maxSum - sum) - sum), so this we seek for delta -> 0, that's why we have this:

    int result = Integer.MAX_VALUE;
    for (int sum = 0; sum < maxSum / 2 + 1; sum++) {
        if (isSumPossible[sum] >= 0) {
            result = Math.min(result, (maxSum - sum) - sum);
        }
    }

warm-up solution

public int solution(int[] A) {
    if (A == null || A.length == 0) {
        return 0;
    }
    if (A.length == 1) {
        return A[0];
    }
    int maxSum = 0;
    for (int i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        maxSum += A[i];
    }
    int[] isSumPossible = new int[maxSum + 1];
    Arrays.fill(isSumPossible, -1);
    isSumPossible[0] = 0;
    for (int number : A) {
        for (int sum = 0; sum < maxSum / 2 + 1; sum++) {
            if (isSumPossible[sum] >= 0) {
                isSumPossible[sum] = 1;
            } else if (sum >= number && isSumPossible[sum - number] == 1) {
                isSumPossible[sum] = 0;
            }
        }
    }
    int result = Integer.MAX_VALUE;
    for (int sum = 0; sum < maxSum / 2 + 1; sum++) {
        if (isSumPossible[sum] >= 0) {
            result = Math.min(result, maxSum - 2 * sum);
        }
    }
    return result;
}

and after this we can optimize it, using the fact that there are many duplicate numbers in big arrays, and we come up with the solution with 100% score, its O(Mx(NxM)), because maxSum = NxM at worst case

public int solution(int[] A) {
    if (A == null || A.length == 0) {
        return 0;
    }
    if (A.length == 1) {
        return A[0];
    }
    int maxNumber = 0;
    int maxSum = 0;
    for (int i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        maxNumber = Math.max(maxNumber, A[i]);
        maxSum += A[i];
    }
    int[] count = new int[maxNumber + 1];
    for (int i = 0; i < A.length; i++) {
        count[A[i]]++;
    }
    int[] isSumPossible = new int[maxSum + 1];
    Arrays.fill(isSumPossible, -1);
    isSumPossible[0] = 0;
    for (int number = 0; number < maxNumber + 1; number++) {
        if (count[number] > 0) {
            for (int sum = 0; sum < maxSum / 2 + 1; sum++) {
                if (isSumPossible[sum] >= 0) {
                    isSumPossible[sum] = count[number];
                } else if (sum >= number && isSumPossible[sum - number] > 0) {
                    isSumPossible[sum] = isSumPossible[sum - number] - 1;
                }
            }
        }
    }
    int result = Integer.MAX_VALUE;
    for (int sum = 0; sum < maxSum / 2 + 1; sum++) {
        if (isSumPossible[sum] >= 0) {
            result = Math.min(result, maxSum - 2 * sum);
        }
    }
    return result;
}

I hope I've made it at least a little clear

Codility MinAbsSum

7 Answers