sparse_table/test/sparse_table.test.cpp

• View this file on GitHub
• Last update: 2022-01-08 20:23:44+09:00
• Problem: https://judge.yosupo.jp/problem/staticrmq

Depends on

• sparse_table/rmq_sparse_table.hpp
• Sparse table (sparse_table/sparse_table.hpp)

Code

#define PROBLEM "https://judge.yosupo.jp/problem/staticrmq"
#include "../sparse_table.hpp"
#include "../rmq_sparse_table.hpp"
#include <cassert>
#include <iostream>
#include <vector>
using namespace std;

int op(int l, int r) { return l < r ? l : r; }
int e() { return 2e9; }

int main() {
    int N, Q;
    cin >> N >> Q;
    vector<int> A(N);
    for (auto &x : A) cin >> x;
    sparse_table<int, op, e> rmq1(A);
    StaticRMQ<int> rmq2(A, 2e9);
    while (Q--) {
        int l, r;
        cin >> l >> r;
        int a = rmq1.prod(l, r), b = rmq2.get(l, r);
        assert(a == b);
        cout << a << '\n';
    }
}

#line 1 "sparse_table/test/sparse_table.test.cpp"
#define PROBLEM "https://judge.yosupo.jp/problem/staticrmq"
#line 2 "sparse_table/sparse_table.hpp"
#include <cassert>
#include <vector>

// CUT begin
// Static sequence sparse table
// Complexity: O(NlogN) for precalculation, O(1) per query
template <class S, S (*op)(S, S), S (*e)()> struct sparse_table {
    int N, lgN;
    std::vector<std::vector<S>> d;
    std::vector<int> lgx_table;
    sparse_table() {}
    sparse_table(const std::vector<S> &sequence) : N(sequence.size()) {
        lgx_table.resize(N + 1);
        for (int i = 2; i < N + 1; ++i) lgx_table[i] = lgx_table[i >> 1] + 1;
        lgN = lgx_table[N] + 1;
        d.assign(lgN, std::vector<S>(N, e()));
        d[0] = sequence;
        for (int h = 1; h < lgN; ++h) {
            for (int i = 0; i + (1 << h) <= N; ++i) {
                d[h][i] = op(d[h - 1][i], d[h - 1][i + (1 << (h - 1))]);
            }
        }
    }
    S prod(int l, int r) const { // [l, r), 0-indexed
        assert(l >= 0 and r <= N);
        if (l >= r) return e();
        int h = lgx_table[r - l];
        return op(d[h][l], d[h][r - (1 << h)]);
    }
};
#line 2 "sparse_table/rmq_sparse_table.hpp"
#include <algorithm>
#line 5 "sparse_table/rmq_sparse_table.hpp"

// CUT begin
// Range Minimum Query for static sequence by sparse table
// Complexity: $O(N \log N)$ for precalculation, $O(1)$ per query
template <typename T> struct StaticRMQ {
    inline T func(const T &l, const T &r) const noexcept { return std::min<T>(l, r); }
    int N, lgN;
    T defaultT;
    std::vector<std::vector<T>> data;
    std::vector<int> lgx_table;
    StaticRMQ() = default;
    StaticRMQ(const std::vector<T> &sequence, T defaultT)
        : N(sequence.size()), defaultT(defaultT) {
        lgx_table.resize(N + 1);
        for (int i = 2; i < N + 1; i++) lgx_table[i] = lgx_table[i >> 1] + 1;
        lgN = lgx_table[N] + 1;
        data.assign(lgN, std::vector<T>(N, defaultT));
        data[0] = sequence;
        for (int d = 1; d < lgN; d++) {
            for (int i = 0; i + (1 << d) <= N; i++) {
                data[d][i] = func(data[d - 1][i], data[d - 1][i + (1 << (d - 1))]);
            }
        }
    }
    T get(int l, int r) const { // [l, r), 0-indexed
        assert(l >= 0 and r <= N);
        if (l >= r) return defaultT;
        int d = lgx_table[r - l];
        return func(data[d][l], data[d][r - (1 << d)]);
    }
};
#line 5 "sparse_table/test/sparse_table.test.cpp"
#include <iostream>
#line 7 "sparse_table/test/sparse_table.test.cpp"
using namespace std;

int op(int l, int r) { return l < r ? l : r; }
int e() { return 2e9; }

int main() {
    int N, Q;
    cin >> N >> Q;
    vector<int> A(N);
    for (auto &x : A) cin >> x;
    sparse_table<int, op, e> rmq1(A);
    StaticRMQ<int> rmq2(A, 2e9);
    while (Q--) {
        int l, r;
        cin >> l >> r;
        int a = rmq1.prod(l, r), b = rmq2.get(l, r);
        assert(a == b);
        cout << a << '\n';
    }
}

Back to top page