#414184 (C++17) No.20 砂漠のオアシス

提出ソース
結果

問題	No.20 砂漠のオアシス
ユーザー	not_522
提出日時	2020-01-04 12:55:12
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	42 ms / 5,000 ms
コード長	28,824 bytes
コンパイル時間	1,669 ms
コンパイル使用メモリ	134,284 KB
実行使用メモリ	9,472 KB
最終ジャッジ日時	2024-11-22 20:16:27
合計ジャッジ時間	2,747 ms
ジャッジサーバーID （参考情報）	judge3 / judge5
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	3 ms 5,248 KB
testcase_02	AC	2 ms 5,248 KB
testcase_03	AC	3 ms 5,248 KB
testcase_04	AC	3 ms 5,248 KB
testcase_05	AC	36 ms 8,696 KB
testcase_06	AC	41 ms 9,424 KB
testcase_07	AC	41 ms 9,436 KB
testcase_08	AC	40 ms 9,472 KB
testcase_09	AC	42 ms 9,472 KB
testcase_10	AC	2 ms 5,248 KB
testcase_11	AC	2 ms 5,248 KB
testcase_12	AC	4 ms 5,248 KB
testcase_13	AC	2 ms 5,248 KB
testcase_14	AC	4 ms 5,248 KB
testcase_15	AC	4 ms 5,248 KB
testcase_16	AC	9 ms 5,248 KB
testcase_17	AC	7 ms 5,248 KB
testcase_18	AC	8 ms 5,248 KB
testcase_19	AC	9 ms 5,248 KB
testcase_20	AC	3 ms 5,248 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
// 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;
  }
};

/***********/
/* 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 std::map<T, S>::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;
}

/*******************/
/* 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 <typename Cost> 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 <typename Cost>
std::ostream &operator<<(std::ostream &s, const WeightedEdge<Cost> &edge) {
  s << edge.to << ',' << edge.cost;
  return s;
}

template <typename Capacity> 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 <typename Capacity, typename Cost>
struct WeightedResidualEdge : public ResidualEdge<Capacity> {
  Cost cost;
  WeightedResidualEdge(int to = -1, Capacity cap = 0, Cost cost = 0)
      : ResidualEdge<Capacity>(to, cap), cost(cost) {}

  WeightedResidualEdge(Input &in) {
    ResidualEdge<Capacity> edge(in);
    Cost cost(in);
    *this = WeightedResidualEdge(edge, cost);
  }

  WeightedResidualEdge reverse(int from) const {
    return WeightedResidualEdge(from, 0, -cost);
  }
};

template <typename Edge> 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 <typename Edge>
std::ostream &operator<<(std::ostream &s, const FullEdge<Edge> &edge) {
  s << '(' << edge.from << ',' << Edge(edge) << ')';
  return s;
}

template <typename Edge> class Graph {
public:
  using EdgeType = Edge;

  virtual int size() const = 0;
  template <typename... Args> void addEdge(int from, int to, Args...) {
    (void)from;
    (void)to;
  }
  template <typename... Args>
  void addUndirectedEdge(int from, int to, Args...) {
    (void)from;
    (void)to;
  }

  Vector<FullEdge<Edge>> getAllEdges() const {
    Vector<FullEdge<Edge>> res;
    for (int i = 0; i < size(); ++i) {
      for (const auto &edge : getEdges(i)) {
        res.emplace_back(i, edge);
      }
    }
    return res;
  }

  virtual Vector<Edge> 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<int> getIndegree() const {
    Vector<int> degree(size());
    for (const auto &edge : getAllEdges()) {
      ++degree[edge.to];
    }
    return degree;
  }
};

template <typename Graph>
Graph readGraph(Input &in, int n, int m, bool undirected, bool one_origin) {
  Graph graph(n);
  for (int i = 0; i < m; ++i) {
    FullEdge<typename Graph::EdgeType> 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 <typename Edge> class AdjacencyList : public Graph<Edge> {
protected:
  Vector<Vector<Edge>> 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<AdjacencyList<Edge>>(in, n, m, undirected, one_origin);
  }

  AdjacencyList(Input &in, int n, int m, bool undirected = true,
                bool one_origin = true) {
    *this = readGraph<AdjacencyList<Edge>>(in, n, m, undirected, one_origin);
  }

  int size() const { return graph.size(); }

  template <typename... Args> void addEdge(int from, int to, Args... args) {
    graph[from].emplace_back(to, args...);
  }

  void addEdge(const FullEdge<Edge> &edge) {
    graph[edge.from].emplace_back(edge);
  }

  template <typename... Args>
  void addUndirectedEdge(int from, int to, Args... args) {
    addEdge(from, to, args...);
    addEdge(to, from, args...);
  }

  void addUndirectedEdge(FullEdge<Edge> edge) {
    graph[edge.from].emplace_back(edge);
    swap(edge.from, edge.to);
    graph[edge.from].emplace_back(edge);
  }

  Vector<Edge> 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<Edge> &operator[](int v) { return graph[v]; }

  const Vector<Edge> &operator[](int v) const { return graph[v]; }
};
/********************/
/* graph/search.hpp */
/********************/

template <typename Graph, typename State> class Search {
protected:
  using Edge = typename Graph::EdgeType;

  const Graph graph;
  Vector<bool> 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<int> &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<int>({from})); }

  bool isReachable(int v) { return visited[v]; }
};
/******************/
/* graph/tree.hpp */
/******************/

template <typename Edge> class Tree {
public:
  using EdgeType = Edge;

  Vector<Edge> parent;
  Vector<Vector<int>> children;
  Vector<int> 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 <typename... Args> 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<Edge> getEdges(int from) const {
    Vector<Edge> 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<int> getPath(int v) {
    Vector<int> res{v};
    while (v != parent[v].to) {
      v = parent[v].to;
      res.emplace_back(v);
    }
    return res;
  }
};
/**********************/
/* priority_queue.hpp */
/**********************/

#include <queue>

template <typename T, bool less> class Comp {
public:
  bool operator()(const T &a, const T &b) const {
    return less ? a < b : !(a < b);
  }
};

template <typename T, bool less = true>
class PriorityQueue
    : public std::priority_queue<T, std::vector<T>, Comp<T, less>> {
private:
  using Queue = std::priority_queue<T, std::vector<T>, Comp<T, less>>;

public:
  PriorityQueue() : Queue() {}

  PriorityQueue(const std::initializer_list<T> &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 <typename Edge> 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 <typename Graph, bool Restoration = false,
          typename State = DijkstraState<typename Graph::EdgeType>>
class Dijkstra : public Search<Graph, State> {
protected:
  using Edge = typename Graph::EdgeType;
  using Cost = typename Edge::CostType;

  PriorityQueue<State> 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<Cost> dis;
  Tree<Edge> shortestPathTree;

  Dijkstra(const Graph &graph)
      : Search<Graph, State>(graph), dis(graph.size(), inf<Cost>()) {
    if (Restoration) {
      shortestPathTree = Tree<Edge>(graph.size());
    }
  }
};

template <typename Graph> Dijkstra<Graph> shortestPath(Graph &graph, int from) {
  Dijkstra<Graph> dijkstra(graph);
  dijkstra.solve(from);
  return dijkstra;
}

template <typename Graph>
typename Graph::EdgeType::CostType shortestPath(Graph &graph, int from,
                                                int to) {
  return shortestPath(graph, from).dis[to];
}

template <typename Graph>
Dijkstra<Graph, true> shortestPathTree(Graph &graph, int from) {
  Dijkstra<Graph, true> 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<int>::makeVector(in, n, n);
  AdjacencyList<WeightedEdge<int>> 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;
  }
}
yukicoder

結果

テストケース

ソースコード
