#906075 (C++23) No.2431 Viral Hotel

提出ソース

結果

問題	No.2431 Viral Hotel
ユーザー	nono00
提出日時	2023-08-18 23:59:35
言語	C++23 (gcc 12.3.0 + boost 1.83.0)
結果	WA
実行時間	-
コード長	6,122 bytes
コンパイル時間	3,126 ms
コンパイル使用メモリ	265,756 KB
実行使用メモリ	26,048 KB
最終ジャッジ日時	2024-05-06 06:52:24
合計ジャッジ時間	8,763 ms
ジャッジサーバーID （参考情報）	judge5 / judge1

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	WA	-
testcase_01	WA	-
testcase_02	WA	-
testcase_03	WA	-
testcase_04	WA	-
testcase_05	WA	-
testcase_06	WA	-
testcase_07	AC	18 ms 6,912 KB
testcase_08	AC	17 ms 6,784 KB
testcase_09	AC	2 ms 5,376 KB
testcase_10	WA	-
testcase_11	WA	-
testcase_12	WA	-
testcase_13	WA	-
testcase_14	WA	-
testcase_15	WA	-
testcase_16	WA	-
testcase_17	WA	-
testcase_18	WA	-
testcase_19	WA	-
testcase_20	WA	-
testcase_21	WA	-
testcase_22	WA	-
testcase_23	WA	-
testcase_24	WA	-
testcase_25	WA	-
testcase_26	WA	-
testcase_27	WA	-
testcase_28	WA	-
testcase_29	WA	-
testcase_30	WA	-
testcase_31	WA	-
testcase_32	WA	-
testcase_33	WA	-
testcase_34	AC	7 ms 5,376 KB
testcase_35	WA	-
testcase_36	WA	-
testcase_37	WA	-
testcase_38	WA	-
testcase_39	AC	2 ms 5,376 KB
testcase_40	AC	1 ms 5,376 KB
testcase_41	AC	2 ms 5,376 KB
testcase_42	AC	2 ms 5,376 KB
testcase_43	WA	-
testcase_44	WA	-
testcase_45	WA	-

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>

// graph/graph-template.hpp
// graph/graph.hpp

#include <cassert>
#include <vector>
// graph/edge.hpp

namespace nono {

//  brief:
//  - Edge構造体
//
//  tparam:
//  - `T`: 重みの型
//
//  note:
//  - `from`, `to`, `weight` がないと、他のライブラリが壊れる
template <class T = int>
struct Edge {
    using value_type = T;

    int from;
    int to;
    T weight;
    int index;

    //  brief:
    //  - Edgeコンストラクタ
    Edge(int from, int to, const T& weight = 1, int index = -1)
        : from(from),
          to(to),
          weight(weight),
          index(index) {}

    friend auto operator<=>(const Edge<T>& lhs, const Edge<T>& rhs) {
        return lhs.weight <=> rhs.weight;
    }
};

}  //  namespace nono

namespace nono {

//  brief:
//  - グラフ構造体
//
//  tparam:
//  - `T`: 辺の重みの型
//  - `directed`: 有向かどうか
//
//  note:
//  - 有向グラフのaliasとして `DiGraph` が存在する
//  - 以下の条件が満たさないと壊れる
//  \ \ 1. `size()` が頂点数を返す
//  \ \ 2. `operator[]` が `range-based for` に対応している
template <class T = int, bool directed = false>
class Graph {
    using EdgeType = Edge<T>;
    using EdgesType = std::vector<EdgeType>;

  public:
    using value_type = EdgesType;

    Graph() = default;

    explicit Graph(int vertex_size)
        : vertex_size_(vertex_size),
          edge_size_(0),
          adj_list_(vertex_size) {}

    Graph(int vertex_size, const std::vector<EdgeType>& edges)
        : vertex_size_(vertex_size),
          edge_size_(0),
          adj_list_(vertex_size) {
        for (const auto& e: edges) {
            adj_list_[e.from].emplace_back(e);
        }
    }

    //  brief:
    //  - 頂点数を取得する
    int size() const {
        return vertex_size_;
    }

    //  brief:
    //  - 頂点 `i` に隣接する頂点を取得する
    const std::vector<EdgeType>& operator[](int i) const {
        return adj_list_[i];
    }

    //  brief:
    //  - 頂点 `i` に隣接する頂点を取得する
    std::vector<EdgeType>& operator[](int i) {
        return adj_list_[i];
    }

    //  brief:
    //  - グラフに辺を追加する
    //
    //  note:
    //  - weightのデフォルト値は1
    void add_edge(int from, int to, T weight = static_cast<T>(1), int index = -1) {
        adj_list_[from].emplace_back(from, to, weight, index);
        if (not directed) adj_list_[to].emplace_back(to, from, weight, index);
        edge_size_++;
    }

    //  brief:
    //  - 頂点 `i` の次数を取得する
    //
    //  note:
    //  - 有向グラフの場合、出次数を取得する
    int degree(int i) const {
        return adj_list_[i].size();
    }

    //  brief:
    //  - 頂点の次数の配列を取得する
    //
    //  note:
    //  - 有向グラフの場合、出次数を取得する
    std::vector<int> degree() const {
        std::vector<int> result(vertex_size_);
        for (int i = 0; i < vertex_size_; i++) {
            result[i] = adj_list_[i].size();
        }
        return result;
    }

    //  brief:
    //  - 辺の配列に取得する
    //
    //  note:
    //  - 単純グラフでないと壊れる
    std::vector<EdgeType> to_edges() const {
        std::vector<EdgeType> edges(edge_size_);
        int count = 0;
        for (int u = 0; u < vertex_size_; u++) {
            for (const auto& e: adj_list_[u]) {
                if (directed || e.from <= e.to) {
                    edges[count] = e;
                    count++;
                }
            }
        }
        return edges;
    }

  private:
    int vertex_size_;
    int edge_size_;
    std::vector<std::vector<EdgeType>> adj_list_;
};

//  brief:
//  - 有向グラフ構造体
//
//  tparam:
//  - `T`: 辺の重みの型
//
//  note:
//  - `Graph` のalias
template <class T = int>
using DiGraph = Graph<T, true>;

}  //  namespace nono

namespace nono {

// type 1: 回復
// type 2: 感染
struct Event {
    int time;
    int type;
    int index;
    Event(int time, int type, int index): time(time), type(type), index(index) {}
};

bool operator<(const Event& lhs, const Event& rhs) {
    if (lhs.time == rhs.time and lhs.type == rhs.type) return lhs.index > rhs.index;
    if (lhs.time == rhs.time) return lhs.type > rhs.type;
    return lhs.time > rhs.time;
}

void solve() {
    int N, M, K, P;
    std::cin >> N >> K >> M >> P;
    Graph graph(N);
    for (int i = 0; i < M; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        graph.add_edge(u, v);
    }
    std::vector<int> s(N);
    for (int i = 0; i < N; i++) std::cin >> s[i];
    std::priority_queue<Event> events;
    std::vector<bool> kansen(N);
    std::vector<bool> keneki(N);
    std::vector<bool> meneki(N);
    for (int i = 0; i < K; i++) {
        int x;
        std::cin >> x;
        x--;
        kansen[x] = true;
        events.emplace(P, 1, x);
        events.emplace(s[x], 2, x);
    }

    std::set<Event> used;
    while (not events.empty()) {
        auto event = events.top();
        events.pop();
        if (used.contains(event)) continue;
        used.insert(event);
        auto [time, type, u] = event;
        
        if (keneki[u]) continue;
        if (type == 1) {
            meneki[u] = true;
        } else {
            for (const auto& e: graph[u]) {
                if (meneki[e.to]) continue;
                if (keneki[e.to]) continue;
                if (not kansen[e.to]) {
                    events.emplace(time + P, 1, e.to);
                    events.emplace(time + s[e.to], 2, e.to);
                    kansen[e.to] = true;
                } else {
                    keneki[e.to] = true;
                }
            }
        }
    }

    std::cout << std::accumulate(keneki.begin(), keneki.end(), 0LL) << std::endl;
}

}  //  namespace nono

int main() {
    std::cin.tie(0)->sync_with_stdio(0);
    std::cout << std::fixed << std::setprecision(15);

    int t = 1;
    //  std::cin >> t;
    while (t--) nono::solve();
}

yukicoder

結果

テストケース

ソースコード