結果
| 問題 | No.924 紲星 |
| ユーザー |
 kuhaku
|
| 提出日時 | 2023-09-13 22:58:16 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 468 ms / 4,000 ms |
| コード長 | 18,225 bytes |
| コンパイル時間 | 4,215 ms |
| コンパイル使用メモリ | 246,996 KB |
| 実行使用メモリ | 27,540 KB |
| 最終ジャッジ日時 | 2023-09-13 22:58:26 |
| 合計ジャッジ時間 | 10,074 ms |
|
ジャッジサーバーID （参考情報） |
judge14 / judge13 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
4,376 KB |
| testcase_01 | AC | 1 ms
4,376 KB |
| testcase_02 | AC | 2 ms
4,376 KB |
| testcase_03 | AC | 3 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,380 KB |
| testcase_07 | AC | 2 ms
4,376 KB |
| testcase_08 | AC | 438 ms
27,356 KB |
| testcase_09 | AC | 444 ms
27,352 KB |
| testcase_10 | AC | 435 ms
27,288 KB |
| testcase_11 | AC | 468 ms
27,376 KB |
| testcase_12 | AC | 441 ms
27,540 KB |
| testcase_13 | AC | 180 ms
13,392 KB |
| testcase_14 | AC | 160 ms
11,588 KB |
| testcase_15 | AC | 155 ms
11,908 KB |
| testcase_16 | AC | 221 ms
19,132 KB |
| testcase_17 | AC | 268 ms
16,108 KB |
| testcase_18 | AC | 1 ms
4,376 KB |
ソースコード
#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 2 "/home/kuhaku/atcoder/github/algo/lib/data_structure/bit_vector.hpp"
/**
* @brief 完備辞書
*
* @see https://ei1333.github.io/library/structure/wavelet/succinct-indexable-dictionary.hpp
*/
struct bit_vector {
bit_vector() = default;
bit_vector(unsigned int _length)
: length(_length), blocks((_length + 31) >> 5), bit((_length + 31) >> 5),
sum((_length + 31) >> 5) {}
void set(unsigned int k) { bit[k >> 5] |= 1U << (k & 31); }
void build() {
sum[0] = 0U;
for (unsigned int i = 1; i < blocks; ++i) {
sum[i] = sum[i - 1] + __builtin_popcount(bit[i - 1]);
}
}
bool operator[](unsigned int k) const { return bit[k >> 5] >> (k & 31) & 1; }
unsigned int rank(unsigned int k) const {
return sum[k >> 5] + __builtin_popcount(bit[k >> 5] & ((1U << (k & 31)) - 1));
}
unsigned int rank(bool val, unsigned int k) const { return val ? rank(k) : k - rank(k); }
unsigned int select(unsigned int k) const {
unsigned int sl = 0, sr = blocks + 1;
while (sr - sl > 1) {
unsigned int m = (sl + sr) >> 1;
if (sum[m] < k) sl = m;
else sr = m;
}
k -= sum[sl];
unsigned int bl = 0, br = 32;
while (br - bl > 1) {
unsigned int m = (bl + br) >> 1;
if (__builtin_popcount(bit[sl] & ((1U << m) - 1)) < k) bl = m;
else br = m;
}
return (sl << 5) + bl;
}
private:
unsigned int length, blocks;
std::vector<unsigned int> bit, sum;
};
#line 3 "/home/kuhaku/atcoder/github/algo/lib/data_structure/wavelet_matrix.hpp"
/**
* @brief ウェーブレット行列
*
* @tparam T
* @tparam L
*
* @see https://ei1333.github.io/library/structure/wavelet/wavelet-matrix.cpp.html
*/
template <class T, int L = 20>
struct wavelet_matrix {
wavelet_matrix() = default;
wavelet_matrix(std::vector<T> v) : length(v.size()) {
std::vector<T> l(length), r(length);
for (int level = L - 1; level >= 0; --level) {
matrix[level] = bit_vector(length + 1);
int left = 0, right = 0;
for (int i = 0; i < length; ++i) {
if (v[i] >> level & 1) {
matrix[level].set(i);
r[right++] = v[i];
} else {
l[left++] = v[i];
}
}
mid[level] = left;
matrix[level].build();
v.swap(l);
for (int i = 0; i < right; ++i) {
v[left + i] = r[i];
}
}
}
T access(int k) const {
T res = 0;
for (int level = L - 1; level >= 0; --level) {
bool f = matrix[level][k];
if (f) res |= T(1) << level;
k = matrix[level].rank(f, k) + mid[level] * f;
}
return res;
}
T operator[](int k) const { return access(k); }
/**
* @brief count i s.t. (0 <= i < r) && v[i] == x
*
* @param x
* @param r
* @return int
*/
int rank(int r, T x) const {
int l = 0;
for (int level = L - 1; level >= 0; --level) {
std::tie(l, r) = succ((x >> level) & 1, l, r, level);
}
return r - l;
}
/**
* @brief count i s.t. (l <= i < r) && v[i] == x
*
* @param l
* @param r
* @param x
* @return int
*/
int rank(int l, int r, T x) const { return rank(r, x) - rank(l, x); }
/**
* @brief k-th smallest number in v[l ... r-1]
*
* @param l
* @param r
* @param k
* @return T
*/
T kth_smallest(int l, int r, int k) const {
assert(0 <= k && k < r - l);
T res = 0;
for (int level = L - 1; level >= 0; --level) {
int cnt = matrix[level].rank(false, r) - matrix[level].rank(false, l);
bool f = cnt <= k;
if (f) {
res |= T(1) << level;
k -= cnt;
}
std::tie(l, r) = succ(f, l, r, level);
}
return res;
}
/**
* @brief k-th largest number in v[l ... r-1]
*
* @param l
* @param r
* @param k
* @return T
*/
T kth_largest(int l, int r, int k) const { return kth_smallest(l, r, r - l - k - 1); }
/**
* @brief count i s.t. (l <= i < r) && (v[i] < upper)
*
* @param l
* @param r
* @param upper
* @return int
*/
int range_freq(int l, int r, T upper) const {
int res = 0;
for (int level = L - 1; level >= 0; --level) {
bool f = ((upper >> level) & 1);
if (f) res += matrix[level].rank(false, r) - matrix[level].rank(false, l);
std::tie(l, r) = succ(f, l, r, level);
}
return res;
}
/**
* @brief count i s.t. (l <= i < r) && (lower <= v[i] < upper)
*
* @param l
* @param r
* @param lower
* @param upper
* @return int
*/
int range_freq(int l, int r, T lower, T upper) const {
return range_freq(l, r, upper) - range_freq(l, r, lower);
}
/**
* @brief max v[i] s.t. (l <= i < r) && (v[i] < upper)
*
* @param l
* @param r
* @param upper
* @return T
*/
T prev_value(int l, int r, T upper) const {
int cnt = range_freq(l, r, upper);
return cnt == 0 ? T(-1) : kth_smallest(l, r, cnt - 1);
}
/**
* @brief min v[i] s.t. (l <= i < r) && (lower <= v[i])
*
* @param l
* @param r
* @param lower
* @return T
*/
T next_value(int l, int r, T lower) const {
int cnt = range_freq(l, r, lower);
return cnt == r - l ? T(-1) : kth_smallest(l, r, cnt);
}
private:
int length;
bit_vector matrix[L];
int mid[L];
std::pair<int, int> succ(bool f, int l, int r, int level) const {
return {matrix[level].rank(f, l) + mid[level] * f,
matrix[level].rank(f, r) + mid[level] * f};
}
};
#line 4 "/home/kuhaku/atcoder/github/algo/lib/data_structure/compressed_wavelet_matrix.hpp"
/**
* @brief ウェーブレット行列
*
* @tparam T
* @tparam L
*
* @see https://ei1333.github.io/library/structure/wavelet/wavelet-matrix.cpp.html
*/
template <class T, int L = 20>
struct compressed_wavelet_matrix {
compressed_wavelet_matrix() = default;
compressed_wavelet_matrix(const std::vector<T> &v) : cps(v) {
int n = v.size();
std::vector<int> t(n);
for (int i = 0; i < n; ++i) t[i] = cps.get(v[i]);
mat = wavelet_matrix<int, L>(t);
}
T access(int k) const { return cps[mat.access(k)]; }
T operator[](int k) const { return access(k); }
/**
* @brief count i s.t. (0 <= i < r) && v[i] == x
*
* @param x
* @param r
* @return int
*/
int rank(int r, T x) const {
auto pos = cps.get(x);
if (pos == cps.size() || cps[pos] != x) return 0;
return mat.rank(r, pos);
}
/**
* @brief count i s.t. (l <= i < r) && v[i] == x
*
* @param l
* @param r
* @param x
* @return int
*/
int rank(int l, int r, T x) const { return rank(r, x) - rank(l, x); }
/**
* @brief k-th smallest number in v[l ... r-1]
*
* @param l
* @param r
* @param k
* @return T
*/
T kth_smallest(int l, int r, int k) const { return cps[mat.kth_smallest(l, r, k)]; }
/**
* @brief k-th largest number in v[l ... r-1]
*
* @param l
* @param r
* @param k
* @return T
*/
T kth_largest(int l, int r, int k) const { return cps[mat.kth_largest(l, r, k)]; }
/**
* @brief count i s.t. (l <= i < r) && (v[i] < upper)
*
* @param l
* @param r
* @param upper
* @return int
*/
int range_freq(int l, int r, T upper) const { return mat.range_freq(l, r, cps.get(upper)); }
/**
* @brief count i s.t. (l <= i < r) && (lower <= v[i] < upper)
*
* @param l
* @param r
* @param lower
* @param upper
* @return int
*/
int range_freq(int l, int r, T lower, T upper) const {
return mat.range_freq(l, r, cps.get(lower), cps.get(upper));
}
/**
* @brief max v[i] s.t. (l <= i < r) && (v[i] < upper)
*
* @param l
* @param r
* @param upper
* @return T
*/
T prev_value(int l, int r, T upper) const {
auto res = mat.prev_value(l, r, cps.get(upper));
return res == -1 ? T(-1) : cps[res];
}
/**
* @brief min v[i] s.t. (l <= i < r) && (lower <= v[i])
*
* @param l
* @param r
* @param lower
* @return T
*/
T next_value(int l, int r, T lower) const {
auto res = mat.next_value(l, r, cps.get(lower));
return res == -1 ? T(-1) : cps[res];
}
private:
wavelet_matrix<int, L> mat;
coordinate_compression<T> cps;
};
#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 6 "a.cpp"
int main(void) {
int n, q;
cin >> n >> q;
vector<ll> a(n);
cin >> a;
vector<pair<int, int>> b(q);
cin >> b;
compressed_wavelet_matrix wm(a);
coordinate_compression cc(a);
int m = cc.size();
auto c = compress(a);
vector<int> ok(q);
rep (i, q) {
ok[i] = wm.kth_smallest(b[i].first - 1, b[i].second, (b[i].second - b[i].first + 1) / 2);
}
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) {
ft1.add(c[i], a[i]);
ft2.add(c[i], 1);
for (auto &&idx : query[i + 1]) {
if (idx >= 0) {
int t = cc.get(ok[idx]);
ans[idx] += ft1.sum(t, m);
ans[idx] -= ok[idx] * ft2.sum(t, m);
ans[idx] += ok[idx] * ft2.sum(t);
ans[idx] -= ft1.sum(t);
} else {
idx = ~idx;
int t = cc.get(ok[idx]);
ans[idx] -= ft1.sum(t, m);
ans[idx] += ok[idx] * ft2.sum(t, m);
ans[idx] -= ok[idx] * ft2.sum(t);
ans[idx] += ft1.sum(t);
}
}
}
for (auto x : ans) co(x);
return 0;
}