結果
問題 | No.350 d=vt |
ユーザー | not_522 |
提出日時 | 2020-01-02 23:37:53 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
AC
|
実行時間 | 3 ms / 2,000 ms |
コード長 | 39,060 bytes |
コンパイル時間 | 1,492 ms |
コンパイル使用メモリ | 131,176 KB |
実行使用メモリ | 5,248 KB |
最終ジャッジ日時 | 2024-11-22 18:41:32 |
合計ジャッジ時間 | 2,318 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge2 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 2 ms
5,248 KB |
testcase_01 | AC | 2 ms
5,248 KB |
testcase_02 | AC | 2 ms
5,248 KB |
testcase_03 | AC | 2 ms
5,248 KB |
testcase_04 | AC | 2 ms
5,248 KB |
testcase_05 | AC | 3 ms
5,248 KB |
testcase_06 | AC | 2 ms
5,248 KB |
testcase_07 | AC | 2 ms
5,248 KB |
testcase_08 | AC | 2 ms
5,248 KB |
testcase_09 | AC | 2 ms
5,248 KB |
testcase_10 | AC | 2 ms
5,248 KB |
testcase_11 | AC | 2 ms
5,248 KB |
testcase_12 | AC | 2 ms
5,248 KB |
testcase_13 | AC | 2 ms
5,248 KB |
testcase_14 | AC | 2 ms
5,248 KB |
ソースコード
// This is free and unencumbered software released into the public domain. // Anyone is free to copy, modify, publish, use, compile, sell, or // distribute this software, either in source code form or as a compiled // binary, for any purpose, commercial or non-commercial, and by any // means. // In jurisdictions that recognize copyright laws, the author or authors // of this software dedicate any and all copyright interest in the // software to the public domain. We make this dedication for the benefit // of the public at large and to the detriment of our heirs and // successors. We intend this dedication to be an overt act of // relinquishment in perpetuity of all present and future rights to this // software under copyright law. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. // IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // OTHER DEALINGS IN THE SOFTWARE. // For more information, please refer to <http://unlicense.org> /****************/ /* template.hpp */ /****************/ #include <algorithm> #include <cassert> #include <functional> #include <iomanip> #include <iostream> #include <limits> using std::cerr; using std::cout; using std::endl; using std::max; using std::min; using std::swap; struct BoolName : std::numpunct<char> { std::string t, f; BoolName(std::string t, std::string f) : t(t), f(f) {} std::string do_truename() const { return t; } std::string do_falsename() const { return f; } }; void setBoolName(std::string t, std::string f) { cout.imbue(std::locale(cout.getloc(), new BoolName(t, f))); } struct Initializer { Initializer() { cout << std::fixed << std::setprecision(15) << std::boolalpha; setBoolName("Yes", "No"); } } initializer; struct Input { bool eof; Input() : eof(false) {} operator char() { char v; this->eof = (std::scanf("%c", &v) != 1); return v; } operator int() { int v; this->eof = (std::scanf("%d", &v) != 1); return v; } operator long() { long v; this->eof = (std::scanf("%ld", &v) != 1); return v; } operator long long() { long long v; this->eof = (std::scanf("%lld", &v) != 1); return v; } operator unsigned int() { unsigned int v; this->eof = (std::scanf("%u", &v) != 1); return v; } operator unsigned long() { unsigned long v; this->eof = (std::scanf("%lu", &v) != 1); return v; } operator unsigned long long() { unsigned long long v; this->eof = (std::scanf("%llu", &v) != 1); return v; } operator double() { double v; this->eof = (std::scanf("%lf", &v) != 1); return v; } operator long double() { long double v; this->eof = (std::scanf("%Lf", &v) != 1); return v; } void ignore() const { getchar(); } } in; template <typename T> T abs(T a) { return a >= 0 ? a : -a; } template <typename T, typename S> bool chmin(T &a, const S &b) { return a > b ? a = b, true : false; } template <typename T, typename S> bool chmax(T &a, const S &b) { return a < b ? a = b, true : false; } template <typename T, typename S> std::function<S(T)> cast() { return [](const T &t) { return static_cast<S>(t); }; } template <typename T> T copy(const T &a) { return T(a); } class ZeroPadding { public: ZeroPadding(int n) : n(n) {} int n; }; std::ostream &operator<<(std::ostream &os, const ZeroPadding &z) { os << std::setw(z.n) << std::setfill('0'); return os; } template <typename T> constexpr T inf() { return std::numeric_limits<T>::max() / 2 - 1; } /******************/ /* arithmetic.hpp */ /******************/ template <typename T> class Addition { public: template <typename V> T operator+(const V &v) const { return T(static_cast<const T &>(*this)) += v; } T operator++() { return static_cast<T &>(*this) += 1; } }; template <typename T> class Subtraction { public: template <typename V> T operator-(const V &v) const { return T(static_cast<const T &>(*this)) -= v; } }; template <typename T> class Multiplication { public: template <typename V> T operator*(const V &v) const { return T(static_cast<const T &>(*this)) *= v; } }; template <typename T> class Division { public: template <typename V> T operator/(const V &v) const { return T(static_cast<const T &>(*this)) /= v; } }; template <typename T> class Modulus { public: template <typename V> T operator%(const V &v) const { return T(static_cast<const T &>(*this)) %= v; } }; template <typename T> class IndivisibleArithmetic : public Addition<T>, public Subtraction<T>, public Multiplication<T> {}; template <typename T> class Arithmetic : public IndivisibleArithmetic<T>, public Division<T> {}; /*************/ /* tuple.hpp */ /*************/ #include <tuple> template <typename... T> class Tuple : public std::tuple<T...> { public: Tuple(Input &in) : std::tuple<T...>() { (void)in; } }; template <typename T, typename... S> class Tuple<T, S...> : public std::tuple<T, S...> { public: Tuple() : std::tuple<T, S...>() {} Tuple(T t, S... s) : std::tuple<T, S...>(t, s...) {} Tuple(const std::tuple<T, S...> &t) : std::tuple<T, S...>(t) {} Tuple(Input &in) { auto a = std::tuple<T>(in); std::tuple<S...> b = Tuple<S...>(in); std::tuple<T, S...> c = std::tuple_cat(a, b); *this = c; } template <int n> auto &get() { return std::get<n>(*this); } template <int n> const auto &get() const { return std::get<n>(*this); } }; template <typename... T> Tuple<T...> makeTuple(const T &... args) { return Tuple<T...>(args...); } namespace std { template <typename... T> class tuple_size<Tuple<T...>> : public std::integral_constant<size_t, sizeof...(T)> {}; template <std::size_t I, typename... T> class tuple_element<I, Tuple<T...>> { public: using type = tuple_element_t<I, std::tuple<T...>>; }; } // namespace std /*****************/ /* container.hpp */ /*****************/ #include <vector> template <typename T> class Container : public T { private: using S = typename T::value_type; using Itr = typename T::iterator; public: Container() : T() {} Container(int n) : T(n) {} Container(int n, S s) : T(n, s) {} template <typename Itr> Container(Itr first, Itr last) : T(first, last) {} Container(const std::initializer_list<S> &v) : T(v) {} Container(int n, Input &in) { std::vector<S> v(n); for (auto &i : v) { i = in; } *this = Container<T>(v.begin(), v.end()); } S max() const { return *std::max_element(this->begin(), this->end()); } template <typename Function> auto max(Function func) const { std::vector<std::pair<decltype(func(S())), S>> res; for (const auto &i : *this) { res.emplace_back(func(i), i); } return std::max_element(res.begin(), res.end())->second; } S min() const { return *std::min_element(this->begin(), this->end()); } Tuple<S, S> minmax() const { auto itrs = std::minmax_element(this->begin(), this->end()); return Tuple<S, S>(*itrs.first, *itrs.second); } template <typename Function> auto min(Function func) const { std::vector<std::pair<decltype(func(S())), S>> res; for (const auto &i : *this) { res.emplace_back(func(i), i); } return std::min_element(res.begin(), res.end())->second; } int argmax() const { return std::distance(std::max_element(this->begin(), this->end()), this->begin()); } int argmin() const { return std::distance(std::min_element(this->begin(), this->end()), this->begin()); } int find(const S &a) const { return std::distance(std::find(this->begin(), this->end(), a), this->begin()); } bool contains(const S &a) const { return std::find(this->begin(), this->end(), a) != this->end(); } int size() const { return T::size(); } std::pair<Itr, Itr> equal_range(const S &a) { return std::equal_range(this->begin(), this->end(), a); } template <typename Function> bool all_of(Function func) const { return std::all_of(this->begin(), this->end(), func); } template <typename Function> bool any_of(Function func) const { return std::any_of(this->begin(), this->end(), func); } template <typename Function> bool none_of(Function func) const { return std::none_of(this->begin(), this->end(), func); } int count(const S &s) const { return std::count(this->begin(), this->end(), s); } bool is_sorted() const { return std::is_sorted(this->begin(), this->end()); } void output(std::string sep = "\n", std::string end = "\n") const { bool first = true; for (const auto &i : *this) { if (!first) { cout << sep; } first = false; cout << i; } cout << end; } }; /***********/ /* map.hpp */ /***********/ #include <map> template <typename T, typename S> class Map : public Container<std::map<T, S>> { public: Map() : Container<std::map<T, S>>() {} bool contains(const T &a) const { return this->count(a) != 0; } int count(const T &t) const { return this->count(t); } }; /***************/ /* ordered.hpp */ /***************/ template <typename T> class Ordered { public: template <typename V> bool operator==(const V &v) const { return !(static_cast<T>(v) < static_cast<const T &>(*this) || static_cast<const T &>(*this) < static_cast<T>(v)); } template <typename V> bool operator!=(const V &v) const { return static_cast<T>(v) < static_cast<const T &>(*this) || static_cast<const T &>(*this) < static_cast<T>(v); } template <typename V> bool operator>(const V &v) const { return static_cast<T>(v) < static_cast<const T &>(*this); } template <typename V> bool operator<=(const V &v) const { return !(static_cast<T>(v) < static_cast<const T &>(*this)); } template <typename V> bool operator>=(const V &v) const { return !(static_cast<const T &>(*this) < static_cast<T>(v)); } }; /**************/ /* vector.hpp */ /**************/ #include <numeric> template <typename T> class Vector : public Container<std::vector<T>>, public Ordered<Vector<T>> { public: Vector() = default; Vector(const Vector<T> &v) = default; Vector(int n) : Container<std::vector<T>>(n) {} Vector(int n, T t) : Container<std::vector<T>>(n, t) {} template <typename Itr> Vector(Itr first, Itr last) : Container<std::vector<T>>(first, last) {} Vector(const std::initializer_list<T> &v) : Container<std::vector<T>>(v) {} Vector(int n, Input &in) : Container<std::vector<T>>(n, in) {} Vector &operator+=(const Vector &v) { if (this->size() < v.size()) { this->resize(v.size()); } for (int i = 0; i < v.size(); ++i) { (*this)[i] += v[i]; } return *this; } Vector &operator+=(const T &v) { for (auto &i : *this) { i += v; } return *this; } Vector &operator-=(const Vector &v) { if (this->size() < v.size()) { this->resize(v.size()); } for (int i = 0; i < v.size(); ++i) { (*this)[i] -= v[i]; } return *this; } Vector &operator-=(const T &v) { for (auto &i : *this) { i -= v; } return *this; } Vector &operator*=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] *= v[i]; } return *this; } Vector &operator*=(const T &v) { for (auto &i : *this) { i *= v; } return *this; } Vector &operator/=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] /= v[i]; } return *this; } Vector &operator/=(const T &v) { for (auto &i : *this) { i /= v; } return *this; } Vector &operator%=(const Vector &v) { for (int i = 0; i < this->size(); ++i) { (*this)[i] %= v[i]; } return *this; } Vector &operator%=(const T &v) { for (auto &i : *this) { i %= v; } return *this; } Vector operator+(const Vector &v) const { return Vector(*this) += v; } Vector operator+(const T &v) const { return Vector(*this) += v; } Vector operator-(const Vector &v) const { return Vector(*this) -= v; } Vector operator-(const T &v) const { return Vector(*this) -= v; } Vector operator*(const Vector &v) const { return Vector(*this) *= v; } Vector operator*(const T &v) const { return Vector(*this) *= v; } Vector operator/(const Vector &v) const { return Vector(*this) /= v; } Vector operator/(const T &v) const { return Vector(*this) /= v; } Vector operator%(const Vector &v) const { return Vector(*this) %= v; } Vector operator%(const T &v) const { return Vector(*this) %= v; } bool operator<(const Vector &v) const { if (this->size() != v.size()) { return this->size() < v.size(); } for (int i = 0; i < this->size(); ++i) { if ((*this)[i] != v[i]) { return (*this)[i] < v[i]; } } return false; } Vector operator-() const { return *this * -1; } T inner_product(const Vector<T> &v) const { return std::inner_product(this->begin(), this->end(), v.begin(), T(0)); } Vector<T> &partial_sort(int k, bool reverse = false) { if (!reverse) { std::partial_sort(this->begin(), this->begin() + k, this->end()); } else { std::partial_sort(this->begin(), this->begin() + k, this->end(), std::greater<T>()); } return *this; } Vector<T> &sort() { std::sort(this->begin(), this->end()); return *this; } template <typename Function> Vector<T> &sort(Function func) { std::sort(this->begin(), this->end(), func); return *this; } Vector<T> &rsort() { std::sort(this->rbegin(), this->rend()); return *this; } Vector<int> argsort() const { Vector<Tuple<T, int>> v; for (int i = 0; i < this->size(); ++i) { v.emplace_back((*this)[i], i); } v.sort(); auto f = [](const Tuple<T, int> &t) { return t.template get<1>(); }; return v.transform(f); } Vector<T> &nth_element(int n, bool reverse = false) { if (!reverse) { std::nth_element(this->begin(), this->begin() + n, this->end()); } else { std::nth_element(this->begin(), this->begin() + n, this->end(), std::greater<T>()); } return *this; } Vector<T> subvector(int a) const { return Vector<T>(this->begin(), this->begin() + a); } Vector<T> subvector(int a, int b) const { return Vector<T>(this->begin() + a, this->begin() + b); } template <typename Function> auto transform(Function func) const { Vector<decltype(func(T()))> res; std::transform(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector<T> partial_sum() const { Vector<T> res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res)); return res; } template <typename Function> Vector<T> partial_sum(Function func) const { Vector<T> res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector<T> &reverse() { std::reverse(this->begin(), this->end()); return *this; } template <typename Function> int count_if(Function func) const { return std::count_if(this->begin(), this->end(), func); } Vector<T> adjacent_difference() const { Vector<T> res; std::adjacent_difference(this->begin(), this->end(), std::back_inserter(res)); return res; } T lower_bound(T t) const { return std::lower_bound(this->begin(), this->end(), t) - this->begin(); } T upper_bound(T t) const { return std::upper_bound(this->begin(), this->end(), t) - this->begin(); } T accumulate() const { return std::accumulate(this->begin(), this->end(), T()); } template <typename S, typename Function> S accumulate(S n, Function func) const { return std::accumulate(this->begin(), this->end(), n, func); } template <typename Int> static Vector<T> makeVector(Int n) { return Vector<T>(n); } template <typename Int> static Vector<T> makeVector(Input &in, Int n) { return Vector<T>(n, in); } template <typename Int, typename... Ints> static auto makeVector(Input &in, Int n, Ints... ints) { Vector<decltype(makeVector(in, ints...))> res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(in, ints...)); } return res; } template <typename Int, typename... Ints> static auto makeVector(Int n, Ints... ints) { Vector<decltype(makeVector(ints...))> res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(ints...)); } return res; } Vector<T> &unique() { this->erase(std::unique(this->begin(), this->end()), this->end()); return *this; } bool next_permutation() { return std::next_permutation(this->begin(), this->end()); } Vector<T> &rotate(int n) { std::rotate(this->begin(), this->begin() + n, this->end()); return *this; } Map<T, int> countAll() const { Map<T, int> res; for (const auto &i : *this) { ++res[i]; } return res; } T matmul(const T &a) const { return this->transform([&](const T &i) { return i.inner_product(a); }); } }; template <typename T> Vector<T> iota(int n, T m = 0) { Vector<T> v(n); std::iota(v.begin(), v.end(), m); return v; } template <typename T, typename S> void read(Vector<T> &t, Vector<S> &s) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); } } template <typename T, typename S, typename U> void read(Vector<T> &t, Vector<S> &s, Vector<U> &u) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); u[i] = U(in); } } template <typename T> Vector<T> operator+(const T &a, const Vector<T> &b) { return b + a; } template <typename T> Vector<T> operator-(const T &a, const Vector<T> &b) { return -b + a; } template <typename T> Vector<T> operator*(const T &a, const Vector<T> &b) { return b * a; } /**************/ /* string.hpp */ /**************/ #include <string> class String : public std::string { public: constexpr static auto npos = std::string::npos; String() : std::string() {} String(char c) : std::string(1, c) {} String(int n) : std::string(std::to_string(n)) {} String(long n) : std::string(std::to_string(n)) {} String(long long n) : std::string(std::to_string(n)) {} String(const char *s) : std::string(s) {} String(const std::string &s) : std::string(s) {} String(int n, char c) : std::string(n, c) {} String(Input &in) { std::cin >> *this; in.eof = std::cin.eof(); } String &operator+=(const String &s) { return *this = *this + s; } String operator+(const String &s) const { return std::operator+(*this, s); } String &operator+=(const char *s) { return *this = *this + s; } String operator+(const char *s) const { return std::operator+(*this, s); } String &operator+=(char s) { return *this = *this + s; } String operator+(char s) const { return std::operator+(*this, s); } static String getline() { String v; std::getline(std::cin, v); in.eof = std::cin.eof(); return v; } String substr(size_t pos, size_t n_pos = std::string::npos) { return std::string::substr(pos, n_pos); } String &reverse() { std::reverse(this->begin(), this->end()); return *this; } Vector<String> split(char delim = ' ') const { std::stringstream ss(*this); Vector<String> res; for (std::string tmp; std::getline(ss, tmp, delim);) { if (tmp != "") { res.emplace_back(tmp); } } return res; } String &toupper() { for (auto &c : *this) { c = std::toupper(c); } return *this; } String &tolower() { for (auto &c : *this) { c = std::tolower(c); } return *this; } template <typename Function> String transform(Function func) const { String res; std::transform(this->begin(), this->end(), std::back_inserter(res), func); return res; } bool contains(const String &s) const { return this->find(s) != std::string::npos; } String &erase(char c) { String res; for (char i : *this) { if (i != c) { res += i; } } return *this = res; } int count(char c) const { return std::count(this->begin(), this->end(), c); } template <bool Repeat = false> String &replaceAll(const String &from, const String &to) { for (size_t pos = 0; (pos = this->find(from, pos)) != std::string::npos;) { this->replace(pos, from.size(), to); if (!Repeat) { pos += to.size(); } } return *this; } String &sort() { std::sort(this->begin(), this->end()); return *this; } String &rsort() { std::sort(this->rbegin(), this->rend()); return *this; } String &unique() { std::string::erase(std::unique(this->begin(), this->end()), this->end()); return *this; } String &rotate(int n) { std::rotate(this->begin(), this->begin() + n, this->end()); return *this; } bool next_permutation() { return std::next_permutation(this->begin(), this->end()); } template <typename T, typename Function1, typename Function2> T inner_product(const String &v, T init, Function1 func1, Function2 func2) const { return std::inner_product(this->begin(), this->end(), v.begin(), init, func1, func2); } template <typename Function> int find_if(Function func) const { return std::find_if(this->begin(), this->end(), func) - this->begin(); } template <typename Function> bool all_of(Function func) const { return std::all_of(this->begin(), this->end(), func); } template <typename Function> bool any_of(Function func) const { return std::any_of(this->begin(), this->end(), func); } template <typename Function> bool none_of(Function func) const { return std::none_of(this->begin(), this->end(), func); } int size() const { return std::string::size(); } operator int() const { return std::stoi(*this); } operator long() const { return std::stol(*this); } operator long long() const { return std::stoll(*this); } operator float() const { return std::stof(*this); } operator double() const { return std::stod(*this); } operator long double() const { return std::stold(*this); } }; /*******************/ /* big_decimal.hpp */ /*******************/ #include <array> #include <cmath> template <int IntegerSize = 6, int DecimalSize = 9> class BigDecimal : public Arithmetic<BigDecimal<IntegerSize, DecimalSize>>, public Ordered<BigDecimal<IntegerSize, DecimalSize>> { private: constexpr static int BitSize = 31; constexpr static bool PLUS = false; constexpr static bool MINUS = true; const static long double EPSILON; bool sign; std::array<int64_t, IntegerSize + DecimalSize> d; public: BigDecimal() { *this = BigDecimal(0); } BigDecimal(int n) { sign = PLUS; for (auto &i : d) { i = 0; } d[DecimalSize] = n; normal(); } BigDecimal(int64_t n) { sign = PLUS; for (auto &i : d) { i = 0; } d[DecimalSize] = n; normal(); } BigDecimal(String str) { *this = BigDecimal(0); bool minus = false; if (str[0] == '-') { minus = true; str = str.substr(1); } BigDecimal t = 1; bool decimal = false; for (int i = 0; i < str.size(); ++i) { if (str[i] == '.') { decimal = true; } else { if (decimal) { *this += (t /= 10) * (str[i] - '0'); } else { *this = *this * 10 + (str[i] - '0'); } } } if (minus) { sign = MINUS; } else { sign = PLUS; } } BigDecimal(double r) { *this = BigDecimal(0); int n; BigDecimal b = (r >= 0 ? BigDecimal(1) : BigDecimal(-1)); r = 2 * abs(std::frexp(abs(r), &n)); b <<= n - 1; while (r) { if (r >= 1) { *this += b; r -= 1; } r *= 2; b >>= 1; } } BigDecimal(long double r) { *this = BigDecimal(0); int n; BigDecimal b = (r >= 0 ? BigDecimal(1) : BigDecimal(-1)); r = 2 * abs(std::frexp(abs(r), &n)); b <<= n - 1; while (r) { if (r >= 1) { *this += b; r -= 1; } r *= 2; b >>= 1; } } BigDecimal(Input &in) { *this = BigDecimal(String(in)); } BigDecimal &normal() { for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) { d[i + 1] += d[i] >> BitSize; d[i] &= (1ll << BitSize) - 1; } if (d.back() < 0) { sign = !sign; for (auto &i : d) { i = -i; } normal(); } if (d.back() >= (1ll << BitSize)) { throw "overflow"; } if (std::all_of(d.begin(), d.end(), [](int64_t i) { return i == 0; })) { sign = PLUS; } return *this; } BigDecimal operator-() const { BigDecimal bd(*this); bd.sign = !bd.sign; return bd; } BigDecimal operator<<(int a) const { return BigDecimal(*this) <<= a; } BigDecimal operator>>(int a) const { return BigDecimal(*this) >>= a; } BigDecimal operator%(const BigDecimal &a) const { return BigDecimal(*this) %= a; } BigDecimal &operator<<=(int a) { if (a < 0) { return *this >>= -a; } while (a >= BitSize) { if (d.back()) { throw "overflow"; } for (int i = IntegerSize + DecimalSize; --i > 0;) { d[i] = d[i - 1]; } d[0] = 0; a -= BitSize; } if (d.back() >= (1ll << (BitSize - a))) { throw "overflow"; } for (auto &i : d) { i <<= a; } return normal(); } BigDecimal &operator>>=(int a) { if (a < 0) { return *this <<= -a; } while (a >= BitSize) { for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) { d[i] = d[i + 1]; } d.back() >>= BitSize; a -= BitSize; } for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) { d[i] |= d[i + 1] << BitSize; d[i + 1] = 0; } for (auto &i : d) { i >>= a; } return normal(); } BigDecimal &operator+=(const BigDecimal &a) { if (sign == a.sign) { for (int i = 0; i < IntegerSize + DecimalSize; ++i) { d[i] += a.d[i]; } } else { for (int i = 0; i < IntegerSize + DecimalSize; ++i) { d[i] -= a.d[i]; } } return normal(); } BigDecimal &operator-=(const BigDecimal &a) { return *this += -a; } BigDecimal &operator*=(const BigDecimal &a) { BigDecimal res = 0; for (int i = 0; i < IntegerSize + DecimalSize; ++i) { if (i < DecimalSize) { res = (res + *this * a.d[i]) >> BitSize; } else { res += *this * a.d[i] << (i - DecimalSize) * BitSize; } } res.sign = (sign == a.sign ? PLUS : MINUS); return *this = res.normal(); } BigDecimal &operator*=(const unsigned int &a) { for (auto &i : d) { i *= a; } return normal(); } BigDecimal &operator/=(const BigDecimal &a) { if (a == 0) { throw "divide by zero"; } BigDecimal rev = 1. / a.toDouble(); for (int i = 0; i < 7; ++i) { rev = (rev << 1) - a * rev * rev; } rev.sign = a.sign; return *this *= rev; } BigDecimal &operator%=(const BigDecimal &a) { if (a == 0) { throw "modulo by zero"; } return *this -= floor(*this / a) * a; } BigDecimal operator-(const BigDecimal &v) const { return BigDecimal(*this) -= v; } BigDecimal &operator++() { return *this += 1; } BigDecimal &operator++(int) { BigDecimal bd = *this; *this += 1; return bd; } BigDecimal &operator--() { return *this -= 1; } BigDecimal &operator--(int) { BigDecimal bd = *this; *this -= 1; return bd; } bool operator<(const BigDecimal &a) const { BigDecimal aa = a - EPSILON; if (sign == MINUS) { if (aa.sign == MINUS) { if (a.sign == MINUS) { return -a < -*this; } else { return *this + EPSILON < a + EPSILON; } } else { return true; } } if (aa.sign == MINUS) { return false; } for (int i = IntegerSize + DecimalSize; i-- > 0;) { if (d[i] != aa.d[i]) { return d[i] < aa.d[i]; } } return false; } bool equals(const BigDecimal &a) const { return sign == a.sign && d == a.d; } int toInt() const { int res = 0; for (int i = 0; i < IntegerSize; ++i) { res += d[DecimalSize + i] << BitSize * i; } if (sign == MINUS) { return -res; } return res; } int64_t toLongLong() const { int64_t res = 0; for (int i = 0; i < IntegerSize; ++i) { res += d[DecimalSize + i] << BitSize * i; } if (sign == MINUS) { return -res; } return res; } String toString(int digit = 100, String mode = "near") const { String str; BigDecimal a = *this, bd = 1; if (a.sign == MINUS) { str += "-"; a.sign = PLUS; } if (mode == "near") { BigDecimal round = BigDecimal(0.5); for (int i = 0; i < digit; ++i) { round /= 10; } a += round + EPSILON; } if (mode == "ceil") { BigDecimal round = 1; for (int i = 0; i < digit; ++i) { round /= 10; } a += round - EPSILON; } for (; bd <= a; bd *= 10) { ++digit; } if (bd > 1) { bd /= 10; --digit; } for (int i = 0; i < digit + 1; ++i) { if (bd == 0) { str += "0"; continue; } if (bd * 10 == 1) { str += "."; } int d = 0; while (bd < a) { a -= bd; ++d; } if (d > 9) { d -= 10; auto itr = str.end(); while (true) { if (itr == str.begin()) { str = "1" + str; break; } --itr; if (*itr == '.') { continue; } ++*itr; if (*itr > '9') { *itr = '0'; } else { break; } } } str += '0' + d; bd /= 10; } return str; } double toDouble() const { double res = 0; for (int i = 0; i < IntegerSize + DecimalSize; ++i) { res += d[i] * pow(2, (i - DecimalSize) * BitSize); } if (sign == MINUS) { return -res; } return res; } bool isPlus() const { return sign == PLUS; } bool isMinus() const { return sign == MINUS; } template <int I, int D> friend BigDecimal<I, D> pow(const BigDecimal<I, D> &x, const BigDecimal<I, D> &y); template <int I, int D> friend BigDecimal<I, D> floor(BigDecimal<I, D> x); }; template <int IntegerSize, int DecimalSize> const long double BigDecimal<IntegerSize, DecimalSize>::EPSILON = std::pow<long double>(2, -(BitSize - 4) * DecimalSize); template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> pi() { const static BigDecimal<IntegerSize, DecimalSize> PI = (atan(BigDecimal<IntegerSize, DecimalSize>(1) / 5) << 4) - (atan(BigDecimal<IntegerSize, DecimalSize>(1) / 239) << 2); return PI; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> operator+(const int &a, BigDecimal<IntegerSize, DecimalSize> b) { return BigDecimal<IntegerSize, DecimalSize>(a) + b; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> operator-(const int &a, BigDecimal<IntegerSize, DecimalSize> b) { return BigDecimal<IntegerSize, DecimalSize>(a) - b; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> operator*(const int &a, BigDecimal<IntegerSize, DecimalSize> b) { return BigDecimal<IntegerSize, DecimalSize>(a) * b; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> operator/(const int &a, BigDecimal<IntegerSize, DecimalSize> b) { return BigDecimal<IntegerSize, DecimalSize>(a) / b; } template <int IntegerSize, int DecimalSize> std::ostream &operator<<(std::ostream &os, BigDecimal<IntegerSize, DecimalSize> a) { os << a.toString(os.precision()); return os; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> sin(BigDecimal<IntegerSize, DecimalSize> x) { BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x; for (int i = 1;; i += 2) { x /= max(i * (i - 1), 1); if (x.equals(0)) { break; } res += x; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> cos(BigDecimal<IntegerSize, DecimalSize> x) { BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x; x = 1; for (int i = 0;; i += 2) { x /= max(i * (i - 1), 1); if (x.equals(0)) { break; } res += x; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> tan(const BigDecimal<IntegerSize, DecimalSize> &x) { return sin(x) / cos(x); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> asin(BigDecimal<IntegerSize, DecimalSize> x) { if (abs(x) > 1) { throw "out of domain"; } if (x > 1 / sqrt(BigDecimal<IntegerSize, DecimalSize>(2))) { return (pi<IntegerSize, DecimalSize>() >> 1) - asin(sqrt(1 - x * x)); } if (x < -1 / sqrt(BigDecimal<IntegerSize, DecimalSize>(2))) { return -(pi<IntegerSize, DecimalSize>() >> 1) + asin(sqrt(1 - x * x)); } BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x >> 2; for (int i = 0;; ++i) { x *= max(i * 2 * (i * 2 - 1), 1); x /= max(i * i, 1); auto add = x / (i * 2 + 1); if (add.equals(0)) { break; } res += add; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> acos(const BigDecimal<IntegerSize, DecimalSize> &x) { return (pi<IntegerSize, DecimalSize>() >> 1) - asin(x); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> atan(BigDecimal<IntegerSize, DecimalSize> x) { if (x.isMinus()) { return -atan(-x); } if (abs(x) > sqrt(2) + 1) { return (pi<IntegerSize, DecimalSize>() >> 1) - atan(1 / x); } if (abs(x) > sqrt(2) - 1) { return (pi<IntegerSize, DecimalSize>() >> 2) + atan((x - 1) / (x + 1)); } BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x; for (int i = 1;; i += 2) { auto add = x / i; if (add.equals(0)) { break; } res += add; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> atan2(const BigDecimal<IntegerSize, DecimalSize> &y, const BigDecimal<IntegerSize, DecimalSize> &x) { if (x == 0) { if (y > 0) { return pi<IntegerSize, DecimalSize>() / 2; } if (y < 0) { return -pi<IntegerSize, DecimalSize>() / 2; } throw "origin can't define argument"; } if (x.isPlus()) { return atan(y / x); } if (y.isPlus()) { return atan(y / x) + pi<IntegerSize, DecimalSize>(); } return atan(y / x) - pi<IntegerSize, DecimalSize>(); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> sinh(BigDecimal<IntegerSize, DecimalSize> x) { BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x; for (int i = 1;; i += 2) { x /= max(i * (i - 1), 1); if (x.equals(0)) { break; } res += x; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> cosh(BigDecimal<IntegerSize, DecimalSize> x) { BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x; x = 1; for (int i = 0;; i += 2) { x /= max(i * (i - 1), 1); if (x.equals(0)) { break; } res += x; x *= xx; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> tanh(const BigDecimal<IntegerSize, DecimalSize> &x) { return sinh(x) / cosh(x); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> exp(const BigDecimal<IntegerSize, DecimalSize> &x) { BigDecimal<IntegerSize, DecimalSize> res = 0, xx = 1; for (int i = 0;; ++i) { xx /= max(i, 1); if (xx.equals(0)) { break; } res += xx; xx *= x; } return res; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> log(const BigDecimal<IntegerSize, DecimalSize> &x) { BigDecimal<IntegerSize, DecimalSize> y = log(x.toDouble()); BigDecimal<IntegerSize, DecimalSize> z = x / exp(y); BigDecimal<IntegerSize, DecimalSize> a = (z - 1) / (z + 1); BigDecimal<IntegerSize, DecimalSize> res = 0, b = a, aa = a * a; for (int i = 1;; i += 2) { if (b.equals(0)) { break; } res += b / i; b *= aa; } return y + res * 2; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> log10(const BigDecimal<IntegerSize, DecimalSize> &x) { return log(x) / log(BigDecimal<IntegerSize, DecimalSize>(10)); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> pow(const BigDecimal<IntegerSize, DecimalSize> &x, const BigDecimal<IntegerSize, DecimalSize> &y) { if (x.isMinus()) { if (floor(y) == y) { return floor(y).d[DecimalSize] % 2 ? -pow(-x, floor(y)) : pow(-x, floor(y)); } throw "power of negative number"; } return exp(y * log(x)); } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> sqrt(const BigDecimal<IntegerSize, DecimalSize> &x) { BigDecimal<IntegerSize, DecimalSize> r = 1 / sqrt(x.toDouble()); for (int i = 0; i < 7; ++i) { r *= (3 - x * r * r) >> 1; } return BigDecimal<IntegerSize, DecimalSize>(1) / r; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> abs(const BigDecimal<IntegerSize, DecimalSize> &x) { return x.isPlus() ? x : -x; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> ceil(const BigDecimal<IntegerSize, DecimalSize> &x) { if (x.isMinus()) { return -floor(-x); } auto f = floor(x); return f == x ? f : x + 1; } template <int IntegerSize, int DecimalSize> BigDecimal<IntegerSize, DecimalSize> floor(BigDecimal<IntegerSize, DecimalSize> x) { if (x.isMinus()) { return -ceil(-x); } x += BigDecimal<IntegerSize, DecimalSize>::EPSILON; for (int i = 0; i < DecimalSize; ++i) { x.d[i] = 0; } return x; } /************/ /* main.cpp */ /************/ int main() { BigDecimal<> v(in), t(in); cout << int((v * t).toDouble()) << endl; }