Better algorithm to calculate this formula - algorithm

Question

Given an array of positive integers A, I want to find the following sum S:
S = 2^1 * (S_1) + 2^2 * (S_2) + 2^3 * (S_3) + ... + 2^n * (S_N)
where S_i is sum of product of consecutive i integers in A, for eg:
S_3 = (A[0]*A[1]*A[2]) + (A[1]*A[2]*A[3]) + .... + (A[n-3]*A[n-2]*A[n-1])
For calculating any of the S_i, I am using method similar to rolling hash, which achieve O(N):
Let tmp = A[0]*A[1]*A[2], S_3 = tmp;
For(i = 3 to n)
(tmp *= A[i]) /= A[i-3]
S_3 += tmp
And for all two's power I can precompute beforehand. So now my algorithm to calculate S is O(N^2)
My question is, is it possible to calculate S with a better complexity?

Answer 1

There is a recurrence pattern you could use for calculating a solution with a linear time complexity.
Consider an example input:
A = [2, 5, 3, 2, 1, 8]
Now look at the partial array with only the first element:
A0 = [2]
Call the outcome for this partial array R0. It is clear that:
R0 = 2⋅A[0] = 2⋅2 = 4
Then consider the array with one more value from the original array:
A1 = [2, 5]
Call the outcome for this partial array R1. We calculate that:
R1 = 2⋅(A[0]+A[1]) + 4⋅(A[0]⋅A[1]) = 54
We can try to write this in terms of R0, hoping we can thus limit the number of calculations to make:
R1 = 2⋅(2⋅A[0] + 1)⋅A[1] + R0
Extending again with a third element, we get:
R2 = 2⋅(A[0]+A[1]+A[2]) + 4⋅(A[0]⋅A[1] + A[1]⋅A[2]) + 8⋅(A[0]⋅A[1]⋅A[2]) = 360
Let's try to write this in terms of R1:
R2 = 2⋅(2⋅(2⋅A[0] + 1)⋅A[1] + 1)⋅A[2] + R1
There is a pattern emerging, where the first term looks much like the first term in the previous R. It is something like 2⋅(X + 1)⋅A[2], where X is the first term of the previous R. We can generally say:
Rn = 2⋅(Rn-1 − Rn-2 + 1)⋅A[n] + Rn-1
...where Rn is 0 when n < 0.
Now that is something that can be calculated in linear time. Here is an implementation in JavaScript, which also includes a second function that does the calculation in the naive, non-optimised way, so that the result can be compared:
function fastCalcS(a) {
let r0, r1, r2;
r1 = r2 = 0;
for (let i = 0; i < a.length; i++) {
r0 = r1;
r1 = r2;
r2 = 2*(r1 - r0 + 1)*a[i] + r1;
}
return r2;
}
// This function does it the slow way, and executes
// the literal definition of S without optimisation:
function slowCalcS(a) {
let coeff = 2;
let s = 0
for (let i = 0; i < a.length; i++) {
let s_i = 0;
for (let j = 0; j < a.length-i; j++) {
let prod = 1;
for (let k = 0; k <= i; k++) {
prod *= a[j+k];
}
s_i += prod;
}
s += coeff * s_i;
coeff *= 2;
}
return s;
}
var a = [2, 5, 3, 2, 1, 8];
console.log('slow way:', slowCalcS(a));
console.log('fast way:', fastCalcS(a));
In languages that provide a reduce array method (as JavaScript does), the function can look like this (ES6 syntax):
function fastCalcS(a) {
return a.reduce( ([r1, r2], v) => [r2, 2*(r2 - r1 + 1)*v + r2], [0, 0] )[1];
}
var a = [2, 5, 3, 2, 1, 8];
console.log(fastCalcS(a));

Answer 2

A very similar approach to trincot, but starting at the other end leads to another linear algorithm.
If we had just the array {A[n-1]} then the sum would be:
T[n-1] = 2*A[n-1]
If we then try { A[n-2], A[n-1]} we get
T[n-2] = 2*A[n-2] + 2*A[n-1] + 4*A[n-2]*A[n-1]
= T[n-1] + 2*A[n-2]*( 1 + 2*A[n-1])
Continuing this way we get the recursions
T[n-k] = T[n-k+1] + 2*A[n-k]* K[n-k+1]
K[n-k] = 1 + 2*A[n-k]*K[n-k+1]
In C
int64_t sum( int64_t n, const int64_t* A)
{
int64_t K = 1;
int64_t T = 0;
int64_t i = n;
while( --i >= 0)
{ T += 2*K*A[i];
K = 1 + 2*A[i]*K;
}
return T;
}