Is it theoretical or practical question?

For practical reasons, this should not bother you. For all reasonable values of $$$n \le 10^{18}$$$, $$$\alpha(n) \le 4$$$ (could be easily calculated, using the recurrence from wikipedia). You can put $$$B = \sqrt{n}$$$, or, if you want to achieve the optimal time, then you need to benchmark the code to get know, which parts of it are more fast and which are more slow to adjust the constant $$$B$$$ properly. It will be somewhere near $$$\sqrt{n}$$$, but could easily be $$$5$$$ times less than it, or $$$5$$$ times greater — all depends on the constant factors.

For theoretical reasons, it is easy to calculate the inverse Ackerman function say in $$$\mathcal{O}(n)$$$. You just need to follow the recurrence, and stop the calculations, once the values are too big. The following is a sketch of the solution, though you need to be careful with big integers and overflowing.

fun inverse_ackerman(int n) {
    int k = sqrt(n) + 10; // I am sure that inverse ackerman of n is less than k 
    int a[k][k] = {n + 1, n + 1, ...}; // n + 1 stands for infinity: any number greater than n
    for m = 0..k:
        for n = 0..k:
            if m == 0: a[m][n] = n + 1;
            else if n == 0: a[m][n] = a[m - 1][n + 1];
            else if (a[m][n - 1] < k) a[m][n] = a[m - 1][a[m][n - 1]];
    for x = 0..k: if a[x][x] >= n: return x;

The Ackerman function grows so fast that it should be not so hard to prove that the code above produces correct answer, though it doesn't calculates all of the required values.