結果
問題 | No.240 ナイト散歩 |
ユーザー |
![]() |
提出日時 | 2020-01-04 12:11:39 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 20 ms / 2,000 ms |
コード長 | 9,292 bytes |
コンパイル時間 | 1,209 ms |
コンパイル使用メモリ | 111,340 KB |
最終ジャッジ日時 | 2025-01-08 16:13:15 |
ジャッジサーバーID (参考情報) |
judge5 / judge5 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 4 |
other | AC * 30 |
ソースコード
// 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;while (!(this->eof = (std::scanf("%c", &v) != 1)) && std::isspace(v)) {}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;}/*************//* 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(this->begin(),std::max_element(this->begin(), this->end()));}int argmin() const {return std::distance(this->begin(),std::min_element(this->begin(), this->end()));}int find(const S &a) const {return std::distance(this->begin(),std::find(this->begin(), this->end(), a));}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;}};/***********//* set.hpp *//***********/#include <set>template <typename T> class Set : public Container<std::set<T>> {public:Set() : Container<std::set<T>>() {}template <typename Itr>Set(Itr first, Itr last) : Container<std::set<T>>(first, last) {}Set(const std::initializer_list<T> &s) : Container<std::set<T>>(s) {}template <typename S> Set<T> &operator&=(const S &a) {Set<T> r;if (this->size() < a.size()) {for (const auto &i : *this) {if (a.in(i)) {r.emplace(i);}}} else {for (const auto &i : a) {if (this->in(i)) {r.emplace(i);}}}*this = r;return *this;}int count(const T &a) const { return std::set<T>::count(a); }int contains(const T &a) const { return count(a) > 0; }};/************//* main.cpp *//************/int main() {setBoolName("YES", "NO");Set<Tuple<int, int>> s;s.emplace(0, 0);const int dy[] = {-2, -2, -1, -1, 1, 1, 2, 2};const int dx[] = {-1, 1, -2, 2, -2, 2, -1, 1};for (int i = 0; i < 3; ++i) {auto ss = s;for (auto p : s) {for (int k = 0; k < 8; ++k) {ss.emplace(p.get<0>() + dy[k], p.get<1>() + dx[k]);}}s = ss;}int x(in), y(in);cout << bool(s.count(makeTuple(x, y))) << endl;}