HackerRank "Lucky Numbers"

Great learning for me:
https://www.hackerrank.com/rest/contests/master/challenges/lucky-numbers/hackers/turuthok/download_solution

Basically it is memorized search application. And we follow a discrete strategy: split it into digits and go digit by digit.

Here is my C++ version of the code above, with comments for easier understanding.

#include <iostream>
#include <limits>
#include <vector>
using namespace std;

typedef long long LL;

const int D = ; // max digit count
const int MD = ; // max single digit
const LL MAX = std::numeric_limits<LL>::max();

vector<vector<vector<LL>>> dp(D, vector<vector<LL>>(D*MD + , vector<LL>(D*MD*MD + , -)));
vector<int> hi(D);
vector<bool> isPrime(D*MD*MD + , true);

LL go(int inx, int sd, int ssd, bool limited)
{
    if (inx == D) return isPrime[sd] && isPrime[ssd] ?  : ;

    //    Memorized Search
    LL &ret = dp[inx][sd][ssd];
    if (!limited && ret >= ) return ret; // We only cache unlimited count

    int upper = limited ? hi[inx] : ;
    //    DP: count of current digit = sum of all counts of all previous digits
    LL r = ;
    for (int i = ; i <= upper; i++)
    {
        r += go(inx + , sd + i, ssd + i * i, limited && i == upper);
    }
    if (!limited) ret = r; // We only cache unlimited count
    return r;
}

LL go(LL n)
{
    if (n <= ) return ;

    //    split digits
    for (int i = D - ; i >= ; i--)
    {
        hi[i] = n % ;
        n /= ;
    }

    return go(, , , true);
}

int main()
{
    // sieving
    isPrime[] = isPrime[] = false;
    for (int i = ; i <= D*MD*MD; i++)
        if (isPrime[i])
            for (int j = i * ; j <= D*MD*MD; j += i)    isPrime[j] = false;

    // go
    int t; cin >> t;
    while (t--)
    {
        LL a, b; cin >> a >> b;
        cout << (go(b) - go(a - )) << endl;
    }

    return ;
}