ACM-ICPC 2018 焦作赛区网络预赛J题 Participate in E-sports

Jessie and Justin want to participate in e-sports. E-sports contain many games, but they don't know which one to choose, so they use a way to make decisions.

They have several boxes of candies, and there are ii candies in the i^{th}ith box, each candy is wrapped in a piece of candy paper. Jessie opens the candy boxes in turn from the first box. Every time a box is opened, Jessie will take out all the candies inside, finish it, and hand all the candy papers to Justin.

When Jessie takes out the candies in the N^{th}Nth box and hasn't eaten yet, if the amount of candies in Jessie's hand and the amount of candy papers in Justin's hand are both perfect square numbers, they will choose Arena of Valor. If only the amount of candies in Jessie's hand is a perfect square number, they will choose Hearth Stone. If only the amount of candy papers in Justin's hand is a perfect square number, they will choose Clash Royale. Otherwise they will choose League of Legends.

Now tell you the value of NN, please judge which game they will choose.

Input

The first line contains an integer T(1 \le T \le 800)T(1≤T≤800) , which is the number of test cases.

Each test case contains one line with a single integer: N(1 \le N \le 10^{200})N(1≤N≤10200) .

Output

For each test case, output one line containing the answer.

样例输入复制

4
1
2
3
4

样例输出复制

Arena of Valor
Clash Royale
League of Legends
Hearth Stone

题目来源

ACM-ICPC 2018 焦作赛区网络预赛

题解：判断N和N*(N-1)/2,由于N范围是1~10^200.数据太大，故用大数运算；

下面附上大数运算模板：

参考代码：

 #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, sa, sb;
     int T; cin >> T;
     while(T--)
     {
         cin >> b;
         a = b * (b - ) / ;
         sa = sqrt(a); sb = sqrt(b);
         bool f1 = (sa * sa) == a;
         bool f2 = (sb * sb) == b;
         if(f1&&f2) cout<<"Arena of Valor"<<endl;
         else if(f1 && !f2) cout<<"Clash Royale"<<endl;
         else if(!f1 && !f2) cout<<"League of Legends"<<endl;
         else if (!f1 && f2) cout<<"Hearth Stone"<<endl;
     }
     return ;
 }
 　　

 　　java代码：

 import java.util.Scanner;
 import java.math.BigInteger;
 public class Main {
     public static void main(String[] args)
     {
         Scanner cin = new Scanner(System.in);
         int T = cin.nextInt();
         for(int cas = ; cas <= T; ++cas)
         {
             String str = cin.next();
             BigInteger n = new BigInteger(str);
             BigInteger m = n.multiply(n.subtract(BigInteger.ONE)).shiftRight();
             boolean nIsSquare = isSquare(n);
             boolean mIsSquare = isSquare(m);
             if(nIsSquare && mIsSquare) System.out.println("Arena of Valor");
             else if(nIsSquare && !mIsSquare) System.out.println("Hearth Stone");
             else if(!nIsSquare && mIsSquare) System.out.println("Clash Royale");
             else System.out.println("League of Legends");
         }
     }
     public static boolean isSquare(BigInteger n)
     {
         BigInteger low = BigInteger.ZERO;
         BigInteger high = n;
         while (low.compareTo(high) <= )
         {
             BigInteger mid = low.add(high).shiftRight();
             BigInteger square = mid.multiply(mid);
             int result = square.compareTo(n);
             if (result == ) return true;
             else if(result>) high=mid.subtract(BigInteger.ONE);
             else low = mid.add(BigInteger.ONE);
         }
         return false;
     }
 }