結果

問題 No.1000 Point Add and Array Add
ユーザー ganmodokixganmodokix
提出日時 2020-02-28 22:24:44
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
RE  
実行時間 -
コード長 6,970 bytes
コンパイル時間 2,249 ms
コンパイル使用メモリ 216,012 KB
実行使用メモリ 20,884 KB
最終ジャッジ日時 2024-10-13 17:55:39
合計ジャッジ時間 7,338 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 2 ms
5,248 KB
testcase_02 RE -
testcase_03 WA -
testcase_04 WA -
testcase_05 AC 2 ms
5,248 KB
testcase_06 RE -
testcase_07 AC 2 ms
5,248 KB
testcase_08 AC 2 ms
5,248 KB
testcase_09 RE -
testcase_10 RE -
testcase_11 RE -
testcase_12 WA -
testcase_13 RE -
testcase_14 RE -
testcase_15 AC 4 ms
5,248 KB
testcase_16 AC 220 ms
19,424 KB
testcase_17 RE -
testcase_18 AC 318 ms
20,884 KB
testcase_19 AC 310 ms
20,756 KB
testcase_20 AC 169 ms
20,884 KB
testcase_21 AC 372 ms
20,884 KB
testcase_22 AC 233 ms
20,884 KB
testcase_23 AC 365 ms
20,880 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

// May this submission get accepted
#include <bits/stdc++.h>

// エイリアス
using  ll = long signed long;
using ull = long unsigned long;
using  ld = long double;
using namespace std;

// エイリアス (補完・コンパイルが重くなる)
// #include <boost/multiprecision/cpp_int.hpp>
// using mll = boost::multiprecision::cpp_int;

// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i,n) for (long long i=0, i##_len=(n); i<i##_len; i++)
#define RANGE(i,is,ie) for (long long i=(is), i##_end=(ie); i<=i##_end; i++)
#define DSRNG(i,is,ie) for (long long i=(is), i##_end=(ie); i>=i##_end; i--)
#define STEP(i, is, ie, step) for (long long i=(is), i##_end=(ie), i##_step = (step); i<=i##_end; i+=i##_step)
#define UNIQUE(v) do { sort((v).begin(), (v).end()); (v).erase(unique((v).begin(), (v).end()), (v).end()); } while (false)
#define FOREACH(i,q) for (auto &i : q)
template<class T> bool chmax(T &a, const T b) { if (a < b) {a = b; return true;} return false; }
template<class T> bool chmin(T &a, const T b) { if (a > b) {a = b; return true;} return false; }
constexpr int INF = numeric_limits<int>::max();
constexpr long long LINF = numeric_limits<long long>::max();
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
#define DUMP(q) DUMP_FUNC(q, #q, __FILE__, __LINE__)
template <typename T> void DUMP_PROC(T x) { cerr << x; }
void DUMP_PROC(string x) { cerr << '"' << x << '"'; }
template <typename T> void DUMP_PROC(vector<T> x) { cerr << "["; for (auto &xi : x) { DUMP_PROC(xi); cerr << (&xi != &*x.rbegin()?", ":""); } cerr << "]"; }
template <typename T> void DUMP_FUNC(T x, const char* name, const char* fn, int ln) { cerr << "\e[32m[DEBUG]\e[0m " << name << ": "; DUMP_PROC(x); cerr << " @ " << fn << "(" << ln << ")" << endl; }
template<class T> T gcd(T a, T b) { if (a < b) swap(a, b); while (b) swap(a %= b, b); return a; }
template<class T> T lcm(const T a, const T b) { return a / gcd(a, b) * b; }

// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll

// 標準入出力
struct inp {
    size_t sz;
    inp(size_t _sz = 1) : sz(_sz) {}
    template <typename T> operator T () const { T a; cin >> a; return a; }
    template <typename T> operator vector<T> () const { vector<T> a(sz); for (size_t i = 0; i < sz; i++) cin >> a[i]; return a; }
    template <typename T, typename U> operator pair<T, U> () const { T f; U s; cin >> f >> s; return pair<T, U>(f, s); }
};
inp inp1; // input one
template <typename T> void say(const T x, const char* end = "\n") { cout << x << end; }
void say(const ld x, const char* end = "\n") { cout << setprecision(30) << x << end; }
template <typename T> void say(const vector<T> x, const char* sep = " ", const char* end = "\n") { REP(i, x.size()) { cout << x[i] << (i+1 == i_len ? end : sep); } }
template <typename T> void say(const vector<vector<T>> x, const char* sep = " ", const char* end = "\n") { REP(i, x.size()) { say(x[i], sep, end); } }

// モジュール

// 遅延評価セグ木 (RminQ(値: 最小値, 操作: 置換)になっているので適宜書き換えのこと)
class segtree {
    
    // ---------- 書き換え部分 はじめ ----------
    
    using T = ll; // 値の型
    using U = ll; // 値を書き換える操作の型
    
    const T IT = 0; // T の単位元
    const U IU = 0; // U の単位元
    
    // 値同士のjoin
    T join_t    (T x, T y) const { return x + y; }
    // 操作を値に適用する
    T apply_u   (T x, U y) const { return x + y; }
    // 操作をjoinする
    U join_u    (U x, U y) const { return x + y; }
    // 操作をn回やる操作を作る（nは2冪で呼ばれる）
    U multiply_u(U x, ll n) const { return x * n; }
    // 半分の操作を作る（Uはmultiply_uで2冪倍されているはず）
    U half_u    (U x) const { return x / 2; }
    
    // ---------- 書き換え部分 おわり ----------
    
    ll n;
    vector<T>    node;
    vector<U>    lazy;
    vector<bool> fall;
    
    // [l, r) を見ており, k を遅延評価
    inline void eval(ll k, ll l, ll r) {
        if (!fall[k]) return;
        node[k] = apply_u(node[k], lazy[k]);
        if (r-l > 1) { // 子があるなら伝播
            lazy[k*2+1] = join_u(lazy[k*2+1], half_u(lazy[k]));
            lazy[k*2+2] = join_u(lazy[k*2+2], half_u(lazy[k]));
            fall[k*2+1] = fall[k*2+2] = true;
        }
        lazy[k] = IU;
        fall[k] = false;
    }
    
public:
    
    // コンストラクタ
    segtree(const vector<T> &v) {
        ll sz = (ll)v.size();
        n = 1; while (n < sz) n *= 2;
        this->node = vector<T>(n * 2 - 1, IT);
        this->lazy = vector<U>(n * 2 - 1, IU);
        this->fall = vector<bool>(n * 2 - 1, false);
        for (ll i = 0; i < sz; i++) node[n-1 + i] = v[i];
        for (ll i = n-1; i--; )  node[i] = join_t(node[i*2+1], node[i*2+2]);
    }
    
    // 区間 [a, b) に x を適用（但し, [l, r)を見て今kをいじっている）
    void apply(ll a, ll b, U x, ll k = 0, ll l = 0, ll r = -1) {
        if (r < 0) r = n; // デフォルト値には定数しか入れられない
        eval(k, l, r);
        if (b <= l || r <= a) return; // セグフォ防止
        if (a <= l && r <= b) {
            lazy[k] = join_u(lazy[k], multiply_u(x, r - l));
            fall[k] = true;
            eval(k, l, r);
        } else {
            apply(a, b, x, k*2+1, l, (l+r)/2);
            apply(a, b, x, k*2+2, (l+r)/2, r);
            node[k] = join_t(node[k*2+1], node[k*2+2]);
        }
    }
    
    // 区間 [a, b) の操作後の値を求める
    T fetch(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
        if (r < 0) r = n; // デフォルト値には定数しか入れられない
        if (b <= l || r <= a) return IT; // セグフォ防止
        eval(k, l, r);
        if (a <= l && r <= b) return node[k];
        T vl = fetch(a, b, k*2+1, l, (l+r)/2);
        T vr = fetch(a, b, k*2+2, (l+r)/2, r);
        return join_t(vl, vr);
    }
    
};

// 処理内容
int main() {
    
    ios::sync_with_stdio(false); // stdioを使うときはコメントアウトすること
    cin.tie(nullptr);            // インタラクティブ問題ではコメントアウトすること
    
    ll n = inp1;
    ll q = inp1;
    vector<ll> a = inp(n);
    vector<tuple<char, ll, ll>> cxy(n);
    REP(i, q) {
        char c = inp1; ll x = inp1, y = inp1;
        x--;
        cxy[i] = make_tuple(c, x, y);
    }

    segtree sgt(vector<ll>(n, 0));
    vector<ll> b(n);

    DSRNG(i, q-1, 0) {
        char c; ll x, y; tie(c, x, y) = cxy[i];
        if (c == 'A') {
            b[x] += sgt.fetch(x, x+1) * y;
        } else {
            sgt.apply(x, y, 1);
        }
    }
    REP(i, n) {
        b[i] += sgt.fetch(i, i+1) * a[i];
    }
    say(b, " ", "\n");
    
}
0