結果

問題 No.1066 #いろいろな色 / Red and Blue and more various colors (Easy)
ユーザー iiljjiiljj
提出日時 2020-07-13 23:57:31
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 32 ms / 2,000 ms
コード長 17,975 bytes
コンパイル時間 3,362 ms
コンパイル使用メモリ 230,728 KB
最終ジャッジ日時 2025-01-11 20:21:56
ジャッジサーバーID
(参考情報)
judge3 / judge4
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 3
other AC * 24
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

/* #region Head */
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pll = pair<ll, ll>;
template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;
using vll = vc<ll>;
using vvll = vvc<ll>;
using vld = vc<ld>;
using vvld = vvc<ld>;
using vs = vc<string>;
using vvs = vvc<string>;
template <class T, class U> using um = unordered_map<T, U>;
template <class T> using pq = priority_queue<T>;
template <class T> using pqa = priority_queue<T, vc<T>, greater<T>>;
template <class T> using us = unordered_set<T>;
#define REP(i, m, n) for (ll i = (m), i##_len = (ll)(n); i < i##_len; ++(i))
#define REPM(i, m, n) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; ++(i))
#define REPR(i, m, n) for (ll i = (m), i##_min = (ll)(n); i >= i##_min; --(i))
#define REPD(i, m, n, d) for (ll i = (m), i##_len = (ll)(n); i < i##_len; i += (d))
#define REPMD(i, m, n, d) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; i += (d))
#define REPI(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define ALL(x) begin(x), end(x)
#define SIZE(x) ((ll)(x).size())
#define PERM(c) \
sort(ALL(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(ALL(c)))
#define UNIQ(v) v.erase(unique(ALL(v)), v.end());
#define endl '\n'
#define sqrt sqrtl
#define floor floorl
#define log2 log2l
constexpr ll INF = 1'010'000'000'000'000'017LL;
constexpr ll MOD = 1'000'000'007LL; // 1e9 + 7
constexpr ld EPS = 1e-12;
constexpr ld PI = 3.14159265358979323846;
template <typename T> istream &operator>>(istream &is, vc<T> &vec) { // vector
for (T &x : vec) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vc<T> &vec) { // vector (for dump)
os << "{";
REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "" : ", ");
os << "}";
return os;
}
template <typename T> ostream &operator>>(ostream &os, vc<T> &vec) { // vector (inline)
REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "\n" : " ");
return os;
}
template <typename T, typename U> istream &operator>>(istream &is, pair<T, U> &pair_var) { // pair
is >> pair_var.first >> pair_var.second;
return is;
}
template <typename T, typename U> ostream &operator<<(ostream &os, pair<T, U> &pair_var) { // pair
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// map, um, set, us
template <class T> ostream &out_iter(ostream &os, T &map_var) {
os << "{";
REPI(itr, map_var) {
os << *itr;
auto itrcp = itr;
if (++itrcp != map_var.end()) os << ", ";
}
return os << "}";
}
template <typename T, typename U> ostream &operator<<(ostream &os, map<T, U> &map_var) { return out_iter(os, map_var); }
template <typename T, typename U> ostream &operator<<(ostream &os, um<T, U> &map_var) {
os << "{";
REPI(itr, map_var) {
auto [key, value] = *itr;
os << "(" << key << ", " << value << ")";
auto itrcp = itr;
if (++itrcp != map_var.end()) os << ", ";
}
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, us<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, pq<T> &pq_var) {
pq<T> pq_cp(pq_var);
os << "{";
if (!pq_cp.empty()) {
os << pq_cp.top(), pq_cp.pop();
while (!pq_cp.empty()) os << ", " << pq_cp.top(), pq_cp.pop();
}
return os << "}";
}
// dump
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail> void dump_func(Head &&head, Tail &&... tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) DUMPOUT << ", ";
dump_func(move(tail)...);
}
// chmax ()
template <typename T, typename U, typename Comp = less<>> bool chmax(T &xmax, const U &x, Comp comp = {}) {
if (comp(xmax, x)) {
xmax = x;
return true;
}
return false;
}
// chmin ()
template <typename T, typename U, typename Comp = less<>> bool chmin(T &xmin, const U &x, Comp comp = {}) {
if (comp(x, xmin)) {
xmin = x;
return true;
}
return false;
}
//
#define DEBUG_
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
struct AtCoderInitialize {
static constexpr int IOS_PREC = 15;
static constexpr bool AUTOFLUSH = false;
AtCoderInitialize() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(IOS_PREC);
if (AUTOFLUSH) cout << unitbuf;
}
} ATCODER_INITIALIZE;
void Yn(bool p) { cout << (p ? "Yes" : "No") << endl; }
void YN(bool p) { cout << (p ? "YES" : "NO") << endl; }
/* #endregion */
/* #region ConvWithMint */
#define rep(i, b) REP(i, 0, b)
#define si(x) int(x.size())
// size of input must be a power of 2
// output of forward fmt is bit-reversed
// output elements are in the range [0,mod*4)
// input of inverse fmt should be bit-reversed
template <class mint> void inplace_fmt(vector<mint> &f, bool inv) {
const int n = si(f);
static const int L = 30;
static mint g[L], ig[L], p2[L];
if (g[0].v == 0) {
rep(i, L) {
mint w = -mint::root().pow(((mint::mod - 1) >> (i + 2)) * 3);
g[i] = w;
ig[i] = w.inv();
p2[i] = mint(1 << i).inv();
}
}
static constexpr uint mod2 = mint::mod * 2;
if (!inv) {
int b = n;
if (b >>= 1) { // input:[0,mod)
rep(i, b) {
uint x = f[i + b].v;
f[i + b].v = f[i].v + mint::mod - x;
f[i].v += x;
}
}
if (b >>= 1) { // input:[0,mod*2)
mint p = 1;
for (int i = 0, k = 0; i < n; i += b * 2) {
REP(j, i, i + b) {
uint x = (f[j + b] * p).v;
// f[j].v=(f[j].v<mint::mod?f[j].v:f[j].v-mint::mod);
f[j + b].v = f[j].v + mint::mod - x;
f[j].v += x;
}
p *= g[__builtin_ctz(++k)];
}
}
while (b) {
if (b >>= 1) { // input:[0,mod*3)
mint p = 1;
for (int i = 0, k = 0; i < n; i += b * 2) {
REP(j, i, i + b) {
uint x = (f[j + b] * p).v;
// f[j].v=(f[j].v<mint::mod?f[j].v:f[j].v-mint::mod);
f[j + b].v = f[j].v + mint::mod - x;
f[j].v += x;
}
p *= g[__builtin_ctz(++k)];
}
}
if (b >>= 1) { // input:[0,mod*4)
mint p = 1;
for (int i = 0, k = 0; i < n; i += b * 2) {
REP(j, i, i + b) {
uint x = (f[j + b] * p).v;
f[j].v = (f[j].v < mod2 ? f[j].v : f[j].v - mod2);
f[j + b].v = f[j].v + mint::mod - x;
f[j].v += x;
}
p *= g[__builtin_ctz(++k)];
}
}
}
} else {
int b = 1;
if (b < n / 2) { // input:[0,mod)
mint p = 1;
for (int i = 0, k = 0; i < n; i += b * 2) {
REP(j, i, i + b) {
ull x = f[j].v + mint::mod - f[j + b].v;
f[j].v += f[j + b].v;
f[j + b].v = x * p.v % mint::mod;
}
p *= ig[__builtin_ctz(++k)];
}
b <<= 1;
}
for (; b < n / 2; b <<= 1) {
mint p = 1;
for (int i = 0, k = 0; i < n; i += b * 2) {
REP(j, i, i + b / 2) { // input:[0,mod*2)
ull x = f[j].v + mod2 - f[j + b].v;
f[j].v += f[j + b].v;
f[j].v = (f[j].v) < mod2 ? f[j].v : f[j].v - mod2;
f[j + b].v = x * p.v % mint::mod;
}
REP(j, i + b / 2, i + b) { // input:[0,mod)
ull x = f[j].v + mint::mod - f[j + b].v;
f[j].v += f[j + b].v;
// f[j].v=(f[j].v)<mod2?f[j].v:f[j].v-mod2;
f[j + b].v = x * p.v % mint::mod;
}
p *= ig[__builtin_ctz(++k)];
}
}
if (b < n) { // input:[0,mod*2)
rep(i, b) {
uint x = f[i + b].v;
f[i + b].v = f[i].v + mod2 - x;
f[i].v += x;
}
}
mint z = p2[__lg(n)];
rep(i, n) f[i] *= z;
}
}
struct modinfo {
uint mod, root;
};
template <modinfo const &ref> struct modular {
static constexpr uint const &mod = ref.mod;
static modular root() { return modular(ref.root); }
uint v;
// modular(initializer_list<uint>ls):v(*ls.bg){}
modular(ll vv = 0) { s(vv % mod + mod); }
modular &s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
modular operator-() const { return modular() - *this; }
modular &operator+=(const modular &rhs) { return s(v + rhs.v); }
modular &operator-=(const modular &rhs) { return s(v + mod - rhs.v); }
modular &operator*=(const modular &rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
modular &operator/=(const modular &rhs) { return *this *= rhs.inv(); }
modular operator+(const modular &rhs) const { return modular(*this) += rhs; }
modular operator-(const modular &rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular &rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular &rhs) const { return modular(*this) /= rhs; }
modular pow(int n) const {
modular res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
modular inv() const { return pow(mod - 2); }
/*modular inv()const{
int x,y;
int g=extgcd(v,mod,x,y);
assert(g==1);
if(x<0)x+=mod;
return modular(x);
}*/
friend modular operator+(int x, const modular &y) { return modular(x) + y; }
friend modular operator-(int x, const modular &y) { return modular(x) - y; }
friend modular operator*(int x, const modular &y) { return modular(x) * y; }
friend modular operator/(int x, const modular &y) { return modular(x) / y; }
friend ostream &operator<<(ostream &os, const modular &m) { return os << m.v; }
friend istream &operator>>(istream &is, modular &m) {
ll x;
is >> x;
m = modular(x);
return is;
}
bool operator<(const modular &r) const { return v < r.v; }
bool operator==(const modular &r) const { return v == r.v; }
bool operator!=(const modular &r) const { return v != r.v; }
explicit operator bool() const { return v; }
};
// 59501818244292734739283969=5.95*10^25
// 2^24
// 2^20 3 使
// VERIFY: yosupo
namespace arbitrary_convolution {
constexpr modinfo base0{167772161, 3}; // 2^25 * 5 + 1
constexpr modinfo base1{469762049, 3}; // 2^26 * 7 + 1
constexpr modinfo base2{754974721, 11}; // 2^24 * 45 + 1
// constexpr modinfo base0{1045430273,3};//2^20 * 997 + 1
// constexpr modinfo base1{1051721729,6};//2^20 * 1003 + 1
// constexpr modinfo base2{1053818881,7};//2^20 * 1005 + 1
using mint0 = modular<base0>;
using mint1 = modular<base1>;
using mint2 = modular<base2>;
template <class t, class mint> vc<t> sub(const vc<mint> &x, const vc<mint> &y, bool same = false) {
int n = si(x) + si(y) - 1;
int s = 1;
while (s < n) s *= 2;
vc<t> z(s);
rep(i, si(x)) z[i] = x[i].v;
inplace_fmt(z, false);
if (!same) {
vc<t> w(s);
rep(i, si(y)) w[i] = y[i].v;
inplace_fmt(w, false);
rep(i, s) z[i] *= w[i];
} else {
rep(i, s) z[i] *= z[i];
}
inplace_fmt(z, true);
z.resize(n);
return z;
}
template <class mint> vc<mint> multiply(const vc<mint> &x, const vc<mint> &y, bool same = false) {
auto d0 = sub<mint0>(x, y, same);
auto d1 = sub<mint1>(x, y, same);
auto d2 = sub<mint2>(x, y, same);
int n = si(d0);
vc<mint> res(n);
static const mint1 r01 = mint1(mint0::mod).inv();
static const mint2 r02 = mint2(mint0::mod).inv();
static const mint2 r12 = mint2(mint1::mod).inv();
static const mint2 r02r12 = r02 * r12;
static const mint w1 = mint(mint0::mod);
static const mint w2 = w1 * mint(mint1::mod);
rep(i, n) {
ull a = d0[i].v;
ull b = (d1[i].v + mint1::mod - a) * r01.v % mint1::mod;
ull c = ((d2[i].v + mint2::mod - a) * r02r12.v + (mint2::mod - b) * r12.v) % mint2::mod;
res[i].v = (a + b * w1.v + c * w2.v) % mint::mod;
}
return res;
}
} // namespace arbitrary_convolution
using arbitrary_convolution::multiply;
template <typename T> vector<T> add_to_vector(vector<T> &z, T v) {
z.push_back(v);
return z;
}
template <typename T, typename... Args> vector<T> add_to_vector(vector<T> &z, T v, Args... args) {
z.push_back(v);
add_to_vector<T>(z, args...);
return z;
}
template <typename T> vector<T> make_vector(T v) {
vector<T> z;
z.push_back(v);
return z;
}
template <typename T, typename... Args> vector<T> make_vector(T v, Args... args) {
vector<T> z;
z.push_back(v);
add_to_vector<T>(z, args...);
return z;
}
constexpr modinfo base{998244353, 0};
using mint = modular<base>;
/* #endregion */
/* #region SegTree */
template <typename T> // T:
struct SegmentTree {
using F = function<T(T, T)>; // max
ll n; //
F f; // 使 max
T ti; // f 0. (a>0 max(a,0)=max(0,a)=a)
vc<T> dat; // 1-indexed (index 1 | 2 3 | 4 5 6 7 | 8 9 10 11 12 13 14 15 | ...)
//
SegmentTree() {}
//
SegmentTree(F f, T ti) : f(f), ti(ti) {}
//
void init(ll n_) {
n = 1;
while (n < n_) n <<= 1;
dat.assign(n << 1, ti);
}
//
void build(const vc<T> &v) {
ll n_ = v.size();
init(n_);
REP(i, 0, n_) dat[n + i] = v[i];
REPR(i, n - 1, 1) dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]);
}
// k x
void set_val(ll k, T x) {
dat[k += n] = x;
while (k >>= 1) dat[k] = f(dat[(k << 1) | 0], dat[(k << 1) | 1]); //
}
// k
T get_val(ll k) { return dat[k + n]; }
// [a, b)
T query(ll a, ll b) {
if (a >= b) return ti;
// assert(a<b)
T vl = ti, vr = ti;
for (ll l = a + n, r = b + n; l < r; l >>= 1, r >>= 1) {
if (l & 1) vl = f(vl, dat[l++]);
if (r & 1) vr = f(dat[--r], vr);
}
return f(vl, vr);
}
//
template <typename C> int find(ll st, C &check, T &acc, ll k, ll l, ll r) {
if (l + 1 == r) {
acc = f(acc, dat[k]);
return check(acc) ? k - n : -1;
}
ll m = (l + r) >> 1;
if (m <= st) return find(st, check, acc, (k << 1) | 1, m, r);
if (st <= l && !check(f(acc, dat[k]))) {
acc = f(acc, dat[k]);
return -1;
}
ll vl = find(st, check, acc, (k << 1) | 0, l, m);
if (~vl) return vl;
return find(st, check, acc, (k << 1) | 1, m, r);
}
// check(query(st, idx)) idx
template <typename C> int find(ll st, C &check) {
T acc = ti;
return find(st, check, acc, 1, 0, n);
}
};
/* #endregion */
// Problem
void solve() {
ll n, q;
cin >> n >> q;
vll a(n), b(q);
cin >> a >> b;
using vm = vc<mint>;
auto f = [](vm a, vm b) -> vm { return arbitrary_convolution::multiply(a, b); };
SegmentTree<vm> seg(f, vm({1}));
vc<vm> data(n);
REP(i, 0, n) data[i] = {a[i] - 1, 1};
seg.build(data);
vm ls = seg.query(0, n);
REP(i, 0, q) cout << ls[b[i]] << endl;
}
// entry point
int main() {
solve();
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0