Просчитать количество вариантов представления числа в виде суммы натуральных цифр 1, 2 и 3

#include <iostream>
#include <set>
#include <vector>
 
 
class Decomposition 
{
public:
    Decomposition (int number_, std::vector<int> summand_) : number (number_), summand(summand_) {}
    void calculate ();
    void output ();
 
private:
 
    std::set<std::multiset<unsigned short>> S; // Множество вариантов разложения (исключаются одинаковые разложения).
    bool decomposition (int current, int plus, std::multiset<unsigned short> tmp); // Рекурсивная функция разложения на слагаемые.
    std::vector<int> const summand; // Слагаемые.
    int const number; // Число для разложения.
};
 
 
 
void Decomposition::calculate ()
{
    std::multiset<unsigned short> tmp;
    for (int i = 0; i < summand.size(); i++) 
    decomposition (0, summand[i], tmp);
}
 
 
 
// Рекурсивная функция разложения на слагаемые.
bool Decomposition::decomposition (int current, int plus, std::multiset<unsigned short> tmp)
{
    tmp.insert(plus);
    current += plus;
 
    if (current == number) 
    {
        S.insert(tmp);
        return true;
    }
 
    if (current > number) 
    {
        return false; 
    }
 
 
    for (int i = 0; i < summand.size(); i++) 
    {
        decomposition (current, summand[i], tmp);
    }
    
}
 
 
// Вывод всех комбинаций.
void Decomposition::output ()
{
    for (auto i = S.begin(); i != S.end(); ++i)
    {
        for (auto j = i->begin(); j != i->end(); ++j)
        {
            std::cout << *j << " ";
        }
        std::cout << std::endl;
    }
}
 
 
int main() 
{
    std::vector<int> S;
 
    // Слагаемые.
    S.push_back(1);
    S.push_back(2);
    S.push_back(3);
 
    int const number = 18; // Число для разложения.
 
    Decomposition D (number, S);
 
    D.calculate();
    D.output();
    
 
    system("pause");
    return 0;
}

#include <iostream>
 
int main() {
    auto f = [](int n, int i, const auto& la) -> int {
        auto go = [&la,n](int j, const auto& lago) -> int {
            return j>3 ? 0 : la(n-j,j,la) + lago(j+1,lago);};
        return n<0 ? 0 : n==0 ? 1 : go(i,go);};
    
    int n; std::cin>>n; std::cout<<"without memoization: "<<f(n, 1, f)<<'\n';
}

    int dp[20000][3];
    auto f_dp = [&dp](int n, int i, const auto& la) -> int {
        auto go = [&la,n](int j, const auto& lago) -> int {
            return j>3 ? 0 : la(n-j,j,la) + lago(j+1,lago);};
            
        auto memo = [&]() mutable -> int {
            if (dp[n][i]==0) dp[n][i]=go(i,go); return dp[n][i];};
        
        return n<0 ? 0 : n==0 ? 1 : memo();};
    
    std::cout<<"with memoization = dp: "<<f_dp(n, 1, f_dp)<<'\n';