Partitioning an array into 3 sets

Question

Given an array of integers , Partition the array into 3 sets such that sum of the elements of the 3 sets are as close as possible.

My method is as follows:

Sort the array in the decreasing order
Insert the element into that set whose sum is minimum.

sort(a, a+n);
int o = 0, tw = 0, th = 0;

while(n--)
{
  if (o <= tw && o <= th)
    o += a[n];
  else if (tw <= o && tw <= th)
    tw += a[n];
  else 
    th += a[n];
}

Can anyone tell me What is wrong with my solution ? Or can advice a better Solution

What makes you think something is wrong with your solution? Or, for that matter, what makes you think this is a good solution at all? — Jon Kiparsky, Dec 29 '14 at 18:52
I am not getting the desired output, and plus i want the algorithm for positive integers first. — Monel Gupta, Dec 29 '14 at 19:02
@MonelGupta, try to explain what "desired output" is exactly. Please provide input and the (undesired) output. — Bart Kiers, Dec 29 '14 at 19:06
array is [3,4,1,3] first set is {3},second set is {3,1},third set is {4}. — Monel Gupta, Dec 29 '14 at 19:11
if you implement brute-force solution you can easily find that your heuristic is wrong and you cannot "fix" it, you need to find another algorithm, but I'm not sure that it exists — Iłya Bursov, Dec 29 '14 at 19:31
@MonelGupta Your algorithm fails on {5,5,3,3,2,2,2,2} which should be partinioned as {5,3}, {5,3}, {2,2,2,2}. — Degustaf, Dec 30 '14 at 13:53

score 0 · Accepted Answer · answered Dec 29 '14 at 19:54

here is brute-force java solution you can use, note - complexity of this solution is O(3^N), which is very very slow

/**
 * Returns absolute difference between 3 values in array
 */
static int getdiff(final int s[])
{
    return Math.abs(s[0] - s[1]) + Math.abs(s[1] - s[2]) + Math.abs(s[2] - s[0]);
}

/**
 * Calculates all possible sums and returns one where difference is minimal
 */
static int[] getsums(final int a[], final int idx, final int[] s)
{
    // no elements can be added to array, return original
    if (idx >= a.length)
        return s;

    // calculate 3 different outcomes
    final int[] s1 = getsums(a, idx + 1, new int[] {s[0] + a[idx], s[1], s[2]});
    final int[] s2 = getsums(a, idx + 1, new int[] {s[0], s[1] + a[idx], s[2]});
    final int[] s3 = getsums(a, idx + 1, new int[] {s[0], s[1], s[2] + a[idx]});

    // calculate difference
    final int d1 = getdiff(s1);
    final int d2 = getdiff(s2);
    final int d3 = getdiff(s3);

    if ((d1 <= d2) && (d1 <= d3))
        return s1;
    else if ((d2 <= d1) && (d2 <= d3))
        return s2;
    else
        return s3;
}

static int[] getsums(final int a[])
{
    return getsums(a, 0, new int[] {0, 0, 0});
}

static void printa(final int a[])
{
    System.out.print("[");
    for (final int t : a)
        System.out.print(t + ",");
    System.out.println("]");
}

static public void main(final String[] args)
{
    final int a[] = new int[] {23, 6, 57, 35, 33, 15, 26, 12, 9, 61, 42, 27};

    final int[] c = getsums(a);

    printa(a);
    printa(c);
}

sample output:

[23,6,57,35,33,15,26,12,9,61,42,27,]
[115,116,115,]

I think there will be a Dynamic Programming Solution for this. — Monel Gupta, Dec 29 '14 at 19:59
@MonelGupta no, it is NP complete problem http://en.wikipedia.org/wiki/Partition_problem and http://en.wikipedia.org/wiki/3-partition_problem — Iłya Bursov, Dec 29 '14 at 20:47

Partitioning an array into 3 sets

1 Answers1