Count sum of a subset of an array without bruteforcing it - c++

Question

I'll start by explaining step by step what I have to do. First I make an array containing N prime numbers that I create like this:
bool isPrime(int n) {
if(n <= 1) return false;
for(int i = 2; i * i <= n; i++)
if(n % i == 0) return false;
return true;
}
int p[n + d], j = 0;
for(int i = 0; j < n + d; i++) {
if(isPrime(i)) {
p[j] = i;
j++;
}
}
I then create a target array Q that I'm going to be using for the calculations:
int q[n];
for(int i = 0; i < n; i++) {
q[i] = p[i] * p[i + d];
}
Now that I have the traget array Q[N] I need to count how many times this equation is true A + B + C + D = E, where {A, B, C, D, E} are items from the array Q and A <= B <= C <= D. I tried this solution, but it's bruteforcing it and for bigger numbers it just takes minutes to calculate, which is not what I want.
int amount = 0;
for(int i = 1; i < n; i++) {
for(int j = i - 1; j >= 0; j--) {
for(int k = j; k >= 0; k--) {
for(int l = k; l >= 0; l--) {
for(int m = l; m >= 0; m--) {
if(q[j] + q[k] + q[l] + q[m] == q[i])
amount++;
}
}
}
}
}
cout << amount << endl;
For example if I input 15 for N and 1 for D the output should be 2 because:
6 + 15 + 323 + 323 = 667
6 + 143 + 221 + 1147 = 1517
But the code has to be optimized enough to calculate fast for N and D up to 2500.

Answer 1

To optimize this you have to invest your mathematical knowledge.
You should start from calculating prime using Sieve of Eratosthenes or some better algorithm.
Then note that all your q but first must be odd. All primes except 2 are odd and all their multiplication is odd too. As a result only first item in q is even.
Why this is important? Your sum has even number of elements, so to be able to have odd outcome which could match E in q, A must be equal to first element of q since it only even value in q.
So you have only 3 free parameters: B, C and D and E can be calculated and check if it exists.
You can iterate over B, C, D and then binary search for E in q. This will gives algorithm with complexity O(n^3 log n) which is great comparing to your O(n^5).
You can use unordered_set to match E in O(1) time instead of O(log n) time. So final algorithm easily ca be O(n^3).
I'm quite sure you can find this kind tricks more effectively. Possibly knowledge of d value could be used in some way to avoid some iterations.

Answer 2

I have one trick to improve #MarekR's answer from time O(n^3) to O(n^2 log(n)). (Unfortunately it also needs O(n^2) memory.)
As noted, A has to be the first element. So we just have to find the other four elements.
Now here is the trick. Generate one array of tuples (B+C, B, C) with B < C. And another array of tuples (E-D, E, D) with D < E. Sort both arrays. Now walk them in parallel, looking to match up cases where A + B+C = E-D. Filter out the cases where D <= C and voila!
Generating the arrays is O(n^2). Sorting them is O(n^2 * log(n)). Walking them in parallel and grouping by value is O(n^2). Processing a group of matches with m1 entries in the first array and m2 in the second is O(m1 * m2). You are generating extra matches per answer, but given how few answers there are, I believe that this is negligible. Which makes it O(n^2 log(n)).

Answer 3

Code can do better than O(n^3)
Use math knowledge.
For A+B+C+D=E as prime to be true, consider the case where A+B+C+D are all odd. In that case, the sum E of 4 odd numbers is an even. Since the only even prime is 2 and sum of 4 odd primes is more than 2, A,B,C,D can not be all odds. Thus A==2.
Form an array BC containing all combinations of [0...N)[B..N) and 3 items: B, C, Sum B+C. Sort by the Sum. O(N * N * log(N)). I suspect the sorted list can be formed perhaps even closer to O(N * N), given the initial list of primes is itself ordered. Hmmm.
Form an array DE in similar fashion with the difference of E-D.
Walk array BC and then walk DE in the reverse direction looking for A+B+C+D=E.
Estimate O(N * N)* log(N)) after prime table made.
For prime, use Sieve of Eratosthenes