PAT甲级题分类汇编——计算

本文为PAT甲级分类汇编系列文章。

计算类，指以数学运算为主或为背景的题。

题号	标题	分数	大意
1058	A+B in Hogwarts	20	特殊进制加法
1059	Prime Factors	25	分解素因数
1060	Are They Equal	25	一定精度下两数是否相等
1065	A+B and C (64bit)	20	大数加法与比较
1069	The Black Hole of Numbers	20	黑洞数
1073	Scientific Notation	20	科学计数法还原
1081	Rational Sum	20	有理数加法
1088	Rational Arithmetic	20	有理数运算
1096	Consecutive Factors	20	最长连续因数
1100	Mars Numbers	20	进制转换

这类题，普遍分数低，大多是20分。20分题放到乙级也没啥问题，比如1069、1081等。然而，即使是20分题，也可能要卡很久。

我挑了1059、1065、1088、1096共4道来做。

1059：

题目要求输出一个数的素因数分解。这么简单的题就不多讲了吧，直接上代码：

 #include <iostream>
 #include <map>
 #include <cmath>
 
 bool isprime(int n)
 {
     int end = std::sqrt(n) + ;
     for (int i = ; i != end; ++i)
         if (n % i == )
             return false;
     return true;
 }
 
 int main(int argc, char const *argv[])
 {
     long n;
     std::cin >> n;
     std::cout << n << '=';
     if (n == )
     {
         std::cout << '';
         return ;
     }
     std::map<int, int> factors;
     int prime = ;
     while (n > )
     {
         if (isprime(prime) && n % prime == )
         {
             ++factors[prime];
             n /= prime;
         }
         else
             ++prime;
     }
     int count = ;
     for (const auto& pair : factors)
     {
         if (count++)
             std::cout << '*';
         std::cout << pair.first;
         if (pair.second > )
             std::cout << '^' << pair.second;
     }
     return ;
 }

其实用 std::vector 也是可以的，但我懒。

需要注意的是 n== 的检查，不过这个很容易发现。

1065：

要求判断两个64位整数相加是否大于另一个数。注意两个64位整数相加以后如果还保存在64位整数中是可能溢出的，并且test case里面一定会有这种情况。

所以要用更大的整数来做计算。然而C++标准库中并没有提供128位整数。这时，伟大的g++出现了，它提供了 __int128_t ：

 #include <iostream>
 
 int main(int argc, char const *argv[])
 {
     int t;
     std::cin >> t;
     std::cout << std::boolalpha;
 
     for (int i = ; i <= t; ++i)
     {
         __int128_t a, b, c;
         int64_t ta, tb, tc;
         std::cin >> ta >> tb >> tc;
         a = ta; b = tb; c = tc;
         std::cout << "Case #" << i << ": " << (a + b > c) << std::endl;
     }
 
     return ;
 }

于是这道题就被秒了。

C++标准库对整数类型的支持不太好，大整数的类只能自己写。至于是以二进制存储还是以十进制存储，那要看应用场景了。

1088：

在一个case上卡了好久，最后发现题目里有一句要用 long int ，WCNM。

难度没什么的，主要是对分子和分母有0或1的特殊情况的处理。

优雅的我写了一份很优雅的实现，又是template又是运算符重载的：

 #include <iostream>
 #include <exception>
 
 template <typename T>
 class Rational
 {
 public:
     Rational() = default;
     Rational(T _num, T _den)
         : numerator(_num), denominator(_den)
     {
         reduce();
     }
     Rational(const Rational&) = default;
     Rational& operator=(const Rational&) = default;
 
     Rational operator+(const Rational& _rhs) const noexcept
     {
         return Rational(numerator * _rhs.denominator + _rhs.numerator * denominator,
             denominator * _rhs.denominator);
     }
     Rational operator-(const Rational& _rhs) const noexcept
     {
         return Rational(numerator * _rhs.denominator - _rhs.numerator * denominator,
             denominator * _rhs.denominator);
     }
     Rational operator*(const Rational& _rhs) const noexcept
     {
         return Rational(numerator * _rhs.numerator,
             denominator * _rhs.denominator);
     }
     Rational operator/(const Rational& _rhs) const
     {
         if (_rhs.numerator == )
             throw std::exception();
         return Rational(numerator * _rhs.denominator,
             denominator * _rhs.numerator);
     }
 
     template <typename U>
     friend std::istream& operator>>(std::istream&, Rational<U>&);
     template <typename U>
     friend std::ostream& operator<<(std::ostream&, const Rational<U>&);
 private:
     static T gcd(T _lhs, T _rhs)
     {
         if (_lhs < )
             _lhs = -_lhs;
         if (_lhs < _rhs)
             return gcd(_rhs, _lhs);
         if (_rhs == )
             return _lhs ? _lhs : ;
         return gcd(_rhs, _lhs % _rhs);
     }
 
     void reduce()
     {
         if (denominator < )
         {
             numerator = -numerator;
             denominator = -denominator;
         }
         auto factor = gcd(numerator, denominator);
         numerator /= factor;
         denominator /= factor;
     }
 
     T numerator;
     T denominator;
 };
 
 template <typename T>
 std::istream& operator>>(std::istream& _is, Rational<T>& _r)
 {
     T n, d;
     std::cin >> n;
     std::cin.get();
     std::cin >> d;
     _r = Rational<T>(n, d);
     return _is;
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& _os, const Rational<T>& _r)
 {
     auto r = _r;
     bool neg = false;
     if (r.numerator < )
     {
         neg = true;
         r.numerator = -r.numerator;
         _os << "(-";
     }
     if (r.denominator == )
         _os << r.numerator;
     else
     {
         if (r.numerator >= r.denominator)
         {
             _os << (r.numerator / r.denominator) << ' ';
             r.numerator %= r.denominator;
         }
         _os << r.numerator << '/' << r.denominator;
     }
     if (neg)
         _os << ')';
     return _os;
 }
 
 int main(int argc, char const *argv[])
 {
     Rational<long long> lhs, rhs;
     std::cin >> lhs >> rhs;
     std::cout << lhs << " + " << rhs << " = " << (lhs + rhs) << std::endl;
     std::cout << lhs << " - " << rhs << " = " << (lhs - rhs) << std::endl;
     std::cout << lhs << " * " << rhs << " = " << (lhs * rhs) << std::endl;
     std::cout << lhs << " / " << rhs << " = ";
     try
     {
         std::cout << (lhs / rhs) << std::endl;
     }
     catch(const std::exception& e)
     {
         std::cout << "Inf" << std::endl;
     }
     return ;
 }

优雅个屁，考试要来不及的。

顺便讲讲写自定义类（特指有成员方法的类而非简单的结构体）和模板的技巧。

构造函数最好给一个默认的，Rule of Three/Five规定的方法最好显式 =default 写出来。

参数尽量用引用，看情况要不要加 const ，大多都是要加的。相应地，成员方法能用 const 修饰的一定要加上去。

对于模板类的友元函数，模板类中还要再套模板，而且要用不一样的类型名称。

以上规则如果不遵守，很可能会编译错误，而且错误信息看起来比较累。

1096：

要求输出给定整数的的分解中可以出现的最长连续因数。乍一看有一点难，但稍微想一想就会发现，这串因数不会太长，因为阶乘是很大的。所以可以一个一个试这串因数中的最小数，连续很多个因数只有没几种情况需要试，到连续两个的情况，也是O(sqrt(n))时间复杂度能搞定的。至于单个因数则需要单独讨论一下，因为试到根号n就可以了，而如果不停止的话会超时。

 #include <iostream>
 #include <utility>
 #include <cmath>
 
 int main(int argc, char const *argv[])
 {
     int n;
     std::cin >> n;
 
     try
     {
         for (int count = ; count > ; --count)
         {
             for (int min = ; ; ++min)
             {
                 long product = ;
                 for (int factor = min; factor != min + count; ++factor)
                     product *= factor;
                 if (product > n)
                     break;
                 if (n % product == )
                     throw std::pair<int, int>(count, min);
             }
         }
         int end = std::sqrt(n) + ;
         for (int factor = ; factor != end; ++factor)
             if (n % factor == )
                 throw std::pair<int, int>(, factor);
         throw std::pair<int, int>(, n);
     }
     catch(const std::pair<int, int>& pair)
     {
         std::cout << pair.first << std::endl;
         for (int i = pair.second; i != pair.second + pair.first - ; ++i)
             std::cout << i << '*';
         std::cout << pair.second + pair.first -  << std::endl;
     }
 
     return ;
 }

长度的初始值是11，是因为2*3*...*13是大于2^31的，而2*3*...*12是小于2^31的，因此长度不会超过11。

总之，计算类题目没有难度，但是要避坑。坑依然是边界条件，包括最小的数（0、1、2等）与很大的数（int放不下的）。