結果

問題 No.1456 Range Xor
ユーザー cutmdocutmdo
提出日時 2023-01-14 10:59:08
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 90 ms / 2,000 ms
コード長 3,094 bytes
コンパイル時間 1,591 ms
コンパイル使用メモリ 115,992 KB
実行使用メモリ 23,036 KB
最終ジャッジ日時 2024-12-25 16:50:53
合計ジャッジ時間 5,261 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 1 ms
5,248 KB
testcase_02 AC 2 ms
5,248 KB
testcase_03 AC 81 ms
22,908 KB
testcase_04 AC 85 ms
22,908 KB
testcase_05 AC 90 ms
23,036 KB
testcase_06 AC 87 ms
22,780 KB
testcase_07 AC 86 ms
22,904 KB
testcase_08 AC 84 ms
22,844 KB
testcase_09 AC 90 ms
22,908 KB
testcase_10 AC 83 ms
22,904 KB
testcase_11 AC 16 ms
6,260 KB
testcase_12 AC 8 ms
5,248 KB
testcase_13 AC 25 ms
8,740 KB
testcase_14 AC 25 ms
8,804 KB
testcase_15 AC 66 ms
18,632 KB
testcase_16 AC 60 ms
17,584 KB
testcase_17 AC 38 ms
11,568 KB
testcase_18 AC 23 ms
8,576 KB
testcase_19 AC 48 ms
14,432 KB
testcase_20 AC 60 ms
17,452 KB
testcase_21 AC 50 ms
14,264 KB
testcase_22 AC 48 ms
14,720 KB
testcase_23 AC 28 ms
9,580 KB
testcase_24 AC 13 ms
5,856 KB
testcase_25 AC 23 ms
8,144 KB
testcase_26 AC 41 ms
12,212 KB
testcase_27 AC 55 ms
16,276 KB
testcase_28 AC 20 ms
7,680 KB
testcase_29 AC 79 ms
21,364 KB
testcase_30 AC 81 ms
22,016 KB
testcase_31 AC 20 ms
7,424 KB
testcase_32 AC 16 ms
6,524 KB
testcase_33 AC 31 ms
10,196 KB
testcase_34 AC 79 ms
21,852 KB
testcase_35 AC 42 ms
12,636 KB
testcase_36 AC 86 ms
22,604 KB
testcase_37 AC 76 ms
19,232 KB
testcase_38 AC 12 ms
6,144 KB
testcase_39 AC 57 ms
16,876 KB
testcase_40 AC 58 ms
16,656 KB
testcase_41 AC 3 ms
5,248 KB
testcase_42 AC 10 ms
5,248 KB
testcase_43 AC 2 ms
5,248 KB
testcase_44 AC 2 ms
5,248 KB
testcase_45 AC 2 ms
5,248 KB
testcase_46 AC 2 ms
5,248 KB
testcase_47 AC 2 ms
5,248 KB
testcase_48 AC 2 ms
5,248 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#define PROBLEM "https://yukicoder.me/problems/no/1456"

#include <iostream>
#include <unordered_set>

#include <vector>
#include <cmath>

template <class SG>
class DisjointSparseTable {

    using S = decltype(SG::Type());

    const int m_n;
    const std::vector<std::vector<SG>> m_table;

    static auto accumulation(int n, const std::vector<S>& a, int l, int r) {
        auto mid = (r + l) >> 1;
        r = std::min(n, r);
        int size = r - l;
        std::vector<SG> acc; acc.reserve(size);
        for(int i = l; i < r; ++i) { acc.emplace_back(a[i]); }
        for(int i = mid - 2; i >= l; --i) if(i - l + 1 < size) {
            acc[i - l] = acc[i - l].binaryOperation(acc[i - l + 1]);
        }
        for(int i = mid + 1; i < r; ++i)if(i - l - 1 >= 0) {
            acc[i - l] = acc[i - l - 1].binaryOperation(acc[i - l]);
        }
        return acc;
    }

    static auto constructTable(int n, const std::vector<S>& a) {
        std::vector<std::vector<SG>> table; table.reserve(std::log2(n) + 1);
        table.emplace_back(a.begin(), a.end());

        auto size = 1;
        while(size < n) {
            size <<= 1;
            std::vector<SG> acc; acc.reserve(n);
            for(int l = 0; l < n; l += size) for(const auto& x : accumulation(n, a, l, l + size)) {
                acc.emplace_back(x);
            }
            table.emplace_back(acc);
        }
        return table;
    }

    static auto msb(int x) {
        auto idx = 0;
        while(x > 0) { ++idx; x >>= 1; }
        return idx;
    }
public:
    DisjointSparseTable(int n, const std::vector<S>& a) :m_n(n), m_table(constructTable(n, a)) {}

    auto get(int l, int r)const {
        if(r < l) { throw std::runtime_error("ERROR! `l` must less than `r`"); }
        l = std::max(l, 0); r = std::min(r, m_n - 1);
        if(l == r) { return m_table[0][l].m_val; }
        auto idx = msb(l ^ r);
        return m_table[idx][l].binaryOperation(m_table[idx][r]).m_val;
    }
};
template<
    class S,// 要素の型
    class T // 2項演算子
>
struct SemiGroup {
    static inline auto Type() { return S(); }
    S m_val;
    SemiGroup(S val) :m_val(val) {}
    SemiGroup binaryOperation(const SemiGroup& m2)const { return T()(m_val, m2.m_val); }
    friend std::ostream& operator<<(std::ostream& os, const SemiGroup<S, T>& m) {
        return os << m.m_val;
    }
};

using ll = long long;
using std::cout;
using std::cin;
constexpr char endl = '\n';

struct F { auto operator()(ll x, ll y) { return x ^ y; } };
using SG = SemiGroup<ll, F>;

signed main() {
    ll n, k;
    cin >> n >> k;

    std::vector<ll> a; a.reserve(n);
    for(int _ = 0; _ < n; ++_) {
        ll x; cin >> x;
        a.emplace_back(x);
    }

    auto dst = DisjointSparseTable<SG>(n, a);
    std::unordered_set<ll> st;
    for(int i = 0; i < n; ++i) {
        st.emplace(dst.get(0, i) ^ k);
    }

    if(st.find(0) != st.end()) { cout << "Yes" << endl; return 0; }
    for(int i = 0; i < n; ++i) {
        if(st.find(dst.get(0, i)) != st.end()) { cout << "Yes" << endl; return 0; }
    }
    cout << "No" << endl;
}
0