#603446 (C++14) No.1347 HS Railway

提出ソース

結果

問題	No.1347 HS Railway
ユーザー	8UqsVg4r
提出日時	2021-01-15 18:48:16
言語	C++14 (gcc 12.3.0 + boost 1.83.0)
結果	RE
実行時間	-
コード長	10,288 bytes
コンパイル時間	2,184 ms
コンパイル使用メモリ	190,284 KB
実行使用メモリ	8,064 KB
最終ジャッジ日時	2024-05-05 01:57:06
合計ジャッジ時間	13,355 ms
ジャッジサーバーID （参考情報）	judge3 / judge1

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	RE	-
testcase_01	RE	-
testcase_02	RE	-
testcase_03	RE	-
testcase_04	RE	-
testcase_05	RE	-
testcase_06	RE	-
testcase_07	RE	-
testcase_08	RE	-
testcase_09	RE	-
testcase_10	RE	-
testcase_11	RE	-
testcase_12	RE	-
testcase_13	RE	-
testcase_14	RE	-
testcase_15	RE	-
testcase_16	RE	-
testcase_17	RE	-
testcase_18	RE	-
testcase_19	RE	-
testcase_20	RE	-
testcase_21	RE	-
testcase_22	RE	-
testcase_23	RE	-
testcase_24	RE	-
testcase_25	RE	-
testcase_26	RE	-
testcase_27	RE	-
testcase_28	RE	-
testcase_29	RE	-
testcase_30	RE	-
testcase_31	RE	-
testcase_32	RE	-
testcase_33	RE	-
testcase_34	RE	-
testcase_35	RE	-
testcase_36	RE	-
testcase_37	RE	-
testcase_38	RE	-
testcase_39	RE	-
testcase_40	RE	-
testcase_41	RE	-
testcase_42	RE	-
testcase_43	RE	-
testcase_44	RE	-
testcase_45	RE	-
testcase_46	RE	-
testcase_47	RE	-
testcase_48	RE	-
testcase_49	RE	-
testcase_50	RE	-
testcase_51	RE	-

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

ソースコード

raw source code

/////////////////////////////////////////////////
/////             Give me AC!!!!            /////
/////////////////////////////////////////////////
//↑これじゃ気合いが足りない！
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////             お願いしますACをくださいそうじゃないと僕泣きますお願いしますACをくださいJudge様....            /////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i,N) for(int i = 0; i < (N); i++)
#define erep(i,N) for(int i = N - 1; i >= 0; i--)
const ll MOD = 1e9+7;
const ll INF = numeric_limits<ll>::max();
const int MAX = 500000;
const ld PI = (acos(-1));
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true;} return false;}
ld rad(ld a) {return a * 180 / PI;}
const int dx[8] = {1, 0, -1, 0, -1, 1, -1, 1};//2次元グリッド上のx軸方向
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};//2次元グリッド上のy軸方向
template<class T> void rm(vector<T> &vec) {
    sort(vec.begin(),vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
//using P = pair<int,int>;
struct UnionFind {
    vector<int> par;
    
    UnionFind(int n) : par(n, -1) { }
 
    int root(int x) {
        if (par[x] < 0) return x;
        else return par[x] = root(par[x]);
    }
    
    bool same(int x, int y) {
        return root(x) == root(y);
    }
    
    bool merge(int x, int y) {
        x = root(x); y = root(y);
        if (x == y) return false;
        if (par[x] > par[y]) swap(x, y); // merge technique
        par[x] += par[y];
        par[y] = x;
        return true;
    }
    
    int size(int x) {
        return -par[root(x)];
    }
};

template <typename T> struct BIT {
private:
    vector<T> array;
    const int n;
public:
    BIT(int _n) : array(_n + 1, 0), n(_n) {}

    T sum(int i) {
        T s = 0;
        while (i > 0) {
            s += array[i];
            i -= i & -i;
        }
        return s;
    }
    T sum(int i,int j) {
        T ret_i = sum(i - 1);
        T ret_j = sum(j);
        return ret_j - ret_i;
    }

    void add(int i,T x) {
        while (i <= n) {
            array[i] += x;
            i += i & -i;
        }
    }
};

map<ll,ll> factorize_list;
 
void factorize(ll k) {
    while(1){
        bool p = true;
        for (ll i = 2; i * i <= k; i++){
            if (k % i == 0){
                factorize_list[i]++;
                k /= i;
                p = false;
                break;
            }
        }
        if(p) {
            factorize_list[k]++;
            break;
        }
    }
    return ;
}
 
ll mod(ll val) {
  ll res = val % MOD;
  if (res < 0) res += MOD;
  return res;
}
 
char upper(char c){
    if('a' <= c && c <= 'z'){
        c = c - ('a' - 'A');
    }
    return c;
}
char lower(char c){
    if('A' <= c && c <= 'Z'){
        c = c + ('a' - 'A');
    }
    return c;
}

ll fac[MAX], finv[MAX], inv[MAX];

void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
ll COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

ll Expo(ll N,ll K) {
    N %= MOD;
    if (K == 0) {
        return 1;
    }
    ll Kc = K,rui = N,ans = 1;
    while(Kc) {
        if (Kc % 2) {
            ans *= rui;
            ans %= MOD;
        }
        rui *= rui;
        rui %= MOD;
        Kc /= 2;
    }
    return ans;
}

int dp[100050];

ll extGCD(ll a, ll b, ll &x, ll &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll d = extGCD(b, a%b, y, x); // 再帰的に解く
    y -= a / b * x;
    return d;
}

// 負の数にも対応した mod (a = -11 とかでも OK) 
/*inline ll mod(ll a, ll m) {
    return (a % m + m) % m;
}*/

// 逆元計算 (ここでは a と m が互いに素であることが必要)
/*ll modinv(ll a, ll m) {
    ll x, y;
    extGCD(a, m, x, y);
    return mod(x, m); // 気持ち的には x % m だが、x が負かもしれないので
}*/

int op(int a,int b) {
    return a ^ b;
}

int e() {
    return (int)0;
}

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
  public:
    int ceil_pow2(int n) {
        int x = 0;
        while ((1U << x) < (unsigned int)(n)) x++;
        return x;
    }
    segtree() : segtree(0) {}
    segtree(int n) : segtree(vector<S>(n, e())) {}
    segtree(const vector<S>& v) : _n(int(v.size())) {
        log = ceil_pow2(_n);
        size = 1 << log;
        d = vector<S>(2 * size, e());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p) {
        assert(0 <= p && p < _n);
        return d[p + size];
    }

    S prod(int l, int r) {
        assert(0 <= l && l <= r && r <= _n);
        S sml = e(), smr = e();
        l += size;
        r += size;

        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

    S all_prod() { return d[1]; }

    template <bool (*f)(S)> int max_right(int l) {
        return max_right(l, [](S x) { return f(x); });
    }
    template <class F> int max_right(int l, F f) {
        assert(0 <= l && l <= _n);
        assert(f(e()));
        if (l == _n) return _n;
        l += size;
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!f(op(sm, d[l]))) {
                while (l < size) {
                    l = (2 * l);
                    if (f(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*f)(S)> int min_left(int r) {
        return min_left(r, [](S x) { return f(x); });
    }
    template <class F> int min_left(int r, F f) {
        assert(0 <= r && r <= _n);
        assert(f(e()));
        if (r == 0) return 0;
        r += size;
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!f(op(d[r], sm))) {
                while (r < size) {
                    r = (2 * r + 1);
                    if (f(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    vector<S> d;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

struct edge {
    int to;
    ll cost;
};
template<class T> T sqroot(T Ex) {
    T l = 0,r = min(Ex,(T)(1e9)),unit = 1e-10;//unit:long longのとき1,long doubleのとき精度
    if (0.1 != (T)(0.1)) unit = 1;
    while (r - l > unit) {
        T val = (l + r) / 2;
        if (val * val > Ex) r = val;
        else l = val;
    }
    return l;//Ex以下のT型の平方根
}

template<class T> using Graph = vector<vector<T>>;
#define Sugsugar cin.tie(0);ios::sync_with_stdio(false)

template<class T> void sitpress(vector<T> &vec) {
    vector<T> array = vec;
    rm(array);
    for (int i = 0; i < vec.size(); i++) {
        int l = -1,r = array.size();
        while (r - l > 1) {
            int mid = (l + r) / 2;
            if (array.at(mid) >= vec.at(i)) r = mid;
            else l = mid;
        }
        vec.at(i) = r;
    }
}

int solve(int v) {
    int cnt = 0,a = 1;
    while (v) {
        cnt += (v % 10) * a;
        a++;
        v /= 10;
    }
    return cnt;
}

signed main() {
    Sugsugar;
    int N;
    cin >> N;
    vector<vector<ll>> A(5,vector<ll>(N));
    for (int i = 0; i < 5; i++) {
        for (int j = 1; j < N; j++) cin >> A.at(i).at(j);
    }
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < N - 1; j++) A.at(i).at(j + 1) += A.at(i).at(j);
    }
    vector<pair<int,int>> sec(5);
    for (int i = 0; i < 5; i++) {
        cin >> sec.at(i).first >> sec.at(i).second;
        sec.at(i).first--;
        sec.at(i).second--;
    }
    int M;
    cin >> M;
    vector<vector<ll>> train(5);
    for (int i = 0; i < M; i++) {
        int B;
        ll S;
        cin >> B >> S;
        B--;
        train.at(B).push_back(S);
    }
    for (int i = 0; i < 5; i++) sort(train.begin(),train.end());
    ll ans = 0;
    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 5; j++) {
            if (max(sec.at(i).first,sec.at(j).first) > min(sec.at(i).second,sec.at(j).second)) continue;
            ll p = 0,q = 0;
            q = A.at(i).at(max(sec.at(i).first,sec.at(j).first)) - A.at(i).at(sec.at(i).first);
            p = A.at(j).at(max(sec.at(i).first,sec.at(j).first)) - A.at(j).at(sec.at(j).first);
            ll c = A.at(i).at(min(sec.at(i).second,sec.at(j).second)) - A.at(i).at(max(sec.at(i).first,sec.at(j).first));
            ll d = A.at(j).at(min(sec.at(i).second,sec.at(j).second)) - A.at(j).at(max(sec.at(i).first,sec.at(j).first));
            for (int k = 0; k < train.at(i).size(); k++) {
                ll f = train.at(i).at(k);
                ll s = lower_bound(train.at(j).begin(),train.at(j).end(),f + q - p) - train.at(j).begin();
                ll t = upper_bound(train.at(j).begin(),train.at(j).end(),f + q + d - c - p) - train.at(j).begin();
                ans += (t - s);
            }
        }
    }
    cout << ans << endl;
    return 0;
}

yukicoder

結果

テストケース

ソースコード