結果

問題 No.924 紲星
ユーザー kuhakukuhaku
提出日時 2023-09-13 21:32:11
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 1,207 ms / 4,000 ms
コード長 9,917 bytes
コンパイル時間 7,100 ms
コンパイル使用メモリ 238,108 KB
実行使用メモリ 36,720 KB
最終ジャッジ日時 2023-09-13 21:32:30
合計ジャッジ時間 16,688 ms
ジャッジサーバーID
（参考情報） 		judge14 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
4,376 KB
testcase_01 AC 2 ms
4,376 KB
testcase_02 AC 2 ms
4,380 KB
testcase_03 AC 2 ms
4,376 KB
testcase_04 AC 2 ms
4,380 KB
testcase_05 AC 3 ms
4,380 KB
testcase_06 AC 2 ms
4,376 KB
testcase_07 AC 2 ms
4,380 KB
testcase_08 AC 1,183 ms
36,568 KB
testcase_09 AC 1,184 ms
36,500 KB
testcase_10 AC 1,207 ms
36,588 KB
testcase_11 AC 1,185 ms
36,720 KB
testcase_12 AC 1,196 ms
36,568 KB
testcase_13 AC 390 ms
16,856 KB
testcase_14 AC 298 ms
14,256 KB
testcase_15 AC 318 ms
14,900 KB
testcase_16 AC 688 ms
26,592 KB
testcase_17 AC 543 ms
19,756 KB
testcase_18 AC 1 ms
4,376 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#line 1 "a.cpp"
#define PROBLEM "https://yukicoder.me/problems/no/924"
#line 2 "/home/kuhaku/atcoder/github/algo/lib/template/template.hpp"
#pragma GCC target("sse4.2,avx2,bmi2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
template <class T, class U>
bool chmax(T &a, const U &b) {
    return a < (T)b ? a = (T)b, true : false;
}
template <class T, class U>
bool chmin(T &a, const U &b) {
    return (T)b < a ? a = (T)b, true : false;
}
constexpr std::int64_t INF = 1000000000000000003;
constexpr int Inf = 1000000003;
constexpr int MOD = 1000000007;
constexpr int MOD_N = 998244353;
constexpr double EPS = 1e-7;
constexpr double PI = M_PI;
#line 3 "/home/kuhaku/atcoder/github/algo/lib/algorithm/compress.hpp"

/**
 * @brief 座標圧縮
 *
 * @tparam T 要素の型
 */
template <class T>
struct coordinate_compression {
    coordinate_compression() = default;
    coordinate_compression(const std::vector<T> &_data) : data(_data) { build(); }

    const T &operator[](int i) const { return data[i]; }
    T &operator[](int i) { return data[i]; }

    void add(T x) { data.emplace_back(x); }

    void build() {
        std::sort(std::begin(data), std::end(data));
        data.erase(std::unique(std::begin(data), std::end(data)), std::end(data));
    }
    void build(const std::vector<T> &v) {
        data = v;
        std::sort(std::begin(data), std::end(data));
        data.erase(std::unique(std::begin(data), std::end(data)), std::end(data));
    }

    bool exists(T x) const {
        auto it = std::lower_bound(std::begin(data), std::end(data), x);
        return it != std::end(data) && *it == x;
    }

    int get(T x) const {
        auto it = std::lower_bound(std::begin(data), std::end(data), x);
        return std::distance(std::begin(data), it);
    }

    int size() const { return std::size(data); }

  private:
    std::vector<T> data;
};

/**
 * @brief 座標圧縮
 *
 * @tparam T 要素の型
 * @param v
 * @return std::vector<T>
 */
template <class T>
std::vector<T> compress(const std::vector<T> &v) {
    coordinate_compression cps(v);
    std::vector<T> res;
    for (auto &&x : v) res.emplace_back(cps.get(x));
    return res;
}
#line 2 "/home/kuhaku/atcoder/github/algo/lib/binary_tree/fenwick_tree.hpp"

/**
 * @brief フェニック木
 * @see http://hos.ac/slides/20140319_bit.pdf
 *
 * @tparam T
 */
template <class T>
struct fenwick_tree {
    fenwick_tree() : _size(), data() {}
    fenwick_tree(int n) : _size(n + 1), data(n + 1) {}
    fenwick_tree(const std::vector<T> &v) : _size((int)v.size() + 1), data((int)v.size() + 1) {
        this->build(v);
    }
    template <class U>
    fenwick_tree(const std::vector<U> &v) : _size((int)v.size() + 1), data((int)v.size() + 1) {
        this->build(v);
    }

    T operator[](int i) const { return this->sum(i + 1) - this->sum(i); }
    T at(int k) const { return this->operator[](k); }
    T get(int k) const { return this->operator[](k); }

    template <class U>
    void build(const std::vector<U> &v) {
        for (int i = 0, n = v.size(); i < n; ++i) this->add(i, v[i]);
    }

    /**
     * @brief v[k] = val
     *
     * @param k index of array
     * @param val new value
     * @return void
     */
    void update(int k, T val) { this->add(k, val - this->at(k)); }
    /**
     * @brief v[k] += val
     *
     * @param k index of array
     * @param val new value
     * @return void
     */
    void add(int k, T val) {
        assert(0 <= k && k < this->_size);
        for (++k; k < this->_size; k += k & -k) this->data[k] += val;
    }
    /**
     * @brief chmax(v[k], val)
     *
     * @param k index of array
     * @param val new value
     * @return bool
     */
    bool chmax(int k, T val) {
        if (this->at(k) >= val) return false;
        this->update(k, val);
        return true;
    }
    /**
     * @brief chmin(v[k], val)
     *
     * @param k index of value
     * @param val new value
     * @return bool
     */
    bool chmin(int k, T val) {
        if (this->at(k) <= val) return false;
        this->update(k, val);
        return true;
    }

    /**
     * @brief v[0] + ... + v[n - 1]
     *
     * @return T
     */
    T all_sum() const { return this->sum(this->_size); }
    /**
     * @brief v[0] + ... + v[k - 1]
     *
     * @param k index of array
     * @return T
     */
    T sum(int k) const {
        assert(0 <= k && k <= this->_size);
        T res = 0;
        for (; k > 0; k -= k & -k) res += this->data[k];
        return res;
    }
    /**
     * @brief v[a] + ... + v[b - 1]
     *
     * @param a first index of array
     * @param b last index of array
     * @return T
     */
    T sum(int a, int b) const { return a < b ? this->sum(b) - this->sum(a) : 0; }

    /**
     * @brief binary search on fenwick_tree
     *
     * @param val target value
     * @return int
     */
    int lower_bound(T val) const {
        if (val <= 0) return 0;
        int k = 1;
        while (k < this->_size) k <<= 1;
        int res = 0;
        for (; k > 0; k >>= 1) {
            if (res + k < this->_size && this->data[res + k] < val) val -= this->data[res += k];
        }
        return res;
    }

  private:
    int _size;
    std::vector<T> data;
};
#line 3 "/home/kuhaku/atcoder/github/algo/lib/template/macro.hpp"
#define FOR(i, m, n) for (int i = (m); i < int(n); ++i)
#define FORR(i, m, n) for (int i = (m)-1; i >= int(n); --i)
#define FORL(i, m, n) for (int64_t i = (m); i < int64_t(n); ++i)
#define rep(i, n) FOR (i, 0, n)
#define repn(i, n) FOR (i, 1, n + 1)
#define repr(i, n) FORR (i, n, 0)
#define repnr(i, n) FORR (i, n + 1, 1)
#define all(s) (s).begin(), (s).end()
#line 3 "/home/kuhaku/atcoder/github/algo/lib/template/sonic.hpp"
struct Sonic {
    Sonic() {
        std::ios::sync_with_stdio(false);
        std::cin.tie(nullptr);
    }

    constexpr void operator()() const {}
} sonic;
#line 5 "/home/kuhaku/atcoder/github/algo/lib/template/atcoder.hpp"
using namespace std;
using ll = std::int64_t;
using ld = long double;
template <class T, class U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    return is >> p.first >> p.second;
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (T &i : v) is >> i;
    return is;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
    return os << '(' << p.first << ',' << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
    for (auto it = v.begin(); it != v.end(); ++it) {
        os << (it == v.begin() ? "" : " ") << *it;
    }
    return os;
}
template <class Head, class... Tail>
void co(Head &&head, Tail &&...tail) {
    if constexpr (sizeof...(tail) == 0) std::cout << head << '\n';
    else std::cout << head << ' ', co(std::forward<Tail>(tail)...);
}
template <class Head, class... Tail>
void ce(Head &&head, Tail &&...tail) {
    if constexpr (sizeof...(tail) == 0) std::cerr << head << '\n';
    else std::cerr << head << ' ', ce(std::forward<Tail>(tail)...);
}
template <typename T, typename... Args>
auto make_vector(T x, int arg, Args... args) {
    if constexpr (sizeof...(args) == 0) return std::vector<T>(arg, x);
    else return std::vector(arg, make_vector<T>(x, args...));
}
void setp(int n) {
    std::cout << std::fixed << std::setprecision(n);
}
void Yes(bool is_correct = true) {
    std::cout << (is_correct ? "Yes" : "No") << '\n';
}
void No(bool is_not_correct = true) {
    Yes(!is_not_correct);
}
void YES(bool is_correct = true) {
    std::cout << (is_correct ? "YES" : "NO") << '\n';
}
void NO(bool is_not_correct = true) {
    YES(!is_not_correct);
}
void Takahashi(bool is_correct = true) {
    std::cout << (is_correct ? "Takahashi" : "Aoki") << '\n';
}
void Aoki(bool is_not_correct = true) {
    Takahashi(!is_not_correct);
}
#line 5 "a.cpp"

int main(void) {
    int n, q;
    cin >> n >> q;
    vector<ll> a(n);
    cin >> a;
    coordinate_compression cc(a);
    auto c = compress(a);
    int m = cc.size();
    vector<vector<int>> v(m);
    rep (i, n) v[c[i]].emplace_back(i);
    vector<pair<int, int>> b(q);
    cin >> b;
    vector<int> ok(q, 0), ng(q, m);
    while (true) {
        vector<int> mid(q);
        rep (i, q) mid[i] = (ok[i] + ng[i]) / 2;
        int cnt = 0;
        vector<vector<int>> mp(m);
        rep (i, q) {
            if (mid[i] == ok[i] || mid[i] == ng[i])
                ++cnt;
            else
                mp[mid[i]].emplace_back(i);
        }
        if (cnt == q)
            break;
        fenwick_tree<int> ft(n);
        repr (i, m) {
            for (int idx : v[i]) ft.add(idx, 1);
            for (int idx : mp[i]) {
                auto [l, r] = b[idx];
                if (ft.sum(l - 1, r) >= (r - l + 2) / 2)
                    ok[idx] = i;
                else
                    ng[idx] = i;
            }
        }
    }

    vector<vector<int>> query(n + 1);
    rep (i, q) {
        auto [l, r] = b[i];
        query[l - 1].emplace_back(~i);
        query[r].emplace_back(i);
    }

    vector<ll> ans(q);
    fenwick_tree<ll> ft1(m), ft2(m);
    rep (i, n) {
        int t = cc.get(a[i]);
        ft1.add(t, a[i]);
        ft2.add(t, 1);
        for (auto &&idx : query[i + 1]) {
            if (idx >= 0) {
                int t = ok[idx];
                ans[idx] += ft1.sum(t, m);
                ans[idx] -= cc[ok[idx]] * ft2.sum(t, m);
                ans[idx] += cc[ok[idx]] * ft2.sum(t);
                ans[idx] -= ft1.sum(t);
            } else {
                idx = ~idx;
                int t = ok[idx];
                ans[idx] -= ft1.sum(t, m);
                ans[idx] += cc[ok[idx]] * ft2.sum(t, m);
                ans[idx] -= cc[ok[idx]] * ft2.sum(t);
                ans[idx] += ft1.sum(t);
            }
        }
    }
    for (auto x : ans) co(x);

    return 0;
}
0