Reducing the time complexity of the code below - c++

Question

The following code is a solution to a problem statement from a contest.
The time constraint given was 1s. The code worked correctly for 5/7 test cases. For the rest cases, the time limit was exceeded.
How can the time complexity for the code below be reduced?
Edit:
The problem statement is defined as return the value of number n or sum of n/2,n/3,n/4 whichever is maximum.
For example, if input is 24
it can be reduced or exchanged for
12+8+6=26
Further, 12 can be reduced to 6+4+3=13.
8 and 6 should not be reduced as it may decrease the value.
So final answer is 13+8+6=27
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#define lli long long int
using namespace std;
lli exchange(lli n){
if(n<12)
return n;
else{
lli sum=0;
sum+=max(n/2,exchange(n/2));
sum+=max(n/3,exchange(n/3));
sum+=max(n/4,exchange(n/4));
return sum;
}
}
int main() {
lli t;
cin>>t;
while(t--){
lli n;
cin>>n;
lli ans;
ans=max(n,exchange(n));
cout<<ans<<endl;
}
return 0;
}

Answer 1

Just trying some ideas out. First, the "true" branch of an if-statement is the branch that the compiler pre-loads instructions on. By making the high-n branch the default, it's a little faster.
EDITED: Some of the other ideas didn't work out (no faster). However, one that is promising is to unroll two levels of the recursion.
exchange(n) = exchange(n/2) + exchange(n/3) + exchange(n/4)
exchange(n/2) = exchange(n/2/2) + exchange(n/3/2) + exchange(n/4/2)
exchange(n/3) = exchange(n/2/3) + exchange(n/3/3) + exchange(n/4/3)
exchange(n/4) = exchange(n/2/4) + exchange(n/3/4) + exchange(n/4/4)
However, these become untrue if n/4 < 12. So we can unroll one full level of recursion and only use the fallback for n < 48. Here's an "opt" version of exchange:
lli exchange_opt(lli n)
{
if (n >= 12 * 4) // for n=48+ none of the terms would trigger n < 12
{
lli sum = 0;
sum += exchange_opt(n / 4);
sum += exchange_opt(n / 6) * 2;
sum += exchange_opt(n / 8) * 2;
sum += exchange_opt(n / 9);
sum += exchange_opt(n / 12) * 2;
sum += exchange_opt(n / 16);
return sum;
}
if (n > 11)
{
lli sum = 0;
sum += exchange_opt(n / 2);
sum += exchange_opt(n / 3);
sum += exchange_opt(n / 4);
return sum;
}
return n;
}
this is 4 times faster on my machine than the default implementation, and the idea is extensible, e.g. you could unroll three levels of recursion, but increase the n-count at which it applies. Here's a version which unrolls three levels of recursion from the base case, and combines like terms to reduce function calls. It's 8 times faster now:
lli exchange_opt(lli n)
{
if (n >= 12 * 4 * 4)
// for n=48+ none of the core terms would trigger n < 12
{
lli sum = 0;
sum += exchange_opt(n / 8);
sum += exchange_opt(n / 12) * 3;
sum += exchange_opt(n / 16) * 3;
sum += exchange_opt(n / 18) * 3;
sum += exchange_opt(n / 24) * 6;
sum += exchange_opt(n / 27);
sum += exchange_opt(n / 32) * 3;
sum += exchange_opt(n / 36) * 3;
sum += exchange_opt(n / 48) * 3;
sum += exchange_opt(n / 64);
return sum;
}
if (n >= 12 * 4)
// for n=48+ none of the core terms would trigger n < 12
{
lli sum = 0;
sum += exchange_opt(n / 4);
sum += exchange_opt(n / 6) * 2;
sum += exchange_opt(n / 8) * 2;
sum += exchange_opt(n / 9);
sum += exchange_opt(n / 12) * 2;
sum += exchange_opt(n / 16);
return sum;
}
if (n >= 12)
{
lli sum = 0;
sum += exchange_opt(n / 2);
sum += exchange_opt(n / 3);
sum += exchange_opt(n / 4);
return sum;
}
return n;
}
BTW for testing, i ran all the numbers from 0 ... 9999 through the system, then added up the time for the OP's original function and my functions, while testing that the results were equal. As this is optimized for large numbers, the results might be even better on very large numbers.
I'm guessing that every level of recursion that's unrolled will roughly double the speed of this algorithm. Instead of computing the unrolling by hand as I have done, it might actually be possible to write a program that outputs the correct equation for the level of unrolling needed. Basically to compute exchange(n) in the minimum time you want to unroll to the nearest level of recursion "k" where n >= 12 * 4^k
But enough of manually unrolling the loop. Here's a recursive function that generates the recursive function to whatever level of unrolling needed. it uses std::vector, std::map so you'll need to include the right headers:
std::vector<std::map<lli, lli>> map1;
map1.push_back(std::map<lli, lli>());
map1[0][2] = 1;
map1[0][3] = 1;
map1[0][4] = 1;
const int unrolled_levels = 20;
for (int level = 1; level < unrolled_levels; ++level)
{
map1.push_back(std::map<lli, lli>());
for (auto i = map1[level - 1].begin(); i != map1[level - 1].end(); ++i)
{
map1[level][(*i).first * 2] += map1[level - 1][(*i).first];
map1[level][(*i).first * 3] += map1[level - 1][(*i).first];
map1[level][(*i).first * 4] += map1[level - 1][(*i).first];
}
}
int level = unrolled_levels - 1;
std::cout << "\tlli exchange_opt(lli n) // unroll" << level << "\n\t{\n\n";
for (int inner_level = level; inner_level >= 0; --inner_level)
{
lli mult = 12;
std::cout << "\t\tif (n >= 12LL ";
for (auto i = 0; i < inner_level; ++i)
{
std::cout << " * 4LL";
mult *= 4LL;
}
std::cout << ") // " << (mult) << "\n\t\t{\n";
std::cout << "\t\t\tlli sum = 0;\n";
for (auto i = map1[inner_level].begin(); i != map1[inner_level].end(); ++i)
{
std::cout << "\t\t\tsum += exchange_opt(n/" << (*i).first << "LL)";
if ((*i).second > 1) std::cout << " * " << (*i).second;
std::cout <<"; \n";
}
std::cout << "\t\t\treturn sum;\n";
std::cout << "\t\t}\n";
}
std::cout << "\t\treturn n;\n";
std::cout << "\n\t}\n\n";
Basically, you set unrolled_levels to whatever you want. Each level unrolls the equation for 4 time bigger numbers. Just be aware that the output function is going to be huge, it tests the number range for n and then proceeds to short-circuit the sub-levels as much as possible. For some higher numbers it works out a partial value and mults by thousands or millions, effective short-circuiting millions of function calls.
Copy and paste the output from this code and use it as the function for calculating exchange(n). For numbers around 1 million, it's 200 times faster than the original formula (0.5% running time). For numbers around 100 million, it took 1/70 of 1% of the original equation, 7000 times faster.
BTW this could be even faster. I haven't gone through and collected terms which are multiplied by like-constants in the same branch.

Answer 2

One of the standard trade-offs in any algorithm is time vs. space; the more memory or disk space you have, the more time you can save, or vice versa. In this case, you need to run within a specific time, but you appear to be allowed to use the full memory of the machine. Therefore, noting that this particular algorithm frequently requests values that it has already calculated, it should be worth saving them all for quick lookup.
Indeed, Python, not often regarded as particularly fast, can calculate 10295 in about a second, though 10300 runs into a maximum recursion depth error if run with an empty result cache:
exchanged = {}
def exchange(n):
if n in exchanged:
value = exchanged[n]
elif n < 12:
exchanged[n] = value = n
else:
exchanged[n] = value = exchange(n//2) + exchange(n//3) + exchange(n//4)
return value
exchange(10**295)
For C++, a static std::map<lli, lli> should work for in place of the exchanged dict. Don't try using an array, though, because you don't need nearly as many values as the largest one calculated; 10295, for example, uses less than 300,000 results.
And yes, the max part can be omitted, because it's handled by the n < 12 check. We can prove this by noting that it would only be necessary if (n-1)/2 + (n-2)/3 + (n-3)/4 < n (accounting for the way integer division throws away the remainder), throwing out all cases above 23; the remaining cases are easy to check by hand, and the largest exception happens to be 11. But that's a minor optimization compared with changing your algorithm from O(n*log(n)) to O(log(n)).