結果
問題 | No.2805 Go to School |
ユーザー | 👑 Nachia |
提出日時 | 2024-07-12 22:13:27 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
AC
|
実行時間 | 167 ms / 2,000 ms |
コード長 | 15,465 bytes |
コンパイル時間 | 1,718 ms |
コンパイル使用メモリ | 135,368 KB |
実行使用メモリ | 19,456 KB |
最終ジャッジ日時 | 2024-07-16 01:40:07 |
合計ジャッジ時間 | 5,316 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge3 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
5,248 KB |
testcase_01 | AC | 2 ms
5,376 KB |
testcase_02 | AC | 2 ms
5,376 KB |
testcase_03 | AC | 2 ms
5,376 KB |
testcase_04 | AC | 64 ms
17,380 KB |
testcase_05 | AC | 90 ms
15,392 KB |
testcase_06 | AC | 50 ms
9,408 KB |
testcase_07 | AC | 45 ms
9,704 KB |
testcase_08 | AC | 76 ms
14,996 KB |
testcase_09 | AC | 50 ms
9,548 KB |
testcase_10 | AC | 48 ms
10,476 KB |
testcase_11 | AC | 167 ms
17,440 KB |
testcase_12 | AC | 100 ms
13,364 KB |
testcase_13 | AC | 143 ms
18,316 KB |
testcase_14 | AC | 21 ms
5,416 KB |
testcase_15 | AC | 1 ms
5,376 KB |
testcase_16 | AC | 2 ms
5,376 KB |
testcase_17 | AC | 2 ms
5,376 KB |
testcase_18 | AC | 73 ms
11,340 KB |
testcase_19 | AC | 48 ms
8,196 KB |
testcase_20 | AC | 107 ms
15,676 KB |
testcase_21 | AC | 143 ms
16,724 KB |
testcase_22 | AC | 64 ms
9,556 KB |
testcase_23 | AC | 98 ms
13,792 KB |
testcase_24 | AC | 99 ms
13,948 KB |
testcase_25 | AC | 33 ms
7,748 KB |
testcase_26 | AC | 119 ms
19,092 KB |
testcase_27 | AC | 51 ms
13,160 KB |
testcase_28 | AC | 6 ms
6,304 KB |
testcase_29 | AC | 10 ms
6,732 KB |
testcase_30 | AC | 28 ms
9,496 KB |
testcase_31 | AC | 48 ms
9,576 KB |
testcase_32 | AC | 105 ms
17,776 KB |
testcase_33 | AC | 134 ms
19,456 KB |
testcase_34 | AC | 2 ms
5,376 KB |
testcase_35 | AC | 2 ms
5,376 KB |
testcase_36 | AC | 51 ms
8,080 KB |
testcase_37 | AC | 52 ms
9,120 KB |
testcase_38 | AC | 100 ms
12,960 KB |
ソースコード
#ifdef NACHIA #define _GLIBCXX_DEBUG #else #define NDEBUG #endif #include <iostream> #include <string> #include <vector> #include <algorithm> #include <utility> #include <queue> #include <array> #include <cmath> using i64 = long long; using u64 = unsigned long long; #define rep(i,n) for(int i=0; i<int(n); i++) #define repr(i,n) for(int i=int(n)-1; i>=0; i--) const i64 INF = 1001001001001001001; const char* yn(bool x){ return x ? "Yes" : "No"; } template<typename A> void chmin(A& l, const A& r){ if(r < l) l = r; } template<typename A> void chmax(A& l, const A& r){ if(l < r) l = r; } template<typename A> using nega_queue = std::priority_queue<A,std::vector<A>,std::greater<A>>; template<class R> auto ComparingBy(R f){ return [g=std::move(f)](auto l, auto r) -> bool { return g(l) < g(r); }; } #include <atcoder/modint> using Modint = atcoder::static_modint<998244353>; #include <iterator> #include <functional> template<class Elem> struct vec; template<class Iter> struct seq_view{ using Ref = typename std::iterator_traits<Iter>::reference; using Elem = typename std::iterator_traits<Iter>::value_type; Iter a, b; Iter begin() const { return a; } Iter end() const { return b; } int size() const { return (int)(b-a); } seq_view(Iter first, Iter last) : a(first), b(last) {} seq_view sort() const { std::sort(a, b); return *this; } Ref& operator[](int x){ return *(a+x); } template<class F = std::less<Elem>, class ret = vec<int>> ret sorti(F f = F()) const { ret x(size()); for(int i=0; i<size(); i++) x[i] = i; x().sort([&](int l, int r){ return f(a[l],a[r]); }); return x; } template<class ret = vec<Elem>> ret col() const { return ret(begin(), end()); } template<class F = std::equal_to<Elem>, class ret = vec<std::pair<Elem, int>>> ret rle(F eq = F()) const { auto x = ret(); for(auto& a : (*this)){ if(x.size() == 0 || !eq(x[x.size()-1].first, a)) x.emp(a, 1); else x[x.size()-1].second++; } return x; } template<class F> seq_view sort(F f) const { std::sort(a, b, f); return *this; } Iter uni() const { return std::unique(a, b); } Iter lb(const Elem& x) const { return std::lower_bound(a, b, x); } Iter ub(const Elem& x) const { return std::upper_bound(a, b, x); } int lbi(const Elem& x) const { return lb(x) - a; } int ubi(const Elem& x) const { return ub(x) - a; } seq_view bound(const Elem& l, const Elem& r) const { return { lb(l), lb(r) }; } template<class F> Iter lb(const Elem& x, F f) const { return std::lower_bound(a, b, x, f); } template<class F> Iter ub(const Elem& x, F f) const { return std::upper_bound(a, b, x, f); } template<class F> Iter when_true_to_false(F f) const { if(a == b) return a; return std::lower_bound(a, b, *a, [&](const Elem& x, const Elem&){ return f(x); }); } seq_view same(Elem x) const { return { lb(x), ub(x) }; } template<class F> auto map(F f) const { vec<typename Iter::value_type> r; for(auto& x : *this) r.emp(f(x)); return r; } Iter max() const { return std::max_element(a, b); } Iter min() const { return std::min_element(a, b); } template<class F = std::less<Elem>> Iter min(F f) const { return std::min_element(a, b, f); } seq_view rev() const { std::reverse(a, b); return *this; } }; template<class Elem> struct vec { using Base = typename std::vector<Elem>; using Iter = typename Base::iterator; using CIter = typename Base::const_iterator; using View = seq_view<Iter>; using CView = seq_view<CIter>; vec(){} explicit vec(int n, const Elem& value = Elem()) : a(0<n?n:0, value) {} template <class I2> vec(I2 first, I2 last) : a(first, last) {} vec(std::initializer_list<Elem> il) : a(std::move(il)) {} vec(Base b) : a(std::move(b)) {} operator Base() const { return a; } Iter begin(){ return a.begin(); } CIter begin() const { return a.begin(); } Iter end(){ return a.end(); } CIter end() const { return a.end(); } int size() const { return a.size(); } bool empty() const { return a.empty(); } Elem& back(){ return a.back(); } const Elem& back() const { return a.back(); } vec sortunied(){ vec x = *this; x().sort(); x.a.erase(x().uni(), x.end()); return x; } Iter operator()(int x){ return a.begin() + x; } CIter operator()(int x) const { return a.begin() + x; } View operator()(int l, int r){ return { (*this)(l), (*this)(r) }; } CView operator()(int l, int r) const { return { (*this)(l), (*this)(r) }; } View operator()(){ return (*this)(0,size()); } CView operator()() const { return (*this)(0,size()); } Elem& operator[](int x){ return a[x]; } const Elem& operator[](int x) const { return a[x]; } Base& operator*(){ return a; } const Base& operator*() const { return a; } vec& push(Elem args){ a.push_back(std::move(args)); return *this; } template<class... Args> vec& emp(Args &&... args){ a.emplace_back(std::forward<Args>(args) ...); return *this; } template<class Range> vec& app(Range& x){ for(auto& v : a) emp(v); } Elem pop(){ Elem x = std::move(a.back()); a.pop_back(); return x; } bool operator==(const vec& r) const { return a == r.a; } bool operator!=(const vec& r) const { return a != r.a; } bool operator<(const vec& r) const { return a < r.a; } bool operator<=(const vec& r) const { return a <= r.a; } bool operator>(const vec& r) const { return a > r.a; } bool operator>=(const vec& r) const { return a >= r.a; } vec<vec<Elem>> pile(int n) const { return vec<vec<Elem>>(n, *this); } template<class F> vec& filter(F f){ int p = 0; for(int q=0; q<size(); q++) if(f(a[q])) std::swap(a[p++],a[q]); a.resize(p); return *this; } private: Base a; }; template<class IStr, class U, class T> IStr& operator>>(IStr& is, vec<std::pair<U,T>>& v){ for(auto& x:v){ is >> x.first >> x.second; } return is; } template<class IStr, class T> IStr& operator>>(IStr& is, vec<T>& v){ for(auto& x:v){ is >> x; } return is; } template<class OStr, class T> OStr& operator<<(OStr& os, const vec<T>& v){ for(int i=0; i<v.size(); i++){ if(i){ os << ' '; } os << v[i]; } return os; } template<class OStr, class U, class T> OStr& operator<<(OStr& os, const vec<std::pair<U,T>>& v){ for(int i=0; i<v.size(); i++){ if(i){ os << ' '; } os << '(' << v[i].first << ',' << v[i].second << ')'; } return os; } #include <cassert> namespace nachia{ template<class Elem> class CsrArray{ public: struct ListRange{ using iterator = typename std::vector<Elem>::iterator; iterator begi, endi; iterator begin() const { return begi; } iterator end() const { return endi; } int size() const { return (int)std::distance(begi, endi); } Elem& operator[](int i) const { return begi[i]; } }; struct ConstListRange{ using iterator = typename std::vector<Elem>::const_iterator; iterator begi, endi; iterator begin() const { return begi; } iterator end() const { return endi; } int size() const { return (int)std::distance(begi, endi); } const Elem& operator[](int i) const { return begi[i]; } }; private: int m_n; std::vector<Elem> m_list; std::vector<int> m_pos; public: CsrArray() : m_n(0), m_list(), m_pos() {} static CsrArray Construct(int n, std::vector<std::pair<int, Elem>> items){ CsrArray res; res.m_n = n; std::vector<int> buf(n+1, 0); for(auto& [u,v] : items){ ++buf[u]; } for(int i=1; i<=n; i++) buf[i] += buf[i-1]; res.m_list.resize(buf[n]); for(int i=(int)items.size()-1; i>=0; i--){ res.m_list[--buf[items[i].first]] = std::move(items[i].second); } res.m_pos = std::move(buf); return res; } static CsrArray FromRaw(std::vector<Elem> list, std::vector<int> pos){ CsrArray res; res.m_n = pos.size() - 1; res.m_list = std::move(list); res.m_pos = std::move(pos); return res; } ListRange operator[](int u) { return ListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; } ConstListRange operator[](int u) const { return ConstListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; } int size() const { return m_n; } int fullSize() const { return (int)m_list.size(); } }; } // namespace nachia namespace nachia{ struct Graph { public: struct Edge{ int from, to; void reverse(){ std::swap(from, to); } int xorval() const { return from ^ to; } }; Graph(int n = 0, bool undirected = false, int m = 0) : m_n(n), m_e(m), m_isUndir(undirected) {} Graph(int n, const std::vector<std::pair<int, int>>& edges, bool undirected = false) : m_n(n), m_isUndir(undirected){ m_e.resize(edges.size()); for(std::size_t i=0; i<edges.size(); i++) m_e[i] = { edges[i].first, edges[i].second }; } template<class Cin> static Graph Input(Cin& cin, int n, bool undirected, int m, bool offset = 0){ Graph res(n, undirected, m); for(int i=0; i<m; i++){ int u, v; cin >> u >> v; res[i].from = u - offset; res[i].to = v - offset; } return res; } int numVertices() const noexcept { return m_n; } int numEdges() const noexcept { return int(m_e.size()); } int addNode() noexcept { return m_n++; } int addEdge(int from, int to){ m_e.push_back({ from, to }); return numEdges() - 1; } Edge& operator[](int ei) noexcept { return m_e[ei]; } const Edge& operator[](int ei) const noexcept { return m_e[ei]; } Edge& at(int ei) { return m_e.at(ei); } const Edge& at(int ei) const { return m_e.at(ei); } auto begin(){ return m_e.begin(); } auto end(){ return m_e.end(); } auto begin() const { return m_e.begin(); } auto end() const { return m_e.end(); } bool isUndirected() const noexcept { return m_isUndir; } void reverseEdges() noexcept { for(auto& e : m_e) e.reverse(); } void contract(int newV, const std::vector<int>& mapping){ assert(numVertices() == int(mapping.size())); for(int i=0; i<numVertices(); i++) assert(0 <= mapping[i] && mapping[i] < newV); for(auto& e : m_e){ e.from = mapping[e.from]; e.to = mapping[e.to]; } m_n = newV; } std::vector<Graph> induce(int num, const std::vector<int>& mapping) const { int n = numVertices(); assert(n == int(mapping.size())); for(int i=0; i<n; i++) assert(-1 <= mapping[i] && mapping[i] < num); std::vector<int> indexV(n), newV(num); for(int i=0; i<n; i++) if(mapping[i] >= 0) indexV[i] = newV[mapping[i]]++; std::vector<Graph> res; res.reserve(num); for(int i=0; i<num; i++) res.emplace_back(newV[i], isUndirected()); for(auto e : m_e) if(mapping[e.from] == mapping[e.to] && mapping[e.to] >= 0) res[mapping[e.to]].addEdge(indexV[e.from], indexV[e.to]); return res; } CsrArray<int> getEdgeIndexArray(bool undirected) const { std::vector<std::pair<int, int>> src; src.reserve(numEdges() * (undirected ? 2 : 1)); for(int i=0; i<numEdges(); i++){ auto e = operator[](i); src.emplace_back(e.from, i); if(undirected) src.emplace_back(e.to, i); } return CsrArray<int>::Construct(numVertices(), src); } CsrArray<int> getEdgeIndexArray() const { return getEdgeIndexArray(isUndirected()); } CsrArray<int> getAdjacencyArray(bool undirected) const { std::vector<std::pair<int, int>> src; src.reserve(numEdges() * (undirected ? 2 : 1)); for(auto e : m_e){ src.emplace_back(e.from, e.to); if(undirected) src.emplace_back(e.to, e.from); } return CsrArray<int>::Construct(numVertices(), src); } CsrArray<int> getAdjacencyArray() const { return getAdjacencyArray(isUndirected()); } private: int m_n; std::vector<Edge> m_e; bool m_isUndir; }; } // namespace nachia namespace nachia{ // require : // Weight + Weight // Weight < Weight // constructor Weight(Weight2) template<class Weight = long long, class Weight2 = Weight> struct DijkstraShortestPath { private: nachia::Graph g; std::vector<Weight> dist; std::vector<int> pre; std::vector<int> ord; public: DijkstraShortestPath( nachia::Graph graph, const std::vector<Weight2>& weight, const std::vector<std::pair<int, Weight>>& starting, const Weight Inf, int goal = -1 ){ using T = std::pair<Weight, int>; g = std::move(graph); auto adj = g.getEdgeIndexArray(); std::vector<Weight> D(g.numVertices(), Inf); std::vector<int> E(g.numVertices(), -1); struct Comp { bool operator()(T a, T b) const noexcept { return b < a; }; }; std::priority_queue<T, std::vector<T>, Comp> Q; ord.clear(); for(auto a : starting) if(a.second < D[a.first]){ D[a.first] = a.second; Q.push({ a.second, a.first }); } while(Q.size()){ int p = Q.top().second; Weight d = Q.top().first; Q.pop(); if(D[p] < d) continue; ord.push_back(p); if(p == goal) break; for(auto e : adj[p]){ int q = g[e].from ^ g[e].to ^ p; Weight nxd = d + Weight(weight[e]); if(!(nxd < D[q])) continue; E[q] = e; D[q] = nxd; Q.emplace(nxd, q); } } dist = std::move(D); pre = std::move(E); } Weight distTo(int v) const noexcept { return dist[v]; } const std::vector<Weight>& distTable() const { return dist; } int prevEdge(int v) const noexcept { return pre[v]; } int prevVertex(int v) const noexcept { return pre[v] >= 0 ? g[pre[v]].from ^ g[pre[v]].to ^ v : -1; } std::vector<int> pathTo(int v) const { std::vector<int> res; while(pre[v] >= 0){ res.push_back(pre[v]); v = prevVertex(v); } std::reverse(res.begin(), res.end()); return res; } std::vector<int> getSearchOrder() const { return ord; } Graph getTree() const { Graph res(g.numVertices(), false); for(int i=0; i<g.numVertices(); i++) if(pre[i] >= 0){ res.addEdge(prevVertex(i), i); } return res; } }; } // namespace nachia using namespace std; void testcase(){ i64 N, M, L, S, E; cin >> N >> M >> L >> S >> E; auto graph = nachia::Graph(N, true); vector<i64> W(M); rep(i,M){ i64 u,v; cin >> u >> v >> W[i]; u--; v--; graph.addEdge(u,v); } vec<i64> T(L); cin >> T; rep(i,L) T[i]--; auto dist0 = nachia::DijkstraShortestPath<i64>(graph, W, {{0,0}}, INF, -1).distTable(); auto distN = nachia::DijkstraShortestPath<i64>(graph, W, {{int(N-1),0}}, INF, -1).distTable(); i64 ans = INF; for(i64 t : T) if(dist0[t] < S+E) chmin(ans, max(dist0[t], S) + 1 + distN[t]); if(ans == INF) ans = -1; cout << ans << endl; } int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); testcase(); return 0; }