Not able to figure out the mistake while calculating catlan number - c++

Question

In this code I am calculating the number of unique Binary Search Trees using catlan numbers.
The answer remains correct until input value n=13 from n>=14 the answer turns out to be less by one. Eg. for n=14 my answer is 2674439 while the actual answer is 2674440.
Here is the code.
#include "stdafx.h"
#include "iostream"
using namespace std;
class Solution {
public:
double arr[20000] = {};
double fact(int n) {
if (n == 1 || n == 0)
return 1;
if (arr[n] != 0)
return arr[n];
return arr[n] = ceil(n*fact(n - 1));
}
int numTrees(int n) {
int res = fact(2 * n) / ((fact(n + 1))*fact(n));
return res;
}
};
int main()
{
Solution s;
cout << s.numTrees(14)<<endl;
return 0;
}

Answer 1

One of your intermediate values, 28! requires 98 bits of precision.
A double has 52-53 bits of precision.
The surprising part isn't that there is an error at 14, but rather that there wasn't an error before 14. This is because some effort was taken with double to reduce cumulative error, and you basically got lucky.
In this case, we are doing lots of math with multiplication, and next to none with addition. Working with prime powers is a good move:
struct product {
std::map<std::size_t, std::ptrdiff_t> powers;
product& operator*=( product const& rhs ) {
for (auto&& e:rhs.powers)
powers[e.first] += e.second;
return tidy(*this);
}
product& operator/=( product const& rhs ) {
for (auto&& e:rhs.powers)
powers[e.first] -= e.second;
return tidy(*this);
}
friend product operator*( product lhs, product const& rhs ) {
lhs *= rhs;
return lhs;
}
friend product operator/( product lhs, product const& rhs ) {
lhs /= rhs;
return lhs;
}
// 1/x overload:
friend product operator~( product p ) {
for (auto& e:p.powers)
e.second = -e.second;
return p;
}
product() = default;
product(product const&) = default;
product(product &&) = default;
product& operator=(product const&) = default;
product& operator=(product &&) = default;
product( std::size_t in ); // TODO
bool is_integral() const {
for (auto& e:powers)
if (e.second < 0) return false;
return true;
}
template<class Scalar=std::size_t>
Scalar numerator() const {
Scalar r = 1;
for( auto& e: powers )
for (std::ptrdiff_t i = 0; i < e.second; ++i)
r *= e.first;
return r;
}
template<class Scalar=std::size_t>
Scalar denominator() const {
Scalar r = 1;
for( auto& e: powers )
for (std::ptrdiff_t i = 0; i > e.second; --i)
r *= e.first;
return r;
}
friend product& tidy(product& p) {
for (auto it = p.powers.begin(); it != p.powers.end();) {
if (!it->second)
it = p.powers.erase(it);
else
++it;
}
return p;
}
};
Here is a little factorial engine:
struct factorial_t {
std::vector<product> values;
factorial_t():values(2) {}
product const& operator()( std::size_t in ) {
if (values.size() > in) {
return values[in];
}
values.push_back( (*this)(in-1)*product{in} );
return values.back();
}
};
factorial_t factorial;
which is perfectly precise up to ridiculous values.
numTrees then becomes:
template<class Scalar=std::size_t>
Scalar numTrees(std::size_t n) {
auto res = factorial(2 * n) / ((factorial(n + 1))*factorial(n));
return res.numerator<Scalar>();
}
what is remaining to do is write code that prime factors a std::size_t.
struct factor_t {
std::vector<std::size_t> primes;
factor_t():primes{2,3,5,7,11,13,17} {}
bool make_primes( std::size_t up_to ) {
if ((primes.back()+2) > up_to)
return false;
bool added_prime = false;
for (std::size_t x = primes.back()+2; x < up_to; x += 2) {
bool found = false;
for (auto p:primes)
{
if (p*p > x) break;
if (x%p) continue;
found = true;
break;
}
if (found)
primes.push_back(x);
added_prime = added_prime || found;
}
return added_prime;
}
product operator()( std::size_t in ) {
product r;
for (auto&& prime:primes)
{
while (!(in%prime)) {
r.powers[prime]++;
in /= prime;
}
}
// are there more primes to apply?
if (make_primes(std::sqrt(in)))
{
r *= (*this)(in);
}
else if (in != 1)
{
// in is a prime
r.powers[in]++;
}
return r;
}
};
factor_t factor;
product::product( std::size_t in ):
product(factor(in))
{}
and bob is your uncle.
(amusingly, the product code I wrote "works" accidentally with a 0, as it factor mistakes 0 for a prime, and a product with a positive 0 factor has a .numerator() of 0. If you divide, you end up with a 0 in the denominator, and if they cancel I pretend it never happens. However, in general, don't feed the product class a 0.)

Answer 2

The problem is this function:
int numTrees(int n) {
int res = fact(2 * n) / ((fact(n + 1))*fact(n));
return res;
}
Basically, by converting the double values to int you are losing some precision, and therefore cant come to the correct value. If you change it to double, the problem disappears.
Corrected function:
double numTrees(int n)
{
double res = fact(2 * n) / ((fact(n + 1))*fact(n));
return res;
}