text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000 * 100 + 1;
const int Q = 100;
const int MOD = 998244353;
const int UNDEF = -10;
int a[MAXN];
int b[MAXN];
int pr[MAXN];
int prpr[MAXN];
int dp[MAXN];
int sum_dp[MAXN / Q + 10][2 * Q + 1];
int sum[MAXN / Q + 10];
int n, k;
void relax(int& x) {
while (... |
#include <bits/stdc++.h>
using namespace std;
const int B = 300;
const int mod = 998244353;
const int N = 1e5 + 10 + B;
int n, k, arr[N];
int memo[N];
int which(int i) { return i / B; }
void mod_add(int &a, int b) { a = (a + 1LL * b) % mod; }
struct bucket {
int ID;
int offset = 0;
int cnt[B];
int prefix[B];
... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 998244353;
int n, m, B, a[N], pos[N], bel[N], lst[N], f[N], cnt[N], delta[440], ans[440],
sum[440][N];
void update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + mod) % mod;
if (cnt[u] + delta[t] <= m) ans[t]... |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 500;
int n, k;
vector<int> dp;
vector<int> pos;
vector<int> offset;
vector<vector<int>> sum;
const int MOD = 998244353;
int plusM(int lhs, int rhs) {
int res = lhs + rhs;
return res >= MOD ? res - MOD : res;
}
int minusM(int lhs, int rhs) {
return lhs... |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100001], pos[100001], pre[100001], b[100001], dp[100001],
c[((100001 / 320) + 1)][2 * 320 + 1], s[((100001 / 320) + 1)];
int GetBlockNumber(int i) { return i / 320 + (i % 320 != 0); }
void UpdateBlock(int k) {
s[k] = 0;
for (int i = 0; i <= 2 * 320; ++i)... |
#include <bits/stdc++.h>
using namespace std;
const int t = 399, mod = 998244353;
inline int mo(const register int x) { return x >= mod ? x - mod : x; }
int a[100010], n, k, bl[100010], p[100010], pre[100010], sum[400][100010],
f[400], S[400], dp[100010], lst[100010];
inline void rebuild(const register int x, const... |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 200;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[200006], lz[200006], cur;
... |
#include <bits/stdc++.h>
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9') break;
if (c == '-') goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
... |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(b... |
#include <bits/stdc++.h>
using namespace std;
int f[100010], val[100010], sep[100010], cnt, k, h[100010], last[100010], n;
int read() {
int tmp = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp;
}
s... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
... |
#include <bits/stdc++.h>
using namespace std;
const int MX_N = 1e5 + 5;
const int MX_K = 1e5 + 5;
const int MX_A = MX_N;
const int MOD = 998244353;
const int B = 300;
int N, K, A[MX_N];
int pos[MX_A], prv[MX_N], dp[MX_N];
struct Bucket {
int pre[B], cnt[B], offset;
Bucket() {
for (int i = (0); i <= (B - 1); ++i... |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void ckmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void ckmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int MOD = 9... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 100005;
const int B = 620;
int n, k, a[N];
int dp[N];
int cnt[N];
vector<int> occ[N];
int delta[B];
vector<int> vet[B];
vector<int> psum[B];
void add(int &aa, int b) { aa = aa + b >= mod ? aa + b - mod : aa + b; }
void rebuild(int id... |
#include <bits/stdc++.h>
using namespace std;
int n, m, Siz, num[100010], pos[100010], bel[100010], lst[100010], f[100010],
cnt[100010], delta[100010], ans[100010], sum[440][100010];
void update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delt... |
#include <bits/stdc++.h>
using namespace std;
namespace zyt {
template <typename T>
inline bool read(T &x) {
char c;
bool f = false;
x = 0;
do c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF) return false;
if (c == '-') f = true, c = getchar();
do x = x * 10 + c - '0', c = getch... |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,popcnt")
using namespace std;
int a[100007], bel[100007], pre[100007], pos[100007], tag[293], delt[100007], n,
k, S;
int f[100007], sum[293][100007 * 2 + 1], ans[293];
const int p = 9... |
#include <bits/stdc++.h>
using namespace std;
int __i__, __j__;
class _Debug {
public:
template <typename T>
_Debug& operator,(T val) {
cout << val << endl;
return *this;
}
};
int n, k;
int a[100000], p[100000];
int last[100000];
int dp[100001];
int num[100001];
int sum[350][100100], shift[350];
int suma... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int b = 325;
int dp[100005];
int a[100005], cnt[100005];
int s[100005], e[100005];
vector<int> v[100005];
struct bucket {
int val[2 * b + 5];
int sum = 0;
void rebuild(int s, int e) {
for (int i = 0; i <= 2 * b; i++) val[i] = 0;
... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int P = 998244353;
int n, m, a[N], pre[N], rec[N], f[N];
inline void add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += P;
}
struct BL {
int bel[N], tag[450], w[N], size, cnt, su... |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 1e5 + 79, s = 350, ns = maxn / s + 5;
int n, k;
vector<int> f(maxn, 0), a(maxn), dp(maxn, 0), myval(ns, 0);
vector<vector<int> > oc(maxn), sum(ns, vector<int>(s * 2 + 2, 0));
void add(int& a, const int& b) {
a += b;
if (... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 2e5;
const int B = 315;
int cnt[MAXN], dp[MAXN];
vector<int> occ[MAXN];
void add_self(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(int &x, int y) { x = min(x, y); }
struct SQRT {
int id, offset, pref_sum[... |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int tzu = 500;
int bs = 350;
int n, k;
int a[100001];
int l[100001];
int p[100001];
int dp[100001];
int v[100001];
int sum[501];
int cnt[501][1001];
int mn[501], mx[501];
int m;
void ref(int bl) {
int curv = tzu;
for (int i = mn[bl... |
#include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 200 - 1) / 200)],
dq[((100000 + 200 - 1) / 200)][200 + 1 + 200];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (200 + 1 + 200) * sizeof *qq);
for (i = (h + 1) * 200; i > h * 200; i--) {
t += bb[i];
... |
#include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, mod = 998244353;
int ri() {
char c = getchar();
int x = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c;
return x * f;
}
int pr[N], las[N], a[N... |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < s... |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
struct sqrt_decomp {
long long n, b;
vector<long long> values;
vector<long long> prefix;
vector<long long> woff;
vector<long long> w;
sqrt_decomp(long long n) {
b = sqrt(n);
if (b * b != n) {
b++;
}
this->b ... |
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 250 + 3;
int bel[N], f[N], g[N], tag[M], s[M][250 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update... |
#include <bits/stdc++.h>
using namespace std;
int n, m, B, a[100005], pos[100005], bel[100005], lst[100005], f[100005],
cnt[100005];
int delta[450], ans[450], sum[450][100005];
void Update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delta[t] <... |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, dt = 320;
int b[100010], a[100010], pre[100010], d[100010];
int f[100010];
int q[320][645];
int n, k, now;
int sum[320];
inline int mo(int x) {
if (x >= MOD) return x - MOD;
return x;
}
void ins(int x, int y) {
b[x] = y;
int z = x / dt;
... |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Pow(T a, T b, T p) {
T ret = 1;
a %= p;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) (ret *= a) %= p;
... |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1, mod = 998244353, b_sz = 500;
int n, k;
int last_occ[maxn], prev_occ[maxn];
int delta[maxn];
int dp[maxn];
int tot_delta[201], psums[201][2 * b_sz + 1];
void update(int i) {
vector<int> blocks = {i / b_sz};
if (i % b_sz == 0 and i) {
blocks.... |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
}
struct Arr {
int x, y;
} b[100000 + 1], c[320 + 1];
int a[100000 + 1], s[100000 + 1... |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
const int N = 100005, B = 320, M = 998244353;
using namespace std;
int n, k, ti, a[N], occ[N], pre[N], b[N], f[N], sum[B], q[B][B << 1 | 1], now;
inline void mdf(int x, int y) {
b[x] = y;
int z = x / B;
if (z == now) return;
sum[z] = 0;
for (int i = 0; i <= B <... |
#include <bits/stdc++.h>
using namespace std;
int n, m, B, a[100005], pos[100005], bel[100005], lst[100005], f[100005],
cnt[100005];
int delta[450], ans[450], sum[450][100005];
void Update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delta[t] <... |
#include <bits/stdc++.h>
using namespace std;
const int B = 320;
const int N = 100000;
const int P = 998244353;
inline int add(int x, int y) {
x += y;
return x >= P ? x - P : x;
}
inline int sub(int x, int y) {
x -= y;
return x < 0 ? x + P : x;
}
inline int mul(int x, int y) { return (int)(1LL * x * y % P); }
i... |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int SZ = 320;
const long long MOD = 998244353;
int N, K;
int prv[MAX_N + 1];
int arr[MAX_N + 1];
int pidx[MAX_N + 1];
int num[MAX_N + 1];
long long dp[MAX_N + 1];
long long dp2[SZ + 1][MAX_N + 1];
long long D;
int add[SZ + 1];
void Update(int... |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&... |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& i : v) os << i << ' ';
return os;
}
template <typename T, typename U>
ist... |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const long long mod = 998244353;
const int bsize = 75;
int cnt[maxn];
int dp[maxn];
int n, k;
vector<int> occurences[maxn];
class bucket {
public:
int id;
int first, last;
int offset, smallest;
int pref[bsize + 5];
void build() {
firs... |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c h, c n) {
return {h, n};
}
template <class c>
auto dud(c* r) -> decltype(cerr << *r);
template <class c>
char dud(...);
struct muu {
template <class c>
muu& opera... |
#include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, mod = 998244353;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
template <typename T>
void add(T &x, T y, T mod) {
x = x + y > mod ? x + y - mod : x + y;
}
template <... |
#include <bits/stdc++.h>
int q, sum[320][2 * 320], tot[320];
int dp[100009], last[100009], last2[100009], v[100009];
inline void add(int &a, int b) {
a += b;
if (a >= 998244353) a -= 998244353;
}
inline void update(int t) {
memset(sum[t], 0, sizeof sum[t]);
int cnt = 0;
for (int i = t * q + q; i > t * q; i--)... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 11, mod = 998244353;
int ans, n, k, blo, bel[N], f[N], g[N], a[N], L[N], R[N], las[N], bef[N],
lim[N], sum[411][N], Sum[411];
inline void inc(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void deal(int l, int r, int x) {
int o = bel... |
#include <bits/stdc++.h>
using namespace std;
int n, k, nr_b;
int t[500010], dp[500010], cnt[500010];
vector<int> _last[500010];
int f(int x) {
if (x >= 998244353)
return x - 998244353;
else
return x;
}
struct bucket {
int offset;
int bucket_id;
vector<int> pref_sum;
bucket() {
offset = 0;
b... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
using namespace std;
int mod = 998244353;
int A[100077];
int B[100077];
int N[100077];
int dp[100077];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, k, ai;
cin >> n >> k;
dp[0] = 1;
signed long long sum = 1;
... |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 7;
const long long MOD = 998244353;
const long long PIERW = 100;
int ciag[MAX];
int ostatnie[MAX];
int poprzedni[MAX];
long long pomocnicza[MAX];
long long DP[MAX];
struct Blok {
int lewa, prawa;
long long suma;
long long sumaDP[PIERW * 2 + 1];
... |
#include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 200 - 1) / 200)],
dq[((100000 + 200 - 1) / 200)][200 + 1 + 200];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (200 + 1 + 200) * sizeof *qq);
for (i = (h + 1) * 200; i > h * 200; i--) {
t += bb[i];
... |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 233;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[200006], lz[200006], cur;
... |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int ch = 0, f = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
const int M = 205, N = 100005, L = 100000, mod = 9982443... |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long m... |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> operator+(const pair<int, int> x, const int y) {
return make_pair(x.first + y, x.second);
}
const int mxn = 131072, siz = 250, md = 998244353;
int n, k, pl[mxn], pr[mxn], d[mxn], f[mxn], bl[mxn], cnt[512][256], tag[512];
pair<int, int> a[mxn], b[mxn], c[mxn... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,popcnt,tune=native")
using namespace std;
const int MN = 100005, inf = 1000000005, mod = 998244353;
const long long INF = 1000000000000000005LL;
int t[MN], dp[MN], i... |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1, mod = 998244353, b_sz = 10;
int n, k;
int last_occ[maxn], prev_occ[maxn];
int delta[maxn];
int dp[maxn];
int tot_delta[10001], psums[10001][2 * b_sz + 1];
void update(int i) {
vector<int> blocks = {i / b_sz};
if (i % b_sz == 0 and i) {
bloc... |
#include <bits/stdc++.h>
int n, k, a[100001], P = 998244353, lcol[100001], last[100001], f[100001],
val[100001], pos[100001], block;
inline int sub(int a, const int &b) {
a -= b;
return a < 0 ? a + P : a;
}
inline int add(int a, const int &b) {
a += b;
return a >= P ? a - P : a;
}
inline in... |
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 320 + 3;
int bel[N], f[N], g[N], tag[M], s[M][320 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const int N = 100100;
const int Q = 250200;
const long long mod = 998244353;
using namespace std;
int n;
int k;
int d[N];
int f[N];
int l[N];
int p[N];
void add(int &x, int y) {
x += y;
if (x >= mod) {
x -= mod;
} else... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
#pragma warning(disable : 4996)
using namespace std;
const long long int mod = 998244353;
long long int sum = 1;
void add(int* anums, long long int* aanss, int X, bool flag) {
if (flag) {
for (int x = 0; x < X; ++x) {
anum... |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const ... |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5, bs = 400, mxBC = (mxN - 1) / bs + 1, M = 998244353;
int n, k, dp[mxN + 1], lst[mxN + 1], nxt[mxN], b[mxN], c[mxBC][2 * mxN + 1],
d[mxBC];
void am(int &a, int b) {
a += b;
if (a >= M) a -= M;
}
void upd(int l1, int r1, int x) {
for (int bi = l1... |
#include <bits/stdc++.h>
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
template <typename T>
void add(T &x, T y, T mod) {
x = x + y > mod ? x + y - mod : x + y;
}
template <typename T>
void sub(T &x, T y, T mod) {
x = x - ... |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[100010], dp[100010];
pair<int, int> b[100010];
vector<int> lst_ind[100010];
int ind[100010];
vector<pair<int, int> > cnt[400];
int acc[400];
int opm[400];
int p = 998244353;
int getBlock(int x) { return x / m; }
int getIndexInBlock(int x) { return x % m; ... |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long MXN = 1e5 + 10;
const long long SQR = 400;
const long long MXB = MXN / SQR + 10;
const long long MXM = SQR * 2 + 10;
const long long Mod = 998244353;
inline void mkay(long long& x) {
if (x >= Mod) x -= Mod;
}
long long n, k;
long... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int B;
vector<int> counts;
vector<int> dp;
void mod_add(int& first, int second) {
first += second;
if (first >= mod) {
first -= mod;
}
}
struct Bucket {
int id;
int offset = 0;
vector<int> pref_sum;
Bucket(int _id) {
id = _id... |
#include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, P = 998244353;
int ri() {
char c = getchar();
int x = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c;
return x * f;
}
int pr[N], las[N], a[N],... |
#include <bits/stdc++.h>
using namespace std;
int blkbase[(350 + 5)][(350 + 5)];
int blkpsum[(350 + 5)][(350 + 5)];
int f[100005];
int n, k;
int a[100005];
int previ[100005];
int previval[100005];
int blk[100005];
int blkbegin[100005];
int blkend[1000005];
int cur[100005];
int cur_offset[(350 + 5)];
int cur_cnt[(350 + ... |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200010], s, la[200010], f[200010], tg[200010], ans, p[200010],
va[320][200010], pr[200010];
int bl(int x) { return (x - 1) / s + 1; }
void ins(int x, int y) {
p[x] -= tg[bl(x)];
ans = (ans + y) % 998244353ll;
va[bl(x)][p[x] + n] = (va[bl(x)][p[x] + n] ... |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int MAXN = 100005;
const int S = 320;
const int MAXB = MAXN / S + 5;
int pool[MAXB][MAXN << 1], *t[MAXB], f[MAXB][S], tag[MAXB], sum[MAXB], dp[MAXN];
int a[MAXN], last[MAXN], pre[MAXN];
int n, k;
void init() {
for (int i = 1; i <= n; i++) ... |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
const int mod = 998244353;
int sqrtN = 128;
struct SqrtDecomposition {
int N, K, tap, ans;
vector<int> data;
vector<int> bucketAdd;
vector<int> uku;
vector<unordered_map<int, int> > mp;
SqrtDecomposition(int n, int tap) : N(n), tap(tap),... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAX_N = 2e5 + 5;
vector<int> occurrences[MAX_N];
int cnt[MAX_N], dp[MAX_N];
void add_self(int& a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
const int B = 256;
struct Bucket {
int id;
int offset;
int pref_sum[B];
vo... |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int ex, mini;
int pref[335];
};
Node block[335];
vector<int> posi[200010];
int n, k, ara[200010], val[200010], dp[200010];
int blockSz;
int which(int p) { return (p / blockSz); }
void add(int &a, int b) {
a += b;
if (a >= 998244353) a -= 998244353;
}
v... |
#include <bits/stdc++.h>
using namespace std;
const int B = 300;
const int mod = 998244353;
const int N = 1e5 + 10 + B;
int n, k, arr[N];
int memo[N];
int which(int i) { return i / B; }
void mod_add(int &a, int b) { a = (a + 1LL * b) % mod; }
struct bucket {
int ID;
int offset = 0;
int cnt[B];
int prefix[B];
... |
#include <bits/stdc++.h>
using namespace std;
int n;
int k;
vector<int> v;
struct block {
int total;
int el[134];
int dp[134];
int sz;
block() {
total = 0;
sz = 0;
}
pair<long long int, long long int> way[134];
bool need;
inline void build() { need = true; }
inline void build(int dum) {
... |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MOD = 998244353;
const int N = 120000;
const int SQRT = 200;
struct Block {
int tl, tr;
vector<tuple<int, int, int> > vals;
vector<int> psum;
int mod = 0;
Block() = default;
void rebuild() {
for (auto& v : vals) {
g... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
int a[100003], b[100003], arr[100003];
int dp[100003], res, n, k, x, i;
int main() {
scanf("%d%d", &n, &k);
dp[0] = 1;
for (int j = 1; j <= n; j++) {
res += dp[j - 1];
if (res >= 998244353) res -... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int mod = 998244353;
int n, k, sq;
int a[N], dp[N], bl[N], bk[405][N], tag[405], val[405], num[N];
vector<int> ve[N], pos[405];
inline void rebuild(int p) {
int l = (p - 1) * sq + 1, r = min(n, p * sq);
for (int i = 0; i < pos[p].size(); ++i... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long MOD = 998244353;
long long add(long long a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
long long mult(long long a, long long... |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxm = 320, tt = 998244353;
int n, m, n1, a[maxn], f[maxn], g[maxm][maxn], bl[maxn], sq, val[maxn],
tag[maxm];
int L[maxn], R[maxn];
int las[maxn], las1[maxn];
void build(int x, int l, int r) {
for (int i = l; i <= r; i++) {
g[x][val[i]] =... |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MM = 998244353;
int n, m;
int a[MAXN];
int dp[MAXN];
void updS(int &x, int y) {
x -= y;
if (x < 0) x += MM;
}
void updA(int &x, int y) {
x += y;
if (x >= MM) x -= MM;
}
namespace Block {
const int Bibi = 512;
const int N = 1e5 + ... |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = get... |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
... |
#include <bits/stdc++.h>
using namespace std;
int n, K, a[100009], pre[100009], ind[100009], ans[100009];
int bf[296][100009 << 1], bst[296], bans[296], f[100009];
inline int read();
inline void M(int& x, int y) {
x = x + y < 998244353 ? x + y : x + y - 998244353;
}
inline int get_B(int x) { return (x + 340 - 1) / 34... |
#include <bits/stdc++.h>
using namespace std;
const int M = 100005, K = 316, mod = 998244353;
int n, k, a[M], b[M], dp[M], sum[K + 5][2 * K + 5], in[M], tot[K + 5];
vector<int> v[M];
void pl(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void update(int i, int x) {
b[i] = x;
memset(sum[in[i]], 0, sizeof(sum... |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e5, msq = 317, mod = 998244353;
int n, sq, k, a[mn + 3];
int inp[mn + 3], lw[msq + 3], rw[msq + 3];
int num[mn + 3];
int topw[mn + 3], secw[mn + 3];
long long f[mn + 3];
long long Sumf[msq + 3][2 * msq + 3];
int add[msq + 3];
void Add(int l, int r, int ad) {... |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
... |
#include <bits/stdc++.h>
using namespace std;
const int mo = 998244353;
const int N = 100005;
const int BLK = 405;
const int K = 255;
int L[K], R[K], tg[K];
int top[K], pos[K];
int id[N], f[N], s[N];
int v[N], V[N], LIM;
int a[N], la[N], pre[N], n;
void pushdown(int k) {
for (int i = (int)(L[k]); i <= (int)(R[k]); i+... |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < 48) f |= c == '-', c = getchar... |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3)
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 233;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[20... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int Mod = 998244353;
int add(int a, int b) { return (a += b) >= Mod ? a - Mod : a; }
int sub(int a, int b) { return (a -= b) < 0 ? a + Mod : a; }
int mul(int a, int b) { return 1ll * a * b % Mod; }
int n, k, a[N], siz, cntblo;
int pre[N], lst[N... |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 2e5;
const int B = 315;
int cnt[1 + MAXN], dp[1 + MAXN];
vector<int> occ[1 + MAXN];
void add_self(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(int &x, int y) { x = min(x, y); }
struct SQRT {
int id, offse... |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
int n, k, a[100102], dp[100102], pre[100102], ap[100102];
int blk, lx[320], rx[320], bel[100102], cn, cnt[100102], laz[320];
int sum[320][100102 << 1], sdp[320];
inline void clr(int x) {
for (int i = lx[x]; i <= rx[x]; i++) sum[x][cnt[i] + n] = 0;... |
#include <bits/stdc++.h>
using namespace std;
int n, k, flag[310], ret[310], a[100100], pos[100100], lst[100100], w[100100],
f[100100], cnt[310][100100];
int mo(int x, int y) { return x + y < 998244353 ? x + y : x + y - 998244353; }
void add(int l, int r, int x) {
int s = (l - 1) / 350 + 1, t = r / 350 + 1;
if ... |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const int maxn = 100010;
const int SQ = 400;
const int maxnsq = maxn / SQ + 10;
int n, k;
int A[maxn], P[maxn];
map<int, int> lst;
int block[maxnsq][maxn * 2];... |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int S = 330;
const int mod = 998244353;
int n, k, a[N], pre[N], last[N];
int s[N / S + 5][N], val[N / S + 5], f[N], dp[N], inblock[N], ans;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
void ins(int u, in... |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int BLK = 320;
const int MXN = 1e5 + 5;
const int MOD = 998244353;
int add(int x, int y) { return (x += y) < MOD ? x : x - MOD; }
int sub(int x, int y) { return (x -= y) >= 00 ? x : ... |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Pow(T a, T b, T p) {
T ret = 1;
a %= p;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) (ret *= a) %= p;
... |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = 1e18L;
const long long MAXN = 2e5;
const long long B = 315;
long long cnt[1 + MAXN], dp[1 + MAXN];
vector<long long> occ[1 + MAXN];
void add_self(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
void m... |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
... |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(s... |
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, block_size, a[200005], k;
int temp[3][100005], pre[3][100005], smallest[319];
long long sum[319][319], f[200005], dp[200005], inf, mod;
int tag[319];
void update(int l, int r, int c) {
int block1, block2, ind1, ind2;
block1 = (l - 1) / block_size;
bloc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.