2017 ACM/ICPC 沈阳 I题 Little Boxes

Little boxes on the hillside. 
Little boxes made of ticky-tacky. 
Little boxes. 
Little boxes. 
Little boxes all the same. 
There are a green boxes, and b pink boxes. 
And c blue boxes and d yellow boxes. 
And they are all made out of ticky-tacky. 
And they all look just the same. 

InputThe input has several test cases. The first line contains the integer t (1 ≤ t ≤ 10) which is the total number of test cases. 
For each test case, a line contains four non-negative integers a, b, c and d where a, b, c, d ≤ 2^62, indicating the numbers of green boxes, pink boxes, blue boxes and yellow boxes. 
OutputFor each test case, output a line with the total number of boxes. 
Sample Input

4
1 2 3 4
0 0 0 0
1 0 0 0
111 222 333 404

Sample Output

10
0
1
1070
题解： 题意就是求a+b+c+d的结果
C++大数模板求即可Orz

 #include <bits/stdc++.h>
 using namespace std;
 // base and base_digits must be consistent
 constexpr int base = ;
 constexpr int base_digits = ;
 struct bigint{
     vector<int> z;
     int sign;
     bigint() : sign() {}
     bigint(long long v) { *this = v; }
     bigint& operator=(long long v)
     {
         sign = v <  ? - : ;
         v*=sign;
         z.clear();
         for(; v > ; v = v / base) z.push_back((int)(v % base));
         return *this;
     }

     bigint(const string& s) { read(s); }

     bigint& operator+=(const bigint& other)
     {
         if (sign == other.sign)
         {
             for (int i = , carry = ; i < other.z.size() || carry; ++i)
             {
                 if(i==z.size()) z.push_back();
                 z[i] += carry + (i < other.z.size() ? other.z[i] : );
                 carry = z[i] >= base;
                 if(carry) z[i] -= base;
             }
         }
         else if (other !=  /* prevent infinite loop */)
         {
             *this -= -other;
         }
         return *this;
     }

     friend bigint operator+(bigint a, const bigint& b)
     {
         return a += b;
     }

     bigint& operator-=(const bigint& other)
     {
         if (sign == other.sign)
         {
             if (sign ==  && *this >= other || sign == - && *this <= other)
             {
                 for (int i = , carry = ; i < other.z.size() || carry; ++i)
                 {
                     z[i] -= carry + (i < other.z.size() ? other.z[i] : );
                     carry = z[i] < ;
                     if(carry) z[i] += base;
                 }
                 trim();
             }
             else
             {
                 *this = other - *this;
                 this->sign = -this->sign;
             }
         }
         else *this += -other;
         return *this;
     }

     friend bigint operator - (bigint a,const bigint& b)
     {
         return a -= b;
     }

     bigint& operator*=(int v)
     {
         if(v<) sign=-sign,v=-v;
         for(int i=,carry=;i<z.size() || carry;++i)
         {
             if(i==z.size()) z.push_back();
             long long cur = (long long)z[i] * v + carry;
             carry = (int)(cur / base);
             z[i] = (int)(cur % base);
         }
         trim();
         return *this;
     }

     bigint operator*(int v) const
     {
         return bigint(*this) *= v;
     }

     friend pair<bigint, bigint> divmod(const bigint& a1, const bigint& b1)
     {
         int norm = base / (b1.z.back() + );
         bigint a = a1.abs() * norm;
         bigint b = b1.abs() * norm;
         bigint q, r;
         q.z.resize(a.z.size());

         for (int i = (int)a.z.size() - ; i >= ; i--)
         {
             r*=base; r+=a.z[i];
             int s1 = b.z.size() < r.z.size() ? r.z[b.z.size()] : ;
             int s2 = b.z.size() -  < r.z.size() ? r.z[b.z.size() - ] : ;
             int d = (int)(((long long)s1 * base + s2) / b.z.back());
             r -= b * d;
             while(r < ) r+=b,--d;
             q.z[i] = d;
         }

         q.sign = a1.sign * b1.sign;
         r.sign = a1.sign;
         q.trim();
         r.trim();
         return {q, r / norm};
     }

     friend bigint sqrt(const bigint& a1)
     {
         bigint a=a1;
         while(a.z.empty()||a.z.size()%==) a.z.push_back();

         int n = a.z.size();
         int firstDigit = (int)::sqrt((double)a.z[n - ] * base + a.z[n - ]);
         int norm = base / (firstDigit + );
         a *= norm;
         a *= norm;
         while(a.z.empty()||a.z.size()%==) a.z.push_back();

         bigint r = (long long)a.z[n - ] * base + a.z[n - ];
         firstDigit = (int)::sqrt((double)a.z[n - ] * base + a.z[n - ]);
         int q = firstDigit;
         bigint res;
         for (int j = n /  - ; j >= ; j--)
         {
             for(;;--q)
             {
                 bigint r1=(r-(res**base+q)*q)*base*base+(j>?(long long)a.z[*j-]*base+a.z[*j-]:);
                 if(r1>=) { r=r1; break; }
             }
             res*=base;res+=q;
             if(j>)
             {
                 int d1 = res.z.size() +  < r.z.size() ? r.z[res.z.size() + ] : ;
                 int d2 = res.z.size() +  < r.z.size() ? r.z[res.z.size() + ] : ;
                 int d3 = res.z.size() < r.z.size() ? r.z[res.z.size()]:;
                 q = (int)(((long long)d1*base*base+(long long)d2*base+d3)/(firstDigit*));
             }
         }

         res.trim();
         return res / norm;
     }

     bigint operator/(const bigint& v) const
     {
         return divmod(*this, v).first;
     }

     bigint operator%(const bigint& v) const
     {
         return divmod(*this, v).second;
     }

     bigint& operator/=(int v)
     {
         if(v<) sign=-sign,v=-v;
         for (int i = (int)z.size() - , rem = ; i >= ; --i)
         {
             long long cur = z[i] + rem * (long long)base;
             z[i] = (int)(cur / v);
             rem = (int)(cur % v);
         }
         trim();
         return *this;
     }

     bigint operator/(int v) const
     {
         return bigint(*this) /= v;
     }

     int operator%(int v) const
     {
         if(v<) v=-v;
         int m=;
         for(int i=(int)z.size()-;i>=;--i) m=(int)((z[i]+m*(long long)base)%v);
         return m * sign;
     }

     bigint& operator*=(const bigint& v)
     {
         *this = *this * v;
         return *this;
     }

     bigint& operator/=(const bigint& v)
     {
         *this = *this / v;
         return *this;
     }

     bool operator<(const bigint& v) const
     {
         if(sign!=v.sign) return sign < v.sign;
         if(z.size()!=v.z.size()) return z.size()*sign<v.z.size()*v.sign;
         for(int i = (int)z.size() - ; i >= ; i--)
             if(z[i] != v.z[i])  return z[i] * sign < v.z[i] * sign;
         return false;
     }

     bool operator>(const bigint& v) const { return v < *this; }
     bool operator<=(const bigint& v) const { return !(v < *this); }
     bool operator>=(const bigint& v) const { return !(*this < v); }
     bool operator==(const bigint& v) const { return !(*this < v) && !(v < *this); }
     bool operator!=(const bigint& v) const { return *this < v || v < *this; }

     void trim()
     {
         while(!z.empty() && z.back() == ) z.pop_back();
         if(z.empty()) sign = ;
     }

     bool isZero() const { return z.empty(); }

     friend bigint operator-(bigint v)
     {
         if(!v.z.empty()) v.sign = -v.sign;
         return v;
     }

     bigint abs() const
     {
         return sign ==  ? *this : -*this;
     }

     long long longValue() const
     {
         long long res = ;
         for(int i = (int)z.size() - ; i >= ; i--) res = res * base + z[i];
         return res * sign;
     }

     friend bigint gcd(const bigint& a, const bigint& b)
     {
         return b.isZero() ? a : gcd(b, a % b);
     }

     friend bigint lcm(const bigint& a, const bigint& b)
     {
         return a / gcd(a, b) * b;
     }

     void read(const string& s)
     {
         sign = ;
         z.clear();
         int pos = ;
         while(pos < s.size() && (s[pos] == '-' || s[pos] == '+'))
         {
             if(s[pos] == '-') sign = -sign;
             ++pos;
         }
         for(int i=(int)s.size()-;i>=pos;i-=base_digits)
         {
             int x=;
             for(int j=max(pos,i-base_digits+);j<=i;j++) x=x*+s[j]-'';
             z.push_back(x);
         }
         trim();
     }

     friend istream& operator>>(istream& stream, bigint& v)
     {
         string s;
         stream >> s;
         v.read(s);
         return stream;
     }

     friend ostream& operator<<(ostream& stream, const bigint& v)
     {
         if(v.sign == -) stream << '-';
         stream << (v.z.empty() ?  : v.z.back());
         for(int i = (int)v.z.size() - ; i >= ; --i)
             stream << setw(base_digits) << setfill('') << v.z[i];
         return stream;
     }

     static vector<int> convert_base(const vector<int>& a, int old_digits, int new_digits)
     {
         vector<long long> p(max(old_digits, new_digits) + );
         p[] = ;
         for(int i=;i<p.size();i++) p[i]=p[i-]*;
         vector<int> res;
         long long cur = ;
         int cur_digits = ;
         for(int v : a)
         {
             cur += v * p[cur_digits];
             cur_digits += old_digits;
             while (cur_digits >= new_digits)
             {
                 res.push_back(int(cur % p[new_digits]));
                 cur /= p[new_digits];
                 cur_digits -= new_digits;
             }
         }
         res.push_back((int)cur);
         while(!res.empty() && res.back()==)
             res.pop_back();
         return res;
     }

     typedef vector<long long> vll;
     static vll karatsubaMultiply(const vll& a, const vll& b)
     {
         int n=a.size();
         vll res(n + n);
         if(n <= )
         {
             for (int i = ; i < n; i++)
                 for (int j = ; j < n; j++)
                     res[i + j] += a[i] * b[j];
             return res;
         }

         int k = n >> ;
         vll a1(a.begin(), a.begin() + k);
         vll a2(a.begin() + k, a.end());
         vll b1(b.begin(), b.begin() + k);
         vll b2(b.begin() + k, b.end());
         vll a1b1 = karatsubaMultiply(a1, b1);
         vll a2b2 = karatsubaMultiply(a2, b2);
         for(int i=;i<k;i++) a2[i]+=a1[i];
         for(int i=;i<k;i++) b2[i]+=b1[i];

         vll r = karatsubaMultiply(a2, b2);
         for(int i=;i<a1b1.size();i++) r[i]-=a1b1[i];
         for(int i=;i<a2b2.size();i++) r[i]-=a2b2[i];
         for(int i=;i<r.size();i++) res[i+k]+=r[i];
         for(int i=;i<a1b1.size();i++) res[i]+=a1b1[i];
         for(int i = ;i<a2b2.size();i++) res[i+n]+=a2b2[i];
         return res;
     }

     bigint operator*(const bigint& v) const
     {
         vector<int> a6=convert_base(this->z,base_digits,);
         vector<int> b6=convert_base(v.z,base_digits,);
         vll a(a6.begin(),a6.end());
         vll b(b6.begin(),b6.end());
         while(a.size()<b.size()) a.push_back();
         while(b.size()<a.size()) b.push_back();
         while(a.size()&(a.size()-)) a.push_back(),b.push_back();
         vll c=karatsubaMultiply(a, b);
         bigint res;
         res.sign = sign * v.sign;
         for (int i = , carry = ; i < c.size(); i++)
         {
             long long cur = c[i] + carry;
             res.z.push_back((int)(cur % ));
             carry = (int)(cur / );
         }
         res.z = convert_base(res.z, , base_digits);
         res.trim();
         return res;
     }
 };
 int main()
 {
     ios::sync_with_stdio();
     cin.tie();
     bigint a, b, c, d;
     int T; cin >> T;
     while(T--)
     {
         cin >>a>>b>>c>>d;
         a=a+b+c+d;
         cout<<a<<endl;

     }
     return ;
 }