Submission #1146524

#	Time	Username	Problem	Language	Result	Execution time	Memory
1146524		Perl32	Matching (CEOI11_mat)	C++20	100 / 100	614 ms	39648 KiB

mat

//I wrote this code 4 u <3
#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#ifdef LOCAL
#include "algo/debug.h"
#else
#define debug(...) 42
#endif

template <typename T>
T inverse(T a, T m) {
   T u = 0, v = 1;
   while (a != 0) {
      T t = m / a;
      m -= t * a; swap(a, m);
      u -= t * v; swap(u, v);
   }
   assert(m == 1);
   return u;
}

template <typename T>
class Modular {
 public:
   using Type = typename decay<decltype(T::value)>::type;

   constexpr Modular() : value() {}
   template <typename U>
   Modular(const U& x) {
      value = normalize(x);
   }

   template <typename U>
   static Type normalize(const U& x) {
      Type v;
      if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
      else v = static_cast<Type>(x % mod());
      if (v < 0) v += mod();
      return v;
   }

   const Type& operator()() const { return value; }
   template <typename U>
   explicit operator U() const { return static_cast<U>(value); }
   constexpr static Type mod() { return T::value; }

   Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
   Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
   template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
   template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
   Modular& operator++() { return *this += 1; }
   Modular& operator--() { return *this -= 1; }
   Modular operator++(int) { Modular result(*this); *this += 1; return result; }
   Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
   Modular operator-() const { return Modular(-value); }

   template <typename U = T>
   typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
      value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
      return *this;
   }
   template <typename U = T>
   typename enable_if<is_same<typename Modular<U>::Type, long long>::value, Modular>::type& operator*=(const Modular& rhs) {
      long long q = static_cast<long long>(static_cast<long double>(value) * rhs.value / mod());
      value = normalize(value * rhs.value - q * mod());
      return *this;
   }
   template <typename U = T>
   typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
      value = normalize(value * rhs.value);
      return *this;
   }

   Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }

   friend const Type& abs(const Modular& x) { return x.value; }

   template <typename U>
   friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);

   template <typename U>
   friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);

   template <typename V, typename U>
   friend V& operator>>(V& stream, Modular<U>& number);

private:
   Type value;
};

template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }

template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }

template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }

template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }

template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }

template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }

template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }

template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
   Modular<T> x = a, res = 1;
   U p = b;
   while (p > 0) {
      if (p & 1) res *= x;
      x *= x;
      p >>= 1;
   }
   return res;
}

template <typename T>
bool IsZero(const Modular<T>& number) {
   return number() == 0;
}

template <typename T>
string to_string(const Modular<T>& number) {
   return to_string(number());
}

template <typename U, typename T>
U& operator<<(U& stream, const Modular<T>& number) {
   return stream << number();
}

template <typename U, typename T>
U& operator>>(U& stream, Modular<T>& number) {
   typename common_type<typename Modular<T>::Type, long long>::type x;
   stream >> x;
   number.value = Modular<T>::normalize(x);
   return stream;
}

constexpr int mod = 998'244'353;
using mint = Modular<std::integral_constant<decay<decltype(mod)>::type, mod>>;

const int maxN = 1e6 + 1;
const int R = 1488;
mint pw[maxN];

void precalc() {
    pw[0] = 1;
    for (int i = 1; i < maxN; ++i) pw[i] = pw[i - 1] * R;
}

struct Info {
    mint hsh = 0;
    int sz = 0;

    Info() = default;
    Info(int v) {
        hsh = v;
        sz = 1;
    }
};

Info operator+(const Info& a, const Info& b) {
    Info res;
    res.sz = a.sz + b.sz;
    res.hsh = a.hsh * pw[b.sz] + b.hsh;
    return res;
}

struct ST {
    vector<Info> t;
    int sz;

    ST(int n) {
        sz = 1;
        while (sz < n) sz <<= 1;
        t.resize(sz << 1);
    }

    void pull(int x) { t[x] = t[x << 1] + t[x << 1 | 1]; }

    void upd(int i, Info v) {
        i += sz;
        t[i] = v;
        i >>= 1;
        while (i) {
            pull(i);
            i >>= 1;
        }
    }

    Info prod() {
        return t[1];
    }
};

signed main(int32_t argc, char *argv[]) {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    precalc();
    int n, m;
    cin >> n >> m;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; ++i) cin >> a[i];
    mint hsh = 0;
    for (int i = 1; i <= n; ++i) hsh = hsh * R + a[i];
    vector<int> b(m + 1);
    for (int i = 1; i <= m; ++i) cin >> b[i];
    vector<int> srt = b;
    sort(srt.begin(), srt.end());
    srt.resize(unique(srt.begin(), srt.end()) - srt.begin());
    for (auto& x : b) x = lower_bound(srt.begin(), srt.end(), x) - srt.begin();
    ST tt(srt.size());
    mint cur = 0, delta = 0;
    for (int i = 0; i < n; ++i) delta += pw[i];
    vector<int> ans;
    for (int i = 1; i <= m; ++i) {
        tt.upd(b[i], Info(i));
        if (i - n > 0) {
            tt.upd(b[i - n], Info());
        }
        if (i >= n) {
            if (tt.prod().hsh - cur == hsh) {
                ans.push_back(i - n + 1);
            }
            cur += delta;
        }
    }
    cout << ans.size() << '\n';
    for (auto x : ans) cout << x << ' ';
}

/*

 */

• Subtask 1: 9 / 9
• Subtask 2: 9 / 9
• Subtask 3: 9 / 9
• Subtask 4: 9 / 9
• Subtask 5: 9 / 9
• Subtask 6: 9 / 9
• Subtask 7: 9 / 9
• Subtask 8: 9 / 9
• Subtask 9: 8 / 8
• Subtask 10: 10 / 10
• Subtask 11: 10 / 10