Strassen（百度之星，大整数模板）

Strassen Accepts: 567 Submissions: 7005
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Problem Description
在本题中，我们只有两种方法计算两个n\times nn×n的矩阵的乘积，第一种为定义法，需要n^3n
​3
​​ 次乘法和(n-1)n^2(n−1)n
​2
​​ 次加法。第二种为Strassen分治法，仅当nn为偶数时可以使用，需要18(n/2)^218(n/2)
​2
​​ 次加法以及再计算77次大小为(n/2)\times(n/2)(n/2)×(n/2)的矩阵的乘积。这77次更小矩阵的乘积也可以选择两种方法之一计算。现假设计算机计算一次加法需要aa单位时间，计算一次乘法需要bb单位时间，其他任何操作不花费时间，问计算两个n\times nn×n的矩阵的乘积至少需要多少时间。输出答案模10^9+710
​9
​​ +7的余数。

Input
第一行一个正整数tt表示数据组数（1\le t \le 201≤t≤20）。 每组数据包含一行三个正整数nn，aa，bb（1\le n\le 2^{32}1≤n≤2
​32
​​ ，nn是22的幂，1\le a\le 10^91≤a≤10
​9
​​ ，1\le b\le 10^91≤b≤10
​9
​​ ）。

Output
每组数据输出一行，包含一个整数表示答案模10^9+710
​9
​​ +7的余数。

Sample Input
1
16 1 1
Sample Output
7872

大整数类真好用！
模板来自：https://www.cnblogs.com/zhgyki/p/9579367.html

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

class DividedByZeroException {};

class BigInteger {
private:
    vector<char> digits;
    bool sign;          //  true for positive, false for negitive
    void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)
public:
    BigInteger(int);    // construct with a int integer
    BigInteger(string&) ;
    BigInteger();
    BigInteger(const BigInteger&);
    BigInteger operator=(const BigInteger& op2);
    
    BigInteger    abs() const;
    BigInteger    pow(int a);
    
    //binary operators
    
    friend BigInteger operator+=(BigInteger&, const BigInteger&);
    friend BigInteger operator-=(BigInteger&, const BigInteger&);
    friend BigInteger operator*=(BigInteger&, const BigInteger&);
    friend BigInteger operator/=(BigInteger&, const BigInteger&) throw(DividedByZeroException);
    friend BigInteger operator%=(BigInteger&, const BigInteger&) throw(DividedByZeroException);
    
    friend BigInteger operator+(const BigInteger&, const BigInteger&);
    friend BigInteger operator-(const BigInteger&, const BigInteger&);
    friend BigInteger operator*(const BigInteger&, const BigInteger&);
    friend BigInteger operator/(const BigInteger&, const BigInteger&) throw(DividedByZeroException);
    friend BigInteger operator%(const BigInteger&, const BigInteger&) throw(DividedByZeroException);
    
    
    //uniary operators
    friend BigInteger operator-(const BigInteger&);   //negative
    
    friend BigInteger operator++(BigInteger&);        //++v
    friend BigInteger operator++(BigInteger&, int);   //v++
    friend BigInteger operator--(BigInteger&);        //--v
    friend BigInteger operator--(BigInteger&, int);   //v--
    
    friend bool operator>(const BigInteger&, const BigInteger&);
    friend bool operator<(const BigInteger&, const BigInteger&);
    friend bool operator==(const BigInteger&, const BigInteger&);
    friend bool operator!=(const BigInteger&, const BigInteger&);
    friend bool operator>=(const BigInteger&, const BigInteger&);
    friend bool operator<=(const BigInteger&, const BigInteger&);
    
    friend ostream& operator<<(ostream&, const BigInteger&);   //print the BigInteger
    friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger
    
public:
    static const BigInteger ZERO;
    static const BigInteger ONE;
    static const BigInteger TEN;
};
const BigInteger BigInteger::ZERO = BigInteger(0);
const BigInteger BigInteger::ONE = BigInteger(1);
const BigInteger BigInteger::TEN = BigInteger(10);


BigInteger::BigInteger() {
    sign = true;
}


BigInteger::BigInteger(int val) { // construct with a int integer
    if (val >= 0) {
        sign = true;
    }
    
    else {
        sign = false;
        val *= (-1);
    }
    
    do {
        digits.push_back((char)(val % 10));
        val /= 10;
    } while (val != 0);
}


BigInteger::BigInteger(string& def) {
    sign = true;
    
    for (string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++) {
        char ch = (*iter);
        
        if (iter == def.rend() - 1) {
            if (ch == '+') {
                break;
            }
            
            if (ch == '-') {
                sign = false;
                break;
            }
        }
        
        digits.push_back((char)((*iter) - '0'));
    }
    
    trim();
}

void BigInteger::trim() {
    vector<char>::reverse_iterator iter = digits.rbegin();
    
    while (!digits.empty() && (*iter) == 0) {
        digits.pop_back();
        iter = digits.rbegin();
    }
    
    if (digits.size() == 0) {
        sign = true;
        digits.push_back(0);
    }
}


BigInteger::BigInteger(const BigInteger& op2) {
    sign = op2.sign;
    digits = op2.digits;
}


BigInteger BigInteger::operator=(const BigInteger& op2) {
    digits = op2.digits;
    sign = op2.sign;
    return (*this);
}


BigInteger BigInteger::abs() const {
    if (sign) {
        return *this;
    }
    
    else {
        return -(*this);
    }
}

BigInteger BigInteger::pow(int a) {
    BigInteger res(1);
    
    for (int i = 0; i < a; i++) {
        res *= (*this);
    }
    
    return res;
}

//binary operators
BigInteger operator+=(BigInteger& op1, const BigInteger& op2) {
    if (op1.sign == op2.sign) {     //只处理相同的符号的情况，异号的情况给-处理
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
        char to_add = 0;        //进位
        
        while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
            (*iter1) = (*iter1) + (*iter2) + to_add;
            to_add = ((*iter1) > 9);    // 大于9进一位
            (*iter1) = (*iter1) % 10;
            iter1++;
            iter2++;
        }
        
        while (iter1 != op1.digits.end()) {    //
            (*iter1) = (*iter1) + to_add;
            to_add = ((*iter1) > 9);
            (*iter1) %= 10;
            iter1++;
        }
        
        while (iter2 != op2.digits.end()) {
            char val = (*iter2) + to_add;
            to_add = (val > 9) ;
            val %= 10;
            op1.digits.push_back(val);
            iter2++;
        }
        
        if (to_add != 0) {
            op1.digits.push_back(to_add);
        }
        
        return op1;
    }
    
    else {
        if (op1.sign) {
            return op1 -= (-op2);
        }
        
        else {
            return op1 = op2 - (-op1);
        }
    }
    
}

BigInteger operator-=(BigInteger& op1, const BigInteger& op2) {
    if (op1.sign == op2.sign) {     //只处理相同的符号的情况，异号的情况给+处理
        if (op1.sign) {
            if (op1 < op2) { // 2 - 3
                return  op1 = -(op2 - op1);
            }
        }
        
        else {
            if (-op1 > -op2) { // (-3)-(-2) = -(3 - 2)
                return op1 = -((-op1) - (-op2));
            }
            
            else {           // (-2)-(-3) = 3 - 2
                return op1 = (-op2) - (-op1);
            }
        }
        
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
        
        char to_substract = 0;  //借位
        
        while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
            (*iter1) = (*iter1) - (*iter2) - to_substract;
            to_substract = 0;
            
            if ((*iter1) < 0) {
                to_substract = 1;
                (*iter1) += 10;
            }
            
            iter1++;
            iter2++;
        }
        
        while (iter1 != op1.digits.end()) {
            (*iter1) = (*iter1) - to_substract;
            to_substract = 0;
            
            if ((*iter1) < 0) {
                to_substract = 1;
                (*iter1) += 10;
            }
            
            else {
                break;
            }
            
            iter1++;
        }
        
        op1.trim();
        return op1;
    }
    
    else {
        if (op1 > BigInteger::ZERO) {
            return op1 += (-op2);
        }
        
        else {
            return op1 = -(op2 + (-op1));
        }
    }
}
BigInteger operator*=(BigInteger& op1, const BigInteger& op2) {
    BigInteger result(0);
    
    if (op1 == BigInteger::ZERO || op2 == BigInteger::ZERO) {
        result = BigInteger::ZERO;
    }
    
    else {
        vector<char>::const_iterator iter2 = op2.digits.begin();
        
        while (iter2 != op2.digits.end()) {
            if (*iter2 != 0) {
                deque<char> temp(op1.digits.begin(), op1.digits.end());
                char to_add = 0;
                deque<char>::iterator iter1 = temp.begin();
                
                while (iter1 != temp.end()) {
                    (*iter1) *= (*iter2);
                    (*iter1) += to_add;
                    to_add = (*iter1) / 10;
                    (*iter1) %= 10;
                    iter1++;
                }
                
                if (to_add != 0) {
                    temp.push_back(to_add);
                }
                
                int num_of_zeros = iter2 - op2.digits.begin();
                
                while (num_of_zeros--) {
                    temp.push_front(0);
                }
                
                BigInteger temp2;
                temp2.digits.insert(temp2.digits.end(), temp.begin(), temp.end());
                temp2.trim();
                result = result + temp2;
            }
            
            iter2++;
        }
        
        result.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
    }
    
    op1 = result;
    return op1;
}

BigInteger operator/=(BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
    if (op2 == BigInteger::ZERO) {
        throw DividedByZeroException();
    }
    
    BigInteger t1 = op1.abs(), t2 = op2.abs();
    
    if (t1 < t2) {
        op1 = BigInteger::ZERO;
        return op1;
    }
    
    //现在 t1 > t2 > 0
    //只需将 t1/t2的结果交给result就可以了
    deque<char> temp;
    vector<char>::reverse_iterator iter = t1.digits.rbegin();
    
    BigInteger temp2(0);
    
    while (iter != t1.digits.rend()) {
        temp2 = temp2 * BigInteger::TEN + BigInteger((int)(*iter));
        char s = 0;
        
        while (temp2 >= t2) {
            temp2 = temp2 - t2;
            s = s + 1;
        }
        
        temp.push_front(s);
        iter++;
    }
    
    op1.digits.clear();
    op1.digits.insert(op1.digits.end(), temp.begin(), temp.end());
    op1.trim();
    op1.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
    return op1;
}

BigInteger operator%=(BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
    return op1 -= ((op1 / op2) * op2);
}

BigInteger operator+(const BigInteger& op1, const BigInteger& op2) {
    BigInteger temp(op1);
    temp += op2;
    return temp;
}
BigInteger operator-(const BigInteger& op1, const BigInteger& op2) {
    BigInteger temp(op1);
    temp -= op2;
    return temp;
}

BigInteger operator*(const BigInteger& op1, const BigInteger& op2) {
    BigInteger temp(op1);
    temp *= op2;
    return temp;
    
}

BigInteger operator/(const BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp /= op2;
    return temp;
}

BigInteger operator%(const BigInteger& op1, const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp %= op2;
    return temp;
}

//uniary operators
BigInteger operator-(const BigInteger& op) {  //negative
    BigInteger temp = BigInteger(op);
    temp.sign = !temp.sign;
    return temp;
}

BigInteger operator++(BigInteger& op) {   //++v
    op += BigInteger::ONE;
    return op;
}

BigInteger operator++(BigInteger& op, int x) { //v++
    BigInteger temp(op);
    ++op;
    return temp;
}

BigInteger operator--(BigInteger& op) {   //--v
    op -=  BigInteger::ONE;
    return op;
}

BigInteger operator--(BigInteger& op, int x) { //v--
    BigInteger temp(op);
    --op;
    return temp;
}

bool operator<(const BigInteger& op1, const BigInteger& op2) {
    if (op1.sign != op2.sign) {
        return !op1.sign;
    }
    
    else {
        if (op1.digits.size() != op2.digits.size())
            return (op1.sign && op1.digits.size() < op2.digits.size())
            || (!op1.sign && op1.digits.size() > op2.digits.size());
        
        vector<char>::const_reverse_iterator iter1, iter2;
        iter1 = op1.digits.rbegin();
        iter2 = op2.digits.rbegin();
        
        while (iter1 != op1.digits.rend()) {
            if (op1.sign &&  *iter1 < *iter2) {
                return true;
            }
            
            if (op1.sign &&  *iter1 > *iter2) {
                return false;
            }
            
            if (!op1.sign &&  *iter1 > *iter2) {
                return true;
            }
            
            if (!op1.sign &&  *iter1 < *iter2) {
                return false;
            }
            
            iter1++;
            iter2++;
        }
        
        return false;
    }
}
bool operator==(const BigInteger& op1, const BigInteger& op2) {
    if (op1.sign != op2.sign  || op1.digits.size() != op2.digits.size()) {
        return false;
    }
    
    vector<char>::const_iterator iter1, iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    
    while (iter1 != op1.digits.end()) {
        if (*iter1 != *iter2) {
            return false;
        }
        
        iter1++;
        iter2++;
    }
    
    return true;
}

bool operator!=(const BigInteger& op1, const BigInteger& op2) {
    return !(op1 == op2);
}

bool operator>=(const BigInteger& op1, const BigInteger& op2) {
    return (op1 > op2) || (op1 == op2);
}

bool operator<=(const BigInteger& op1, const BigInteger& op2) {
    return (op1 < op2) || (op1 == op2);
}

bool operator>(const BigInteger& op1, const BigInteger& op2) {
    return !(op1 <= op2);
}

ostream& operator<<(ostream& stream, const BigInteger& val) {  //print the BigInteger
    if (!val.sign) {
        stream << "-";
    }
    
    for (vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++) {
        stream << (char)((*iter) + '0');
    }
    
    return stream;
}

istream& operator>>(istream& stream, BigInteger& val) {   //Input the BigInteger
    string str;
    stream >> str;
    val = BigInteger(str);
    return stream;
}


//int main() {
//    BigInteger A;
//    int B;
//    BigInteger C = 888;
//    cin >>B;
//    cout << "A-B:" << A - B << endl;
//    cout << "A+B:" << A + B << endl;
//    cout << "A*B:" << A*B << endl;
//    cout << "A/B:" << A / B << endl;
//    cout << "A%B:" << A % B << endl;
//    cout <<  A.pow(B-3) << endl;
//    A++;
//    cout << "A++:" << A << endl;
//    A--;
//    cout << "A--:" << A << endl;
//    cout << "++B:" << ++B << endl;
//    cout << "--B:" << --B << endl;
//    cout << "C:" << C << endl;
//}
typedef long long ll;

BigInteger MOD = 1000000007;
ll a,b;

BigInteger cal(BigInteger n)
{
    return n * n * n * b + (n - 1) * n * n * a;
}

BigInteger dfs(BigInteger x,BigInteger a,BigInteger b)
{
    if(x % 2 == 0)
    {
        BigInteger ans;
        BigInteger tmp1 = x * x * x * b + (x - 1) * x * x * a;
        BigInteger tmp2 = (18 * (x / 2) * (x / 2) * a + 7 * dfs(x / 2,a,b));
        if(tmp1 > tmp2)
            ans = tmp2;
        else ans = tmp1;
        return ans;
    }
    else return x * x * x * b + (x - 1) * x * x * a;
}

int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        BigInteger n,a,b;
        cin >> n >> a >> b;
        BigInteger ans = dfs(n,a,b);
        
        cout << ans % MOD << endl;
    }
    return 0;
}