// 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 /****************/ /* template.hpp */ /****************/ #include #include #include #include #include #include using std::cerr; using std::cout; using std::endl; using std::max; using std::min; using std::swap; struct BoolName : std::numpunct { 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 T abs(T a) { return a >= 0 ? a : -a; } template bool chmin(T &a, const S &b) { return a > b ? a = b, true : false; } template bool chmax(T &a, const S &b) { return a < b ? a = b, true : false; } template std::function cast() { return [](const T &t) { return static_cast(t); }; } template 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 constexpr T inf() { return std::numeric_limits::max() / 2 - 1; } /*************/ /* tuple.hpp */ /*************/ #include template class Tuple : public std::tuple { public: Tuple(Input &in) : std::tuple() { (void)in; } }; template class Tuple : public std::tuple { public: Tuple() : std::tuple() {} Tuple(T t, S... s) : std::tuple(t, s...) {} Tuple(const std::tuple &t) : std::tuple(t) {} Tuple(Input &in) { auto a = std::tuple(in); std::tuple b = Tuple(in); std::tuple c = std::tuple_cat(a, b); *this = c; } template auto &get() { return std::get(*this); } template const auto &get() const { return std::get(*this); } }; template Tuple makeTuple(const T &... args) { return Tuple(args...); } namespace std { template class tuple_size> : public std::integral_constant {}; template class tuple_element> { public: using type = tuple_element_t>; }; } // namespace std /*****************/ /* container.hpp */ /*****************/ #include template 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 Container(Itr first, Itr last) : T(first, last) {} Container(const std::initializer_list &v) : T(v) {} Container(int n, Input &in) { std::vector v(n); for (auto &i : v) { i = in; } *this = Container(v.begin(), v.end()); } S max() const { return *std::max_element(this->begin(), this->end()); } template auto max(Function func) const { std::vector> 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 minmax() const { auto itrs = std::minmax_element(this->begin(), this->end()); return Tuple(*itrs.first, *itrs.second); } template auto min(Function func) const { std::vector> 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 equal_range(const S &a) { return std::equal_range(this->begin(), this->end(), a); } template bool all_of(Function func) const { return std::all_of(this->begin(), this->end(), func); } template bool any_of(Function func) const { return std::any_of(this->begin(), this->end(), func); } template 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 template class Map : public Container> { public: Map() : Container>() {} bool contains(const T &a) const { return this->count(a) != 0; } int count(const T &t) const { return std::map::count(t); } }; /***************/ /* ordered.hpp */ /***************/ template class Ordered { public: template bool operator==(const V &v) const { return !(static_cast(v) < static_cast(*this) || static_cast(*this) < static_cast(v)); } template bool operator!=(const V &v) const { return static_cast(v) < static_cast(*this) || static_cast(*this) < static_cast(v); } template bool operator>(const V &v) const { return static_cast(v) < static_cast(*this); } template bool operator<=(const V &v) const { return !(static_cast(v) < static_cast(*this)); } template bool operator>=(const V &v) const { return !(static_cast(*this) < static_cast(v)); } }; /**************/ /* vector.hpp */ /**************/ #include template class Vector : public Container>, public Ordered> { public: Vector() = default; Vector(const Vector &v) = default; Vector(int n) : Container>(n) {} Vector(int n, T t) : Container>(n, t) {} template Vector(Itr first, Itr last) : Container>(first, last) {} Vector(const std::initializer_list &v) : Container>(v) {} Vector(int n, Input &in) : Container>(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 &v) const { return std::inner_product(this->begin(), this->end(), v.begin(), T(0)); } Vector &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()); } return *this; } Vector &sort() { std::sort(this->begin(), this->end()); return *this; } template Vector &sort(Function func) { std::sort(this->begin(), this->end(), func); return *this; } Vector &rsort() { std::sort(this->rbegin(), this->rend()); return *this; } Vector argsort() const { Vector> v; for (int i = 0; i < this->size(); ++i) { v.emplace_back((*this)[i], i); } v.sort(); auto f = [](const Tuple &t) { return t.template get<1>(); }; return v.transform(f); } Vector &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()); } return *this; } Vector subvector(int a) const { return Vector(this->begin(), this->begin() + a); } Vector subvector(int a, int b) const { return Vector(this->begin() + a, this->begin() + b); } template auto transform(Function func) const { Vector res; std::transform(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector partial_sum() const { Vector res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res)); return res; } template Vector partial_sum(Function func) const { Vector res; std::partial_sum(this->begin(), this->end(), std::back_inserter(res), func); return res; } Vector &reverse() { std::reverse(this->begin(), this->end()); return *this; } template int count_if(Function func) const { return std::count_if(this->begin(), this->end(), func); } Vector adjacent_difference() const { Vector 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 S accumulate(S n, Function func) const { return std::accumulate(this->begin(), this->end(), n, func); } template static Vector makeVector(Int n) { return Vector(n); } template static Vector makeVector(Input &in, Int n) { return Vector(n, in); } template static auto makeVector(Input &in, Int n, Ints... ints) { Vector res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(in, ints...)); } return res; } template static auto makeVector(Int n, Ints... ints) { Vector res; for (int i = 0; i < n; ++i) { res.emplace_back(makeVector(ints...)); } return res; } Vector &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 &rotate(int n) { std::rotate(this->begin(), this->begin() + n, this->end()); return *this; } Map countAll() const { Map 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 Vector iota(int n, T m = 0) { Vector v(n); std::iota(v.begin(), v.end(), m); return v; } template void read(Vector &t, Vector &s) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); } } template void read(Vector &t, Vector &s, Vector &u) { for (int i = 0; i < t.size(); ++i) { t[i] = T(in); s[i] = S(in); u[i] = U(in); } } template Vector operator+(const T &a, const Vector &b) { return b + a; } template Vector operator-(const T &a, const Vector &b) { return -b + a; } template Vector operator*(const T &a, const Vector &b) { return b * a; } /*******************/ /* graph/graph.hpp */ /*******************/ struct Edge { using CostType = int; const static int cost = 1; int to; Edge(int to = -1) : to(to) {} Edge(Input &in) : to(in) {} bool isNone() const { return to == -1; } operator int() const { return to; } }; std::ostream &operator<<(std::ostream &s, const Edge &edge) { s << edge.to; return s; } template struct WeightedEdge : public Edge { using CostType = Cost; Cost cost; WeightedEdge(int to = -1, Cost cost = 0) : Edge(to), cost(cost) {} WeightedEdge(Input &in) : Edge(in), cost(in) {} }; template std::ostream &operator<<(std::ostream &s, const WeightedEdge &edge) { s << edge.to << ',' << edge.cost; return s; } template struct ResidualEdge : public Edge { using CapacityType = Capacity; Capacity cap; int rev; ResidualEdge(int to = -1, Capacity cap = 0) : Edge(to), cap(cap) {} ResidualEdge(Input &in) { Edge edge(in); Capacity cap(in); *this = ResidualEdge(edge, cap); } ResidualEdge reverse(int from) const { return ResidualEdge(from, 0); } }; template struct WeightedResidualEdge : public ResidualEdge { Cost cost; WeightedResidualEdge(int to = -1, Capacity cap = 0, Cost cost = 0) : ResidualEdge(to, cap), cost(cost) {} WeightedResidualEdge(Input &in) { ResidualEdge edge(in); Cost cost(in); *this = WeightedResidualEdge(edge, cost); } WeightedResidualEdge reverse(int from) const { return WeightedResidualEdge(from, 0, -cost); } }; template struct FullEdge : public Edge { int from; FullEdge() = default; FullEdge(const int from, const Edge &edge) : Edge(edge), from(from) {} FullEdge(Input &in) { int from(in); Edge edge(in); *this = FullEdge(from, edge); } }; template std::ostream &operator<<(std::ostream &s, const FullEdge &edge) { s << '(' << edge.from << ',' << Edge(edge) << ')'; return s; } template class Graph { public: using EdgeType = Edge; virtual int size() const = 0; template void addEdge(int from, int to, Args...) { (void)from; (void)to; } template void addUndirectedEdge(int from, int to, Args...) { (void)from; (void)to; } Vector> getAllEdges() const { Vector> res; for (int i = 0; i < size(); ++i) { for (const auto &edge : getEdges(i)) { res.emplace_back(i, edge); } } return res; } virtual Vector getEdges(int from) const = 0; virtual Edge getEdge(int from, int to) const = 0; virtual bool hasEdge(int from, int to) const = 0; int getDegree(int v) const { return getEdges(v).size(); } Vector getIndegree() const { Vector degree(size()); for (const auto &edge : getAllEdges()) { ++degree[edge.to]; } return degree; } }; template Graph readGraph(Input &in, int n, int m, bool undirected, bool one_origin) { Graph graph(n); for (int i = 0; i < m; ++i) { FullEdge edge(in); if (one_origin) { --edge.from; --edge.to; } if (undirected) { graph.addUndirectedEdge(edge); } else { graph.addEdge(edge); } } return graph; } /****************************/ /* graph/adjacency_list.hpp */ /****************************/ template class AdjacencyList : public Graph { protected: Vector> graph; public: using EdgeType = Edge; AdjacencyList() = default; AdjacencyList(int n) : graph(n) {} AdjacencyList(Input &in, bool undirected = true, bool one_origin = true) { int n(in), m(in); *this = readGraph>(in, n, m, undirected, one_origin); } AdjacencyList(Input &in, int n, int m, bool undirected = true, bool one_origin = true) { *this = readGraph>(in, n, m, undirected, one_origin); } int size() const { return graph.size(); } template void addEdge(int from, int to, Args... args) { graph[from].emplace_back(to, args...); } void addEdge(const FullEdge &edge) { graph[edge.from].emplace_back(edge); } template void addUndirectedEdge(int from, int to, Args... args) { addEdge(from, to, args...); addEdge(to, from, args...); } void addUndirectedEdge(FullEdge edge) { graph[edge.from].emplace_back(edge); swap(edge.from, edge.to); graph[edge.from].emplace_back(edge); } Vector getEdges(int from) const { return graph[from]; } Edge getEdge(int from, int to) const { Edge res; for (const auto &edge : graph[from]) { if (edge.to == to) { res = edge; } } return res; } bool hasEdge(int from, int to) const { for (const auto &edge : graph[from]) { if (edge.to == to) { return true; } } return false; } Vector &operator[](int v) { return graph[v]; } const Vector &operator[](int v) const { return graph[v]; } }; /********************/ /* graph/search.hpp */ /********************/ template class Search { protected: using Edge = typename Graph::EdgeType; const Graph graph; Vector visited; virtual void push(const State &) = 0; virtual State next() = 0; virtual bool isRunning() = 0; virtual void visit(const State &) {} public: Search(const Graph &graph) : graph(graph), visited(graph.size(), false) {} void solve(const Vector &from) { for (int i : from) { push(State(i)); } while (isRunning()) { State now = next(); int pos = now.getPos(); if (visited[pos]) { continue; } visited[pos] = true; visit(now); for (const Edge &edge : graph.getEdges(pos)) { State nextState = now.next(pos, edge); if (visited[nextState.getPos()]) { continue; } push(nextState); } } } void solve(int from) { solve(Vector({from})); } bool isReachable(int v) { return visited[v]; } }; /******************/ /* graph/tree.hpp */ /******************/ template class Tree { public: using EdgeType = Edge; Vector parent; Vector> children; Vector depth; Tree() {} Tree(int n) : children(n), depth(n, -1) { for (int i = 0; i < n; ++i) { parent.emplace_back(i); } } Tree(int n, Input in) : children(n), depth(n, -1) { for (int i = 0; i < n; ++i) { parent.emplace_back(i); } for (int i = 1; i < n; ++i) { this->addEdge(i, int(in) - 1); } } int size() const { return parent.size(); } template void addEdge(int from, int to, Args... args) { parent[from] = Edge(to, args...); children[to].emplace_back(from); } void addEdge(int from, const Edge &edge) { parent[from] = edge; children[edge.to].emplace_back(from); } Vector getEdges(int from) const { Vector res; for (int v : children[from]) { auto e = parent[v]; e.to = v; res.emplace_back(e); } if (from != parent[from].to) { res.emplace_back(parent[from]); } return res; } int getDepth(int v) { if (depth[v] != -1) { return depth[v]; } if (parent[v].to == v) { return depth[v] = 0; } return depth[v] = getDepth(parent[v].to) + 1; } Vector getPath(int v) { Vector res{v}; while (v != parent[v].to) { v = parent[v].to; res.emplace_back(v); } return res; } }; /**********************/ /* priority_queue.hpp */ /**********************/ #include template class Comp { public: bool operator()(const T &a, const T &b) const { return less ? a < b : !(a < b); } }; template class PriorityQueue : public std::priority_queue, Comp> { private: using Queue = std::priority_queue, Comp>; public: PriorityQueue() : Queue() {} PriorityQueue(const std::initializer_list &s) : Queue(s) {} T top() { T res = Queue::top(); Queue::pop(); return res; } T peek() const { return Queue::top(); } void pop() const { assert(false); } }; /***************************/ /* graph/shortest_path.hpp */ /***************************/ template struct DijkstraState { using Cost = typename Edge::CostType; int from; Edge edge; Cost cost; DijkstraState(const int pos) : from(pos), edge(pos), cost(0) {} DijkstraState(const int from, const Edge &edge, const Cost cost) : from(from), edge(edge), cost(cost) {} DijkstraState next(const int from, const Edge &edge) const { return DijkstraState(from, edge, cost + edge.cost); } bool operator<(const DijkstraState &state) const { return cost > state.cost; } int getPos() const { return edge.to; } }; template > class Dijkstra : public Search { protected: using Edge = typename Graph::EdgeType; using Cost = typename Edge::CostType; PriorityQueue que; void push(const State &state) { if (dis[state.getPos()] <= state.cost) { return; } que.push(state); dis[state.getPos()] = state.cost; } State next() { State now = que.top(); return now; } bool isRunning() { return !que.empty(); } void visit(const State &state) { if (Restoration) { int from = state.from, to = state.edge.to; if (from != to) { auto e = state.edge; e.to = from; shortestPathTree.addEdge(to, e); } } } public: Vector dis; Tree shortestPathTree; Dijkstra(const Graph &graph) : Search(graph), dis(graph.size(), inf()) { if (Restoration) { shortestPathTree = Tree(graph.size()); } } }; template Dijkstra shortestPath(Graph &graph, int from) { Dijkstra dijkstra(graph); dijkstra.solve(from); return dijkstra; } template typename Graph::EdgeType::CostType shortestPath(Graph &graph, int from, int to) { return shortestPath(graph, from).dis[to]; } template Dijkstra shortestPathTree(Graph &graph, int from) { Dijkstra dijkstra(graph); dijkstra.solve(from); return dijkstra; } /************/ /* main.cpp */ /************/ int main() { setBoolName("YES", "NO"); int n(in), v(in), x(in), y(in); --x, --y; auto l = Vector::makeVector(in, n, n); AdjacencyList> graph(n * n); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (i != n - 1) { graph.addEdge(i * n + j, i * n + j + n, l[i + 1][j]); graph.addEdge(i * n + j + n, i * n + j, l[i][j]); } if (j != n - 1) { graph.addEdge(i * n + j, i * n + j + 1, l[i][j + 1]); graph.addEdge(i * n + j + 1, i * n + j, l[i][j]); } } } if (shortestPath(graph, 0, n * n - 1) < v) { cout << true << endl; } else if (x == -1 && y == -1) { cout << false << endl; } else { cout << ((v - shortestPath(graph, 0, y * n + x)) * 2 > shortestPath(graph, y * n + x, n * n - 1)) << endl; } }