sparse_table/test/sparse_table_aoj.test.cpp

View this file on GitHub
Last update: 2022-01-08 20:23:44+09:00
Problem: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_3_D

Depends on

Code

#define PROBLEM "http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_3_D"
#include "../rmq_sparse_table.hpp"
#include "../sparse_table.hpp"
#include <iostream>
#include <vector>
using namespace std;

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

int main() {
    cin.tie(nullptr), ios::sync_with_stdio(false);

    int N, L;
    cin >> N >> L;
    vector<int> A(N);
    for (auto &a : A) cin >> a;
    sparse_table<int, op, e> sp1(A);
    StaticRMQ<int> sp2(A, 1e9);
    for (int l = 0; l + L <= N; l++) {
        int a = sp1.prod(l, l + L);
        int b = sp2.get(l, l + L);
        assert(a == b);
        cout << a << (l + L == N ? '\n' : ' ');
    }
}

#line 1 "sparse_table/test/sparse_table_aoj.test.cpp"
#define PROBLEM "http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_3_D"
#line 2 "sparse_table/rmq_sparse_table.hpp"
#include <algorithm>
#include <cassert>
#include <vector>

// 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 4 "sparse_table/sparse_table.hpp"

// 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 4 "sparse_table/test/sparse_table_aoj.test.cpp"
#include <iostream>
#line 6 "sparse_table/test/sparse_table_aoj.test.cpp"
using namespace std;

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

int main() {
    cin.tie(nullptr), ios::sync_with_stdio(false);

    int N, L;
    cin >> N >> L;
    vector<int> A(N);
    for (auto &a : A) cin >> a;
    sparse_table<int, op, e> sp1(A);
    StaticRMQ<int> sp2(A, 1e9);
    for (int l = 0; l + L <= N; l++) {
        int a = sp1.prod(l, l + L);
        int b = sp2.get(l, l + L);
        assert(a == b);
        cout << a << (l + L == N ? '\n' : ' ');
    }
}