Largest sum of k elements not larger than m - algorithm

Question

This problem is from a programing competition, and I can't manage to solve it in acceptable time.
You are given an array a of n integers. Find the largest sum s of exactly k elements (not necessarily continuous) that does not exceed a given integer m (s < m).
Constraints:
0 < k <= n < 100
m < 3000
0 < a[i] < 100
Info: A solution is guaranteed to exist for the given input.
Now, I guess my best bet is a DP approach, but couldn't come up with the correct formula.

Answer 1

I would try two things. They are both based on the following idea:
If we can solve the problem of deciding if there are k elements that sum exactly to p, then we can binary search for the answer in [1, m].
1. Optimized bruteforce
Simply sort your array and cut your search short when the current sum exceeds p. The idea is that you will generally only have to backtrack very little, since the sorted array should help eliminate bad solutions early.
To be honest, I doubt this will be fast enough however.
2. A randomized algorithm
Keep a used array of size k. Randomly assign elements to it. While their sum is not p, randomly replace an element with another and make sure to update their sum in constant time.
Keep doing this a maximum of e times (experiment with its value for best results, the complexity will be O(e log m) in the end, so it can probably go quite high), if you couldn't get to sum p during this time, assume that it is not possible.
Alternatively, forget the binary search. Run the randomized algorithm directly and return the largest valid sum it finds in e runs or until your allocated running time ends.
I am not sure how DP would efficiently keep track of the number of elements used in the sum. I think the randomized algorithm is worth a shot since it is easy to implement.

Answer 2

Both of the accepted methods are inferior. Also, this is not a problem type that can be solved by DP.
The following is the correct method illustrated via example:
imagine a = { 2, 3, 5, 9, 11, 14, 17, 23 } (hence n = 8), k = 3, and s = 30
Sort the array a.
Define three pointers into the array, P1, P2, and P3 going from 1 to n. P1 < P2 < P3
Set P3 to a_max (here 23), P1 to 1, and P2 to 2. Calculate the sum s (here 23 + 2 + 3 = 28). If s > S, then decrease P3 by one and try again until you find a solution. If P3 < 3, then there is no solution. Store your first solution as best known solution so far (BKSSF).
Next, increase P2 until s > S. If you find a better solution update BKSSF. Decrease P2 by one.
Next increase P1 until s > S. Update if you find a better solution.
Now go back to P2 and decrease it by one.
Then increase P1 until s > S. etc.
You can see this is a recursive algorithm, in which for every increase or decrease, there is one or more corresponding decreases, increases.
This algorithm will be much, much faster than the attempts above.

Answer 3

for l <= k and r <= s:
V[l][r] = true iff it is possible to choose exactly l elements that sum up to r.
V[0][0] = true
for i in 1..n:
V'[][] - initialize with false
for l in 0..k-1:
for r in 0..s:
if V[l][r] and s + a[i] <= s:
V'[l + 1][r + a[i]] = true
V |= V'
That gives you all achievable sums in O(k * n * s).

Answer 4

I think Tyler Durden had the right idea. But you don't have to sum -all- the elements, and you can basically do it greedily, so you can cut down the loop a lot. In C++:
#include <iostream>
#include <algorithm>
using namespace std;
#define FI(n) for(int i=0;i<(n);i++)
int m, n, k;
int a[] = { 12, 43, 1, 4, 3, 5, 13, 34, 24, 22, 31 },
e[20];
inline int max(int i) { return n-k+i+1; }
void print(int e[], int ii, int sum)
{ cout << sum << '\t';
FI(ii+1) cout << e[i]<<','; cout<<'\n';
}
bool desc(int a, int b) { return a>b; }
int solve()
{ sort(a, a+n, desc);
cout <<"a="; FI(n) cout << a[i]<<','; cout<<"\nsum\tindexes\n";
int i,sum;
i = e[0] = sum = 0;
print (e,i,a[0]);
while(1)
{ while (e[i]<max(i) && sum+a[e[i]]>=m) e[i]++;
if (e[i]==max(i))
{ if (!i) return -1; // FAIL
cout<<"*"; print (e,i,sum);
sum -= a[e[--i]++];
} else // sum+a[e[i]]<m
{ sum += a[e[i]];
print (e,i,sum);
if (i+1==k) return sum;
e[i+1] = e[i]+1;
i++;
}
}
}
int main()
{ n = sizeof(a)/sizeof(int);
k = 3;
m = 39;
cout << "n,k,m="<<n<<' '<<k<<' '<<m<<'\n';
cout << solve();
}
For m=36 it gives the output
n,k,m=11 3 36
a=43,34,31,24,22,13,12,5,4,3,1,
sum indexes
43 0,
34 1,
*34 1,10,
31 2,
35 2,8,
*35 2,8,11,
34 2,9,
35 2,9,10,
35
For m=37 it gives
n,k,m=11 3 37
a=43,34,31,24,22,13,12,5,4,3,1,
sum indexes
43 0,
34 1,
*34 1,10,
31 2,
36 2,7,
*36 2,7,11,
35 2,8,
36 2,8,10,
36
(One last try: for m=39 it also gives the right answer, 38)
Output: the last number is the sum and the line above it has the indexes. Lines with an asterisk are before backtracking, so the last index of the line is one too high. Runtime should be O(k*n).
Sorry for the hard-to-understand code. I can clean it up and provide explanation upon request but I have another project due at the moment ;).