代码

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>

const long long UNIT_SIZE = 2;
const long long UNIT_MOD = std::pow(10, UNIT_SIZE);

class big_int {
	private:
		bool is_neg;
		std::vector<long long> units;

	public:
		big_int() {
			is_neg = false;
		}

		big_int(std::string s) {
			is_neg = false;
			if (s.size() > 1 && s[0] == '-') {
				is_neg = true;
				s.erase(s.begin());
			}
			long long x = 0, p = 1;
			units.reserve(s.size() / UNIT_SIZE + 1);
			for (long long i = s.size() - 1; i >= 0; --i) {
				x += p * (s[i] - '0');
				p *= 10;
				if (p == UNIT_MOD) {
					units.push_back(x);
					p = 1;
					x = 0;
				}
			}
			if (x != 0) {
				units.push_back(x);
			}
		}

		big_int(long long s) {
			is_neg = false;
			if (s < 0) {
				s = -s;
				is_neg = true;
			}
			while (s != 0) {
				units.push_back(s % UNIT_MOD);
				s /= UNIT_MOD;
			}
		}

		void print() const {
			if (is_neg) {
				std::cout << "-";
			}
			std::cout << std::setfill('0');
			if (units.size() >= 1) {
				std::cout << units[units.size() - 1];
			}
			for (long long i = units.size() - 2; i >= 0; --i) {
				std::cout << std::setw(UNIT_SIZE) << units[i];
			}
		}

		bool negative() const {
			return is_neg;
		}
		
		void truncate_zero() {
			while (units.size() > 1 && units[units.size() - 1] == 0) {
				units.pop_back();
			}
		}

		friend big_int operator-(const big_int &a) {
			big_int ans = a;
			ans.is_neg ^= true;
			return ans;
		}

		friend bool operator<(const big_int &a, const big_int &b) {
			if (a.is_neg ^ b.is_neg) {
				if (a.is_neg) {
					return true;
				} else {
					return false;
				}
			} else if (a.is_neg) {
				return !((-a) < (-b));
			} else {
				if (a.units.size() > b.units.size()) {
					return false;
				} else if (a.units.size() < b.units.size()) {
					return true;
				}
				for (long long i = a.units.size() - 1; i >= 0; --i) {
					if (a.units[i] > b.units[i]) {
						return false;
					} else if (a.units[i] < b.units[i]) {
						return true;
					}
				}
			}
		}

		friend big_int operator+(const big_int &a, const big_int &b) {
			if (a.is_neg ^ b.is_neg) {
				if (a.is_neg) {
					return b - (-a);
				} else {
					return a - (-b);
				}
			} else if (a.is_neg) {
				return -((-a) + (-b));
			}
			big_int ans;
			ans.units.resize(std::max(a.units.size(), b.units.size()) + 1);
			for (long long i = 0; i < ans.units.size() - 1; ++i) {
				if (i >= a.units.size()) {
					ans.units[i] += b.units[i];
				} else if (i >= b.units.size()) {
					ans.units[i] += a.units[i];
				} else {
					ans.units[i] += a.units[i] + b.units[i];
				}
				ans.units[i + 1] += ans.units[i] / UNIT_MOD;
				ans.units[i] %= UNIT_MOD;
			}
			ans.truncate_zero();
			return ans;
		}

		friend big_int operator-(const big_int &a, const big_int &b) {
			if (a.is_neg ^ b.is_neg) {
				if (a.is_neg) {
					return -((-a) + b);
				} else {
					return a + (-b);
				}
			} else if (a.is_neg) {
				return -((-a) - (-b));
			}
			if (a < b) {
				return -(b - a);
			}
			big_int ans;
			ans.units.resize(a.units.size());
			for (long long i = 0; i < a.units.size(); ++i) {
				if (i >= b.units.size()) {
					ans.units[i] += a.units[i];
				} else {
					ans.units[i] += a.units[i] - b.units[i];
				}
				if (ans.units[i] < 0) {
					ans.units[i + 1] -= 1;
					ans.units[i] += UNIT_MOD;
				}
			}
			ans.truncate_zero();
			return ans;
		}
		
		friend big_int operator*(const big_int &a, const big_int &b) {
			if (a.is_neg ^ b.is_neg) {
				if (a.is_neg) {
					return -((-a) * b);
				} else {
					return -(a * (-b));
				}
			} else if (a.is_neg) {
				return (-a) * (-b);
			}
			big_int ans;
			ans.units.resize(a.units.size() + b.units.size() + 1);
			for (long long i = 0; i < a.units.size(); ++i) {
				for (long long j = 0; j < b.units.size(); ++j) {
					long long k = i + j;
					ans.units[k] += a.units[i] * b.units[j];
					ans.units[k + 1] += ans.units[k] / UNIT_MOD;
					ans.units[k] %= UNIT_MOD;
				}
			}
			ans.truncate_zero();
			return ans;
		}
};

using namespace std;

int main() {
string sa, sb;
cin >> sa >> sb;
big_int a(sa), b(sb);
(a * b).print();
}

评测结果