最大总和

Question

Here is example of my input data:
5 // Number of 1D arrays, in this case we'll have array[5][3] 1 2 3 // Values of array[i][0..2] 1 1 1 1 0 0 1 1 0 2 1 0

And output is:
12 // Maximum sum ({1 2 3} + {1 1 1} + {2 1 0} = {4 4 4} = 12) - END SUM VALUES MUST BE EQUAL(4 4 4). 3 // Number of arrays used to get this sum

The problem is to find maximum sum using n arrays, and secod condition is to use minimum number of arrays. Also if sum > 300 we stop algorithm. (300 is maximum). Here is my code, it's I get good answers but it's time complexity is O(2^n-1). I'm thinking that it's possible to save results in some way and don't calculate same things many times, but I don't know how yet.

public static int[] fuel(int start, int[] sum, int counter) {
    int[] val = { sum[0] + crystal[start][0], sum[1] + crystal[start][1], sum[2] + crystal[start][2] };
    int newSum = val[0] + val[1] + val[2];

    if(newSum > 300) 
        return null;

    if(val[0] == val[1] && val[1] == val[2]) { // All 3 values have to be equal!
        if(newSum > result[0]) {
            result[0] = newSum;
            result[1] = counter;
        } else if(newSum == result[0] && result[1] > counter) {
            result[1] = counter;
        }
    }

    if(start + 1 < crystalNumber) {
        fuel(start + 1, val, counter + 1);
        fuel(start + 1, sum, counter);
    }

    return result;
}

Answer 1

This may not be the best algorithm to solve this but it should be quicker than O(2^N).

The idea is to record all reachable sums as you loop through the input array. You can use a dictionary whose key is a unique hash of the possible sums, for the sake of simplicity let's just assume the key is a string which concatenates the three sums, for example, the sums [3,5,4] we'll use the key "003005004" , the value of the dictionary will be the minimum numbers of arrays to reach that sum.

So in your case:

1 2 3 => [001002003] =1
1 1 1 => [001001001] =1, [002003004]=2  (itself and use [001002003] from above)
1 0 0 => [001000000] =1, [002002003] =2, [002001001] =2, [003003004] =3
1 1 0 ...
2 1 0 ...

In the end, you will find [004004004] =3 and that's your answer.

This may seems going through all combinations as well so why it's quicker, it's because the maximum sum is 300 for each number, so in the very worst case, we may have 301^3 keys filled and have to update their values for each new input array. This is however still O(n) and despite of the large constant, it should still run much faster than O(2^n). (If you solve 300^3*n = 2^n, n is around 30-ish)

A simple hash function would be a*301*301+b*301+c

Answer 2

I think the problem is given m 1-D arrays and a number n , find the maximum sum using n arrays from m ;

The solution looks straight forward. keep sum of each 1-D array in a separate array, say sum[]

1 2 3 = 6
1 1 1 = 3
1 0 0 = 1
1 1 0 = 2
2 1 0 = 3

Sort this array sum

6,3,3,2,1

and return the sum of first n elements of this array.