Алгоритм быстрого извлечения корня (длинная арифметика)

#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>
 
using namespace std;
 
typedef vector<int> NUMBER;
typedef char* CHRS;
const int base = 1000*1000*1000;
 
//============_INPUT/OUTPUT_FUNCTIONS_============
void SCANA(CHRS &str, NUMBER &A)
{
    cin >> str;
    A.clear();
    for (int i=(int)strlen(str); i>0; i-=9) 
    {
        str[i] = 0;
        A.push_back(atoi(i>=9 ? str+i-9 : str));
    }
}
//------------------------------------------------
void PRINTA(const NUMBER G)
{
    cout << setfill(' ') << (G.empty() ? 0 : G.back());
    for (int i=(int)G.size()-2; i>=0; --i)
        cout << setw(9) << setfill('0') << G[i];
}
 
//============_MATH_ALGO_FUNCTIONS_============
NUMBER Summation(const NUMBER X,const NUMBER B)
{
    int Remainder = 0;
    NUMBER A=X;
    for (size_t i=0; i<max(A.size(),B.size()) || Remainder; ++i) 
    {
        if (i == A.size())
            A.push_back (0);
        A[i] += Remainder + (i < B.size() ? B[i] : 0);
        Remainder = A[i] >= base;
        if (Remainder)
            A[i] -= base;
    }
    return A;
}
//------------------------------------------------
NUMBER Division(const NUMBER X,const int B)
{
    int Remainder=0;
    NUMBER A=X;
    for (int i=(int)A.size()-1; i>=0; --i) 
    {
        long long Q = A[i] + Remainder * 1ll * base;
        A[i] = int (Q / B);
        Remainder = int (Q % B);
    }
    while (A.size() > 1 && A.back() == 0)
        A.pop_back();
    return A;
}
//------------------------------------------------
NUMBER Multiplication(const NUMBER A,const NUMBER B)
{
    int Remainder=0;
    NUMBER C;
    C.resize(A.size()+B.size());
    for (size_t i=0; i<A.size(); ++i)
        for (int j=0, Remainder=0; j<(int)B.size() || Remainder; ++j)
        {
            long long Q = C[i+j] + A[i] * 1ll * (j < (int)B.size() ? B[j] : 0) + Remainder;
            C[i+j] = int (Q % base);
            Remainder = int (Q / base);
        }
    while (C.size() > 1 && C.back() == 0)
        C.pop_back();
    return C;
}
//------------------------------------------------
NUMBER RaiseToPower(const NUMBER A,const int N)
{
    NUMBER C=A;
    for(int i=1;i<N;i++)
        C=Multiplication(C,A);
    return C;
}
//------------------------------------------------
bool Bigger(const NUMBER A,const NUMBER B)
{
    if(A.size()<B.size())
    {
        return false;
    }
    else
        if(A.size()>B.size())
        {
            return true;
        }
        else
        {
            for(size_t i=A.size()-1;i>=0;i--)
            {
                if(A[i]>B[i])
                    return true;
                else
                    if(A[i]<B[i])
                        return false;
                    else
                        continue;
            }
        }
    return false;
}
//------------------------------------------------
bool Bigger(const NUMBER A,const int B)
{
    if(A[A.size()-1]>B)
    {
        return true;
    }
    else
    {
        return A.size()>1;
    }
}
//------------------------------------------------
NUMBER SubtractionOfEndpoints(const NUMBER A,const NUMBER B)
{
    NUMBER X;
    int Remainder = 0;
    if(Bigger(A,B))
    {
        X=A;
        for (size_t i=0; i<B.size() || Remainder; ++i) 
        {
            X[i] -= Remainder + (i < B.size() ? B[i] : 0);
            Remainder = X[i] < 0;
            if (Remainder)
                X[i] += base;
        }
        while (X.size() > 1 && X.back() == 0)
            X.pop_back();
    }
    else
    {
        X=B;
        for (size_t i=0; i<A.size() || Remainder; ++i) 
        {
            X[i] -= Remainder + (i < A.size() ? A[i] : 0);
            Remainder = X[i] < 0;
            if (Remainder)
                X[i] += base;
        }
        while (X.size() > 1 && X.back() == 0)
            X.pop_back();
    }
    return X;
}
//------------------------------------------------
NUMBER Root(const NUMBER Value,const int N)
{
    if(N==1)
        return Value;
    NUMBER Left,Right,Base,Tmp,SUB;
    Left.push_back(0);
    Right=Value;
    SUB=Value;
    Base.push_back(1);
    if(Bigger(Base,Value))
        return Value;
    while(Bigger(SUB,1))
    {
        Tmp=Summation(Left,Right);
        Tmp=Division(Tmp,2);
        Base=Tmp;
        SUB=SubtractionOfEndpoints(Right,Left);
 
        Tmp=RaiseToPower(Base,N);
    
        if(Tmp==Value)
        {
            return Base;
        }
        else
            if(Bigger(Tmp,Value))
            {
                Right=Base;
            }
            else
            {
                Left=Base;
            }
    }
    if(Bigger(RaiseToPower(Right,N),Value))
        Base=Left;
    else
        Base=Right;
    return Base;    
}
//=======================================================   
 
//============_MAIN_PART_============
 
int main(void)
{
    std::ios::sync_with_stdio(false);
    
    ifstream fin("input.txt");
    cin.rdbuf(fin.rdbuf());
    
    ofstream fout("output.txt");
    cout.rdbuf(fout.rdbuf());   
    
//  ifstream test_fin("T2.txt");
//  cin.rdbuf(test_fin.rdbuf());
 
    int N,M;
    NUMBER A,SUM,DIVSUM,PROD,P;
    CHRS str = new char[100];
    
//================================================================  
    
    cin >> N;
    PROD.push_back(1);
    for(int it_n=1;it_n<=N;it_n++)
    {
        cin >> M;
        SCANA(str,A);
        SUM=A;
        for(int it_m=1;it_m<M;it_m++)
        {
            SCANA(str,A);
            SUM=Summation(SUM,A);
        }
 
        DIVSUM=Division(SUM,M);
        PROD=Multiplication(DIVSUM,PROD);
    }
    P=Root(PROD,N);
    PRINTA(P);
    
//================================================================  
 
    delete[] str;
    return 0;
}

if(n>1)

if(n>1)
  throw std::invalid_argument(std::string("'n>1' with n = ")+std::to_string(n));

std::pow(x,n_1)