#388022 (C++14) No.871 かえるのうた

提出ソース

結果

問題	No.871 かえるのうた
ユーザー	ganmodokix
提出日時	2019-10-08 21:24:55
言語	C++14 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	47 ms / 2,000 ms
コード長	9,010 bytes
コンパイル時間	3,064 ms
コンパイル使用メモリ	196,452 KB
実行使用メモリ	14,592 KB
最終ジャッジ日時	2024-04-27 02:57:34
合計ジャッジ時間	4,496 ms
ジャッジサーバーID （参考情報）	judge1 / judge3

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 6,816 KB
testcase_01	AC	2 ms 6,812 KB
testcase_02	AC	2 ms 6,940 KB
testcase_03	AC	2 ms 6,940 KB
testcase_04	AC	1 ms 6,944 KB
testcase_05	AC	1 ms 6,940 KB
testcase_06	AC	2 ms 6,940 KB
testcase_07	AC	2 ms 6,944 KB
testcase_08	AC	2 ms 6,944 KB
testcase_09	AC	2 ms 6,940 KB
testcase_10	AC	2 ms 6,940 KB
testcase_11	AC	2 ms 6,940 KB
testcase_12	AC	7 ms 6,940 KB
testcase_13	AC	2 ms 6,944 KB
testcase_14	AC	36 ms 14,592 KB
testcase_15	AC	34 ms 14,592 KB
testcase_16	AC	36 ms 14,592 KB
testcase_17	AC	31 ms 14,336 KB
testcase_18	AC	7 ms 6,944 KB
testcase_19	AC	35 ms 14,592 KB
testcase_20	AC	4 ms 6,944 KB
testcase_21	AC	15 ms 8,576 KB
testcase_22	AC	1 ms 6,940 KB
testcase_23	AC	1 ms 6,940 KB
testcase_24	AC	2 ms 6,944 KB
testcase_25	AC	2 ms 6,940 KB
testcase_26	AC	4 ms 6,944 KB
testcase_27	AC	4 ms 6,944 KB
testcase_28	AC	1 ms 6,940 KB
testcase_29	AC	14 ms 9,472 KB
testcase_30	AC	24 ms 13,824 KB
testcase_31	AC	2 ms 6,940 KB
testcase_32	AC	22 ms 13,568 KB
testcase_33	AC	29 ms 14,464 KB
testcase_34	AC	8 ms 6,944 KB
testcase_35	AC	18 ms 9,344 KB
testcase_36	AC	25 ms 14,080 KB
testcase_37	AC	16 ms 8,704 KB
testcase_38	AC	33 ms 14,464 KB
testcase_39	AC	31 ms 14,208 KB
testcase_40	AC	47 ms 13,568 KB
testcase_41	AC	1 ms 6,944 KB
testcase_42	AC	17 ms 13,696 KB
testcase_43	AC	2 ms 6,944 KB
testcase_44	AC	1 ms 6,940 KB
testcase_45	AC	2 ms 6,940 KB
testcase_46	AC	2 ms 6,940 KB
testcase_47	AC	1 ms 6,940 KB
testcase_48	AC	1 ms 6,940 KB

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

ソースコード

raw source code

// May this submission get accepted!

#pragma GCC optimize ("O3")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")

#include <bits/stdc++.h>

// 汎用マクロ
#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)
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; }
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#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) cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) do { cerr << "[DEBUG] " #q ": ["; REP(i, (q).size()) { cerr << (q)[i] << (i == i_len-1 ? "" : ", "); } cerr << "] at " __FILE__ ":" << __LINE__ << endl; } while (false)
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

// エイリアス
#define DANCE_ long
#define ROBOT_ unsigned
#define HUMAN_ signed
#define CHOKUDAI_ const
using  ll = DANCE_ HUMAN_ DANCE_;
using ull = DANCE_ ROBOT_ DANCE_;
using cll = DANCE_ DANCE_ CHOKUDAI_;
using  ld = long double;
using namespace std;

// モジュール
// 遅延評価セグ木 (RminQ(値: 最小値, 操作: 置換)になっているので適宜書き換えのこと)
class segtree_rminq {
    
    // ---------- 書き換え部分 はじめ ----------
    
    using T = ll; // 値の型
    using U = ll; // 値を書き換える操作の型
    
    const T IT = 0x7FFFFFFFFFFFFFFFLL; // T の単位元
    const U IU = 0x7FFFFFFFFFFFFFFFLL; // U の単位元
    
    // 値同士のjoin
    T join_t    (T x, T y) const { return x < y ? x : y; }
    // 操作を値に適用する
    T apply_u   (T x, U y) const { return y; }
    // 操作をjoinする
    U join_u    (U x, U y) const { return x < y ? x : y; }
    // 操作をn回やる操作を作る（nは2冪で呼ばれる）
    U multiply_u(U x, ll n) const { return x; }
    // 半分の操作を作る（Uはmultiply_uで2冪倍されているはず）
    U half_u    (U x) const { return x; }
    
    // ---------- 書き換え部分 おわり ----------
    
    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_rminq(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<T>(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);
    }
    
};

// 遅延評価セグ木 (RminQ(値: 最小値, 操作: 置換)になっているので適宜書き換えのこと)
class segtree_rmaxq {
    
    // ---------- 書き換え部分 はじめ ----------
    
    using T = ll; // 値の型
    using U = ll; // 値を書き換える操作の型
    
    const T IT = -0x7FFFFFFFFFFFFFFFLL; // T の単位元
    const U IU = -0x7FFFFFFFFFFFFFFFLL; // U の単位元
    
    // 値同士のjoin
    T join_t    (T x, T y) const { return x > y ? x : y; }
    // 操作を値に適用する
    T apply_u   (T x, U y) const { return y; }
    // 操作をjoinする
    U join_u    (U x, U y) const { return x > y ? x : y; }
    // 操作をn回やる操作を作る（nは2冪で呼ばれる）
    U multiply_u(U x, ll n) const { return x; }
    // 半分の操作を作る（Uはmultiply_uで2冪倍されているはず）
    U half_u    (U x) const { return x; }
    
    // ---------- 書き換え部分 おわり ----------
    
    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_rmaxq(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<T>(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);
    cin.tie(nullptr);
    
    ll n, k; cin >> n >> k;
    k--; // 0-indexed
    vector<ll> x(n), a(n);
    REP(i, n) cin >> x[i];
    REP(i, n) cin >> a[i];

    vector<ll> xmin(n), xmax(n);
    REP(i, n) {
        xmin[i] = x[i] - a[i];
        xmax[i] = x[i] + a[i];
    }

    segtree_rminq rminq(xmin);
    segtree_rmaxq rmaxq(xmax);
    
    ll sl = x[k], sr = x[k];

    while (true) {
        ll l = lower_bound(ALL_OF(x), sl) - x.begin();
        ll r = upper_bound(ALL_OF(x), sr) - x.begin();
        bool okay = true;
        if (chmin(sl, rminq.fetch(l, r))) okay = false;
        if (chmax(sr, rmaxq.fetch(l, r))) okay = false;
        if (okay) break;
    }

    cout << upper_bound(ALL_OF(x), sr) - lower_bound(ALL_OF(x), sl) << endl;
    
}

yukicoder

結果

テストケース

ソースコード