Submission #28508569

---

Source Code Expand

#include <bits/stdc++.h>
#define ENABLE_AVX2

using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;

class Range {
    struct Iter {
        int itr;
        constexpr Iter(const int pos) noexcept : itr(pos) {}
        constexpr void operator++() noexcept { ++itr; }
        constexpr bool operator!=(const Iter& other) const noexcept { return itr != other.itr; }
        constexpr int operator*() const noexcept { return itr; }
    };
    const Iter first, last;

  public:
    explicit constexpr Range(const int first, const int last) noexcept : first(first), last(std::max(first, last)) {}
    constexpr Iter begin() const noexcept { return first; }
    constexpr Iter end() const noexcept { return last; }
};

constexpr Range rep(const int l, const int r) noexcept { return Range(l, r); }
constexpr Range rep(const int n) noexcept { return Range(0, n); }

template <class F> struct RecursiveLambda : private F {
    explicit constexpr RecursiveLambda(F&& f) : F(std::forward<F>(f)) {}
    template <class... Args> constexpr decltype(auto) operator()(Args&&... args) const {
        return F::operator()(*this, std::forward<Args>(args)...);
    }
};

template <class F> constexpr decltype(auto) rec_lambda(F&& f) { return RecursiveLambda<F>(std::forward<F>(f)); }

using std::array;
using std::pair;
using std::tuple;
using std::vector;

constexpr int pow4(const int e) { return 1 << (2 * e); }

int read() {
    std::string s;
    std::cin >> s;
    int ret = 0;
    for (const char c : s) {
        ret *= 4;
        if (c == 'R') ret += 1;
        if (c == 'S') ret += 2;
    }
    return ret;
}

void main_() {
    int K, N, M;
    std::cin >> K >> N >> M;
    const int L = pow4(K);
    vector<i64> A(L), B(L);
    for (const int i : rep(N)) {
        A[read()] += 1;
    }
    for (const int i : rep(M)) {
        B[read()] += 1;
    }
    for (const int d : rep(K)) {
        const int j = pow4(d);
        for (const int i : rep(L)) {
            if ((i / j) % 4 == 3) {
                A[i] += A[i - 1 * j] + A[i - 2 * j] + A[i - 3 * j];
                B[i] += B[i - 1 * j] + B[i - 2 * j] + B[i - 3 * j];
            }
        }
    }
    for (const int i : rep(L)) {
        A[i] *= B[i];
    }
    for (const int d : rep(K)) {
        const int j = pow4(d);
        for (const int i : rep(L)) {
            if ((i / j) % 4 == 3) {
                A[i] -= A[i - 1 * j] + A[i - 2 * j] + A[i - 3 * j];
            }
        }
    }
    for (const int d : rep(K)) {
        const int j = pow4(d);
        for (const int i : rep(L)) {
            if ((i / j) % 4 == 3) {
                const i64 a = A[i - 3 * j], b = A[i - 2 * j], c = A[i - 1 * j];
                A[i - 3 * j] = c + a + A[i];
                A[i - 2 * j] = a + b + A[i];
                A[i - 1 * j] = b + c + A[i];
            }
        }
    }
    rec_lambda([&](auto&& dfs, const int k, const int x) -> void {
        if (k == K) {
            std::cout << (i64)N * M - A[x] << '\n';
        } else {
            for (const int i : rep(3)) {
                dfs(k + 1, 4 * x + i);
            }
        }
    })(0, 0);
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    main_();
    return 0;
}

Submission Info

Compile Error

./Main.cpp: In function ‘void main_()’:
./Main.cpp:63:20: warning: unused variable ‘i’ [-Wunused-variable]
   63 |     for (const int i : rep(N)) {
      |                    ^
./Main.cpp:66:20: warning: unused variable ‘i’ [-Wunused-variable]
   66 |     for (const int i : rep(M)) {
      |                    ^

Judge Result