#952512 (C++17) No.2640 traO Stamps

提出ソース

結果

問題	No.2640 traO Stamps
ユーザー	Forested
提出日時	2024-02-19 21:29:27
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	64 ms / 2,000 ms
コード長	7,250 bytes
コンパイル時間	2,049 ms
コンパイル使用メモリ	211,208 KB
実行使用メモリ	6,676 KB
最終ジャッジ日時	2024-02-19 21:29:36
合計ジャッジ時間	6,317 ms
ジャッジサーバーID （参考情報）	judge16 / judge15

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 6,676 KB
testcase_01	AC	1 ms 6,676 KB
testcase_02	AC	1 ms 6,676 KB
testcase_03	AC	2 ms 6,676 KB
testcase_04	AC	2 ms 6,676 KB
testcase_05	AC	2 ms 6,676 KB
testcase_06	AC	49 ms 6,676 KB
testcase_07	AC	51 ms 6,676 KB
testcase_08	AC	58 ms 6,676 KB
testcase_09	AC	45 ms 6,676 KB
testcase_10	AC	54 ms 6,676 KB
testcase_11	AC	44 ms 6,676 KB
testcase_12	AC	52 ms 6,676 KB
testcase_13	AC	46 ms 6,676 KB
testcase_14	AC	57 ms 6,676 KB
testcase_15	AC	52 ms 6,676 KB
testcase_16	AC	52 ms 6,676 KB
testcase_17	AC	50 ms 6,676 KB
testcase_18	AC	49 ms 6,676 KB
testcase_19	AC	54 ms 6,676 KB
testcase_20	AC	54 ms 6,676 KB
testcase_21	AC	46 ms 6,676 KB
testcase_22	AC	58 ms 6,676 KB
testcase_23	AC	49 ms 6,676 KB
testcase_24	AC	53 ms 6,676 KB
testcase_25	AC	55 ms 6,676 KB
testcase_26	AC	51 ms 6,676 KB
testcase_27	AC	53 ms 6,676 KB
testcase_28	AC	49 ms 6,676 KB
testcase_29	AC	54 ms 6,676 KB
testcase_30	AC	64 ms 6,676 KB
testcase_31	AC	63 ms 6,676 KB
testcase_32	AC	56 ms 6,676 KB
testcase_33	AC	57 ms 6,676 KB

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

ソースコード

raw source code

#ifndef LOCAL
#define FAST_IO
#endif

// ============
#include <bits/stdc++.h>
#define OVERRIDE(a, b, c, d, ...) d
#define REP2(i, n) for (i32 i = 0; i < (i32)(n); ++i)
#define REP3(i, m, n) for (i32 i = (i32)(m); i < (i32)(n); ++i)
#define REP(...) OVERRIDE(__VA_ARGS__, REP3, REP2)(__VA_ARGS__)
#define PER2(i, n) for (i32 i = (i32)(n)-1; i >= 0; --i)
#define PER3(i, m, n) for (i32 i = (i32)(n)-1; i >= (i32)(m); --i)
#define PER(...) OVERRIDE(__VA_ARGS__, PER3, PER2)(__VA_ARGS__)
#define ALL(x) begin(x), end(x)
#define LEN(x) (i32)(x.size())
using namespace std;
using u32 = unsigned int;
using u64 = unsigned long long;
using i32 = signed int;
using i64 = signed long long;
using f64 = double;
using f80 = long double;
using pi = pair<i32, i32>;
using pl = pair<i64, i64>;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = V<V<T>>;
template <typename T>
using VVV = V<V<V<T>>>;
template <typename T>
using VVVV = V<V<V<V<T>>>>;
template <typename T>
using PQR = priority_queue<T, V<T>, greater<T>>;
template <typename T>
bool chmin(T &x, const T &y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
bool chmax(T &x, const T &y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}
template <typename T>
i32 lob(const V<T> &arr, const T &v) {
    return (i32)(lower_bound(ALL(arr), v) - arr.begin());
}
template <typename T>
i32 upb(const V<T> &arr, const T &v) {
    return (i32)(upper_bound(ALL(arr), v) - arr.begin());
}
template <typename T>
V<i32> argsort(const V<T> &arr) {
    V<i32> ret(arr.size());
    iota(ALL(ret), 0);
    sort(ALL(ret), [&](i32 i, i32 j) -> bool {
        if (arr[i] == arr[j]) {
            return i < j;
        } else {
            return arr[i] < arr[j];
        }
    });
    return ret;
}
#ifdef INT128
using u128 = __uint128_t;
using i128 = __int128_t;
#endif
[[maybe_unused]] constexpr i32 INF = 1000000100;
[[maybe_unused]] constexpr i64 INF64 = 3000000000000000100;
struct SetUpIO {
    SetUpIO() {
#ifdef FAST_IO
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
#endif
        cout << fixed << setprecision(15);
    }
} set_up_io;
void scan(char &x) { cin >> x; }
void scan(u32 &x) { cin >> x; }
void scan(u64 &x) { cin >> x; }
void scan(i32 &x) { cin >> x; }
void scan(i64 &x) { cin >> x; }
void scan(string &x) { cin >> x; }
template <typename T>
void scan(V<T> &x) {
    for (T &ele : x) {
        scan(ele);
    }
}
void read() {}
template <typename Head, typename... Tail>
void read(Head &head, Tail &...tail) {
    scan(head);
    read(tail...);
}
#define CHAR(...)     \
    char __VA_ARGS__; \
    read(__VA_ARGS__);
#define U32(...)     \
    u32 __VA_ARGS__; \
    read(__VA_ARGS__);
#define U64(...)     \
    u64 __VA_ARGS__; \
    read(__VA_ARGS__);
#define I32(...)     \
    i32 __VA_ARGS__; \
    read(__VA_ARGS__);
#define I64(...)     \
    i64 __VA_ARGS__; \
    read(__VA_ARGS__);
#define STR(...)        \
    string __VA_ARGS__; \
    read(__VA_ARGS__);
#define VEC(type, name, size) \
    V<type> name(size);       \
    read(name);
#define VVEC(type, name, size1, size2)    \
    VV<type> name(size1, V<type>(size2)); \
    read(name);
// ============

#ifdef DEBUGF
#else
#define DBG(...) (void)0
#endif

// ============

#include <cassert>
#include <vector>
// ============

#include <algorithm>
#include <limits>
#include <utility>

template <typename T>
struct Add {
    using Value = T;
    static Value id() { return T(0); }
    static Value op(const Value &lhs, const Value &rhs) { return lhs + rhs; }
    static Value inv(const Value &x) { return -x; }
};

template <typename T>
struct Mul {
    using Value = T;
    static Value id() { return Value(1); }
    static Value op(const Value &lhs, const Value &rhs) { return lhs * rhs; }
    static Value inv(const Value &x) { return Value(1) / x; }
};

template <typename T>
struct Min {
    static_assert(std::numeric_limits<T>::is_specialized);
    using Value = T;
    static Value id() { return std::numeric_limits<T>::max(); }
    static Value op(const Value &lhs, const Value &rhs) {
        return std::min(lhs, rhs);
    }
};

template <typename T>
struct Max {
    static_assert(std::numeric_limits<T>::is_specialized);
    using Value = T;
    static Value id() { return std::numeric_limits<Value>::min(); }
    static Value op(const Value &lhs, const Value &rhs) {
        return std::max(lhs, rhs);
    }
};

template <typename T>
struct Xor {
    using Value = T;
    static Value id() { return T(0); }
    static Value op(const Value &lhs, const Value &rhs) { return lhs ^ rhs; }
    static Value inv(const Value &x) { return x; }
};

template <typename Monoid>
struct Reversible {
    using Value = std::pair<typename Monoid::Value, typename Monoid::Value>;
    static Value id() { return Value(Monoid::id(), Monoid::id()); }
    static Value op(const Value &v1, const Value &v2) {
        return Value(Monoid::op(v1.first, v2.first),
                     Monoid::op(v2.second, v1.second));
    }
};
// ============

template <typename CommutativeGroup>
class FenwickTree {
public:
    using Value = typename CommutativeGroup::Value;

private:
    std::vector<Value> data;

public:
    FenwickTree(int n) : data(n, CommutativeGroup::id()) {}

    void add(int idx, const Value &x) {
        assert(idx >= 0 && idx < (int)data.size());
        for (; idx < (int)data.size(); idx |= idx + 1) {
            data[idx] = CommutativeGroup::op(data[idx], x);
        }
    }

    Value sum(int r) const {
        assert(r >= 0 && r <= (int)data.size());
        Value ret = CommutativeGroup::id();
        for (; r > 0; r &= r - 1) {
            ret = CommutativeGroup::op(ret, data[r - 1]);
        }
        return ret;
    }

    Value sum(int l, int r) const {
        assert(l >= 0 && l <= r && r <= (int)data.size());
        return CommutativeGroup::op(sum(r), CommutativeGroup::inv(sum(l)));
    }
};

template <typename T>
using FenwickTreeAdd = FenwickTree<Add<T>>;
// ============

void solve() {
    I32(n, m, k);
    VEC(i32, s, k + 1);
    REP(i, k + 1) {
        --s[i];
    }
    VV<i64> dist(n, V<i64>(n, INF64));
    REP(i, n) {
        dist[i][i] = 0;
    }
    REP(i, m) {
        I32(a, b);
        I64(c);
        --a;
        --b;
        chmin(dist[a][b], c);
        chmin(dist[b][a], c);
    }
    REP(l, n) REP(i, n) REP(j, n) {
        chmin(dist[i][j], dist[i][l] + dist[l][j]);
    }
    FenwickTreeAdd<i64> fw(k);
    REP(i, k) {
        fw.add(i, dist[s[i]][s[i + 1]]);
    }
    I32(q);
    REP(qi, q) {
        I32(ty);
        if (ty == 1) {
            I32(x, y);
            --y;
            if (x != 0) {
                fw.add(x - 1, -dist[s[x - 1]][s[x]]);
            }
            if (x != k) {
                fw.add(x, -dist[s[x]][s[x + 1]]);
            }
            s[x] = y;
            if (x != 0) {
                fw.add(x - 1, dist[s[x - 1]][s[x]]);
            }
            if (x != k) {
                fw.add(x, dist[s[x]][s[x + 1]]);
            }
        } else {
            I32(x, y);
            cout << fw.sum(x, y) << '\n';
        }
    }
}

int main() {
    i32 t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
}

yukicoder

結果

テストケース

ソースコード