problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02537 | C++ | Runtime Error |
// Problem : D - Flat Subsequence
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
// $%U%$
// Mere bas ka nahi hai
// still i'm trying
// apna time aayega
//
// .--------------.
// | Try First One|
// '--------------'
// | .--------------.
// | | |
// V V |
// .--------------. |
// | AC. |<---. |
// '--------------' | |
// (True)| |(False) | |
// .--------' | | |
// | V | |
// | .--------------. | |
// | | Try Again |----' |
// | '--------------' |
// | |
// | .--------------. |
// '->| Try Next One |-------'
// '--------------'
//
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll power(ll x, ll y, ll m) {
if (y == 0)
return 1;
ll p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
ll nCr(ll n, ll r, ll m) {
if (r > n)
return 0;
ll a = 1, b = 1, i;
for (i = 0; i < r; i++) {
a = (a * n) % m;
--n;
}
while (r) {
b = (b * r) % m;
--r;
}
return (a * power(b, m - 2, m)) % m;
}
#define Test \
int t; \
cin >> t; \
while (t--)
#define endl '\n'
vector<int> tree, v, t;
void update(int l, int r, int index, int cindex) {
if (l == r) {
tree[index] = t[l];
return;
}
int mid = (l + r) / 2;
if (cindex <= mid)
update(l, mid, 2 * index + 1, cindex);
else
update(mid + 1, r, 2 * index + 2, cindex);
tree[index] = max(tree[index * 2 + 1], tree[index * 2 + 2]);
}
int find(int l, int r, int tl, int tr, int index) {
if (tl > tr) {
return 0;
}
if (tl == l && tr == r) {
return tree[index];
}
int mid = (l + r) / 2;
int t1 = find(l, mid, tl, min(tr, mid), 2 * index + 1);
int t2 = find(mid + 1, r, max(tl, mid + 1), tr, 2 * index + 2);
return max(t1, t2);
}
void solve() {
int n, k;
cin >> n >> k;
v = t = vector<int>(n);
tree = vector<int>(4 * (300001));
for (int i = 0; i < n; ++i) {
cin >> v[i];
int temp = find(0, 300000, max(v[i] - k, 0), min(v[i] + k, 300000), 0);
// cout << temp << endl;
t[v[i]] = temp + 1;
update(0, 300000, 0, v[i]);
}
cout << tree[0] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// Test
solve();
return 0;
}
|
// Problem : D - Flat Subsequence
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
// $%U%$
// Mere bas ka nahi hai
// still i'm trying
// apna time aayega
//
// .--------------.
// | Try First One|
// '--------------'
// | .--------------.
// | | |
// V V |
// .--------------. |
// | AC. |<---. |
// '--------------' | |
// (True)| |(False) | |
// .--------' | | |
// | V | |
// | .--------------. | |
// | | Try Again |----' |
// | '--------------' |
// | |
// | .--------------. |
// '->| Try Next One |-------'
// '--------------'
//
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll power(ll x, ll y, ll m) {
if (y == 0)
return 1;
ll p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
ll nCr(ll n, ll r, ll m) {
if (r > n)
return 0;
ll a = 1, b = 1, i;
for (i = 0; i < r; i++) {
a = (a * n) % m;
--n;
}
while (r) {
b = (b * r) % m;
--r;
}
return (a * power(b, m - 2, m)) % m;
}
#define Test \
int t; \
cin >> t; \
while (t--)
#define endl '\n'
vector<int> tree, v, t;
void update(int l, int r, int index, int cindex) {
if (l == r) {
tree[index] = t[l];
return;
}
int mid = (l + r) / 2;
if (cindex <= mid)
update(l, mid, 2 * index + 1, cindex);
else
update(mid + 1, r, 2 * index + 2, cindex);
tree[index] = max(tree[index * 2 + 1], tree[index * 2 + 2]);
}
int find(int l, int r, int tl, int tr, int index) {
if (tl > tr) {
return 0;
}
if (tl == l && tr == r) {
return tree[index];
}
int mid = (l + r) / 2;
int t1 = find(l, mid, tl, min(tr, mid), 2 * index + 1);
int t2 = find(mid + 1, r, max(tl, mid + 1), tr, 2 * index + 2);
return max(t1, t2);
}
void solve() {
int n, k;
cin >> n >> k;
v = vector<int>(n);
t = vector<int>(300001);
tree = vector<int>(4 * (300001));
for (int i = 0; i < n; ++i) {
cin >> v[i];
int temp = find(0, 300000, max(v[i] - k, 0), min(v[i] + k, 300000), 0);
// cout << temp << endl;
t[v[i]] = temp + 1;
update(0, 300000, 0, v[i]);
}
cout << tree[0] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// Test
solve();
return 0;
}
| replace | 92 | 93 | 92 | 94 | 0 | |
p02537 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
vector<int> T[20];
int query(int h, int k, int i, int j) {
int m = (k << h) + (1 << h - 1);
if (i == (k << h) && j == (k + 1 << h) - 1)
return T[h][k];
if (j < m)
return query(h - 1, k << 1, i, j);
if (i >= m)
return query(h - 1, k << 1 | 1, i, j);
return max(query(h - 1, k << 1, i, m - 1), query(h - 1, k << 1 | 1, m, j));
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
int d = ceil(log2(n + 5));
for (int i = 0; i <= d; i++) {
T[i].clear();
T[i].resize(1 << (d - i), 0);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
int q = query(d, 0, max(a - k, 0), min(a + k, 300000));
ans = max(ans, q + 1);
int p = a;
T[0][p] = max(T[0][p], q + 1);
p >>= 1;
for (int j = 1; j <= d; j++) {
T[j][p] = max(T[j - 1][p << 1], T[j - 1][p << 1 | 1]);
p >>= 1;
}
}
printf("%d\n", ans);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
vector<int> T[20];
int query(int h, int k, int i, int j) {
int m = (k << h) + (1 << h - 1);
if (i == (k << h) && j == (k + 1 << h) - 1)
return T[h][k];
if (j < m)
return query(h - 1, k << 1, i, j);
if (i >= m)
return query(h - 1, k << 1 | 1, i, j);
return max(query(h - 1, k << 1, i, m - 1), query(h - 1, k << 1 | 1, m, j));
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
int d = 19;
for (int i = 0; i <= d; i++) {
T[i].clear();
T[i].resize(1 << (d - i), 0);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
int q = query(d, 0, max(a - k, 0), min(a + k, 300000));
ans = max(ans, q + 1);
int p = a;
T[0][p] = max(T[0][p], q + 1);
p >>= 1;
for (int j = 1; j <= d; j++) {
T[j][p] = max(T[j - 1][p << 1], T[j - 1][p << 1 | 1]);
p >>= 1;
}
}
printf("%d\n", ans);
return 0;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02537 | C++ | Runtime Error | // One Batch Two Batch Penny and Dime
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ll long long
#define hii cout << "hii" << endl
#define int long long
#define endl '\n'
#define all(s) s.begin(), s.end()
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const unordered_map<T, S> &v) {
for (auto i : v)
os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <class Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <class Arg1, class... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *sep = strchr(names + 1, ',');
cerr.write(names, sep - names) << " : " << arg1 << " ";
__f(sep + 1, args...);
}
#else
#define trace(...) 0
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"avx2,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#endif // ifndef ONLINE_JUDGE
const int N = 1e5 + 5;
const int MAXN = 1e6 + 5;
const int M = 1e6 + 5;
const int mod = 998244353;
const int MOD = 998244353;
const int INF = 1e18 + 8;
const int LG = 21;
int arr[N];
class segtree {
public:
vector<int> v;
int N;
segtree(int n) {
v.assign(4 * n + 5, 0);
N = n;
}
void buildtree(int s, int e, int treenode) {
if (s == e) {
v[treenode] = 0;
return;
}
int mid = s + e >> 1;
buildtree(s, mid, 2 * treenode + 1);
buildtree(mid + 1, e, 2 * treenode + 2);
v[treenode] = max(v[2 * treenode + 1], v[2 * treenode + 2]);
}
void updatetree(int idx, int val, int s, int e, int treenode) {
if (s == e) {
v[treenode] = val;
return;
}
int mid = s + e >> 1;
if (idx <= mid)
updatetree(idx, val, s, mid, 2 * treenode + 1);
else
updatetree(idx, val, mid + 1, e, 2 * treenode + 2);
v[treenode] = max(v[2 * treenode + 1], v[2 * treenode + 2]);
}
int querytree(int l, int r, int s, int e, int treenode) {
if (s >= l and e <= r) {
return v[treenode];
}
if (s > r or l > e)
return 0;
int mid = s + e >> 1;
int left = querytree(l, r, s, mid, 2 * treenode + 1);
int right = querytree(l, r, mid + 1, e, 2 * treenode + 2);
return max(left, right);
}
void update(int idx, int val) { updatetree(idx, val, 0, N - 1, 0); }
int query(int l, int r) {
if (l > r)
return 0;
return querytree(l, r, 0, N - 1, 0);
}
void build() { buildtree(0, N - 1, 0); }
};
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ret = 0;
segtree stree(300005);
for (int i = 0; i < n; i++) {
int l = max(0LL, arr[i] - k);
int r = min(arr[i] + k, 300000LL);
int temp = 1 + stree.query(l, r);
ret = max(ret, temp);
stree.update(arr[i], temp);
}
cout << ret << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | // One Batch Two Batch Penny and Dime
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ll long long
#define hii cout << "hii" << endl
#define int long long
#define endl '\n'
#define all(s) s.begin(), s.end()
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const unordered_map<T, S> &v) {
for (auto i : v)
os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <class Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <class Arg1, class... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *sep = strchr(names + 1, ',');
cerr.write(names, sep - names) << " : " << arg1 << " ";
__f(sep + 1, args...);
}
#else
#define trace(...) 0
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"avx2,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#endif // ifndef ONLINE_JUDGE
const int N = 5e5 + 5;
const int MAXN = 1e6 + 5;
const int M = 1e6 + 5;
const int mod = 998244353;
const int MOD = 998244353;
const int INF = 1e18 + 8;
const int LG = 21;
int arr[N];
class segtree {
public:
vector<int> v;
int N;
segtree(int n) {
v.assign(4 * n + 5, 0);
N = n;
}
void buildtree(int s, int e, int treenode) {
if (s == e) {
v[treenode] = 0;
return;
}
int mid = s + e >> 1;
buildtree(s, mid, 2 * treenode + 1);
buildtree(mid + 1, e, 2 * treenode + 2);
v[treenode] = max(v[2 * treenode + 1], v[2 * treenode + 2]);
}
void updatetree(int idx, int val, int s, int e, int treenode) {
if (s == e) {
v[treenode] = val;
return;
}
int mid = s + e >> 1;
if (idx <= mid)
updatetree(idx, val, s, mid, 2 * treenode + 1);
else
updatetree(idx, val, mid + 1, e, 2 * treenode + 2);
v[treenode] = max(v[2 * treenode + 1], v[2 * treenode + 2]);
}
int querytree(int l, int r, int s, int e, int treenode) {
if (s >= l and e <= r) {
return v[treenode];
}
if (s > r or l > e)
return 0;
int mid = s + e >> 1;
int left = querytree(l, r, s, mid, 2 * treenode + 1);
int right = querytree(l, r, mid + 1, e, 2 * treenode + 2);
return max(left, right);
}
void update(int idx, int val) { updatetree(idx, val, 0, N - 1, 0); }
int query(int l, int r) {
if (l > r)
return 0;
return querytree(l, r, 0, N - 1, 0);
}
void build() { buildtree(0, N - 1, 0); }
};
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ret = 0;
segtree stree(300005);
for (int i = 0; i < n; i++) {
int l = max(0LL, arr[i] - k);
int r = min(arr[i] + k, 300000LL);
int temp = 1 + stree.query(l, r);
ret = max(ret, temp);
stree.update(arr[i], temp);
}
cout << ret << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | replace | 55 | 56 | 55 | 56 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define irep(i, a, b) for (ll i = ll(a); i >= ll(b); i--)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
using ll = long long;
using ld = long double;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
using namespace std;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
int op(int a, int b) { return max(a, b); }
int e() { return 0; }
int main() {
ll n, k, a, ans = 0;
cin >> n >> k;
segtree<int, op, e> seg(300010);
rep(i, 0, n) {
cin >> a;
ll l = max((ll)0, a - k);
ll r = min(n, a + k);
ll tmp = seg.prod(l, r + 1) + 1;
ans = max(ans, tmp);
seg.set(a, tmp);
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define irep(i, a, b) for (ll i = ll(a); i >= ll(b); i--)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
using ll = long long;
using ld = long double;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
using namespace std;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
int op(int a, int b) { return max(a, b); }
int e() { return 0; }
int main() {
ll n, k, a, ans = 0;
cin >> n >> k;
segtree<int, op, e> seg(300010);
rep(i, 0, n) {
cin >> a;
ll l = max((ll)0, a - k);
ll r = min(300000LL, a + k);
ll tmp = seg.prod(l, r + 1) + 1;
ans = max(ans, tmp);
seg.set(a, tmp);
}
cout << ans;
} | replace | 160 | 161 | 160 | 161 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define watch(x) std::cout << (#x) << " is " << (x) << std::endl
#define print(x) std::cout << (x) << std::endl
#define println std::cout << std::endl;
using LL = long long;
#define lrt rt << 1
#define rrt rt << 1 | 1
#define lson l, m, lrt
#define rson m + 1, r, rrt
const int N = 3e5 + 2;
int mx[N * 3];
void update(int p, int val, int l, int r, int rt) {
mx[rt] = std::max(mx[rt], val);
if (l == r)
return;
int m = (l + r) >> 1;
if (p > m)
update(p, val, rson);
else
update(p, val, lson);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r)
return mx[rt];
int m = (l + r) >> 1;
int ans = 0;
if (L <= m)
ans = std::max(ans, query(L, R, lson));
if (R > m)
ans = std::max(ans, query(L, R, rson));
return ans;
}
int main() {
// freopen("in","r",stdin);
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> n >> k;
for (int i = 0, x; i < n; ++i) {
std::cin >> x;
++x;
int now = query(x - k, x + k, 1, N, 1);
update(x, now + 1, 1, N, 1);
}
print(mx[1]);
return 0;
} | #include <bits/stdc++.h>
#define watch(x) std::cout << (#x) << " is " << (x) << std::endl
#define print(x) std::cout << (x) << std::endl
#define println std::cout << std::endl;
using LL = long long;
#define lrt rt << 1
#define rrt rt << 1 | 1
#define lson l, m, lrt
#define rson m + 1, r, rrt
const int N = 3e5 + 2;
int mx[N * 5];
void update(int p, int val, int l, int r, int rt) {
mx[rt] = std::max(mx[rt], val);
if (l == r)
return;
int m = (l + r) >> 1;
if (p > m)
update(p, val, rson);
else
update(p, val, lson);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r)
return mx[rt];
int m = (l + r) >> 1;
int ans = 0;
if (L <= m)
ans = std::max(ans, query(L, R, lson));
if (R > m)
ans = std::max(ans, query(L, R, rson));
return ans;
}
int main() {
// freopen("in","r",stdin);
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> n >> k;
for (int i = 0, x; i < n; ++i) {
std::cin >> x;
++x;
int now = query(x - k, x + k, 1, N, 1);
update(x, now + 1, 1, N, 1);
}
print(mx[1]);
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p02537 | C++ | Time Limit Exceeded | #pragma GCC target("sse4.2")
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define ln "\n"
#define forn(i, e) for (ll i = 0; i < e; i++)
#define forsn(i, s, e) for (ll i = s; i < e; i++)
#define rforn(i, e) for (ll i = e; i >= 0; i--)
#define rforsn(i, e, s) for (ll i = e; i >= s; i--)
#define vasort(v) sort(v.begin(), v.end());
#define vdsort(v) sort(v.begin(), v.end(), greater<ll>());
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define mem(a, b) memset(a, b, sizeof(a))
#define sz(x) ((int)size(x))
#define EB emplace_back
#define flush fflush(stdout)
#define out1(x1) cout << x1 << ln
#define out2(x1, x2) cout << x1 << " " << x2 << endl
#define out3(x1, x2, x3) cout << x1 << " " << x2 << " " << x3 << endl
#define out4(x1, x2, x3, x4) \
cout << x1 << " " << x2 << " " << x3 << " " << x4 << ln
#define all(d) d.begin(), d.end()
#define unordered_set(T) unordered_set<T, custom_hash>
#define unordered_map(T1, T2) unordered_map<T1, T2, custom_hash>
#define in1(x1) cin >> x1
#define in2(x1, x2) cin >> x1 >> x2
#define in3(x1, x2, x3) cin >> x1 >> x2 >> x3
#define in4(x1, x2, x3, x4) cin >> x1 >> x2 >> x3 >> x4
#define arrin(a, n) forn(i, n) cin >> a[i];
#define arrout(a, n) \
forn(i, n) { cout << a[i] << " "; } \
cout << ln;
/* ---------------- IO ----------------*/
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0)
input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len)
_update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T> inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-')
negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative)
number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE)
_flush_output();
output_buffer[output_pos++] = c;
}
template <typename T> inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
if (number != 0 || length == 0)
write_char(number + '0');
for (int i = length - 1; i >= 0; i--)
write_char(number_buffer[i]);
if (after)
write_char(after);
}
void IOinit() {
// Make sure _flush_output() is called at the end of the program.
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++)
lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
using namespace IO;
/* ---------------- typedefs ----------------*/
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
/* ---------------- utility functions ---------------- */
int dr[] = {0, 1, -1, 0, 1, -1, 1, -1};
int dc[] = {1, 0, 0, -1, 1, -1, -1, 1};
int drr[] = {-2, -1, 0, 1, 2};
int dcc[] = {-2, -1, 0, 1, 2};
bool chk(int a, int b, int n, int m) {
return 0 <= a && a < n && 0 <= b && b < m;
}
ll exp(ll n, ll m, ll md) {
ll a = 1;
while (m > 0) {
if (m & 1)
a = (a * n % md) % md;
m /= 2;
n = (n * n) % md;
}
return a % md;
}
ll expm(ll n, ll m) {
ll a = 1;
while (m > 0) {
if (a < 0 or a >= (1e18 + n - 1) / n) {
return -1;
}
if (m & 1)
a = (a * n);
m /= 2;
n = (n * n);
}
return a;
}
void disp(vi v) {
for (auto u : v)
cout << u << " ";
cout << "\n";
}
void disp(vll v) {
for (auto u : v)
cout << u << " ";
cout << endl;
}
int getSqr(int x) {
if (x < 0)
return -1;
int l = sqrt(x);
for (int i = -2; i <= 2; ++i)
if (l + i >= 0 && (l + i) * (l + i) == x)
return l;
return -1;
}
const int NPRR = 1e7;
vi lp;
vector<int> prr;
void prfac(int n = NPRR) {
assert(n <= NPRR);
lp.assign(n + 1, 0);
int i;
for (i = 2; i <= n; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prr.push_back(i);
}
for (int u : prr) {
if (i * u > n || u > lp[i])
break;
lp[i * u] = u;
}
}
}
bool check_composite_for_prime_function(ll n, ll a, ll d, int s) {
ll x = exp(a, d, n);
if (x == 1 || x == n - 1)
return false;
for (int r = 1; r < s; ++r) {
x = x * x % n;
x %= n;
if (x == n - 1)
return false;
}
return true;
}
bool prime(ll n) {
if (n < 4)
return n == 2 || n == 3;
if (!(n & 1))
return false;
int s = 0;
ll d = n - 1;
while (!(d & 1)) {
d >>= 1;
s++;
}
for (int a : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
if (n == a)
return true;
if (check_composite_for_prime_function(n, a, d, s))
return false;
}
return true;
}
ll binomialCoeff(ll n, ll k) {
ll res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (ll i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
/* custom hash for unordered map */
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline void read(int &x) { scanf("%d", &x); }
auto random_address = [] {
char *p = new char;
delete p;
return uint64_t(p);
};
const uint64_t SEED = chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1);
mt19937_64 rng(SEED);
/* ---------------- constants ---------------- */
const ll MAXn = 1e6 + 33, MAXlg = __lg(MAXn) + 2;
const ll MOD = 1000000007;
const ll INF = ll(1e15);
/* ---------------- gcd_extended ---------------- */
/*
* CAREFUL: Overflow at x *= c/g out of 10**18
* Lookout for A = 0 or B = 0
*/
void shift(ll &x, ll &y, ll cnt, ll a, ll b) {
x += cnt * b;
y -= cnt * a;
}
ll gcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool give_range(ll a, ll b, ll c, ll mina, ll maxa, ll minb, ll maxb, ll &lx,
ll &rx) {
ll x, y;
ll g = gcd(a, b, x, y);
if (c % g != 0)
return false;
// out2(x, y);
x *= c / g;
y *= c / g;
// out2(x, y);
a /= g;
b /= g;
if (a == 0 || b == 0) {
if (x >= mina && x <= maxa && y >= minb && y <= maxb) {
lx = x;
rx = x;
return true;
}
return false;
}
ll sign_a = (a > 0 ? 1 : -1);
ll sign_b = (b > 0 ? 1 : -1);
ll lx1, lx2, rx1, rx2;
{
ll cnt = (mina - x) / b;
shift(x, y, cnt, a, b);
if (x < 0)
shift(x, y, sign_a, a, b);
if (x > maxa) {
return false;
}
// out2(x, y);
lx1 = x;
}
{
ll cnt = (maxa - x) / b;
shift(x, y, cnt, a, b);
// out2(x, y);
rx1 = x;
}
{
ll cnt = -(minb - y) / a;
shift(x, y, cnt, a, b);
if (y < 0)
shift(x, y, -sign_b, a, b);
if (y > maxb) {
return false;
}
// out2(x, y);
lx2 = x;
}
{
ll cnt = -(maxb - y) / a;
shift(x, y, cnt, a, b);
// out2(x, y);
rx2 = x;
}
if (lx2 > rx2)
swap(lx2, rx2);
// out4(lx1, lx2, rx1, rx2);
ll lxx = max(lx1, lx2);
ll rxx = min(rx1, rx2);
if (lxx > rxx) {
return false;
}
lx = lxx;
rx = rxx;
return true;
}
/* ---------------- start of code ---------------- */
/*vector<set<int> > ad;
vi par;
vi lev;
vi maxdepth;
int n;
void dfs_for_par(int s, int parent, int level) {
par[s] = parent;
lev[s] = level;
for(auto u: ad[s]) {
if(u==parent) continue;
dfs_for_par(u, s, level+1);
}
}
int dfsmaxdepth(int s, int e) {
int res = 0;
for(auto u: ad[s]) {
if(u == e) continue;
dfsmaxdepth(u,s);
res = max(res, maxdepth[u]);
}
maxdepth[s] = ++res;
return res;
}
vi ans;
void dfs(int s, int e) {
vi res(n+1, 0);
for(auto u: ad[s]) {
if(u == e) continue;
res[0]++;
res[maxdepth[u]+1]--;
}
for(auto u: ad[e]) {
if(u == s or u == par[e]) continue;
res[0]++;
res[maxdepth[u] + 1]--;
}
forn(i, n) res[i+1] += res[i];
forn(i, n+1) ans[i] = max(ans[i], res[i]);
for(auto u: ad[s]) {
if(u == e) continue;
dfs(u, s);
}
}
void go2() {
cin >> n;
ad.assign(n, {});
par.assign(n,0);
ans.assign(n,0);
lev.assign(n,0);
maxdepth.assign(n,0);
forn(i, n-1) {
int r,s;in2(r,s);
r--;s--;
ad[r].insert(s);
ad[s].insert(r);
}
if(n == 2) {
out2(2, 2);
return;
}
dfs_for_par(0,0,0);
dfsmaxdepth(0,0);
}
void go1() {
int n;
string s;cin >> s;
n = s.size();
int i = 0;
if(n <=3) {
cout << s[0] << ln;
return;
}
string ans;
while(i < n/2) {
if(n % 4 > 0 and i >= (n/4 * 4) / 2) break;
int cnt[3] = {0};
cnt[s[i] - 'a']++;
cnt[s[i+1] - 'a']++;
cnt[s[n-i-1] - 'a']++;
cnt[s[n-i-2] - 'a']++;
forn(j, 3) {
if(cnt[j] > 1) {
ans += (char)(j + 'a');
break;
}
}
i+=2;
}
string anss = ans;
reverse(all(anss));
if(n % 4 > 0) {
ans += s[n/2];
}
ans += anss;
assert(ans.size() >= n/2);
cout << ans << ln;
}
ll md = 998244353;
void go3() {
ll n;cin >> n;
ll q;cin >> q;
ll a[n];
forn(i, n) cin >> a[i];
if(n == 1) {
cout << a[0] << ln;
return;
}
if(n == 2) {
cout << max(a[0], a[1]) << ln;
return;
}
ll o[n], e[n];
o[0] = a[0];
e[0] = -1e9-7;
o[1] = a[1];
e[1] = a[0] - a[1];
ll me = max(e[0], e[1]);
ll mo = max(o[0], o[1]);
ll prev[n];
prev[0] = -1;
prev[1] = -1;
forsn(i, 2, n) {
o[i] = max(a[i], me + a[i]);
e[i] = mo - a[i];
me = max(me, e[i]);
mo = max(mo, o[i]);
}
cout << max(mo, me) << ln;
}
ll c(ll n, ll k) {
if(n <= 0 or k > n) {
return 0;
}
ll res = 1;
k = min(k, n - k);
forn(i, k) {
res = (res * (ll)(n - i)) % md;
res /= (ll)(i + 1);
res %= md;
}
return res;
}*/
namespace SegmentTree {
int n;
pii t[4 * MAXn];
int mod[4 * MAXn] = {0};
vi a;
void pull(int v) {
t[v] = {max(t[2 * v + 1].F, t[2 * v + 2].F),
min(t[2 * v + 1].S, t[2 * v + 2].S)};
}
void apply(int v, int val) {
t[v] = {max(t[v].F, val), val};
mod[v] = val;
}
void push(int v) {
if (mod[v] != 0) {
apply(2 * v + 1, mod[v]);
apply(2 * v + 2, mod[v]);
mod[v] = 0;
}
}
void build(int v, int l, int r) {
if (l + 1 == r) {
t[v] = {a[l], a[l]};
} else {
int m = (r + l) >> 1;
build(2 * v + 1, l, m);
build(2 * v + 2, m, r);
pull(v);
}
// out4(v, t[v], l, r);
}
void modify_max(int v, int l, int r, int ql, int qr, int val) {
if (r <= ql || qr <= l) {
return;
} else if (ql <= l && r <= qr) {
apply(v, val);
} else {
push(v);
int m = (r + l) >> 1;
modify_max(2 * v + 1, l, m, ql, qr, val);
modify_max(2 * v + 2, m, r, ql, qr, val);
pull(v);
}
}
void modify_max(int l, int r, int val) { modify_max(0, 0, n, l, r, val); }
void modify_max(int pos, int val) { modify_max(0, 0, n, pos, pos + 1, val); }
void init(int n_) {
n = n_;
build(0, 0, n);
}
void init(const vi &b) {
n = (int)b.size();
a.clear();
for (const auto &u : b)
a.PB(u);
build(0, 0, n);
}
int getval_max(int v, int ql, int qr, int l, int r) {
if (r <= ql || qr <= l) {
return 0;
} else if (ql <= l && r <= qr) {
return t[v].F;
}
push(v);
int res = 0;
int mid = (l + r) >> 1;
res = max(res, getval_max(2 * v + 1, ql, qr, l, mid));
res = max(res, getval_max(2 * v + 2, ql, qr, mid, r));
pull(v);
return res;
}
// ql, qr analogous to modify_max(). 0-indexed.
ll getval_max(int ql, int qr) { return getval_max(0, ql, qr, 0, n); }
} // namespace SegmentTree
vi b(1000033, 0);
vi anss;
void go4() {
int n, k;
in2(n, k);
vi a(n);
anss.assign(n, 0);
forn(i, n) cin >> a[i];
SegmentTree::init(b);
anss[0] = 1;
int j = 3e5 + 1 + a[0];
SegmentTree::modify_max(j, j + 1, 1);
// forn(i, 10) {
// cout << SegmentTree::getval_max(3e5+1+i, 3e5+1+i+1) << " ";
// }cout << ln;
int ans = SegmentTree::getval_max(0, 1e6 + 30);
forsn(i, 1, n) {
int j = 3e5 + 1 + a[i];
int p = SegmentTree::getval_max(j - k, j + k + 1);
// cout << p << " ";
p++;
SegmentTree::modify_max(j, j + 1, p);
anss[i] = p;
ans = max(ans, p);
forn(i, 12) {
cerr << SegmentTree::getval_max(3e5 + 1 + i, 3e5 + 1 + i + 1) << " ";
}
cerr << ln;
}
// cout << ln;
// forn(i, 10) {
// cout << SegmentTree::getval_max(3e5+1+i, 3e5+1+i+1) << " ";
// }cout << ln;
// disp(anss);
cout << ans << ln;
}
int main() {
fio;
fflush(stdout);
cout << fixed << setprecision(0);
cerr << fixed << setprecision(10);
// freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
ll tt = 1;
/*
cin >> tt;
ll t = tt;
//*/
// forn(i, 100) cout << fac[i] << " ";
auto start = std::chrono::high_resolution_clock::now();
while (tt--) {
// cout << "Case #" << t - tt << ": ";
go4();
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
// cerr << "Time taken : " << ((long double)duration.count())/((long double)
// 1e9) <<"s "<< endl;
return 0;
}
/* ---------------- end of code ---------------- */
| #pragma GCC target("sse4.2")
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define ln "\n"
#define forn(i, e) for (ll i = 0; i < e; i++)
#define forsn(i, s, e) for (ll i = s; i < e; i++)
#define rforn(i, e) for (ll i = e; i >= 0; i--)
#define rforsn(i, e, s) for (ll i = e; i >= s; i--)
#define vasort(v) sort(v.begin(), v.end());
#define vdsort(v) sort(v.begin(), v.end(), greater<ll>());
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define mem(a, b) memset(a, b, sizeof(a))
#define sz(x) ((int)size(x))
#define EB emplace_back
#define flush fflush(stdout)
#define out1(x1) cout << x1 << ln
#define out2(x1, x2) cout << x1 << " " << x2 << endl
#define out3(x1, x2, x3) cout << x1 << " " << x2 << " " << x3 << endl
#define out4(x1, x2, x3, x4) \
cout << x1 << " " << x2 << " " << x3 << " " << x4 << ln
#define all(d) d.begin(), d.end()
#define unordered_set(T) unordered_set<T, custom_hash>
#define unordered_map(T1, T2) unordered_map<T1, T2, custom_hash>
#define in1(x1) cin >> x1
#define in2(x1, x2) cin >> x1 >> x2
#define in3(x1, x2, x3) cin >> x1 >> x2 >> x3
#define in4(x1, x2, x3, x4) cin >> x1 >> x2 >> x3 >> x4
#define arrin(a, n) forn(i, n) cin >> a[i];
#define arrout(a, n) \
forn(i, n) { cout << a[i] << " "; } \
cout << ln;
/* ---------------- IO ----------------*/
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0)
input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len)
_update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T> inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-')
negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative)
number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE)
_flush_output();
output_buffer[output_pos++] = c;
}
template <typename T> inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
if (number != 0 || length == 0)
write_char(number + '0');
for (int i = length - 1; i >= 0; i--)
write_char(number_buffer[i]);
if (after)
write_char(after);
}
void IOinit() {
// Make sure _flush_output() is called at the end of the program.
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++)
lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
using namespace IO;
/* ---------------- typedefs ----------------*/
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
/* ---------------- utility functions ---------------- */
int dr[] = {0, 1, -1, 0, 1, -1, 1, -1};
int dc[] = {1, 0, 0, -1, 1, -1, -1, 1};
int drr[] = {-2, -1, 0, 1, 2};
int dcc[] = {-2, -1, 0, 1, 2};
bool chk(int a, int b, int n, int m) {
return 0 <= a && a < n && 0 <= b && b < m;
}
ll exp(ll n, ll m, ll md) {
ll a = 1;
while (m > 0) {
if (m & 1)
a = (a * n % md) % md;
m /= 2;
n = (n * n) % md;
}
return a % md;
}
ll expm(ll n, ll m) {
ll a = 1;
while (m > 0) {
if (a < 0 or a >= (1e18 + n - 1) / n) {
return -1;
}
if (m & 1)
a = (a * n);
m /= 2;
n = (n * n);
}
return a;
}
void disp(vi v) {
for (auto u : v)
cout << u << " ";
cout << "\n";
}
void disp(vll v) {
for (auto u : v)
cout << u << " ";
cout << endl;
}
int getSqr(int x) {
if (x < 0)
return -1;
int l = sqrt(x);
for (int i = -2; i <= 2; ++i)
if (l + i >= 0 && (l + i) * (l + i) == x)
return l;
return -1;
}
const int NPRR = 1e7;
vi lp;
vector<int> prr;
void prfac(int n = NPRR) {
assert(n <= NPRR);
lp.assign(n + 1, 0);
int i;
for (i = 2; i <= n; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prr.push_back(i);
}
for (int u : prr) {
if (i * u > n || u > lp[i])
break;
lp[i * u] = u;
}
}
}
bool check_composite_for_prime_function(ll n, ll a, ll d, int s) {
ll x = exp(a, d, n);
if (x == 1 || x == n - 1)
return false;
for (int r = 1; r < s; ++r) {
x = x * x % n;
x %= n;
if (x == n - 1)
return false;
}
return true;
}
bool prime(ll n) {
if (n < 4)
return n == 2 || n == 3;
if (!(n & 1))
return false;
int s = 0;
ll d = n - 1;
while (!(d & 1)) {
d >>= 1;
s++;
}
for (int a : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
if (n == a)
return true;
if (check_composite_for_prime_function(n, a, d, s))
return false;
}
return true;
}
ll binomialCoeff(ll n, ll k) {
ll res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (ll i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
/* custom hash for unordered map */
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline void read(int &x) { scanf("%d", &x); }
auto random_address = [] {
char *p = new char;
delete p;
return uint64_t(p);
};
const uint64_t SEED = chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1);
mt19937_64 rng(SEED);
/* ---------------- constants ---------------- */
const ll MAXn = 1e6 + 33, MAXlg = __lg(MAXn) + 2;
const ll MOD = 1000000007;
const ll INF = ll(1e15);
/* ---------------- gcd_extended ---------------- */
/*
* CAREFUL: Overflow at x *= c/g out of 10**18
* Lookout for A = 0 or B = 0
*/
void shift(ll &x, ll &y, ll cnt, ll a, ll b) {
x += cnt * b;
y -= cnt * a;
}
ll gcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool give_range(ll a, ll b, ll c, ll mina, ll maxa, ll minb, ll maxb, ll &lx,
ll &rx) {
ll x, y;
ll g = gcd(a, b, x, y);
if (c % g != 0)
return false;
// out2(x, y);
x *= c / g;
y *= c / g;
// out2(x, y);
a /= g;
b /= g;
if (a == 0 || b == 0) {
if (x >= mina && x <= maxa && y >= minb && y <= maxb) {
lx = x;
rx = x;
return true;
}
return false;
}
ll sign_a = (a > 0 ? 1 : -1);
ll sign_b = (b > 0 ? 1 : -1);
ll lx1, lx2, rx1, rx2;
{
ll cnt = (mina - x) / b;
shift(x, y, cnt, a, b);
if (x < 0)
shift(x, y, sign_a, a, b);
if (x > maxa) {
return false;
}
// out2(x, y);
lx1 = x;
}
{
ll cnt = (maxa - x) / b;
shift(x, y, cnt, a, b);
// out2(x, y);
rx1 = x;
}
{
ll cnt = -(minb - y) / a;
shift(x, y, cnt, a, b);
if (y < 0)
shift(x, y, -sign_b, a, b);
if (y > maxb) {
return false;
}
// out2(x, y);
lx2 = x;
}
{
ll cnt = -(maxb - y) / a;
shift(x, y, cnt, a, b);
// out2(x, y);
rx2 = x;
}
if (lx2 > rx2)
swap(lx2, rx2);
// out4(lx1, lx2, rx1, rx2);
ll lxx = max(lx1, lx2);
ll rxx = min(rx1, rx2);
if (lxx > rxx) {
return false;
}
lx = lxx;
rx = rxx;
return true;
}
/* ---------------- start of code ---------------- */
/*vector<set<int> > ad;
vi par;
vi lev;
vi maxdepth;
int n;
void dfs_for_par(int s, int parent, int level) {
par[s] = parent;
lev[s] = level;
for(auto u: ad[s]) {
if(u==parent) continue;
dfs_for_par(u, s, level+1);
}
}
int dfsmaxdepth(int s, int e) {
int res = 0;
for(auto u: ad[s]) {
if(u == e) continue;
dfsmaxdepth(u,s);
res = max(res, maxdepth[u]);
}
maxdepth[s] = ++res;
return res;
}
vi ans;
void dfs(int s, int e) {
vi res(n+1, 0);
for(auto u: ad[s]) {
if(u == e) continue;
res[0]++;
res[maxdepth[u]+1]--;
}
for(auto u: ad[e]) {
if(u == s or u == par[e]) continue;
res[0]++;
res[maxdepth[u] + 1]--;
}
forn(i, n) res[i+1] += res[i];
forn(i, n+1) ans[i] = max(ans[i], res[i]);
for(auto u: ad[s]) {
if(u == e) continue;
dfs(u, s);
}
}
void go2() {
cin >> n;
ad.assign(n, {});
par.assign(n,0);
ans.assign(n,0);
lev.assign(n,0);
maxdepth.assign(n,0);
forn(i, n-1) {
int r,s;in2(r,s);
r--;s--;
ad[r].insert(s);
ad[s].insert(r);
}
if(n == 2) {
out2(2, 2);
return;
}
dfs_for_par(0,0,0);
dfsmaxdepth(0,0);
}
void go1() {
int n;
string s;cin >> s;
n = s.size();
int i = 0;
if(n <=3) {
cout << s[0] << ln;
return;
}
string ans;
while(i < n/2) {
if(n % 4 > 0 and i >= (n/4 * 4) / 2) break;
int cnt[3] = {0};
cnt[s[i] - 'a']++;
cnt[s[i+1] - 'a']++;
cnt[s[n-i-1] - 'a']++;
cnt[s[n-i-2] - 'a']++;
forn(j, 3) {
if(cnt[j] > 1) {
ans += (char)(j + 'a');
break;
}
}
i+=2;
}
string anss = ans;
reverse(all(anss));
if(n % 4 > 0) {
ans += s[n/2];
}
ans += anss;
assert(ans.size() >= n/2);
cout << ans << ln;
}
ll md = 998244353;
void go3() {
ll n;cin >> n;
ll q;cin >> q;
ll a[n];
forn(i, n) cin >> a[i];
if(n == 1) {
cout << a[0] << ln;
return;
}
if(n == 2) {
cout << max(a[0], a[1]) << ln;
return;
}
ll o[n], e[n];
o[0] = a[0];
e[0] = -1e9-7;
o[1] = a[1];
e[1] = a[0] - a[1];
ll me = max(e[0], e[1]);
ll mo = max(o[0], o[1]);
ll prev[n];
prev[0] = -1;
prev[1] = -1;
forsn(i, 2, n) {
o[i] = max(a[i], me + a[i]);
e[i] = mo - a[i];
me = max(me, e[i]);
mo = max(mo, o[i]);
}
cout << max(mo, me) << ln;
}
ll c(ll n, ll k) {
if(n <= 0 or k > n) {
return 0;
}
ll res = 1;
k = min(k, n - k);
forn(i, k) {
res = (res * (ll)(n - i)) % md;
res /= (ll)(i + 1);
res %= md;
}
return res;
}*/
namespace SegmentTree {
int n;
pii t[4 * MAXn];
int mod[4 * MAXn] = {0};
vi a;
void pull(int v) {
t[v] = {max(t[2 * v + 1].F, t[2 * v + 2].F),
min(t[2 * v + 1].S, t[2 * v + 2].S)};
}
void apply(int v, int val) {
t[v] = {max(t[v].F, val), val};
mod[v] = val;
}
void push(int v) {
if (mod[v] != 0) {
apply(2 * v + 1, mod[v]);
apply(2 * v + 2, mod[v]);
mod[v] = 0;
}
}
void build(int v, int l, int r) {
if (l + 1 == r) {
t[v] = {a[l], a[l]};
} else {
int m = (r + l) >> 1;
build(2 * v + 1, l, m);
build(2 * v + 2, m, r);
pull(v);
}
// out4(v, t[v], l, r);
}
void modify_max(int v, int l, int r, int ql, int qr, int val) {
if (r <= ql || qr <= l) {
return;
} else if (ql <= l && r <= qr) {
apply(v, val);
} else {
push(v);
int m = (r + l) >> 1;
modify_max(2 * v + 1, l, m, ql, qr, val);
modify_max(2 * v + 2, m, r, ql, qr, val);
pull(v);
}
}
void modify_max(int l, int r, int val) { modify_max(0, 0, n, l, r, val); }
void modify_max(int pos, int val) { modify_max(0, 0, n, pos, pos + 1, val); }
void init(int n_) {
n = n_;
build(0, 0, n);
}
void init(const vi &b) {
n = (int)b.size();
a.clear();
for (const auto &u : b)
a.PB(u);
build(0, 0, n);
}
int getval_max(int v, int ql, int qr, int l, int r) {
if (r <= ql || qr <= l) {
return 0;
} else if (ql <= l && r <= qr) {
return t[v].F;
}
push(v);
int res = 0;
int mid = (l + r) >> 1;
res = max(res, getval_max(2 * v + 1, ql, qr, l, mid));
res = max(res, getval_max(2 * v + 2, ql, qr, mid, r));
pull(v);
return res;
}
// ql, qr analogous to modify_max(). 0-indexed.
ll getval_max(int ql, int qr) { return getval_max(0, ql, qr, 0, n); }
} // namespace SegmentTree
vi b(1000033, 0);
vi anss;
void go4() {
int n, k;
in2(n, k);
vi a(n);
anss.assign(n, 0);
forn(i, n) cin >> a[i];
SegmentTree::init(b);
anss[0] = 1;
int j = 3e5 + 1 + a[0];
SegmentTree::modify_max(j, j + 1, 1);
// forn(i, 10) {
// cout << SegmentTree::getval_max(3e5+1+i, 3e5+1+i+1) << " ";
// }cout << ln;
int ans = SegmentTree::getval_max(0, 1e6 + 30);
forsn(i, 1, n) {
int j = 3e5 + 1 + a[i];
int p = SegmentTree::getval_max(j - k, j + k + 1);
// cout << p << " ";
p++;
SegmentTree::modify_max(j, j + 1, p);
anss[i] = p;
ans = max(ans, p);
// forn(i, 12) {
// cerr << SegmentTree::getval_max(3e5+1+i, 3e5+1+i+1) << " ";
// }cerr << ln;
}
// cout << ln;
// forn(i, 10) {
// cout << SegmentTree::getval_max(3e5+1+i, 3e5+1+i+1) << " ";
// }cout << ln;
// disp(anss);
cout << ans << ln;
}
int main() {
fio;
fflush(stdout);
cout << fixed << setprecision(0);
cerr << fixed << setprecision(10);
// freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
ll tt = 1;
/*
cin >> tt;
ll t = tt;
//*/
// forn(i, 100) cout << fac[i] << " ";
auto start = std::chrono::high_resolution_clock::now();
while (tt--) {
// cout << "Case #" << t - tt << ": ";
go4();
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
// cerr << "Time taken : " << ((long double)duration.count())/((long double)
// 1e9) <<"s "<< endl;
return 0;
}
/* ---------------- end of code ---------------- */
| replace | 647 | 651 | 647 | 650 | TLE | |
p02537 | C++ | Runtime Error | // #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include "bits/stdc++.h"
using namespace std;
#define PI 3.1415926535897932384626433832795l
#define pb push_back
#define mp make_pair
#define lb lower_bound // First element which is not less than val
#define ub upper_bound // First element greater than val
#define f first
#define s second
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define endl '\n'
#define re return
#define repz(i, a) for (ll i = 0; i < (a); i++)
#define vecin(n, v) \
for (ll i = 0; i < n; i++) \
cin >> v[i];
#define full(v) v.begin(), v.end()
struct S {
int x;
// This should be the identity element
S() { x = 0; }
S(int _x) : x(_x) {}
};
S op(S &a, S &b) { return {max(a.x, b.x)}; }
// Predicate for binary search. Must be true for identity.
bool f(S /*x*/) {
// Dummy for binary search
return true;
}
struct segtree {
int _n;
vector<S> t;
int size;
int log;
segtree() : segtree(0) {}
segtree(int n = -1) {
if (n >= 0)
init(n);
}
void init(int n) {
_n = n;
log = 0;
while ((1U << log) < (unsigned int)(n))
log++;
size = 1 << log;
t.assign(2 * _n, S());
}
void build(vector<S> v) {
init((int)v.size());
assert(_n != 0);
for (int i = 0; i < _n; i++)
t[size + i] = v[i];
for (int i = size - 1; i > 0; i--)
t[i] = op(t[2 * i], t[2 * i + 1]);
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
t[p] = x;
for (int i = 1; i <= log; i++)
t[p >> i] = op(t[2 * (p >> i)], t[2 * (p >> i) + 1]);
}
S get(int p) {
assert(0 <= p && p < _n);
return t[p + size];
}
// Find result for range [l,r)
S query(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S ansl, ansr;
l += size;
r += size;
while (l < r) {
if (l & 1)
ansl = op(ansl, t[l++]);
if (r & 1)
ansr = op(t[--r], ansr);
l >>= 1;
r >>= 1;
}
return op(ansl, ansr);
}
/* Binary Search */
// Find the maximum value of r such that [l,r) is true
int max_right(int l) {
assert(0 <= l && l <= _n);
if (l == _n)
return _n;
l += size;
S sm;
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, t[l]))) {
while (l < size) {
l *= 2;
if (f(op(sm, t[l]))) {
sm = op(sm, t[l]);
l++;
}
}
return l - size;
}
sm = op(sm, t[l]);
l++;
} while ((l & -l) != l);
return _n;
}
// This is the minimum l such that [l,r) is true
int min_left(int r) {
assert(0 <= r && r <= _n);
if (r == 0)
return 0;
r += size;
S sm;
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(t[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(t[r], sm))) {
sm = op(t[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(t[r], sm);
} while ((r & -r) != r);
return 0;
}
};
const int N = 6e5 + 57;
void solve() {
int n, k;
cin >> n >> k;
vi a(n);
vecin(n, a);
segtree T(N);
repz(i, n) {
S s = T.query(max(a[i] - k, 0), a[i] + k + 1);
T.set(a[i], {s.x + 1});
}
cout << T.t[1].x << endl;
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
| // #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include "bits/stdc++.h"
using namespace std;
#define PI 3.1415926535897932384626433832795l
#define pb push_back
#define mp make_pair
#define lb lower_bound // First element which is not less than val
#define ub upper_bound // First element greater than val
#define f first
#define s second
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define endl '\n'
#define re return
#define repz(i, a) for (ll i = 0; i < (a); i++)
#define vecin(n, v) \
for (ll i = 0; i < n; i++) \
cin >> v[i];
#define full(v) v.begin(), v.end()
struct S {
int x;
// This should be the identity element
S() { x = 0; }
S(int _x) : x(_x) {}
};
S op(S &a, S &b) { return {max(a.x, b.x)}; }
// Predicate for binary search. Must be true for identity.
bool f(S /*x*/) {
// Dummy for binary search
return true;
}
struct segtree {
int _n;
vector<S> t;
int size;
int log;
segtree() : segtree(0) {}
segtree(int n = -1) {
if (n >= 0)
init(n);
}
void init(int n) {
_n = n;
log = 0;
while ((1U << log) < (unsigned int)(n))
log++;
size = 1 << log;
t.assign(2 * size, S());
}
void build(vector<S> v) {
init((int)v.size());
assert(_n != 0);
for (int i = 0; i < _n; i++)
t[size + i] = v[i];
for (int i = size - 1; i > 0; i--)
t[i] = op(t[2 * i], t[2 * i + 1]);
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
t[p] = x;
for (int i = 1; i <= log; i++)
t[p >> i] = op(t[2 * (p >> i)], t[2 * (p >> i) + 1]);
}
S get(int p) {
assert(0 <= p && p < _n);
return t[p + size];
}
// Find result for range [l,r)
S query(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S ansl, ansr;
l += size;
r += size;
while (l < r) {
if (l & 1)
ansl = op(ansl, t[l++]);
if (r & 1)
ansr = op(t[--r], ansr);
l >>= 1;
r >>= 1;
}
return op(ansl, ansr);
}
/* Binary Search */
// Find the maximum value of r such that [l,r) is true
int max_right(int l) {
assert(0 <= l && l <= _n);
if (l == _n)
return _n;
l += size;
S sm;
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, t[l]))) {
while (l < size) {
l *= 2;
if (f(op(sm, t[l]))) {
sm = op(sm, t[l]);
l++;
}
}
return l - size;
}
sm = op(sm, t[l]);
l++;
} while ((l & -l) != l);
return _n;
}
// This is the minimum l such that [l,r) is true
int min_left(int r) {
assert(0 <= r && r <= _n);
if (r == 0)
return 0;
r += size;
S sm;
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(t[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(t[r], sm))) {
sm = op(t[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(t[r], sm);
} while ((r & -r) != r);
return 0;
}
};
const int N = 6e5 + 57;
void solve() {
int n, k;
cin >> n >> k;
vi a(n);
vecin(n, a);
segtree T(N);
repz(i, n) {
S s = T.query(max(a[i] - k, 0), a[i] + k + 1);
T.set(a[i], {s.x + 1});
}
cout << T.t[1].x << endl;
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
| replace | 75 | 76 | 75 | 76 | 0 | |
p02537 | C++ | Runtime Error | // includes
#include <bits/stdc++.h>
using namespace std;
// macros
#define pb emplace_back
#define mk make_pair
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define irep(itr, st) for (auto itr = (st).begin(); itr != (st).end(); ++itr)
#define irrep(itr, st) for (auto itr = (st).rbegin(); itr != (st).rend(); ++itr)
#define whole(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define bit(n) (1LL << (n))
#define F first
#define S second
// functions
template <typename T> void unique(T &c) {
c.erase(std::unique(c.begin(), c.end()), c.end());
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
os << vec[i];
if (i + 1 != vec.size())
os << " ";
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << ")";
auto titr = itr;
if (++titr != mp.end())
os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << ")";
auto titr = itr;
if (++titr != mp.end())
os << " ";
}
return os;
}
// types
using ll = long long int;
using P = pair<int, int>;
// constants
const int inf = 1e9;
const ll linf = 1LL << 60;
const double EPS = 1e-10;
const int mod = 1000000007;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
// io
struct fast_io {
fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(20);
}
} fast_io_;
template <class Monoid> class SegmentTree {
public:
int n;
using T = typename Monoid::value_type;
vector<T> val;
T identity;
SegmentTree() {}
SegmentTree(int n_, vector<T> v = vector<T>()) {
n = 1;
while (n < n_)
n *= 2;
identity = Monoid::identity;
val.assign(2 * n - 1, identity);
for (size_t i = 0; i < v.size(); i++) {
val[i + n - 1] = v[i];
}
for (int i = n - 2; i >= 0; i--) {
val[i] = Monoid::operation(val[2 * i + 1], val[2 * i + 2]);
}
}
void update(int k, const T &t) {
k = k + n - 1;
val[k] = t;
while (k > 0) {
k = (k - 1) / 2;
val[k] = Monoid::operation(val[2 * k + 1], val[2 * k + 2]);
}
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return identity;
if (a <= l && r <= b)
return val[k];
T lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
T rv = query(a, b, 2 * k + 2, (l + r) / 2, r);
return Monoid::operation(lv, rv);
}
T query(int a, int b) { return query(a, b, 0, 0, n); }
T get(int i) { return val[i + n - 1]; }
};
template <typename T> class RMQ {
public:
const static T identity;
using value_type = T;
RMQ() {}
static T operation(T &l, T &r) { return max(l, r); }
};
template <typename T> const T RMQ<T>::identity = numeric_limits<T>::min();
const int B = 300010;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
vector<int> a(n);
cin >> a;
SegmentTree<RMQ<int>> seg(n);
int res = 0;
rep(i, n) {
int l = max(0, a[i] - k);
int r = min(a[i] + k, B - 1);
int p = seg.query(l, r + 1);
if (p == seg.identity)
p = 0;
p++;
seg.update(a[i], p);
chmax(res, p);
}
cout << res << endl;
return 0;
}
| // includes
#include <bits/stdc++.h>
using namespace std;
// macros
#define pb emplace_back
#define mk make_pair
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define irep(itr, st) for (auto itr = (st).begin(); itr != (st).end(); ++itr)
#define irrep(itr, st) for (auto itr = (st).rbegin(); itr != (st).rend(); ++itr)
#define whole(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define bit(n) (1LL << (n))
#define F first
#define S second
// functions
template <typename T> void unique(T &c) {
c.erase(std::unique(c.begin(), c.end()), c.end());
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
os << vec[i];
if (i + 1 != vec.size())
os << " ";
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end())
os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << ")";
auto titr = itr;
if (++titr != mp.end())
os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << ")";
auto titr = itr;
if (++titr != mp.end())
os << " ";
}
return os;
}
// types
using ll = long long int;
using P = pair<int, int>;
// constants
const int inf = 1e9;
const ll linf = 1LL << 60;
const double EPS = 1e-10;
const int mod = 1000000007;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
// io
struct fast_io {
fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(20);
}
} fast_io_;
template <class Monoid> class SegmentTree {
public:
int n;
using T = typename Monoid::value_type;
vector<T> val;
T identity;
SegmentTree() {}
SegmentTree(int n_, vector<T> v = vector<T>()) {
n = 1;
while (n < n_)
n *= 2;
identity = Monoid::identity;
val.assign(2 * n - 1, identity);
for (size_t i = 0; i < v.size(); i++) {
val[i + n - 1] = v[i];
}
for (int i = n - 2; i >= 0; i--) {
val[i] = Monoid::operation(val[2 * i + 1], val[2 * i + 2]);
}
}
void update(int k, const T &t) {
k = k + n - 1;
val[k] = t;
while (k > 0) {
k = (k - 1) / 2;
val[k] = Monoid::operation(val[2 * k + 1], val[2 * k + 2]);
}
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return identity;
if (a <= l && r <= b)
return val[k];
T lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
T rv = query(a, b, 2 * k + 2, (l + r) / 2, r);
return Monoid::operation(lv, rv);
}
T query(int a, int b) { return query(a, b, 0, 0, n); }
T get(int i) { return val[i + n - 1]; }
};
template <typename T> class RMQ {
public:
const static T identity;
using value_type = T;
RMQ() {}
static T operation(T &l, T &r) { return max(l, r); }
};
template <typename T> const T RMQ<T>::identity = numeric_limits<T>::min();
const int B = 300010;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
vector<int> a(n);
cin >> a;
SegmentTree<RMQ<int>> seg(B);
int res = 0;
rep(i, n) {
int l = max(0, a[i] - k);
int r = min(a[i] + k, B - 1);
int p = seg.query(l, r + 1);
if (p == seg.identity)
p = 0;
p++;
seg.update(a[i], p);
chmax(res, p);
}
cout << res << endl;
return 0;
}
| replace | 191 | 192 | 191 | 192 | 0 | |
p02537 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
// #include <numeric> //iota
// #include <sstream>
// #include <cstring>
// #include <tuple>
// #include <random>
// #include <string>
// #include <unordered_set>
// #include <bitset>
// #include <unordered_map>
// #include <stack>
// #include <cmath>
// #include <deque>
// #include <queue>
// #include <list>
#include <array>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define vec vector
#define pb push_back
#define pp pop_back
#define fi first
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define se second
#define un_map unordered_map
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define inc_rep(i, a, n, inc) for (int i = a; i < n; i += inc)
#define couts(x) cout << x << "\n"
#define watch(x) cout << #x << " : " << x << endl;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLII;
template <typename T> void print(vector<T> &v) {
rep(i, 0, (int)v.size()) cout << v[i] << " ";
cout << endl;
}
int nxt() {
int x;
cin >> x;
return x;
}
ll nxtl() {
ll x;
cin >> x;
return x;
}
string nxts() {
string x;
cin >> x;
return x;
}
double nxtd() {
double x;
cin >> x;
return x;
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
ll power_mod(ll a, ll b, ll mo) {
ll ans = 1;
while (b) {
if (b & 1) {
ans = (ans % mo * a % mo) % mo;
}
a = (a % mo * a % mo) % mo;
b /= 2;
}
return ans;
}
ll POW(ll a, ll b) {
ll ans = 1;
while (b) {
if (b & 1) {
ans = ans * a;
}
a = a * a;
b /= 2;
}
return ans;
}
// string int_to_string(int x) {
// stringstream ss;
// ss << x;
// string ni = ss.str();
// return ni;
//}
// int string_to_int(string x) {
// int n;
// stringstream s(x);
// s >> n;
// return n;
//}
// char int_to_char(int a) {
// return a + '0';
//}
// void INVERSE() {
// fact[0] = 1;
// for (ll i = 1; i <= z; ++i) {
// fact[i] = (fact[i - 1] * i) % mod;
//}
// inv[0] = 1;
// inv[1] = 1;
// for (ll i = 2; i <= z; ++i) {
// inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
//}
// mul[0] = 1;
// for (int i = 1; i <= z; ++i) {
// mul[i] = (mul[i - 1] * inv[i]) % mod;
//}
//}
// read questions carefully , write clean code and check your logic again on WA
// !!!
// problems are not difficult just make sure you understand the qusetion and
// just think smartly (make sure to use pen and paper when needed)
int const p = 300000;
int dp[p + 1];
int v[p + 1];
int segment_tree[2 * p + 2];
int n, k;
int sized = p;
int query(int l_in, int r_in, int index = 1, int l = 1, int r = sized) {
if (r_in >= r && l_in <= l) {
return segment_tree[index];
}
if (l_in > r || r_in < l) {
return 0;
}
int mid = (l + r) / 2;
return max(query(l_in, r_in, index * 2, l, mid),
query(l_in, r_in, index * 2 + 1, mid + 1, r));
}
void update(int index_in, int val, int index = 1, int l = 1, int r = sized) {
if (l == r) {
segment_tree[index] = val;
return;
}
int mid = (l + r) / 2;
if (index_in <= mid) {
update(index_in, val, index * 2, l, mid);
} else {
update(index_in, val, index * 2 + 1, mid + 1, r);
}
segment_tree[index] =
max(segment_tree[index * 2], segment_tree[index * 2 + 1]);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> v[i];
v[i]++;
}
for (int i = n - 1; i >= 0; --i) {
int r = (v[i] + k >= p) ? p : v[i] + k;
int l = (v[i] - k >= 1) ? v[i] - k : 1;
int val = query(l, r);
dp[v[i]] = val + 1;
update(v[i], dp[v[i]]);
}
int maxm = 0;
for (int i = 0; i <= p; ++i)
maxm = max(maxm, dp[i]);
cout << maxm;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
// #include <numeric> //iota
// #include <sstream>
// #include <cstring>
// #include <tuple>
// #include <random>
// #include <string>
// #include <unordered_set>
// #include <bitset>
// #include <unordered_map>
// #include <stack>
// #include <cmath>
// #include <deque>
// #include <queue>
// #include <list>
#include <array>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define vec vector
#define pb push_back
#define pp pop_back
#define fi first
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define se second
#define un_map unordered_map
#define rep(i, a, n) for (int i = a; i < n; ++i)
#define inc_rep(i, a, n, inc) for (int i = a; i < n; i += inc)
#define couts(x) cout << x << "\n"
#define watch(x) cout << #x << " : " << x << endl;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLII;
template <typename T> void print(vector<T> &v) {
rep(i, 0, (int)v.size()) cout << v[i] << " ";
cout << endl;
}
int nxt() {
int x;
cin >> x;
return x;
}
ll nxtl() {
ll x;
cin >> x;
return x;
}
string nxts() {
string x;
cin >> x;
return x;
}
double nxtd() {
double x;
cin >> x;
return x;
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
ll power_mod(ll a, ll b, ll mo) {
ll ans = 1;
while (b) {
if (b & 1) {
ans = (ans % mo * a % mo) % mo;
}
a = (a % mo * a % mo) % mo;
b /= 2;
}
return ans;
}
ll POW(ll a, ll b) {
ll ans = 1;
while (b) {
if (b & 1) {
ans = ans * a;
}
a = a * a;
b /= 2;
}
return ans;
}
// string int_to_string(int x) {
// stringstream ss;
// ss << x;
// string ni = ss.str();
// return ni;
//}
// int string_to_int(string x) {
// int n;
// stringstream s(x);
// s >> n;
// return n;
//}
// char int_to_char(int a) {
// return a + '0';
//}
// void INVERSE() {
// fact[0] = 1;
// for (ll i = 1; i <= z; ++i) {
// fact[i] = (fact[i - 1] * i) % mod;
//}
// inv[0] = 1;
// inv[1] = 1;
// for (ll i = 2; i <= z; ++i) {
// inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
//}
// mul[0] = 1;
// for (int i = 1; i <= z; ++i) {
// mul[i] = (mul[i - 1] * inv[i]) % mod;
//}
//}
// read questions carefully , write clean code and check your logic again on WA
// !!!
// problems are not difficult just make sure you understand the qusetion and
// just think smartly (make sure to use pen and paper when needed)
int const p = 300000;
int dp[p + 1];
int v[p + 1];
int segment_tree[4 * p + 2];
int n, k;
int sized = p;
int query(int l_in, int r_in, int index = 1, int l = 1, int r = sized) {
if (r_in >= r && l_in <= l) {
return segment_tree[index];
}
if (l_in > r || r_in < l) {
return 0;
}
int mid = (l + r) / 2;
return max(query(l_in, r_in, index * 2, l, mid),
query(l_in, r_in, index * 2 + 1, mid + 1, r));
}
void update(int index_in, int val, int index = 1, int l = 1, int r = sized) {
if (l == r) {
segment_tree[index] = val;
return;
}
int mid = (l + r) / 2;
if (index_in <= mid) {
update(index_in, val, index * 2, l, mid);
} else {
update(index_in, val, index * 2 + 1, mid + 1, r);
}
segment_tree[index] =
max(segment_tree[index * 2], segment_tree[index * 2 + 1]);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> v[i];
v[i]++;
}
for (int i = n - 1; i >= 0; --i) {
int r = (v[i] + k >= p) ? p : v[i] + k;
int l = (v[i] - k >= 1) ? v[i] - k : 1;
int val = query(l, r);
dp[v[i]] = val + 1;
update(v[i], dp[v[i]]);
}
int maxm = 0;
for (int i = 0; i <= p; ++i)
maxm = max(maxm, dp[i]);
cout << maxm;
}
| replace | 175 | 176 | 175 | 176 | 0 | |
p02537 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define owo \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define MOD (ll)(1e8)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d) \
for (long blockTime = 0; \
(blockTime == 0 ? (blockTime = clock()) != 0 : false); \
debug("%s time : %.4fs\n", d, \
(double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<int, int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
ll gcd(ll a, ll b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
class pointseg {
private:
int n;
vector<ll> t, a;
void upd(int v, int tl, int tr, int pos, ll val) {
if (tl == tr) {
t[v] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm) {
upd(2 * v, tl, tm, pos, val);
} else {
upd(2 * v + 1, tm + 1, tr, pos, val);
}
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
ll query(int v, int l, int r, int tl, int tr) {
if (l > r)
return 0;
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return merge(query(2 * v, l, min(r, tm), tl, tm),
query(2 * v + 1, max(l, tm + 1), r, tm + 1, tr));
}
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
public:
ll merge(ll a, ll b) { return max(a, b); }
void upd(int pos, ll val) { upd(1, 1, n, pos, val); }
ll query(int l, int r) { return query(1, l, r, 1, n); }
void build() { build(1, 1, n); }
pointseg(int _n, vector<ll> _a = {}) {
n = _n;
t.assign(4 * (n + 4), 0);
a = _a;
}
pointseg() {}
void reset(int _n, vector<ll> _a = {}) {
n = _n;
t.clear();
t.assign(4 * (_n + 4), 0);
a.clear();
a = _a;
}
};
int main() {
owo ll n, k;
cin >> n >> k;
vector<ll> a(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]++;
}
ll ans = 1;
pointseg s(400000);
for (int i = 0; i < n; i++) {
ll l = max(1LL, a[i] - k);
ll r = a[i] + k;
ll res = s.query(l, r);
ll now = s.query(a[i], a[i]);
if (res + 1 > now)
s.upd(a[i], res + 1);
ans = max(ans, now);
ans = max(ans, res + 1);
}
cout << ans;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define owo \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#define MOD (ll)(1e8)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d) \
for (long blockTime = 0; \
(blockTime == 0 ? (blockTime = clock()) != 0 : false); \
debug("%s time : %.4fs\n", d, \
(double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<int, int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
ll gcd(ll a, ll b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
class pointseg {
private:
int n;
vector<ll> t, a;
void upd(int v, int tl, int tr, int pos, ll val) {
if (tl == tr) {
t[v] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm) {
upd(2 * v, tl, tm, pos, val);
} else {
upd(2 * v + 1, tm + 1, tr, pos, val);
}
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
ll query(int v, int l, int r, int tl, int tr) {
if (l > r)
return 0;
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return merge(query(2 * v, l, min(r, tm), tl, tm),
query(2 * v + 1, max(l, tm + 1), r, tm + 1, tr));
}
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
public:
ll merge(ll a, ll b) { return max(a, b); }
void upd(int pos, ll val) { upd(1, 1, n, pos, val); }
ll query(int l, int r) { return query(1, l, r, 1, n); }
void build() { build(1, 1, n); }
pointseg(int _n, vector<ll> _a = {}) {
n = _n;
t.assign(4 * (n + 4), 0);
a = _a;
}
pointseg() {}
void reset(int _n, vector<ll> _a = {}) {
n = _n;
t.clear();
t.assign(4 * (_n + 4), 0);
a.clear();
a = _a;
}
};
int main() {
owo ll n, k;
cin >> n >> k;
vector<ll> a(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]++;
}
ll ans = 1;
pointseg s(400000);
for (int i = 0; i < n; i++) {
ll l = max(1LL, a[i] - k);
ll r = min(ll(300001), a[i] + k);
ll res = s.query(l, r);
ll now = s.query(a[i], a[i]);
if (res + 1 > now)
s.upd(a[i], res + 1);
ans = max(ans, now);
ans = max(ans, res + 1);
}
cout << ans;
}
| replace | 102 | 103 | 102 | 103 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <set>
// #include <vector>
// #include <ostream>
// #include <atcoder/notall>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using VD = vector<double>;
using VS = vector<string>;
using VB = vector<bool>;
using VVB = vector<vector<bool>>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using VVD = vector<VD>;
using PII = std::pair<int, int>;
using VPII = std::vector<std::pair<int, int>>;
using PLL = std::pair<ll, ll>;
using VPLL = std::vector<std::pair<ll, ll>>;
using TI3 = std::tuple<int, int, int>;
using TI4 = std::tuple<int, int, int, int>;
using TL3 = std::tuple<ll, ll, ll>;
using TL4 = std::tuple<ll, ll, ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, s, n, d) for (int i = (s); i < (int)(n); i += (d))
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
#define allpt_cr(v) (v).crbegin(), (v).crend()
const int mod1 = 1e9 + 7, mod2 = 998244353, mod3 = 1e9 + 9;
const int mod = mod1;
const ll inf = 1e18;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
const string alphabets = "abcdefghijklmnopqrstuvwxyz";
template <typename T> void show1dvec(const vector<T> &v) {
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n] << rt;
return;
}
void show2dvec(const vector<string> &v) {
int n = v.size();
rep(i, n) cout << v[i] << rt;
}
template <typename T> void show2dvec(const vector<vector<T>> &v) {
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T> void range_sort(vector<T> &arr, int l, int r) {
sort(arr.begin() + l, arr.begin() + r);
}
template <typename T, typename S> void show1dpair(const vector<pair<T, S>> &v) {
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s) {
int n = v.size();
rep(i, n) {
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T> void maxvec(vector<T> &v) {
T s = v[0];
int n = v.size();
rep(i, n - 1) {
if (s > v[i + 1]) {
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S> bool myfind(T t, S s) {
return find(t.cbegin(), t.cend(), s) != t.cend();
}
bool check(int y, int x, int h, int w) {
return 0 <= y && y < h && 0 <= x && x < w;
}
bool iskadomatsu(int a, int b, int c) {
return (a != b && b != c && c != a) && ((a > b && b < c) || (a < b && b > c));
}
double euc_dist(PII a, PII b) {
return sqrt(pow(a.first - b.first, 2) + pow(a.second - b.second, 2));
}
VS split(string s, char c) {
VS ret;
string part;
s += c;
rep(i, s.length()) {
if (s[i] == c) {
if (part != "")
ret.emplace_back(part);
part = "";
} else if (s[i] != c) {
part += s[i];
}
}
return ret;
}
template <typename T, typename S, typename R>
ll pow_mod(T p, S q, R mod = 1ll) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r, ret %= mod;
r = (r * r) % mod, q /= 2;
}
return ret % mod;
}
template <typename T, typename S> ll pow_no_mod(T p, S q) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r;
r = (r * r), q /= 2;
}
return ret;
}
void make_frac_tables(VL &frac_list, VL &frac_inv_list) {
rep(i, frac_list.size() - 1) {
frac_list[i + 1] *= frac_list[i] * (i + 1);
frac_list[i + 1] %= mod;
frac_inv_list[i + 1] *= frac_inv_list[i] * pow_mod(i + 1, mod - 2, mod);
frac_inv_list[i + 1] %= mod;
}
}
pair<VL, VL> make_frac_tables(int n) {
VL frac_list(n + 1, 1), frac_inv_list(n + 1, 1);
rep(i, n) {
frac_list[i + 1] *= frac_list[i] * (i + 1);
frac_list[i + 1] %= mod;
frac_inv_list[i + 1] *= frac_inv_list[i] * pow_mod(i + 1, mod - 2, mod);
frac_inv_list[i + 1] %= mod;
}
return make_pair(frac_list, frac_inv_list);
}
ll comb(int a, int b, const VL &frac_list, const VL &frac_inv_list) {
if (a < b)
return 0;
if (b < 0)
return 0;
ll ret = frac_list[a];
ret *= frac_inv_list[b];
ret %= mod;
ret *= frac_inv_list[a - b];
ret %= mod;
return ret;
}
struct vec2d {
ll x;
ll y;
vec2d(ll _x, ll _y) {
x = _x;
y = _y;
}
ll dot(vec2d p) { return x * p.x + y * p.y; }
vec2d diff(vec2d p) { return vec2d(x - p.x, y - p.y); }
};
// void djkstra(int n, vector<vec2d> point_list, const VVL cost_list,
// const VVI &connect) {
// const ll llm = 1e18;
// VVL min_cost(n, VL(n, llm));
// min_cost[0][0] = 0;
// vector<PII> search = {make_pair(0, 0)};
// vector<PII> new_search;
// while (!search.empty()) {
// for (auto [p, q] : search) {
// for (auto r : connect[p]) {
// if (point_list[r]
// .diff(point_list[p])
// .dot(point_list[q].diff(point_list[p])) <= 0 &&
// min_cost[r][p] > cost_list[r][p] + min_cost[p][q]) {
// min_cost[r][p] = cost_list[r][p] + min_cost[p][q];
// new_search.emplace_back(make_pair(r, p));
// }
// }
// }
// search.clear();
// search = new_search;
// new_search.clear();
// // show1dvec(search);
// // show1dvec(shortest);
// }
// auto ans = *min_element(allpt_c(min_cost[1]));
// cout << ((ans == llm) ? -1 : ans) << rt;
// // show2dvec(min_cost);
// }
struct node {
int parent = -1;
ll weight = 0;
int depth = 0;
int subtree = 0;
VPII children;
VPII connect;
node(int n) {
parent = -1;
weight = 0;
depth = 0;
subtree = 0;
children;
connect;
}
};
struct graph {
int _n;
int root = 0;
vector<node> nodes;
graph(int n) {
_n = n;
rep(i, _n) nodes.emplace_back(node(_n));
}
void getconnect1() {
int a, b;
cin >> a >> b;
a--, b--;
nodes[a].connect.emplace_back(b, 0);
nodes[b].connect.emplace_back(a, 0);
}
void getconnect2() {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
nodes[a].connect.emplace_back(b, c);
nodes[b].connect.emplace_back(a, c);
}
void showparent() {
rep(i, _n - 1) cout << nodes[i].parent << wsp;
cout << nodes[_n - 1].parent << rt;
}
void showweight() {
rep(i, _n - 1) cout << nodes[i].weight << wsp;
cout << nodes[_n - 1].weight << rt;
}
void showsubtree() {
rep(i, _n - 1) cout << nodes[i].subtree << wsp;
cout << nodes[_n - 1].subtree << rt;
}
void showdepth() {
rep(i, _n - 1) cout << nodes[i].depth << wsp;
cout << nodes[_n - 1].depth << rt;
}
};
struct point {
int x;
int y;
point() {
x = 0;
y = 0;
}
point(int _x, int _y) {
x = _x;
y = _y;
}
void pointinput() {
int _x, _y;
cin >> _x >> _y;
x = _x;
y = _y;
}
void pointinv() { swap(x, y); }
};
double pointseuc(point a, point b) {
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
double dist_segment_point(TL3 segment, point p) {
double a = get<0>(segment);
double b = get<1>(segment);
double c = get<2>(segment);
return abs(a * p.x + b * p.y - c) / (a * a + b * b + c * c);
}
TL3 segment_parameter(point p, point q) {
ll a, b, c;
a = q.y - p.y;
b = p.x - q.x;
c = a * p.x + b * p.y;
TL3 ret = (TL3){a, b, c};
// cout << a << b << c << rt;
return ret;
}
int cross_check(TL3 segment, point p) {
ll a = get<0>(segment);
ll b = get<1>(segment);
ll c = get<2>(segment);
auto f = a * p.x + b * p.y - c;
int ret;
if (f > 0)
ret = 1;
if (f == 0)
ret = 0;
if (f < 0)
ret = -1;
return ret;
}
template <typename T>
class RangeMinorMaxorSumQuery // 0-index
{
int const intmax = 1147483647;
int const intmin = 0;
vector<T> sgt;
int n;
int k;
public:
RangeMinorMaxorSumQuery(int n1, int f = -1) {
if (f == -1)
f = -1;
else if (f == 0)
f = intmin;
int na = 1;
int ka = 0;
while (na < n1) {
na *= 2;
ka++;
}
for (int i = 0; i < 2 * na; i++)
sgt.push_back(f);
n = na;
k = ka;
}
void update_min(int i, int x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = min(sgt[2 * i], sgt[2 * i + 1]);
}
}
void update_max(int i, T x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = max(sgt[2 * i], sgt[2 * i + 1]);
}
}
void update_sum(int i, T x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = sgt[2 * i] + sgt[2 * i + 1];
}
}
void add_sum(int i, T x) {
i += n;
sgt[i] += x;
while (i > 1) {
i /= 2;
sgt[i] = sgt[2 * i] + sgt[2 * i + 1];
}
}
T getmin(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmax;
if (a == l && b == r)
return sgt[k];
else
return min(getmin(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2),
getmin(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r));
}
T getmax(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmin;
if (a == l && b == r)
return sgt[k];
else
return max(getmax(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2),
getmax(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r));
}
T getsum(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmin;
if (a == l && b == r)
return sgt[k];
else
return getsum(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2) +
getsum(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r);
}
T operator[](int i) { return sgt[i + n]; }
void printsegtree() {
for (int i = 0; i < 2 * n; i++) {
cout << sgt[i] << " ";
}
cout << endl;
}
};
class Unionfind {
vector<int> p;
public:
int find(int x);
void unite(int x, int y);
bool isunion(int x, int y);
Unionfind(int n);
void showtree();
};
Unionfind::Unionfind(int n) {
for (int i = 0; i < n; i++) {
p.push_back(i);
}
}
int Unionfind::find(int x) {
while (p[x] != x) {
p[x] = p[p[x]];
x = p[x];
}
return x;
}
void Unionfind::unite(int x, int y) {
x = Unionfind::find(x);
y = Unionfind::find(y);
if (x != y) {
p[x] = y;
}
}
bool Unionfind::isunion(int x, int y) {
return Unionfind::find(x) == Unionfind::find(y);
}
void Unionfind::showtree() {
for (int i = 0; i < p.size() - 1; i++) {
cout << p[i] << " ";
}
cout << p[p.size() - 1] << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// リアクティブ問題のときはコメントアウト
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt"); // for debug
cin.rdbuf(in.rdbuf()); // for debug
#endif
int n, k, a, b;
const int m = 400000;
cin >> n >> k;
RangeMinorMaxorSumQuery<int> sgt(m, 0);
rep(i, n) {
cin >> a;
b = sgt.getmax(max(0, a - k), a + k + 1);
sgt.update_max(a, b + 1);
}
cout << sgt.getmax(0, m) << rt;
return 0;
}
| #include <bits/stdc++.h>
// #include <set>
// #include <vector>
// #include <ostream>
// #include <atcoder/notall>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using VD = vector<double>;
using VS = vector<string>;
using VB = vector<bool>;
using VVB = vector<vector<bool>>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using VVD = vector<VD>;
using PII = std::pair<int, int>;
using VPII = std::vector<std::pair<int, int>>;
using PLL = std::pair<ll, ll>;
using VPLL = std::vector<std::pair<ll, ll>>;
using TI3 = std::tuple<int, int, int>;
using TI4 = std::tuple<int, int, int, int>;
using TL3 = std::tuple<ll, ll, ll>;
using TL4 = std::tuple<ll, ll, ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, s, n, d) for (int i = (s); i < (int)(n); i += (d))
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
#define allpt_cr(v) (v).crbegin(), (v).crend()
const int mod1 = 1e9 + 7, mod2 = 998244353, mod3 = 1e9 + 9;
const int mod = mod1;
const ll inf = 1e18;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
const string alphabets = "abcdefghijklmnopqrstuvwxyz";
template <typename T> void show1dvec(const vector<T> &v) {
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n] << rt;
return;
}
void show2dvec(const vector<string> &v) {
int n = v.size();
rep(i, n) cout << v[i] << rt;
}
template <typename T> void show2dvec(const vector<vector<T>> &v) {
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T> void range_sort(vector<T> &arr, int l, int r) {
sort(arr.begin() + l, arr.begin() + r);
}
template <typename T, typename S> void show1dpair(const vector<pair<T, S>> &v) {
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s) {
int n = v.size();
rep(i, n) {
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T> void maxvec(vector<T> &v) {
T s = v[0];
int n = v.size();
rep(i, n - 1) {
if (s > v[i + 1]) {
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S> bool myfind(T t, S s) {
return find(t.cbegin(), t.cend(), s) != t.cend();
}
bool check(int y, int x, int h, int w) {
return 0 <= y && y < h && 0 <= x && x < w;
}
bool iskadomatsu(int a, int b, int c) {
return (a != b && b != c && c != a) && ((a > b && b < c) || (a < b && b > c));
}
double euc_dist(PII a, PII b) {
return sqrt(pow(a.first - b.first, 2) + pow(a.second - b.second, 2));
}
VS split(string s, char c) {
VS ret;
string part;
s += c;
rep(i, s.length()) {
if (s[i] == c) {
if (part != "")
ret.emplace_back(part);
part = "";
} else if (s[i] != c) {
part += s[i];
}
}
return ret;
}
template <typename T, typename S, typename R>
ll pow_mod(T p, S q, R mod = 1ll) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r, ret %= mod;
r = (r * r) % mod, q /= 2;
}
return ret % mod;
}
template <typename T, typename S> ll pow_no_mod(T p, S q) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r;
r = (r * r), q /= 2;
}
return ret;
}
void make_frac_tables(VL &frac_list, VL &frac_inv_list) {
rep(i, frac_list.size() - 1) {
frac_list[i + 1] *= frac_list[i] * (i + 1);
frac_list[i + 1] %= mod;
frac_inv_list[i + 1] *= frac_inv_list[i] * pow_mod(i + 1, mod - 2, mod);
frac_inv_list[i + 1] %= mod;
}
}
pair<VL, VL> make_frac_tables(int n) {
VL frac_list(n + 1, 1), frac_inv_list(n + 1, 1);
rep(i, n) {
frac_list[i + 1] *= frac_list[i] * (i + 1);
frac_list[i + 1] %= mod;
frac_inv_list[i + 1] *= frac_inv_list[i] * pow_mod(i + 1, mod - 2, mod);
frac_inv_list[i + 1] %= mod;
}
return make_pair(frac_list, frac_inv_list);
}
ll comb(int a, int b, const VL &frac_list, const VL &frac_inv_list) {
if (a < b)
return 0;
if (b < 0)
return 0;
ll ret = frac_list[a];
ret *= frac_inv_list[b];
ret %= mod;
ret *= frac_inv_list[a - b];
ret %= mod;
return ret;
}
struct vec2d {
ll x;
ll y;
vec2d(ll _x, ll _y) {
x = _x;
y = _y;
}
ll dot(vec2d p) { return x * p.x + y * p.y; }
vec2d diff(vec2d p) { return vec2d(x - p.x, y - p.y); }
};
// void djkstra(int n, vector<vec2d> point_list, const VVL cost_list,
// const VVI &connect) {
// const ll llm = 1e18;
// VVL min_cost(n, VL(n, llm));
// min_cost[0][0] = 0;
// vector<PII> search = {make_pair(0, 0)};
// vector<PII> new_search;
// while (!search.empty()) {
// for (auto [p, q] : search) {
// for (auto r : connect[p]) {
// if (point_list[r]
// .diff(point_list[p])
// .dot(point_list[q].diff(point_list[p])) <= 0 &&
// min_cost[r][p] > cost_list[r][p] + min_cost[p][q]) {
// min_cost[r][p] = cost_list[r][p] + min_cost[p][q];
// new_search.emplace_back(make_pair(r, p));
// }
// }
// }
// search.clear();
// search = new_search;
// new_search.clear();
// // show1dvec(search);
// // show1dvec(shortest);
// }
// auto ans = *min_element(allpt_c(min_cost[1]));
// cout << ((ans == llm) ? -1 : ans) << rt;
// // show2dvec(min_cost);
// }
struct node {
int parent = -1;
ll weight = 0;
int depth = 0;
int subtree = 0;
VPII children;
VPII connect;
node(int n) {
parent = -1;
weight = 0;
depth = 0;
subtree = 0;
children;
connect;
}
};
struct graph {
int _n;
int root = 0;
vector<node> nodes;
graph(int n) {
_n = n;
rep(i, _n) nodes.emplace_back(node(_n));
}
void getconnect1() {
int a, b;
cin >> a >> b;
a--, b--;
nodes[a].connect.emplace_back(b, 0);
nodes[b].connect.emplace_back(a, 0);
}
void getconnect2() {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
nodes[a].connect.emplace_back(b, c);
nodes[b].connect.emplace_back(a, c);
}
void showparent() {
rep(i, _n - 1) cout << nodes[i].parent << wsp;
cout << nodes[_n - 1].parent << rt;
}
void showweight() {
rep(i, _n - 1) cout << nodes[i].weight << wsp;
cout << nodes[_n - 1].weight << rt;
}
void showsubtree() {
rep(i, _n - 1) cout << nodes[i].subtree << wsp;
cout << nodes[_n - 1].subtree << rt;
}
void showdepth() {
rep(i, _n - 1) cout << nodes[i].depth << wsp;
cout << nodes[_n - 1].depth << rt;
}
};
struct point {
int x;
int y;
point() {
x = 0;
y = 0;
}
point(int _x, int _y) {
x = _x;
y = _y;
}
void pointinput() {
int _x, _y;
cin >> _x >> _y;
x = _x;
y = _y;
}
void pointinv() { swap(x, y); }
};
double pointseuc(point a, point b) {
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
double dist_segment_point(TL3 segment, point p) {
double a = get<0>(segment);
double b = get<1>(segment);
double c = get<2>(segment);
return abs(a * p.x + b * p.y - c) / (a * a + b * b + c * c);
}
TL3 segment_parameter(point p, point q) {
ll a, b, c;
a = q.y - p.y;
b = p.x - q.x;
c = a * p.x + b * p.y;
TL3 ret = (TL3){a, b, c};
// cout << a << b << c << rt;
return ret;
}
int cross_check(TL3 segment, point p) {
ll a = get<0>(segment);
ll b = get<1>(segment);
ll c = get<2>(segment);
auto f = a * p.x + b * p.y - c;
int ret;
if (f > 0)
ret = 1;
if (f == 0)
ret = 0;
if (f < 0)
ret = -1;
return ret;
}
template <typename T>
class RangeMinorMaxorSumQuery // 0-index
{
int const intmax = 1147483647;
int const intmin = 0;
vector<T> sgt;
int n;
int k;
public:
RangeMinorMaxorSumQuery(int n1, int f = -1) {
if (f == -1)
f = -1;
else if (f == 0)
f = intmin;
int na = 1;
int ka = 0;
while (na < n1) {
na *= 2;
ka++;
}
for (int i = 0; i < 2 * na; i++)
sgt.push_back(f);
n = na;
k = ka;
}
void update_min(int i, int x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = min(sgt[2 * i], sgt[2 * i + 1]);
}
}
void update_max(int i, T x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = max(sgt[2 * i], sgt[2 * i + 1]);
}
}
void update_sum(int i, T x) {
i += n;
sgt[i] = x;
while (i > 1) {
i /= 2;
sgt[i] = sgt[2 * i] + sgt[2 * i + 1];
}
}
void add_sum(int i, T x) {
i += n;
sgt[i] += x;
while (i > 1) {
i /= 2;
sgt[i] = sgt[2 * i] + sgt[2 * i + 1];
}
}
T getmin(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmax;
if (a == l && b == r)
return sgt[k];
else
return min(getmin(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2),
getmin(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r));
}
T getmax(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmin;
if (a == l && b == r)
return sgt[k];
else
return max(getmax(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2),
getmax(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r));
}
T getsum(int a, int b, int k = 1, int l = 0,
int r = -1) // 閉区間 l <= x < r とする
{
if (r == -1)
r = n;
if (r <= a || b <= l)
return intmin;
if (a == l && b == r)
return sgt[k];
else
return getsum(a, min(b, (l + r) / 2), 2 * k, l, (l + r) / 2) +
getsum(max(a, (l + r) / 2), b, 2 * k + 1, (l + r) / 2, r);
}
T operator[](int i) { return sgt[i + n]; }
void printsegtree() {
for (int i = 0; i < 2 * n; i++) {
cout << sgt[i] << " ";
}
cout << endl;
}
};
class Unionfind {
vector<int> p;
public:
int find(int x);
void unite(int x, int y);
bool isunion(int x, int y);
Unionfind(int n);
void showtree();
};
Unionfind::Unionfind(int n) {
for (int i = 0; i < n; i++) {
p.push_back(i);
}
}
int Unionfind::find(int x) {
while (p[x] != x) {
p[x] = p[p[x]];
x = p[x];
}
return x;
}
void Unionfind::unite(int x, int y) {
x = Unionfind::find(x);
y = Unionfind::find(y);
if (x != y) {
p[x] = y;
}
}
bool Unionfind::isunion(int x, int y) {
return Unionfind::find(x) == Unionfind::find(y);
}
void Unionfind::showtree() {
for (int i = 0; i < p.size() - 1; i++) {
cout << p[i] << " ";
}
cout << p[p.size() - 1] << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// リアクティブ問題のときはコメントアウト
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt"); // for debug
cin.rdbuf(in.rdbuf()); // for debug
#endif
int n, k, a, b;
const int m = 400000;
cin >> n >> k;
RangeMinorMaxorSumQuery<int> sgt(m, 0);
rep(i, n) {
cin >> a;
b = sgt.getmax(max(0, a - k), min(m, a + k + 1));
sgt.update_max(a, b + 1);
}
cout << sgt.getmax(0, m) << rt;
return 0;
}
| replace | 507 | 508 | 507 | 508 | 0 | |
p02537 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long LL;
#define N 100010
struct Data {
LL val, idx;
};
LL a[N], c[N], q[N];
LL Maxn[N * 4];
Data b[N];
int n;
LL ans, d;
bool cmp(Data x, Data y) { return (x.val < y.val); }
void update(int o, int l, int r, int x, LL v) {
if (l == x && r == x) {
Maxn[o] = v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(o * 2, l, mid, x, v);
if (x > mid)
update(o * 2 + 1, mid + 1, r, x, v);
Maxn[o] = max(Maxn[o * 2], Maxn[o * 2 + 1]);
}
void query(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
ans = max(Maxn[o], ans);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
query(o * 2, l, mid, x, y);
if (y > mid)
query(o * 2 + 1, mid + 1, r, x, y);
}
int main() {
cin >> n >> d;
memset(Maxn, 0, sizeof(Maxn));
memset(q, 0, sizeof(q));
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].val = a[i];
b[i].idx = i;
}
sort(b, b + n, cmp);
for (int i = 0; i < n; i++) {
c[i] = b[i].val;
q[b[i].idx] = i;
}
LL tot = 1;
for (int i = 0; i < n; i++) {
LL l = a[i] - d, r = a[i] + d;
int ll = lower_bound(c, c + n, l) - c;
int rr = upper_bound(c, c + n, r) - c - 1;
ans = 0;
query(1, 0, n - 1, ll, rr);
if (ans == 0)
update(1, 0, n - 1, q[i], 1);
else {
update(1, 0, n - 1, q[i], ans + 1);
if (ans + 1 > tot)
tot = ans + 1;
}
}
cout << tot << endl;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long LL;
#define N 1000010
struct Data {
LL val, idx;
};
LL a[N], c[N], q[N];
LL Maxn[N * 4];
Data b[N];
int n;
LL ans, d;
bool cmp(Data x, Data y) { return (x.val < y.val); }
void update(int o, int l, int r, int x, LL v) {
if (l == x && r == x) {
Maxn[o] = v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(o * 2, l, mid, x, v);
if (x > mid)
update(o * 2 + 1, mid + 1, r, x, v);
Maxn[o] = max(Maxn[o * 2], Maxn[o * 2 + 1]);
}
void query(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
ans = max(Maxn[o], ans);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
query(o * 2, l, mid, x, y);
if (y > mid)
query(o * 2 + 1, mid + 1, r, x, y);
}
int main() {
cin >> n >> d;
memset(Maxn, 0, sizeof(Maxn));
memset(q, 0, sizeof(q));
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].val = a[i];
b[i].idx = i;
}
sort(b, b + n, cmp);
for (int i = 0; i < n; i++) {
c[i] = b[i].val;
q[b[i].idx] = i;
}
LL tot = 1;
for (int i = 0; i < n; i++) {
LL l = a[i] - d, r = a[i] + d;
int ll = lower_bound(c, c + n, l) - c;
int rr = upper_bound(c, c + n, r) - c - 1;
ans = 0;
query(1, 0, n - 1, ll, rr);
if (ans == 0)
update(1, 0, n - 1, q[i], 1);
else {
update(1, 0, n - 1, q[i], ans + 1);
if (ans + 1 > tot)
tot = ans + 1;
}
}
cout << tot << endl;
return 0;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007LL;
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
//_______________________________________________________________________________
const int N = 300005;
int seg[2 * N];
int a[N];
int dp[N];
void build(int ind, int rl, int rr) {
if (rl == rr) {
seg[ind] = a[rr];
return;
}
int mid = (rl + rr) / 2;
build(2 * ind, rl, mid);
build((2 * ind) + 1, mid + 1, rr);
seg[ind] = max(seg[2 * ind], seg[(2 * ind) + 1]);
}
void update(int ind, int idx, int val, int rl, int rr) {
if (rl == rr) {
seg[ind] = val;
// a[idx] = val;
return;
}
int mid = (rl + rr) / 2;
if (idx >= rl && idx <= mid) {
update(2 * ind, idx, val, rl, mid);
} else {
update((2 * ind) + 1, idx, val, mid + 1, rr);
}
seg[ind] = max(seg[2 * ind], seg[(2 * ind) + 1]);
}
int query(int ind, int ql, int qr, int rl, int rr) {
if (ql > rr || rl > qr) {
return -1;
}
if (rr <= qr && rl >= ql) {
return seg[ind];
}
int mid = (rl + rr) / 2;
return max(query(2 * ind, ql, qr, rl, mid),
query((2 * ind) + 1, ql, qr, mid + 1, rr));
}
int main() {
int n, k;
cin >> n >> k;
memset(dp, 0, sizeof dp);
memset(seg, 0, sizeof seg);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
int mn = max(a[i] - k, 0);
int mx = min(a[i] + k, 300002);
dp[a[i]] = max(dp[a[i]], query(1, mn, mx, 0, 300002) + 1);
// cout<<a[i]<<" "<<query(1,mn,mx,0,300002)<<endl;
update(1, a[i], dp[a[i]], 0, 300002);
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[a[i]]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007LL;
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
//_______________________________________________________________________________
const int N = 300005;
int seg[4 * N];
int a[N];
int dp[N];
void build(int ind, int rl, int rr) {
if (rl == rr) {
seg[ind] = a[rr];
return;
}
int mid = (rl + rr) / 2;
build(2 * ind, rl, mid);
build((2 * ind) + 1, mid + 1, rr);
seg[ind] = max(seg[2 * ind], seg[(2 * ind) + 1]);
}
void update(int ind, int idx, int val, int rl, int rr) {
if (rl == rr) {
seg[ind] = val;
// a[idx] = val;
return;
}
int mid = (rl + rr) / 2;
if (idx >= rl && idx <= mid) {
update(2 * ind, idx, val, rl, mid);
} else {
update((2 * ind) + 1, idx, val, mid + 1, rr);
}
seg[ind] = max(seg[2 * ind], seg[(2 * ind) + 1]);
}
int query(int ind, int ql, int qr, int rl, int rr) {
if (ql > rr || rl > qr) {
return -1;
}
if (rr <= qr && rl >= ql) {
return seg[ind];
}
int mid = (rl + rr) / 2;
return max(query(2 * ind, ql, qr, rl, mid),
query((2 * ind) + 1, ql, qr, mid + 1, rr));
}
int main() {
int n, k;
cin >> n >> k;
memset(dp, 0, sizeof dp);
memset(seg, 0, sizeof seg);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
int mn = max(a[i] - k, 0);
int mx = min(a[i] + k, 300002);
dp[a[i]] = max(dp[a[i]], query(1, mn, mx, 0, 300002) + 1);
// cout<<a[i]<<" "<<query(1,mn,mx,0,300002)<<endl;
update(1, a[i], dp[a[i]], 0, 300002);
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[a[i]]);
}
cout << ans << endl;
}
| replace | 9 | 10 | 9 | 10 | 0 | |
p02537 | C++ | Runtime Error | /*
Created by Rahul Goel.
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
/*******************************************************************************/
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
/*******************************************************************************/
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
const int INF = 1e9;
const ll LINF = 1e18;
/*******************************************************************************/
ll mod_sum() { return 0LL; }
template <typename T, typename... Args> T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % MOD + MOD) % MOD;
}
/*******************************************************************************/
ll mod_prod() { return 1LL; }
template <typename T, typename... Args> T mod_prod(T a, Args... args) {
return (a * mod_prod(args...)) % MOD;
}
/*******************************************************************************/
#ifdef ONLINE_JUDGE
#define endl '\n'
#endif
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define all(c) (c).begin(), (c).end()
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define uniq(c) (c).resize(distance((c).begin(), unique(all(c))))
#define min_pq(t) priority_queue<t, vector<t>, greater<t>>
#define max_pq(t) priority_queue<t>
#define pb push_back
#define ff first
#define ss second
/*******************************************************************************/
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vpii = vector<pii>;
using vvpii = vector<vector<pii>>;
/*******************************************************************************/
//.-.. . -. -.- .- .. ... .-.. --- ...- .
/*
Code begins after this.
*/
struct SegmentTree {
vi t;
SegmentTree(int n) { t.resize(n << 2); }
void pull(int v) { t[v] = max(t[v << 1], t[v << 1 | 1]); }
void upd(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = val;
return;
}
int tm = (tl + tr) >> 1;
if (pos <= tm) {
upd(v << 1, tl, tm, pos, val);
} else {
upd(v << 1 | 1, tm + 1, tr, pos, val);
}
pull(v);
}
int query(int v, int tl, int tr, int ql, int qr) {
if (ql <= tl && tr <= qr) {
return t[v];
}
int tm = (tl + tr) >> 1;
int ret = -INF;
if (ql <= tm) {
ret = max(ret, query(v << 1, tl, tm, ql, qr));
}
if (tm + 1 <= qr) {
ret = max(ret, query(v << 1 | 1, tm + 1, tr, ql, qr));
}
pull(v);
return ret;
}
};
int solve() {
int n, k;
cin >> n >> k;
SegmentTree st(300005);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int y = st.query(1, 0, n - 1, max(0, x - k), min(300000, x + k));
st.upd(1, 0, n - 1, x, y + 1);
}
int ans = st.query(1, 0, 300005 - 1, 0, 300000);
cout << ans << endl;
return 0;
}
signed main() {
fastio;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| /*
Created by Rahul Goel.
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
/*******************************************************************************/
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
/*******************************************************************************/
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
// const ll MOD = 998244353;
const int INF = 1e9;
const ll LINF = 1e18;
/*******************************************************************************/
ll mod_sum() { return 0LL; }
template <typename T, typename... Args> T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % MOD + MOD) % MOD;
}
/*******************************************************************************/
ll mod_prod() { return 1LL; }
template <typename T, typename... Args> T mod_prod(T a, Args... args) {
return (a * mod_prod(args...)) % MOD;
}
/*******************************************************************************/
#ifdef ONLINE_JUDGE
#define endl '\n'
#endif
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define all(c) (c).begin(), (c).end()
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define uniq(c) (c).resize(distance((c).begin(), unique(all(c))))
#define min_pq(t) priority_queue<t, vector<t>, greater<t>>
#define max_pq(t) priority_queue<t>
#define pb push_back
#define ff first
#define ss second
/*******************************************************************************/
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vpii = vector<pii>;
using vvpii = vector<vector<pii>>;
/*******************************************************************************/
//.-.. . -. -.- .- .. ... .-.. --- ...- .
/*
Code begins after this.
*/
struct SegmentTree {
vi t;
SegmentTree(int n) { t.resize(n << 2); }
void pull(int v) { t[v] = max(t[v << 1], t[v << 1 | 1]); }
void upd(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = val;
return;
}
int tm = (tl + tr) >> 1;
if (pos <= tm) {
upd(v << 1, tl, tm, pos, val);
} else {
upd(v << 1 | 1, tm + 1, tr, pos, val);
}
pull(v);
}
int query(int v, int tl, int tr, int ql, int qr) {
if (ql <= tl && tr <= qr) {
return t[v];
}
int tm = (tl + tr) >> 1;
int ret = -INF;
if (ql <= tm) {
ret = max(ret, query(v << 1, tl, tm, ql, qr));
}
if (tm + 1 <= qr) {
ret = max(ret, query(v << 1 | 1, tm + 1, tr, ql, qr));
}
pull(v);
return ret;
}
};
int solve() {
int n, k;
cin >> n >> k;
SegmentTree st(300005);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int y = st.query(1, 0, 300005 - 1, max(0, x - k), min(300000, x + k));
st.upd(1, 0, 300005 - 1, x, y + 1);
}
int ans = st.query(1, 0, 300005 - 1, 0, 300000);
cout << ans << endl;
return 0;
}
signed main() {
fastio;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| replace | 106 | 108 | 106 | 108 | 0 | |
p02537 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
using namespace std;
ll c[600005] = {0}, tree[1200005] = {0};
ll query(ll ql, ll qr, ll s, ll e, ll in) {
if (ql > e || qr < s || s > e)
return -1;
if (ql <= s && qr >= e) {
return tree[in];
}
int mid = (s + e) / 2;
// cout<<"Okay";
return max(query(ql, qr, s, mid, 2 * in + 1),
query(ql, qr, mid + 1, e, 2 * in + 2));
}
void update(ll s, ll e, ll in, ll key, ll up) {
if (s > e)
return;
if (s == e && s == key) {
tree[in] = up;
return;
} else if (s == e)
return;
ll mid = (s + e) / 2;
update(s, mid, 2 * in + 1, key, up);
update(mid + 1, e, 2 * in + 2, key, up);
tree[in] = max(tree[2 * in + 1], tree[2 * in + 2]);
}
int main() {
ll n, k;
cin >> n >> k;
ll a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
ll ans = 1;
for (int i = 0; i < n; i++) {
ll curr = query(max(0ll, a[i] - k), min(300000ll, a[i] + k), 0, 300000, 0);
// cout<<curr<<endl;
ans = max(ans, curr + 1);
update(0, 300000, 0, a[i], curr + 1);
}
cout << ans;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
using namespace std;
ll c[600005] = {0}, tree[1200005] = {0};
ll query(ll ql, ll qr, ll s, ll e, ll in) {
if (ql > e || qr < s || s > e)
return -1;
if (ql <= s && qr >= e) {
return tree[in];
}
int mid = (s + e) / 2;
// cout<<"Okay";
return max(query(ql, qr, s, mid, 2 * in + 1),
query(ql, qr, mid + 1, e, 2 * in + 2));
}
void update(ll s, ll e, ll in, ll key, ll up) {
if (s > e)
return;
if (s == e && s == key) {
tree[in] = up;
return;
} else if (s == e)
return;
ll mid = (s + e) / 2;
if (mid >= key)
update(s, mid, 2 * in + 1, key, up);
else
update(mid + 1, e, 2 * in + 2, key, up);
tree[in] = max(tree[2 * in + 1], tree[2 * in + 2]);
}
int main() {
ll n, k;
cin >> n >> k;
ll a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
ll ans = 1;
for (int i = 0; i < n; i++) {
ll curr = query(max(0ll, a[i] - k), min(300000ll, a[i] + k), 0, 300000, 0);
// cout<<curr<<endl;
ans = max(ans, curr + 1);
update(0, 300000, 0, a[i], curr + 1);
}
cout << ans;
}
| replace | 29 | 32 | 29 | 33 | TLE | |
p02537 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define NMAX 300005
using namespace std;
typedef long long ll;
ll segmTree[NMAX * 4], l[NMAX * 4], r[NMAX * 4], leaves[NMAX];
void init(size_t nd) {
if (nd == 0)
l[0] = 0, r[0] = NMAX - 1;
else {
if (nd & 1)
l[nd] = l[nd / 2], r[nd] = (l[nd / 2] + r[nd / 2]) / 2;
else
l[nd] = r[nd - 1] + 1, r[nd] = r[nd / 2 - 1];
}
if (l[nd] == r[nd])
leaves[l[nd]] = nd;
else {
init(nd * 2 + 1);
init(nd * 2 + 2);
}
}
void upd(ll p, ll x) {
ll nd = leaves[p];
if (segmTree[nd] >= x)
return;
segmTree[nd] = x;
do {
nd = (nd - 1) / 2;
segmTree[nd] = max(segmTree[nd * 2 + 1], segmTree[nd * 2 + 2]);
} while (nd > 0);
}
ll query(ll L, ll R) {
ll ans = 0;
while (L <= R) {
ll nd = leaves[L];
while (nd > 0 && l[(nd - 1) / 2] >= L && r[(nd - 1) / 2] <= R)
nd = (nd - 1) / 2;
ans = max(ans, segmTree[nd]);
L = r[nd] + 1;
}
return ans;
}
ll dp[NMAX], v[NMAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init(0);
ll n, k, ans = 0;
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = n - 1; i >= 0; i--) {
dp[i] = query(max(0ll, v[i] - k), v[i] + k) + 1;
upd(v[i], dp[i]);
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define NMAX 300005
using namespace std;
typedef long long ll;
ll segmTree[NMAX * 4], l[NMAX * 4], r[NMAX * 4], leaves[NMAX];
void init(size_t nd) {
if (nd == 0)
l[0] = 0, r[0] = NMAX - 1;
else {
if (nd & 1)
l[nd] = l[nd / 2], r[nd] = (l[nd / 2] + r[nd / 2]) / 2;
else
l[nd] = r[nd - 1] + 1, r[nd] = r[nd / 2 - 1];
}
if (l[nd] == r[nd])
leaves[l[nd]] = nd;
else {
init(nd * 2 + 1);
init(nd * 2 + 2);
}
}
void upd(ll p, ll x) {
ll nd = leaves[p];
if (segmTree[nd] >= x)
return;
segmTree[nd] = x;
do {
nd = (nd - 1) / 2;
segmTree[nd] = max(segmTree[nd * 2 + 1], segmTree[nd * 2 + 2]);
} while (nd > 0);
}
ll query(ll L, ll R) {
ll ans = 0;
while (L <= R) {
ll nd = leaves[L];
while (nd > 0 && l[(nd - 1) / 2] >= L && r[(nd - 1) / 2] <= R)
nd = (nd - 1) / 2;
ans = max(ans, segmTree[nd]);
L = r[nd] + 1;
}
return ans;
}
ll dp[NMAX], v[NMAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init(0);
ll n, k, ans = 0;
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = n - 1; i >= 0; i--) {
dp[i] = query(max(0ll, v[i] - k), min((ll)NMAX - 1, v[i] + k)) + 1;
upd(v[i], dp[i]);
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
| replace | 53 | 54 | 53 | 54 | TLE | |
p02537 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
vector<int> sgt;
int sz{1};
void g() {
while (sz < 3e4)
sz *= 2;
sgt.resize(2 * sz);
}
int f(int l, int r) {
int ans{};
l += sz, r += sz;
while (l <= r) {
if (l & 1)
ans = max(ans, sgt[l++]);
if (!(r & 1))
ans = max(ans, sgt[r--]);
l /= 2, r /= 2;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
g();
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++) {
int z = f(max(0, a[i] - k), min(300000, a[i] + k));
// cout << z << endl;
a[i] += sz;
sgt[a[i]] = z + 1;
a[i] /= 2;
while (a[i]) {
sgt[a[i]] = max(sgt[2 * a[i]], sgt[2 * a[i] + 1]);
a[i] /= 2;
}
}
cout << sgt[1];
} | #include "bits/stdc++.h"
using namespace std;
vector<int> sgt;
int sz{1};
void g() {
while (sz < 3e5)
sz *= 2;
sgt.resize(2 * sz);
}
int f(int l, int r) {
int ans{};
l += sz, r += sz;
while (l <= r) {
if (l & 1)
ans = max(ans, sgt[l++]);
if (!(r & 1))
ans = max(ans, sgt[r--]);
l /= 2, r /= 2;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
g();
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++) {
int z = f(max(0, a[i] - k), min(300000, a[i] + k));
// cout << z << endl;
a[i] += sz;
sgt[a[i]] = z + 1;
a[i] /= 2;
while (a[i]) {
sgt[a[i]] = max(sgt[2 * a[i]], sgt[2 * a[i] + 1]);
a[i] /= 2;
}
}
cout << sgt[1];
} | replace | 7 | 8 | 7 | 8 | 0 | |
p02537 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long int
#define lld long double
#define pb push_back
#define pii pair<ll, ll>
#define mi map<ll, ll>
#define vec vector<ll>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repi(i, a, b) for (ll i = a; i <= b; i++)
#define per(i, a, b) for (ll i = a; i >= b; i--)
#define mp make_pair
#define mit map<ll, ll>::iterator
#define sit set<ll>::iterator
#define pit pair<ll, ll>::iterator
#define xxx exit(0);
#define tr(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
using namespace std;
ll xo(ll x, ll y) { return (x | y) & (~x | ~y); }
ll bin_Expo(ll x, ll n) {
if (x == 0)
return 0;
if (n == 0)
return 1;
else if (n % 2 == 0) // n is even
return bin_Expo(x * x, n / 2);
else // n is odd
return x * bin_Expo(x * x, (n - 1) / 2);
}
ll mod_Expo(ll x, ll n, ll M) {
if (x == 0)
return 0;
if (n == 0)
return 1;
else if (n % 2 == 0) // n is even
return mod_Expo((x * x) % M, n / 2, M);
else // n is odd
return (x * mod_Expo((x * x) % M, (n - 1) / 2, M)) % M;
}
bool prime_check(ll x) {
bool prime = (x >= 2);
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime = false;
break;
}
}
return prime;
}
ll logg(ll base, ll x) { return (ll)(log(x) / log(base)); }
ll a[300005], dp[300005], n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
// cin>>TESTS;
while (TESTS--) {
ll m, i, j, l, h, w, q, ans, x, y;
cin >> n >> k;
rep(i, 0, n) cin >> a[i], dp[i] = 1;
x = 1;
rep(i, 1, n) {
rep(j, 0, i) {
if (abs(a[i] - a[j]) <= k)
dp[i] = max(dp[i], dp[j] + 1);
}
x = max(x, dp[i]);
}
cout << x;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
#define lld long double
#define pb push_back
#define pii pair<ll, ll>
#define mi map<ll, ll>
#define vec vector<ll>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repi(i, a, b) for (ll i = a; i <= b; i++)
#define per(i, a, b) for (ll i = a; i >= b; i--)
#define mp make_pair
#define mit map<ll, ll>::iterator
#define sit set<ll>::iterator
#define pit pair<ll, ll>::iterator
#define xxx exit(0);
#define tr(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
using namespace std;
ll xo(ll x, ll y) { return (x | y) & (~x | ~y); }
ll bin_Expo(ll x, ll n) {
if (x == 0)
return 0;
if (n == 0)
return 1;
else if (n % 2 == 0) // n is even
return bin_Expo(x * x, n / 2);
else // n is odd
return x * bin_Expo(x * x, (n - 1) / 2);
}
ll mod_Expo(ll x, ll n, ll M) {
if (x == 0)
return 0;
if (n == 0)
return 1;
else if (n % 2 == 0) // n is even
return mod_Expo((x * x) % M, n / 2, M);
else // n is odd
return (x * mod_Expo((x * x) % M, (n - 1) / 2, M)) % M;
}
bool prime_check(ll x) {
bool prime = (x >= 2);
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime = false;
break;
}
}
return prime;
}
ll logg(ll base, ll x) { return (ll)(log(x) / log(base)); }
ll a[300005], dp[300005], n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
// cin>>TESTS;
while (TESTS--) {
ll m, i, j, l, h, w, q, ans, x, y;
cin >> n >> k;
rep(i, 0, n) cin >> a[i], dp[i] = 1;
x = 1;
rep(i, 1, n) {
for (j = i - 1; j >= 0 && i - j <= 100; j--) {
if (abs(a[i] - a[j]) <= k)
dp[i] = max(dp[i], dp[j] + 1);
}
x = max(x, dp[i]);
}
cout << x;
}
return 0;
} | replace | 68 | 69 | 68 | 69 | TLE | |
p02537 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, k, a[N], f[N << 2];
void pushup(int o) { f[o] = max(f[o << 1], f[o << 1 | 1]); }
int ask(int l, int r, int o, int ld, int rd) {
if (l == r)
return f[o];
int mid = l + r >> 1, ans = 0;
if (rd > mid)
ans = max(ans, ask(mid + 1, r, o << 1 | 1, ld, rd));
if (ld <= mid)
ans = max(ans, ask(l, mid, o << 1, ld, rd));
return ans;
}
void modify(int l, int r, int o, int x, int y) {
if (l == r) {
f[o] = y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, o << 1, x, y);
else
modify(mid + 1, r, o << 1 | 1, x, y);
pushup(o);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), a[i]++;
for (int i = 1; i <= n; i++) {
int x = ask(1, 300001, 1, max(1, a[i] - k), min(300001, a[i] + k)) + 1;
modify(1, 300001, 1, a[i], x);
}
printf("%d\n", f[1]);
} | #include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, k, a[N], f[N << 2];
void pushup(int o) { f[o] = max(f[o << 1], f[o << 1 | 1]); }
int ask(int l, int r, int o, int ld, int rd) {
if (l == r)
return f[o];
if (ld <= l && rd >= r)
return f[o];
int mid = l + r >> 1, ans = 0;
if (rd > mid)
ans = max(ans, ask(mid + 1, r, o << 1 | 1, ld, rd));
if (ld <= mid)
ans = max(ans, ask(l, mid, o << 1, ld, rd));
return ans;
}
void modify(int l, int r, int o, int x, int y) {
if (l == r) {
f[o] = y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, o << 1, x, y);
else
modify(mid + 1, r, o << 1 | 1, x, y);
pushup(o);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), a[i]++;
for (int i = 1; i <= n; i++) {
int x = ask(1, 300001, 1, max(1, a[i] - k), min(300001, a[i] + k)) + 1;
modify(1, 300001, 1, a[i], x);
}
printf("%d\n", f[1]);
} | insert | 8 | 8 | 8 | 10 | TLE | |
p02537 | C++ | Runtime Error | // #pragma GCC optimize ("Ofast")
// #pragma GCC target
// ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define pb push_back
#define all(_obj) _obj.begin(), _obj.end()
#define F first
#define S second
#define INF 1e18
#define pll pair<ll, ll>
#define vll vector<ll>
ll n, m, a, b, c, k, temp, x, y;
const int MAXN = 1e5 + 11, mod = 1e9 + 7;
ll max(ll a, ll b) { return ((a > b) ? a : b); }
ll min(ll a, ll b) { return ((a > b) ? b : a); }
vll read(int n) {
vll v(n);
for (int i = 0; i < v.size(); i++)
cin >> v[i];
return v;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int tree[4 * MAXN];
int qfst(int l, int r) {
int res = 0;
for (l += 300001, r += 300001; l < r; l >>= 1, r >>= 1) {
if (l & 1)
res = max(tree[l++], res);
if (r & 1)
res = max(tree[--r], res);
}
return res;
}
void modify(int p, int value) {
for (tree[p += 300001] = value; p > 1; p >>= 1)
tree[p >> 1] = max(tree[p], tree[p ^ 1]);
}
void sol(void) {
cin >> n >> k;
vll v = read(n);
for (int i = 0; i < n; i++) {
int mx = qfst(v[i], v[i] + 1);
int ending = qfst(max(0, v[i] - k), min(v[i] + k + 1, 300001)) + 1;
modify(v[i], max(mx, ending));
}
cout << qfst(0, 300001);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
// cin>>test;
for (int i = 1; i <= test; i++)
sol();
}
| // #pragma GCC optimize ("Ofast")
// #pragma GCC target
// ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define pb push_back
#define all(_obj) _obj.begin(), _obj.end()
#define F first
#define S second
#define INF 1e18
#define pll pair<ll, ll>
#define vll vector<ll>
ll n, m, a, b, c, k, temp, x, y;
const int MAXN = 1e5 + 11, mod = 1e9 + 7;
ll max(ll a, ll b) { return ((a > b) ? a : b); }
ll min(ll a, ll b) { return ((a > b) ? b : a); }
vll read(int n) {
vll v(n);
for (int i = 0; i < v.size(); i++)
cin >> v[i];
return v;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int tree[6 * MAXN];
int qfst(int l, int r) {
int res = 0;
for (l += 300001, r += 300001; l < r; l >>= 1, r >>= 1) {
if (l & 1)
res = max(tree[l++], res);
if (r & 1)
res = max(tree[--r], res);
}
return res;
}
void modify(int p, int value) {
for (tree[p += 300001] = value; p > 1; p >>= 1)
tree[p >> 1] = max(tree[p], tree[p ^ 1]);
}
void sol(void) {
cin >> n >> k;
vll v = read(n);
for (int i = 0; i < n; i++) {
int mx = qfst(v[i], v[i] + 1);
int ending = qfst(max(0, v[i] - k), min(v[i] + k + 1, 300001)) + 1;
modify(v[i], max(mx, ending));
}
cout << qfst(0, 300001);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
// cin>>test;
for (int i = 1; i <= test; i++)
sol();
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
ll mod2 = 998244353;
ll mod = 1e9 + 7;
vector<int> seg;
vector<int> dp;
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr)
seg[v] = val;
else {
int mid = (tl + tr) / 2;
if (pos <= mid)
update(2 * v, tl, mid, pos, val);
else {
update(2 * v + 1, mid + 1, tr, pos, val);
}
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l)
return 0;
if (tl >= l && tr <= r)
return seg[v];
int mid = (tl + tr) / 2;
return max(get(2 * v, tl, mid, l, r), get(2 * v + 1, mid + 1, tr, l, r));
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i];
int p = *max_element(begin(a), end(a));
seg.resize(p + 6, 0);
int ans = 1;
for (int i = 1; i <= n; i++) {
int val = get(1, 1, p, max(0, a[i] - k), min(p, a[i] + k));
update(1, 1, p, a[i], val + 1);
ans = max(ans, val + 1);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
ll mod2 = 998244353;
ll mod = 1e9 + 7;
vector<int> seg;
vector<int> dp;
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr)
seg[v] = val;
else {
int mid = (tl + tr) / 2;
if (pos <= mid)
update(2 * v, tl, mid, pos, val);
else {
update(2 * v + 1, mid + 1, tr, pos, val);
}
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l)
return 0;
if (tl >= l && tr <= r)
return seg[v];
int mid = (tl + tr) / 2;
return max(get(2 * v, tl, mid, l, r), get(2 * v + 1, mid + 1, tr, l, r));
}
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i];
int p = 3e5;
seg.resize(4 * p, 0);
int ans = 1;
for (int i = 1; i <= n; i++) {
int val = get(1, 1, p, max(0, a[i] - k), min(p, a[i] + k));
update(1, 1, p, a[i], val + 1);
ans = max(ans, val + 1);
}
cout << ans << endl;
} | replace | 34 | 36 | 34 | 36 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define LL long long
#define ULL unsigned long long
const LL INF = 1LL << 59;
const double PI = 2.0 * acos(0.0);
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
typedef vector<int> vi;
typedef vector<LL> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
//// Including Policy Based DS
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
//
/////cout<<*X.find_by_order(1)<<endl;
/////cout<<X.order_of_key(-5)<<endl;
//
// typedef tree<
// int,
// null_type,
// less< int >,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
#define READ freopen("in.txt", "r", stdin)
#define WRITE freopen("out.txt", "w", stdout)
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define sf scanf
#define pf printf
#define F first
#define S second
#define pb push_back
#define NL pf("\n")
#define ALL(v) v.begin(), v.end()
#define si(x) sf("%d", &x);
#define sii(x, y) sf("%d%d", &x, &y);
#define siii(x, y, z) sf("%d%d%d", &x, &y, &z);
#define sl(x) sf("%lld", &x);
#define sll(x, y) sf("%lld%lld", &x, &y);
#define slll(x, y, z) sf("%lld%lld%lld", &x, &y, &z);
#define sqr(x) ((x) * (x))
#define mem(x, y) memset(x, y, sizeof x)
#define ch printf("Came Here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n")
#define deb(x) cerr << #x << " :: " << x << "\n"
#define SV(v) sort(v.begin(), v.end())
#define SVR(v, cmp) sort(v.begin(), v.end(), cmp)
#define FOR(i, n) for (int i = 0; i < n; i++)
#define cnd tree[idx]
#define lc tree[idx * 2]
#define rc tree[idx * 2 + 1]
#define lnd (2 * idx), (b), ((b + e) / 2)
#define rnd ((2 * idx) + 1), (((b + e) / 2) + 1), (e)
// graph direction array [4]
int X[4] = {0, 0, -1, 1};
int Y[4] = {1, -1, 0, 0};
// graph direction array [8]
// int X[8]={0,0,1,-1,-1,1,1,-1};
// int Y[8]={1,-1,0,0,-1,-1,1,1};
// Bishop direction array [8]
// int BX[8]={0,0,1,-1,-1,1,1,-1};
// int BY[8]={1,-1,0,0,-1,-1,1,1};
// Knight Direction Array
// int KX[8] = {1,1,2,2,-1,-1,-2,-2};
// int KY[8] = {2,-2,1,-1,2,-2,1,-1};
// Bit Operations
#define popcountL __builtin_popcountll
#define popcount __builtin_popcount
inline bool checkBit(int N, int pos) {
return (bool)(N & (1 << pos));
} // check bit
inline int setBit(int N, int pos) { return N = N | (1 << pos); } // set bit
inline int unsetBit(int N, int pos) {
return N = (N & (~(1 << pos)));
} // unset bit
inline int toggleBit(int N, int pos) {
return N = (N ^ (1 << pos));
} // toggle bit
inline LL modMul(LL a, LL b, LL mod) {
LL ans = 0;
a = a % mod;
while (b > 0) {
if (b % 2)
ans = (ans % mod + a % mod) % mod;
a = (a % mod * 2 % mod) % mod;
b /= 2;
}
return ans % mod;
}
inline LL powerMod(LL a, LL b, LL mod) {
if (b == 0)
return 1LL % mod;
LL x = powerMod(a, b / 2, mod);
x = (x % mod * x % mod) % mod;
if (b % 2 == 1)
x = (x % mod * a % mod) % mod;
return x % mod;
}
inline LL lcm(LL a, LL b) {
LL g = __gcd(a, b);
return ((a / g) * b);
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
const int mx = 3e5 + 50;
int tree[mx];
void update(int idx, int b, int e, int pos, int v) {
if (b == e && b == pos) {
cnd = max(cnd, v);
return;
}
int mid = (b + e) >> 1;
if (pos <= mid)
update(lnd, pos, v);
else
update(rnd, pos, v);
cnd = max(lc, rc);
}
int query(int idx, int b, int e, int l, int r) {
if (l > e || r < b)
return 0;
if (l <= b && r >= e)
return cnd;
return max(query(lnd, l, r), query(rnd, l, r));
}
int arr[mx];
int ans[mx];
int main() {
BOOST;
#ifdef MujahidPC
double start = clock();
// READ;
// WRITE;
#endif
int t, n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> arr[i];
for (int i = 1; i <= n; i++)
arr[i]++;
const int M = 300002;
int res = 0;
for (int i = n; i > 0; i--) {
int x = arr[i];
int l = max(1, arr[i] - m);
int r = min(M, arr[i] + m);
int d = query(1, 1, M, l, r);
ans[i] = d + 1;
update(1, 1, M, x, ans[i]);
res = max(res, ans[i]);
}
cout << res << endl;
#ifdef MujahidPC
double tim = (clock() - start) / CLOCKS_PER_SEC;
cerr << "Running Time : " << tim << " \n";
#endif
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define LL long long
#define ULL unsigned long long
const LL INF = 1LL << 59;
const double PI = 2.0 * acos(0.0);
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
typedef vector<int> vi;
typedef vector<LL> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
//// Including Policy Based DS
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
//
/////cout<<*X.find_by_order(1)<<endl;
/////cout<<X.order_of_key(-5)<<endl;
//
// typedef tree<
// int,
// null_type,
// less< int >,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
#define READ freopen("in.txt", "r", stdin)
#define WRITE freopen("out.txt", "w", stdout)
#define BOOST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define sf scanf
#define pf printf
#define F first
#define S second
#define pb push_back
#define NL pf("\n")
#define ALL(v) v.begin(), v.end()
#define si(x) sf("%d", &x);
#define sii(x, y) sf("%d%d", &x, &y);
#define siii(x, y, z) sf("%d%d%d", &x, &y, &z);
#define sl(x) sf("%lld", &x);
#define sll(x, y) sf("%lld%lld", &x, &y);
#define slll(x, y, z) sf("%lld%lld%lld", &x, &y, &z);
#define sqr(x) ((x) * (x))
#define mem(x, y) memset(x, y, sizeof x)
#define ch printf("Came Here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n")
#define deb(x) cerr << #x << " :: " << x << "\n"
#define SV(v) sort(v.begin(), v.end())
#define SVR(v, cmp) sort(v.begin(), v.end(), cmp)
#define FOR(i, n) for (int i = 0; i < n; i++)
#define cnd tree[idx]
#define lc tree[idx * 2]
#define rc tree[idx * 2 + 1]
#define lnd (2 * idx), (b), ((b + e) / 2)
#define rnd ((2 * idx) + 1), (((b + e) / 2) + 1), (e)
// graph direction array [4]
int X[4] = {0, 0, -1, 1};
int Y[4] = {1, -1, 0, 0};
// graph direction array [8]
// int X[8]={0,0,1,-1,-1,1,1,-1};
// int Y[8]={1,-1,0,0,-1,-1,1,1};
// Bishop direction array [8]
// int BX[8]={0,0,1,-1,-1,1,1,-1};
// int BY[8]={1,-1,0,0,-1,-1,1,1};
// Knight Direction Array
// int KX[8] = {1,1,2,2,-1,-1,-2,-2};
// int KY[8] = {2,-2,1,-1,2,-2,1,-1};
// Bit Operations
#define popcountL __builtin_popcountll
#define popcount __builtin_popcount
inline bool checkBit(int N, int pos) {
return (bool)(N & (1 << pos));
} // check bit
inline int setBit(int N, int pos) { return N = N | (1 << pos); } // set bit
inline int unsetBit(int N, int pos) {
return N = (N & (~(1 << pos)));
} // unset bit
inline int toggleBit(int N, int pos) {
return N = (N ^ (1 << pos));
} // toggle bit
inline LL modMul(LL a, LL b, LL mod) {
LL ans = 0;
a = a % mod;
while (b > 0) {
if (b % 2)
ans = (ans % mod + a % mod) % mod;
a = (a % mod * 2 % mod) % mod;
b /= 2;
}
return ans % mod;
}
inline LL powerMod(LL a, LL b, LL mod) {
if (b == 0)
return 1LL % mod;
LL x = powerMod(a, b / 2, mod);
x = (x % mod * x % mod) % mod;
if (b % 2 == 1)
x = (x % mod * a % mod) % mod;
return x % mod;
}
inline LL lcm(LL a, LL b) {
LL g = __gcd(a, b);
return ((a / g) * b);
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
const int mx = 3e5 + 50;
int tree[4 * mx];
void update(int idx, int b, int e, int pos, int v) {
if (b == e && b == pos) {
cnd = max(cnd, v);
return;
}
int mid = (b + e) >> 1;
if (pos <= mid)
update(lnd, pos, v);
else
update(rnd, pos, v);
cnd = max(lc, rc);
}
int query(int idx, int b, int e, int l, int r) {
if (l > e || r < b)
return 0;
if (l <= b && r >= e)
return cnd;
return max(query(lnd, l, r), query(rnd, l, r));
}
int arr[mx];
int ans[mx];
int main() {
BOOST;
#ifdef MujahidPC
double start = clock();
// READ;
// WRITE;
#endif
int t, n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
cin >> arr[i];
for (int i = 1; i <= n; i++)
arr[i]++;
const int M = 300002;
int res = 0;
for (int i = n; i > 0; i--) {
int x = arr[i];
int l = max(1, arr[i] - m);
int r = min(M, arr[i] + m);
int d = query(1, 1, M, l, r);
ans[i] = d + 1;
update(1, 1, M, x, ans[i]);
res = max(res, ans[i]);
}
cout << res << endl;
#ifdef MujahidPC
double tim = (clock() - start) / CLOCKS_PER_SEC;
cerr << "Running Time : " << tim << " \n";
#endif
return 0;
} | replace | 120 | 121 | 120 | 121 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 1e9 + 1;
const ll INFll = (ll)1e18 + 1;
ll MOD = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
vector<int> A(N);
for (int i(0); i < N; i++) {
cin >> A[i];
}
vector<int> dp(N, 1);
for (int i(0); i < N; i++) {
for (int j(i + 1); j < i + 1000; j++) {
if (abs(A[i] - A[j]) <= K) {
dp[j] = max(dp[j], dp[i] + 1);
}
}
}
int ans(0);
for (int i(0); i < N; i++) {
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 1e9 + 1;
const ll INFll = (ll)1e18 + 1;
ll MOD = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
vector<int> A(N);
for (int i(0); i < N; i++) {
cin >> A[i];
}
vector<int> dp(N, 1);
for (int i(0); i < N; i++) {
for (int j(i + 1); j < min(i + 1000, N); j++) {
if (abs(A[i] - A[j]) <= K) {
dp[j] = max(dp[j], dp[i] + 1);
}
}
}
int ans(0);
for (int i(0); i < N; i++) {
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
| replace | 18 | 19 | 18 | 19 | -6 | malloc(): corrupted top size
|
p02537 | C++ | Time Limit Exceeded |
// Problem : D - Flat Subsequence
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
// #pragma GCC optimize "trapv"// WA to RE int!!
#include <bits/stdc++.h>
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORR(i, n) for (int i = n; i >= 0; i--)
#define pb push_back
#define vint vector<int>
#define sint set<int>
#define mint map<int, int>
#define pint pair<int, int>
#define int long long int
#define test \
int tt1234; \
cin >> tt1234; \
while (tt1234--)
#define endl "\n"
#define SI(a, n) \
int a[n]; \
FOR(i, n) cin >> a[i];
#define input(a, n) \
int n; \
cin >> n; \
SI(a, n)
#define all(zz) zz.begin(), zz.end()
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define error(x) cerr << #x << " is " << x << endl;
#define Error(a, b) \
cerr << "( " << #a << " , " << #b << " ) = ( " << (a) << " , " << (b) \
<< " )\n";
#define precision(x) cout << fixed << setprecision(x);
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define present(container, element) (container.find(element) != container.end())
#define fint \
fast; \
test
#define set(a, x) memset(a, x, sizeof(a))
#define L(x) ((x) << 1)
#define R(x) (((x) << 1) + 1)
#define ft first
#define se second
#define MOD 1000000007
using namespace std;
template <typename... T> void rd(T &...args) { ((cin >> args), ...); }
template <typename... T> void pp(T... args) {
((cout << args << " "), ...);
cout << "\n";
}
void solve() {
int n, k;
rd(n, k);
vint dp(n, 1);
vint arr(n);
for (int &v : arr)
rd(v);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs(arr[i] - arr[j]) <= k)
dp[i] = max(dp[i], 1ll + dp[j]);
}
}
pp(*max_element(all(dp)));
return;
}
int32_t main() {
// fint{
fast;
solve();
// }
return 0;
}
|
// Problem : D - Flat Subsequence
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
// #pragma GCC optimize "trapv"// WA to RE int!!
#include <bits/stdc++.h>
#define FOR(i, n) for (int i = 0; i < n; i++)
#define FORR(i, n) for (int i = n; i >= 0; i--)
#define pb push_back
#define vint vector<int>
#define sint set<int>
#define mint map<int, int>
#define pint pair<int, int>
#define int long long int
#define test \
int tt1234; \
cin >> tt1234; \
while (tt1234--)
#define endl "\n"
#define SI(a, n) \
int a[n]; \
FOR(i, n) cin >> a[i];
#define input(a, n) \
int n; \
cin >> n; \
SI(a, n)
#define all(zz) zz.begin(), zz.end()
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define error(x) cerr << #x << " is " << x << endl;
#define Error(a, b) \
cerr << "( " << #a << " , " << #b << " ) = ( " << (a) << " , " << (b) \
<< " )\n";
#define precision(x) cout << fixed << setprecision(x);
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define present(container, element) (container.find(element) != container.end())
#define fint \
fast; \
test
#define set(a, x) memset(a, x, sizeof(a))
#define L(x) ((x) << 1)
#define R(x) (((x) << 1) + 1)
#define ft first
#define se second
#define MOD 1000000007
using namespace std;
template <typename... T> void rd(T &...args) { ((cin >> args), ...); }
template <typename... T> void pp(T... args) {
((cout << args << " "), ...);
cout << "\n";
}
void solve() {
int n, k;
rd(n, k);
vint dp(n, 1);
vint arr(n);
for (int &v : arr)
rd(v);
for (int i = 1; i < n; i++) {
int L = max(0ll, i - 99);
for (int j = L; j < i; j++) {
if (abs(arr[i] - arr[j]) <= k)
dp[i] = max(dp[i], 1ll + dp[j]);
}
}
pp(*max_element(all(dp)));
return;
}
int32_t main() {
// fint{
fast;
solve();
// }
return 0;
}
| replace | 67 | 68 | 67 | 69 | TLE | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template <class T> void debug(T itr1, T itr2) {
auto now = itr1;
while (now < itr2) {
cout << *now << " ";
now++;
}
cout << endl;
}
#define repr(i, from, to) for (ll i = (ll)from; i < (ll)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i, N) repr(i, 0, N)
#define per(i, N) for (ll i = (ll)N - 1; i >= 0; i--)
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const ll INF = pow(2, 30) - 1;
vector<ll> fac;
void c_fac(ll x = pow(10, 6) + 10) {
fac.resize(x, true);
rep(i, x) fac[i] = i ? (fac[i - 1] * i) % MOD : 1;
}
ll inv(ll a, ll m = MOD) {
ll b = m, x = 1, y = 0;
while (b != 0) {
ll d = a / b;
a -= b * d;
swap(a, b);
x -= y * d;
swap(x, y);
}
return (x + m) % m;
}
ll nck(ll n, ll k) { return fac[n] * inv(fac[k] * fac[n - k] % MOD) % MOD; }
ll modpow(ll x, ll p) {
ll result = 1, now = 1, pm = x;
while (now <= p) {
if (p & now) {
result = result * pm % MOD;
}
now *= 2;
pm = pm * pm % MOD;
}
return result;
}
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b == 0 ? a : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
struct SegTree {
ll size;
vector<ll> pos;
SegTree(ll N) {
size = 1;
while (size < N)
size <<= 1;
pos.resize(2 * size, 0);
}
ll operator[](const ll &x) const { return pos[x + size]; }
void set(ll x, const ll v) { pos[x + size] = v; }
void update(ll x, const ll v) {
set(x, v);
x += size;
while (x >>= 1)
operate(x);
}
ll query(ll a, ll b) {
ll L = 0, R = 0;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
L = q(L, pos[a]);
a++;
}
if (b & 1) {
b--;
R = q(pos[b], R);
}
}
return q(L, R);
}
void operate(ll i) { pos[i] = q(pos[i * 2], pos[i * 2 + 1]); }
ll q(ll x, ll y) { return max(x, y); }
};
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
ll A[N];
rep(i, N) cin >> A[i];
ll MA = 10;
SegTree st(MA);
rep(i, N) {
st.update(A[i],
st.query(max(0ll, A[i] - K), min(MA - 1, A[i] + K) + 1) + 1);
// rep(i,MA) cout << st[i] << " "; cout << endl;
}
ll result = st.query(0, MA);
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template <class T> void debug(T itr1, T itr2) {
auto now = itr1;
while (now < itr2) {
cout << *now << " ";
now++;
}
cout << endl;
}
#define repr(i, from, to) for (ll i = (ll)from; i < (ll)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i, N) repr(i, 0, N)
#define per(i, N) for (ll i = (ll)N - 1; i >= 0; i--)
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const ll INF = pow(2, 30) - 1;
vector<ll> fac;
void c_fac(ll x = pow(10, 6) + 10) {
fac.resize(x, true);
rep(i, x) fac[i] = i ? (fac[i - 1] * i) % MOD : 1;
}
ll inv(ll a, ll m = MOD) {
ll b = m, x = 1, y = 0;
while (b != 0) {
ll d = a / b;
a -= b * d;
swap(a, b);
x -= y * d;
swap(x, y);
}
return (x + m) % m;
}
ll nck(ll n, ll k) { return fac[n] * inv(fac[k] * fac[n - k] % MOD) % MOD; }
ll modpow(ll x, ll p) {
ll result = 1, now = 1, pm = x;
while (now <= p) {
if (p & now) {
result = result * pm % MOD;
}
now *= 2;
pm = pm * pm % MOD;
}
return result;
}
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b == 0 ? a : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
struct SegTree {
ll size;
vector<ll> pos;
SegTree(ll N) {
size = 1;
while (size < N)
size <<= 1;
pos.resize(2 * size, 0);
}
ll operator[](const ll &x) const { return pos[x + size]; }
void set(ll x, const ll v) { pos[x + size] = v; }
void update(ll x, const ll v) {
set(x, v);
x += size;
while (x >>= 1)
operate(x);
}
ll query(ll a, ll b) {
ll L = 0, R = 0;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
L = q(L, pos[a]);
a++;
}
if (b & 1) {
b--;
R = q(pos[b], R);
}
}
return q(L, R);
}
void operate(ll i) { pos[i] = q(pos[i * 2], pos[i * 2 + 1]); }
ll q(ll x, ll y) { return max(x, y); }
};
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
int main() {
ll N, K;
cin >> N >> K;
ll A[N];
rep(i, N) cin >> A[i];
ll MA = 300010;
SegTree st(MA);
rep(i, N) {
st.update(A[i],
st.query(max(0ll, A[i] - K), min(MA - 1, A[i] + K) + 1) + 1);
// rep(i,MA) cout << st[i] << " "; cout << endl;
}
ll result = st.query(0, MA);
cout << result << endl;
return 0;
} | replace | 106 | 107 | 106 | 107 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
template <class T> void get_unique(vector<T> &x) {
x.erase(unique(x.begin(), x.end()), x.end());
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (int i = 0; i < sz(v); i++) {
os << v[i];
if (i < sz(v) - 1)
os << " ";
}
return os;
}
template <class S, S (*op)(S, S), S (*e)()> struct SegmentTree {
public:
SegmentTree() : SegmentTree(0) {}
SegmentTree(int n) : SegmentTree(std::vector<S>(n, e())) {}
SegmentTree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
using S = int;
S op(S a, S b) { return max(a, b); }
S e() { return 0; }
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
SegmentTree<S, op, e> segt(300300);
rep(i, n) {
int MAX = segt.prod(max(0, a[i] - k), min(n - 1, a[i] + k) + 1);
segt.set(a[i], max(segt.get(a[i]), MAX + 1));
}
// rep(i, 10) cout << i << ':' << segt.prod(i, i + 1) << '\n';
cout << segt.all_prod() << '\n';
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
template <class T> void get_unique(vector<T> &x) {
x.erase(unique(x.begin(), x.end()), x.end());
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (int i = 0; i < sz(v); i++) {
os << v[i];
if (i < sz(v) - 1)
os << " ";
}
return os;
}
template <class S, S (*op)(S, S), S (*e)()> struct SegmentTree {
public:
SegmentTree() : SegmentTree(0) {}
SegmentTree(int n) : SegmentTree(std::vector<S>(n, e())) {}
SegmentTree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
using S = int;
S op(S a, S b) { return max(a, b); }
S e() { return 0; }
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
SegmentTree<S, op, e> segt(300300);
rep(i, n) {
int MAX = segt.prod(max(0, a[i] - k), min(300300, a[i] + k + 1));
segt.set(a[i], max(segt.get(a[i]), MAX + 1));
}
// rep(i, 10) cout << i << ':' << segt.prod(i, i + 1) << '\n';
cout << segt.all_prod() << '\n';
} | replace | 165 | 166 | 165 | 166 | 0 | |
p02537 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 500100;
#define lson rt << 1 // == rt * 2 左儿子
#define rson rt << 1 | 1 // == rt * 2 + 1 右儿子
#define int_mid int mid = tree[rt].l + tree[rt].r >> 1
int num[N];
struct node {
int l, r;
ll val, lazy;
} tree[N * 4];
void push_up(int rt) {
// tree[rt].val = min(tree[lson].val, tree[rson].val);
tree[rt].val = max(tree[lson].val, tree[rson].val);
// tree[rt].val = tree[lson].val + tree[rson].val;
}
void push_down(int rt) {
if (tree[rt].lazy) {
tree[lson].lazy += tree[rt].lazy;
tree[rson].lazy += tree[rt].lazy;
{ // 维护最大最小值
tree[lson].val += tree[rt].lazy;
tree[rson].val += tree[rt].lazy;
}
// { // 维护和
// int l = tree[rt].l, r = tree[rt].r;
// int mid = l + r >> 1;
// tree[lson].val += 1ll * (mid - l + 1) * tree[rt].lazy;
// tree[rson].val += 1ll * (r - mid) * tree[rt].lazy;
// }
tree[rt].lazy = 0;
}
}
void build(int rt, int l, int r) { // 建树
tree[rt].l = l, tree[rt].r = r;
tree[rt].lazy = 0;
if (l == r) {
tree[rt].val = 0; // 给定一个初始值
return;
} else {
int mid = l + r >> 1; // (l + r) / 2
build(lson, l, mid);
build(rson, mid + 1, r);
push_up(rt);
}
}
void update_point(int rt, int pos, ll val) { // 单点更新
if (tree[rt].l == tree[rt].r && pos == tree[rt].l) {
tree[rt].val = val;
return;
}
int_mid;
if (pos <= mid)
update_point(lson, pos, val);
else
update_point(rson, pos, val);
push_up(rt);
}
// void update_interval(int rt, int l, int r, ll val) { // 区间更新
// if (l <= tree[rt].l && r >= tree[rt].r) {
// tree[rt].lazy += val;
// //tree[rt].val += val; // 维护最大最小值
// tree[rt].val += 1ll * (tree[rt].r - tree[rt].l + 1) * val; //
// 维护和 return;
// }
// push_down(rt);
// int_mid;
// if (l <= mid) update_interval(lson, l, r, val);
// if (r > mid) update_interval(rson, l, r, val);
// push_up(rt);
// }
// ll query_point(int rt, int pos) { // 单点查询
// if (tree[rt].l == tree[rt].r && tree[rt].l == pos)
// return tree[rt].val;
// push_down(rt);
// int_mid;
// if (pos <= mid) query_point(lson, pos);
// else query_point(rson, pos);
// }
ll query_interval(int rt, int l, int r) { // 区间查询
if (l <= tree[rt].l && r >= tree[rt].r)
return tree[rt].val;
push_down(rt);
int_mid;
if (r <= mid)
return query_interval(lson, l, r);
else if (l > mid)
return query_interval(rson, l, r);
else {
// return min(query_interval(lson, l, mid), query_interval(rson, mid + 1,
// r));
return max(query_interval(lson, l, mid), query_interval(rson, mid + 1, r));
// return query_interval(lson, l, mid) + query_interval(rson, mid + 1, r);
}
}
void solve(int T) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
build(1, 0, n);
int ans = 0;
for (int i = 1; i <= n; i++) {
int t = num[i];
int l = max(0, t - k), r = min(300000, t + k);
int q = query_interval(1, l, r);
ans = max(ans, q + 1);
update_point(1, t, q + 1);
}
printf("%d", ans);
}
signed main() {
int t = 1;
// scanf("%d",&t);
for (int i = 1; i <= t; i++) {
solve(i);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 500100;
#define lson rt << 1 // == rt * 2 左儿子
#define rson rt << 1 | 1 // == rt * 2 + 1 右儿子
#define int_mid int mid = tree[rt].l + tree[rt].r >> 1
int num[N];
struct node {
int l, r;
ll val, lazy;
} tree[N * 4];
void push_up(int rt) {
// tree[rt].val = min(tree[lson].val, tree[rson].val);
tree[rt].val = max(tree[lson].val, tree[rson].val);
// tree[rt].val = tree[lson].val + tree[rson].val;
}
void push_down(int rt) {
if (tree[rt].lazy) {
tree[lson].lazy += tree[rt].lazy;
tree[rson].lazy += tree[rt].lazy;
{ // 维护最大最小值
tree[lson].val += tree[rt].lazy;
tree[rson].val += tree[rt].lazy;
}
// { // 维护和
// int l = tree[rt].l, r = tree[rt].r;
// int mid = l + r >> 1;
// tree[lson].val += 1ll * (mid - l + 1) * tree[rt].lazy;
// tree[rson].val += 1ll * (r - mid) * tree[rt].lazy;
// }
tree[rt].lazy = 0;
}
}
void build(int rt, int l, int r) { // 建树
tree[rt].l = l, tree[rt].r = r;
tree[rt].lazy = 0;
if (l == r) {
tree[rt].val = 0; // 给定一个初始值
return;
} else {
int mid = l + r >> 1; // (l + r) / 2
build(lson, l, mid);
build(rson, mid + 1, r);
push_up(rt);
}
}
void update_point(int rt, int pos, ll val) { // 单点更新
if (tree[rt].l == tree[rt].r && pos == tree[rt].l) {
tree[rt].val = val;
return;
}
int_mid;
if (pos <= mid)
update_point(lson, pos, val);
else
update_point(rson, pos, val);
push_up(rt);
}
// void update_interval(int rt, int l, int r, ll val) { // 区间更新
// if (l <= tree[rt].l && r >= tree[rt].r) {
// tree[rt].lazy += val;
// //tree[rt].val += val; // 维护最大最小值
// tree[rt].val += 1ll * (tree[rt].r - tree[rt].l + 1) * val; //
// 维护和 return;
// }
// push_down(rt);
// int_mid;
// if (l <= mid) update_interval(lson, l, r, val);
// if (r > mid) update_interval(rson, l, r, val);
// push_up(rt);
// }
// ll query_point(int rt, int pos) { // 单点查询
// if (tree[rt].l == tree[rt].r && tree[rt].l == pos)
// return tree[rt].val;
// push_down(rt);
// int_mid;
// if (pos <= mid) query_point(lson, pos);
// else query_point(rson, pos);
// }
ll query_interval(int rt, int l, int r) { // 区间查询
if (l <= tree[rt].l && r >= tree[rt].r)
return tree[rt].val;
push_down(rt);
int_mid;
if (r <= mid)
return query_interval(lson, l, r);
else if (l > mid)
return query_interval(rson, l, r);
else {
// return min(query_interval(lson, l, mid), query_interval(rson, mid + 1,
// r));
return max(query_interval(lson, l, mid), query_interval(rson, mid + 1, r));
// return query_interval(lson, l, mid) + query_interval(rson, mid + 1, r);
}
}
void solve(int T) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
build(1, 0, 300000);
int ans = 0;
for (int i = 1; i <= n; i++) {
int t = num[i];
int l = max(0, t - k), r = min(300000, t + k);
int q = query_interval(1, l, r);
ans = max(ans, q + 1);
update_point(1, t, q + 1);
}
printf("%d", ans);
}
signed main() {
int t = 1;
// scanf("%d",&t);
for (int i = 1; i <= t; i++) {
solve(i);
}
return 0;
} | replace | 121 | 122 | 121 | 122 | 0 | |
p02537 | C++ | Runtime Error | #include <algorithm>
#include <stdio.h>
int n, k;
int a[100010];
int DT[100010];
int ans;
int max_a;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
struct seg {
int tree[2000010], lim;
void init(int n) {
for (lim = 1; lim <= n; lim <<= 1)
;
for (int i = 0; i < 2 * lim; i++) {
tree[i] = 0;
}
}
void add(int x, int v) {
x += lim;
tree[x] = v;
while (x > 1) {
x >>= 1;
tree[x] = max(tree[2 * x], tree[2 * x + 1]);
}
}
int query(int s, int e) {
s += lim;
e += lim;
int ret = 0;
while (s < e) {
if (s % 2 == 1)
ret = max(ret, tree[s++]);
if (e % 2 == 0)
ret = max(ret, tree[e--]);
s >>= 1;
e >>= 1;
}
if (s == e)
ret = max(ret, tree[s]);
return ret;
}
} seg;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
max_a = max_a > a[i] ? max_a : a[i];
}
seg.init(max_a);
for (int i = n - 1; i >= 0; i--) {
int t = seg.query(max(0, a[i] - k), min(max_a, a[i] + k)) + 1;
ans = max(ans, t);
seg.add(a[i], t);
}
printf("%d\n", ans);
} | #include <algorithm>
#include <stdio.h>
int n, k;
int a[300010];
int ans;
int max_a;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
struct seg {
int tree[2000010], lim;
void init(int n) {
for (lim = 1; lim <= n; lim <<= 1)
;
for (int i = 0; i < 2 * lim; i++) {
tree[i] = 0;
}
}
void add(int x, int v) {
x += lim;
tree[x] = v;
while (x > 1) {
x >>= 1;
tree[x] = max(tree[2 * x], tree[2 * x + 1]);
}
}
int query(int s, int e) {
s += lim;
e += lim;
int ret = 0;
while (s < e) {
if (s % 2 == 1)
ret = max(ret, tree[s++]);
if (e % 2 == 0)
ret = max(ret, tree[e--]);
s >>= 1;
e >>= 1;
}
if (s == e)
ret = max(ret, tree[s]);
return ret;
}
} seg;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
max_a = max_a > a[i] ? max_a : a[i];
}
seg.init(max_a);
for (int i = n - 1; i >= 0; i--) {
int t = seg.query(max(0, a[i] - k), min(max_a, a[i] + k)) + 1;
ans = max(ans, t);
seg.add(a[i], t);
}
printf("%d\n", ans);
} | replace | 3 | 5 | 3 | 4 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ls ch[x][0]
#define rs ch[x][1]
#define ll long long
using namespace std;
inline ll read() {
ll num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-')
neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
int n, k, tree[300010 << 2], a[300010], f[300010];
inline void push_up(int x) { tree[x] = max(tree[x << 1], tree[x << 1 | 1]); }
inline void update(int u, int l, int r, int x, int k) {
if (l == r) {
tree[x] = max(tree[x], k);
return;
}
int mid = l + r >> 1;
if (u <= mid)
update(u, l, mid, x << 1, k);
else
update(u, mid + 1, r, x << 1 | 1, k);
push_up(x);
return;
}
inline int query(int ql, int qr, int l, int r, int x) {
if (ql <= l && qr >= r)
return tree[x];
int mid = l + r >> 1, res = 0;
if (ql <= mid)
res = max(res, query(ql, qr, l, mid, x << 1));
if (qr > mid)
res = max(res, query(ql, qr, mid + 1, r, x << 1 | 1));
return res;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; i++)
a[i] = read();
for (int i = 1; i <= n; i++) {
f[i] = query(max(a[i] - k, 0), min(300000, a[i] + k), 1, n, 1) + 1;
update(a[i], 1, n, 1, f[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(f[i], ans);
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define ls ch[x][0]
#define rs ch[x][1]
#define ll long long
using namespace std;
inline ll read() {
ll num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-')
neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
int n, k, tree[300010 << 2], a[300010], f[300010];
inline void push_up(int x) { tree[x] = max(tree[x << 1], tree[x << 1 | 1]); }
inline void update(int u, int l, int r, int x, int k) {
if (l == r) {
tree[x] = max(tree[x], k);
return;
}
int mid = l + r >> 1;
if (u <= mid)
update(u, l, mid, x << 1, k);
else
update(u, mid + 1, r, x << 1 | 1, k);
push_up(x);
return;
}
inline int query(int ql, int qr, int l, int r, int x) {
if (ql <= l && qr >= r)
return tree[x];
int mid = l + r >> 1, res = 0;
if (ql <= mid)
res = max(res, query(ql, qr, l, mid, x << 1));
if (qr > mid)
res = max(res, query(ql, qr, mid + 1, r, x << 1 | 1));
return res;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; i++)
a[i] = read();
for (int i = 1; i <= n; i++) {
f[i] = query(max(a[i] - k, 0), min(300000, a[i] + k), 1, 300000, 1) + 1;
update(a[i], 1, 300000, 1, f[i]);
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(f[i], ans);
cout << ans;
return 0;
}
| replace | 53 | 55 | 53 | 55 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x, i##end = y; i <= i##end; ++i)
#define _rep(i, x, y) for (int i = x, i##end = y; i >= i##end; --i)
#define ll long long
typedef std::pair<int, int> pii;
inline bool up(int &x, const int y) { return x < y ? x = y, 1 : 0; }
inline bool down(int &x, const int y) { return x > y ? x = y, 1 : 0; }
#define N 300005
int n, k, a[N];
int dp[N];
struct segment {
#define ls rt << 1
#define rs rt << 1 | 1
#define lson ls, l, mid
#define rson rs, mid + 1, r
int mx[N];
inline void pushup(int rt) { mx[rt] = std::max(mx[ls], mx[rs]); }
inline void build(int rt, int l, int r) {
mx[rt] = 0;
if (l == r)
return;
int mid = l + r >> 1;
build(lson), build(rson), pushup(rt);
}
inline void ins(int rt, int l, int r, int x, int v) {
if (l == r)
return mx[rt] = v, void();
int mid = l + r >> 1;
if (x <= mid)
ins(lson, x, v);
else
ins(rson, x, v);
pushup(rt);
}
inline int qry(int rt, int l, int r, int x, int y) {
if (x <= l && r <= y)
return mx[rt];
int mid = l + r >> 1, ret = 0;
if (x <= mid)
up(ret, qry(lson, x, y));
if (mid < y)
up(ret, qry(rson, x, y));
// std::cerr<<x<<' '<<y<<' '<<ret<<'\n';
return ret;
}
} T;
int m;
int main() {
std::ios::sync_with_stdio(0);
std::cin >> n >> k;
rep(i, 1, n) std::cin >> a[i], ++a[i], up(m, a[i]);
memset(dp, 0, sizeof(dp));
T.build(1, 1, m);
int ret = 0;
rep(i, 1, n) {
int l = std::max(1, a[i] - k), r = std::min(m, a[i] + k);
dp[i] = T.qry(1, 1, m, l, r) + 1;
T.ins(1, 1, m, a[i], dp[i]);
up(ret, dp[i]);
}
// rep(i,1,n) std::cerr<<dp[i]<<" \n"[i==n];
std::cout << ret << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x, i##end = y; i <= i##end; ++i)
#define _rep(i, x, y) for (int i = x, i##end = y; i >= i##end; --i)
#define ll long long
typedef std::pair<int, int> pii;
inline bool up(int &x, const int y) { return x < y ? x = y, 1 : 0; }
inline bool down(int &x, const int y) { return x > y ? x = y, 1 : 0; }
#define N 300005
int n, k, a[N];
int dp[N];
struct segment {
#define ls rt << 1
#define rs rt << 1 | 1
#define lson ls, l, mid
#define rson rs, mid + 1, r
int mx[N << 2];
inline void pushup(int rt) { mx[rt] = std::max(mx[ls], mx[rs]); }
inline void build(int rt, int l, int r) {
mx[rt] = 0;
if (l == r)
return;
int mid = l + r >> 1;
build(lson), build(rson), pushup(rt);
}
inline void ins(int rt, int l, int r, int x, int v) {
if (l == r)
return mx[rt] = v, void();
int mid = l + r >> 1;
if (x <= mid)
ins(lson, x, v);
else
ins(rson, x, v);
pushup(rt);
}
inline int qry(int rt, int l, int r, int x, int y) {
if (x <= l && r <= y)
return mx[rt];
int mid = l + r >> 1, ret = 0;
if (x <= mid)
up(ret, qry(lson, x, y));
if (mid < y)
up(ret, qry(rson, x, y));
// std::cerr<<x<<' '<<y<<' '<<ret<<'\n';
return ret;
}
} T;
int m;
int main() {
std::ios::sync_with_stdio(0);
std::cin >> n >> k;
rep(i, 1, n) std::cin >> a[i], ++a[i], up(m, a[i]);
memset(dp, 0, sizeof(dp));
T.build(1, 1, m);
int ret = 0;
rep(i, 1, n) {
int l = std::max(1, a[i] - k), r = std::min(m, a[i] + k);
dp[i] = T.qry(1, 1, m, l, r) + 1;
T.ins(1, 1, m, a[i], dp[i]);
up(ret, dp[i]);
}
// rep(i,1,n) std::cerr<<dp[i]<<" \n"[i==n];
std::cout << ret << '\n';
return 0;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p02537 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
REP(i, n) cin >> a[i];
vector<int> dp(n, 0);
REP(i, n) REP(j, i) {
if (abs(a[i] - a[j]) <= k)
dp[i] = max(dp[i], dp[j] + 1);
}
int res = 0;
REP(i, n)
res = max(res, dp[i]);
cout << res + 1 << '\n';
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
REP(i, n) cin >> a[i];
vector<int> dp(n, 0);
REP(i, n) for (int j = max(0, i - 100); j < i; j++) {
if (abs(a[i] - a[j]) <= k)
dp[i] = max(dp[i], dp[j] + 1);
}
int res = 0;
REP(i, n)
res = max(res, dp[i]);
cout << res + 1 << '\n';
return 0;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct SegmentTree { // 1-indexed
T m_id;
T op(const T &a, const T &b) const { return max(a, b); }
vector<T> m_SegT;
SegmentTree(int N) : m_id(0), m_SegT(2 * N, m_id) {}
SegmentTree(const vector<T> &data) : m_id(0), m_SegT(2 * data.size()) {
int N = m_SegT.size() >> 1;
for (int i = 0; i < N; i++) {
m_SegT.at(i + N) = data.at(i);
}
for (int i = N - 1; i > 0; i--) {
m_SegT.at(i) = op(m_SegT.at(i << 1), m_SegT.at((i << 1) | 1));
}
}
void set_val(int idx, T val) {
idx += m_SegT.size() >> 1;
m_SegT.at(idx) = val;
while ((idx >> 1) > 0) {
idx >>= 1;
m_SegT.at(idx) = op(m_SegT.at(idx << 1), m_SegT.at((idx << 1) | 1));
}
}
T range(int left, int right) const { // [left, right)
left += m_SegT.size() >> 1;
right += m_SegT.size() >> 1;
T calc_l = m_id;
T calc_r = m_id;
while (left < right) {
if (left & 1) {
calc_l = op(calc_l, m_SegT.at(left));
left++;
}
if (right & 1) {
calc_r = op(m_SegT.at(right - 1), calc_r);
}
left >>= 1;
right >>= 1;
}
return op(calc_l, calc_r);
}
};
int main() {
int N, K;
cin >> N >> K;
vector<int> data(N);
for (int i = 0; i < N; i++) {
cin >> data.at(i);
data.at(i)++; // [0,N] -> [1,N+1]
}
const int Vmax = N + 1;
SegmentTree<int> st(Vmax + 1);
for (int i = 0; i < N; i++) {
int left = max(1, data.at(i) - K);
int right = min(Vmax, data.at(i) + K);
int len_prev = st.range(left, right + 1);
st.set_val(data.at(i), len_prev + 1);
}
int ans = st.range(0, Vmax + 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct SegmentTree { // 1-indexed
T m_id;
T op(const T &a, const T &b) const { return max(a, b); }
vector<T> m_SegT;
SegmentTree(int N) : m_id(0), m_SegT(2 * N, m_id) {}
SegmentTree(const vector<T> &data) : m_id(0), m_SegT(2 * data.size()) {
int N = m_SegT.size() >> 1;
for (int i = 0; i < N; i++) {
m_SegT.at(i + N) = data.at(i);
}
for (int i = N - 1; i > 0; i--) {
m_SegT.at(i) = op(m_SegT.at(i << 1), m_SegT.at((i << 1) | 1));
}
}
void set_val(int idx, T val) {
idx += m_SegT.size() >> 1;
m_SegT.at(idx) = val;
while ((idx >> 1) > 0) {
idx >>= 1;
m_SegT.at(idx) = op(m_SegT.at(idx << 1), m_SegT.at((idx << 1) | 1));
}
}
T range(int left, int right) const { // [left, right)
left += m_SegT.size() >> 1;
right += m_SegT.size() >> 1;
T calc_l = m_id;
T calc_r = m_id;
while (left < right) {
if (left & 1) {
calc_l = op(calc_l, m_SegT.at(left));
left++;
}
if (right & 1) {
calc_r = op(m_SegT.at(right - 1), calc_r);
}
left >>= 1;
right >>= 1;
}
return op(calc_l, calc_r);
}
};
int main() {
int N, K;
cin >> N >> K;
vector<int> data(N);
for (int i = 0; i < N; i++) {
cin >> data.at(i);
data.at(i)++; // [0,N] -> [1,N+1]
}
constexpr int Vmax = 300'001; // '
SegmentTree<int> st(Vmax + 1);
for (int i = 0; i < N; i++) {
int left = max(1, data.at(i) - K);
int right = min(Vmax, data.at(i) + K);
int len_prev = st.range(left, right + 1);
st.set_val(data.at(i), len_prev + 1);
}
int ans = st.range(0, Vmax + 1);
cout << ans << endl;
} | replace | 61 | 62 | 61 | 62 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define F first
#define S second
#define _IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const ll N = 3e5, mod = 1e9 + 7, inf = 1e18;
ll seg[3 * N];
void update(ll rt, ll l, ll r, ll id, ll v) {
if (l > id || r < id)
return;
if (l == r) {
seg[rt] = max(seg[rt], v);
return;
}
ll md = (l + r) / 2;
update(rt * 2, l, md, id, v);
update(rt * 2 + 1, md + 1, r, id, v);
seg[rt] = max(seg[rt * 2], seg[rt * 2 + 1]);
}
ll query(ll rt, ll l, ll r, ll i, ll j) {
if (l > j || r < i)
return -inf;
if (l >= i && r <= j)
return seg[rt];
ll md = (l + r) / 2;
return max(query(rt * 2, l, md, i, j), query(rt * 2 + 1, md + 1, r, i, j));
}
int main() {
_IO;
ll n, k;
cin >> n >> k;
ll mx = 0;
while (n--) {
ll x;
cin >> x;
ll p = query(1, 0, N, max(0LL, x - k), min(N, x + k));
update(1, 0, N, x, p + 1);
mx = max(mx, p + 1);
}
cout << mx << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define F first
#define S second
#define _IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const ll N = 3e5 + 5, mod = 1e9 + 7, inf = 1e18;
ll seg[4 * N];
void update(ll rt, ll l, ll r, ll id, ll v) {
if (l > id || r < id)
return;
if (l == r) {
seg[rt] = max(seg[rt], v);
return;
}
ll md = (l + r) / 2;
update(rt * 2, l, md, id, v);
update(rt * 2 + 1, md + 1, r, id, v);
seg[rt] = max(seg[rt * 2], seg[rt * 2 + 1]);
}
ll query(ll rt, ll l, ll r, ll i, ll j) {
if (l > j || r < i)
return -inf;
if (l >= i && r <= j)
return seg[rt];
ll md = (l + r) / 2;
return max(query(rt * 2, l, md, i, j), query(rt * 2 + 1, md + 1, r, i, j));
}
int main() {
_IO;
ll n, k;
cin >> n >> k;
ll mx = 0;
while (n--) {
ll x;
cin >> x;
ll p = query(1, 0, N, max(0LL, x - k), min(N, x + k));
update(1, 0, N, x, p + 1);
mx = max(mx, p + 1);
}
cout << mx << "\n";
}
| replace | 11 | 13 | 11 | 13 | 0 | |
p02537 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(ri, n) for (int ri = (int)(n - 1); ri >= 0; ri--)
#define rep2(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri, x, n) for (int ri = (int)(n - 1); ri >= (int)(x); ri--)
#define repit(itr, x) for (auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr, x) for (auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
#include <algorithm>
#include <array>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value, __uint128_t,
unsigned __int128>;
template <class T>
using is_integral =
typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_signed_int =
typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value, make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned =
typename std::conditional<is_signed_int<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)> * = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0)
x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
static_modint(bool v) { _v = ((unsigned int)(v) % umod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v -= rhs._v;
if (_v >= umod())
_v += umod();
return *this;
}
mint &operator*=(const mint &rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0)
x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
dynamic_modint(bool v) { _v = ((unsigned int)(v) % mod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v += mod() - rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator*=(const mint &rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt = 998244353;
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <type_traits>
#include <vector>
namespace atcoder {
namespace internal {
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now;
now *= ies[i];
}
}
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p] * now;
a[i + offset] = l + r;
a[i + offset + p] = l - r;
}
now *= sum_e[bsf(~(unsigned int)(s))];
}
}
}
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly_inv(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_ie[30]; // sum_ie[i] = es[0] * ... * es[i - 1] * ies[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now;
now *= es[i];
}
}
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p];
a[i + offset] = l + r;
a[i + offset + p] =
(unsigned long long)(mint::mod() + l.val() - r.val()) * inow.val();
}
inow *= sum_ie[bsf(~(unsigned int)(s))];
}
}
}
} // namespace internal
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
std::vector<mint> convolution(std::vector<mint> a, std::vector<mint> b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
if (std::min(n, m) <= 60) {
if (n < m) {
std::swap(n, m);
std::swap(a, b);
}
std::vector<mint> ans(n + m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[i + j] += a[i] * b[j];
}
}
return ans;
}
int z = 1 << internal::ceil_pow2(n + m - 1);
a.resize(z);
internal::butterfly(a);
b.resize(z);
internal::butterfly(b);
for (int i = 0; i < z; i++) {
a[i] *= b[i];
}
internal::butterfly_inv(a);
a.resize(n + m - 1);
mint iz = mint(z).inv();
for (int i = 0; i < n + m - 1; i++)
a[i] *= iz;
return a;
}
template <unsigned int mod = 998244353, class T,
std::enable_if_t<internal::is_integral<T>::value> * = nullptr>
std::vector<T> convolution(const std::vector<T> &a, const std::vector<T> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
using mint = static_modint<mod>;
std::vector<mint> a2(n), b2(m);
for (int i = 0; i < n; i++) {
a2[i] = mint(a[i]);
}
for (int i = 0; i < m; i++) {
b2[i] = mint(b[i]);
}
auto c2 = convolution(move(a2), move(b2));
std::vector<T> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
c[i] = c2[i].val();
}
return c;
}
std::vector<long long> convolution_ll(const std::vector<long long> &a,
const std::vector<long long> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
static constexpr unsigned long long MOD1 = 754974721; // 2^24
static constexpr unsigned long long MOD2 = 167772161; // 2^25
static constexpr unsigned long long MOD3 = 469762049; // 2^26
static constexpr unsigned long long M2M3 = MOD2 * MOD3;
static constexpr unsigned long long M1M3 = MOD1 * MOD3;
static constexpr unsigned long long M1M2 = MOD1 * MOD2;
static constexpr unsigned long long M1M2M3 = MOD1 * MOD2 * MOD3;
static constexpr unsigned long long i1 =
internal::inv_gcd(MOD2 * MOD3, MOD1).second;
static constexpr unsigned long long i2 =
internal::inv_gcd(MOD1 * MOD3, MOD2).second;
static constexpr unsigned long long i3 =
internal::inv_gcd(MOD1 * MOD2, MOD3).second;
auto c1 = convolution<MOD1>(a, b);
auto c2 = convolution<MOD2>(a, b);
auto c3 = convolution<MOD3>(a, b);
std::vector<long long> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
unsigned long long x = 0;
x += (c1[i] * i1) % MOD1 * M2M3;
x += (c2[i] * i2) % MOD2 * M1M3;
x += (c3[i] * i3) % MOD3 * M1M2;
// B = 2^63, -B <= x, r(real value) < B
// (x, x - M, x - 2M, or x - 3M) = r (mod 2B)
// r = c1[i] (mod MOD1)
// focus on MOD1
// r = x, x - M', x - 2M', x - 3M' (M' = M % 2^64) (mod 2B)
// r = x,
// x - M' + (0 or 2B),
// x - 2M' + (0, 2B or 4B),
// x - 3M' + (0, 2B, 4B or 6B) (without mod!)
// (r - x) = 0, (0)
// - M' + (0 or 2B), (1)
// -2M' + (0 or 2B or 4B), (2)
// -3M' + (0 or 2B or 4B or 6B) (3) (mod MOD1)
// we checked that
// ((1) mod MOD1) mod 5 = 2
// ((2) mod MOD1) mod 5 = 3
// ((3) mod MOD1) mod 5 = 4
long long diff =
c1[i] - internal::safe_mod((long long)(x), (long long)(MOD1));
if (diff < 0)
diff += MOD1;
static constexpr unsigned long long offset[5] = {0, 0, M1M2M3, 2 * M1M2M3,
3 * M1M2M3};
x -= offset[diff % 5];
c[i] = x;
}
return c;
}
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y)
return x;
if (-parent_or_size[x] < -parent_or_size[y])
std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0)
return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int> &v) { return v.empty(); }),
result.end());
return result;
}
private:
int _n;
// root node: -1 * component size
// otherwise: parent
std::vector<int> parent_or_size;
};
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference: https://en.wikipedia.org/wiki/Fenwick_tree
template <class T> struct fenwick_tree {
using U = internal::to_unsigned_t<T>;
public:
fenwick_tree() : _n(0) {}
fenwick_tree(int n) : _n(n), data(n) {}
void add(int p, T x) {
assert(0 <= p && p < _n);
p++;
while (p <= _n) {
data[p - 1] += U(x);
p += p & -p;
}
}
T sum(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
return sum(r) - sum(l);
}
private:
int _n;
std::vector<U> data;
U sum(int r) {
U s = 0;
while (r > 0) {
s += data[r - 1];
r -= r & -r;
}
return s;
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
#include <algorithm>
#include <vector>
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T &t) { payload.push_back(t); }
T &front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap> struct mf_graph {
public:
mf_graph() : _n(0) {}
mf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result;
for (int i = 0; i < m; i++) {
result.push_back(get_edge(i));
}
return result;
}
void change_edge(int i, Cap new_cap, Cap new_flow) {
int m = int(pos.size());
assert(0 <= i && i < m);
assert(0 <= new_flow && new_flow <= new_cap);
auto &_e = g[pos[i].first][pos[i].second];
auto &_re = g[_e.to][_e.rev];
_e.cap = new_cap - new_flow;
_re.cap = new_flow;
}
Cap flow(int s, int t) { return flow(s, t, std::numeric_limits<Cap>::max()); }
Cap flow(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
std::vector<int> level(_n), iter(_n);
internal::simple_queue<int> que;
auto bfs = [&]() {
std::fill(level.begin(), level.end(), -1);
level[s] = 0;
que.clear();
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto e : g[v]) {
if (e.cap == 0 || level[e.to] >= 0)
continue;
level[e.to] = level[v] + 1;
if (e.to == t)
return;
que.push(e.to);
}
}
};
auto dfs = [&](auto self, int v, Cap up) {
if (v == s)
return up;
Cap res = 0;
int level_v = level[v];
for (int &i = iter[v]; i < int(g[v].size()); i++) {
_edge &e = g[v][i];
if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0)
continue;
Cap d = self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
if (d <= 0)
continue;
g[v][i].cap += d;
g[e.to][e.rev].cap -= d;
res += d;
if (res == up)
break;
}
return res;
};
Cap flow = 0;
while (flow < flow_limit) {
bfs();
if (level[t] == -1)
break;
std::fill(iter.begin(), iter.end(), 0);
while (flow < flow_limit) {
Cap f = dfs(dfs, t, flow_limit - flow);
if (!f)
break;
flow += f;
}
}
return flow;
}
std::vector<bool> min_cut(int s) {
std::vector<bool> visited(_n);
internal::simple_queue<int> que;
que.push(s);
while (!que.empty()) {
int p = que.front();
que.pop();
visited[p] = true;
for (auto e : g[p]) {
if (e.cap && !visited[e.to]) {
visited[e.to] = true;
que.push(e.to);
}
}
}
return visited;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap, class Cost> struct mcf_graph {
public:
mcf_graph() {}
mcf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap, cost});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result(m);
for (int i = 0; i < m; i++) {
result[i] = get_edge(i);
}
return result;
}
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
std::vector<Cost> dual(_n, 0), dist(_n);
std::vector<int> pv(_n), pe(_n);
std::vector<bool> vis(_n);
auto dual_ref = [&]() {
std::fill(dist.begin(), dist.end(), std::numeric_limits<Cost>::max());
std::fill(pv.begin(), pv.end(), -1);
std::fill(pe.begin(), pe.end(), -1);
std::fill(vis.begin(), vis.end(), false);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::priority_queue<Q> que;
dist[s] = 0;
que.push(Q{0, s});
while (!que.empty()) {
int v = que.top().to;
que.pop();
if (vis[v])
continue;
vis[v] = true;
if (v == t)
break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
for (int i = 0; i < int(g[v].size()); i++) {
auto e = g[v][i];
if (vis[e.to] || !e.cap)
continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
que.push(Q{dist[e.to], e.to});
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v])
continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
// (shortest(s, v) + dual[s] - dual[v]) = - shortest(s, t) +
// dual[t] + shortest(s, v) = shortest(s, v) - shortest(s, t) >=
// 0 - (n-1)C
dual[v] -= dist[t] - dist[v];
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost = -1;
std::vector<std::pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (!dual_ref())
break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = pv[v]) {
c = std::min(c, g[pv[v]][pe[v]].cap);
}
for (int v = t; v != s; v = pv[v]) {
auto &e = g[pv[v]][pe[v]];
e.cap -= c;
g[v][e.rev].cap += c;
}
Cost d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost = cost;
}
return result;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <algorithm>
#include <utility>
#include <vector>
namespace atcoder {
namespace internal {
template <class E> struct csr {
std::vector<int> start;
std::vector<E> elist;
csr(int n, const std::vector<std::pair<int, E>> &edges)
: start(n + 1), elist(edges.size()) {
for (auto e : edges) {
start[e.first + 1]++;
}
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
auto counter = start;
for (auto e : edges) {
elist[counter[e.first]++] = e.second;
}
}
};
// Reference:
// R. Tarjan,
// Depth-First Search and Linear Graph Algorithms
struct scc_graph {
public:
scc_graph(int n) : _n(n) {}
int num_vertices() { return _n; }
void add_edge(int from, int to) { edges.push_back({from, {to}}); }
// @return pair of (# of scc, scc id)
std::pair<int, std::vector<int>> scc_ids() {
auto g = csr<edge>(_n, edges);
int now_ord = 0, group_num = 0;
std::vector<int> visited, low(_n), ord(_n, -1), ids(_n);
visited.reserve(_n);
auto dfs = [&](auto self, int v) -> void {
low[v] = ord[v] = now_ord++;
visited.push_back(v);
for (int i = g.start[v]; i < g.start[v + 1]; i++) {
auto to = g.elist[i].to;
if (ord[to] == -1) {
self(self, to);
low[v] = std::min(low[v], low[to]);
} else {
low[v] = std::min(low[v], ord[to]);
}
}
if (low[v] == ord[v]) {
while (true) {
int u = visited.back();
visited.pop_back();
ord[u] = _n;
ids[u] = group_num;
if (u == v)
break;
}
group_num++;
}
};
for (int i = 0; i < _n; i++) {
if (ord[i] == -1)
dfs(dfs, i);
}
for (auto &x : ids) {
x = group_num - 1 - x;
}
return {group_num, ids};
}
std::vector<std::vector<int>> scc() {
auto ids = scc_ids();
int group_num = ids.first;
std::vector<int> counts(group_num);
for (auto x : ids.second)
counts[x]++;
std::vector<std::vector<int>> groups(ids.first);
for (int i = 0; i < group_num; i++) {
groups[i].reserve(counts[i]);
}
for (int i = 0; i < _n; i++) {
groups[ids.second[i]].push_back(i);
}
return groups;
}
private:
int _n;
struct edge {
int to;
};
std::vector<std::pair<int, edge>> edges;
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
struct scc_graph {
public:
scc_graph() : internal(0) {}
scc_graph(int n) : internal(n) {}
void add_edge(int from, int to) {
int n = internal.num_vertices();
assert(0 <= from && from < n);
assert(0 <= to && to < n);
internal.add_edge(from, to);
}
std::vector<std::vector<int>> scc() { return internal.scc(); }
private:
internal::scc_graph internal;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <numeric>
#include <string>
#include <vector>
namespace atcoder {
namespace internal {
std::vector<int> sa_naive(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n);
std::iota(sa.begin(), sa.end(), 0);
std::sort(sa.begin(), sa.end(), [&](int l, int r) {
if (l == r)
return false;
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] < s[r];
l++;
r++;
}
return l == n;
});
return sa;
}
std::vector<int> sa_doubling(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n), rnk = s, tmp(n);
std::iota(sa.begin(), sa.end(), 0);
for (int k = 1; k < n; k *= 2) {
auto cmp = [&](int x, int y) {
if (rnk[x] != rnk[y])
return rnk[x] < rnk[y];
int rx = x + k < n ? rnk[x + k] : -1;
int ry = y + k < n ? rnk[y + k] : -1;
return rx < ry;
};
std::sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp(sa[i - 1], sa[i]) ? 1 : 0);
}
std::swap(tmp, rnk);
}
return sa;
}
// SA-IS, linear-time suffix array construction
// Reference:
// G. Nong, S. Zhang, and W. H. Chan,
// Two Efficient Algorithms for Linear Time Suffix Array Construction
template <int THRESHOLD_NAIVE = 10, int THRESHOLD_DOUBLING = 40>
std::vector<int> sa_is(const std::vector<int> &s, int upper) {
int n = int(s.size());
if (n == 0)
return {};
if (n == 1)
return {0};
if (n == 2) {
if (s[0] < s[1]) {
return {0, 1};
} else {
return {1, 0};
}
}
if (n < THRESHOLD_NAIVE) {
return sa_naive(s);
}
if (n < THRESHOLD_DOUBLING) {
return sa_doubling(s);
}
std::vector<int> sa(n);
std::vector<bool> ls(n);
for (int i = n - 2; i >= 0; i--) {
ls[i] = (s[i] == s[i + 1]) ? ls[i + 1] : (s[i] < s[i + 1]);
}
std::vector<int> sum_l(upper + 1), sum_s(upper + 1);
for (int i = 0; i < n; i++) {
if (!ls[i]) {
sum_s[s[i]]++;
} else {
sum_l[s[i] + 1]++;
}
}
for (int i = 0; i <= upper; i++) {
sum_s[i] += sum_l[i];
if (i < upper)
sum_l[i + 1] += sum_s[i];
}
auto induce = [&](const std::vector<int> &lms) {
std::fill(sa.begin(), sa.end(), -1);
std::vector<int> buf(upper + 1);
std::copy(sum_s.begin(), sum_s.end(), buf.begin());
for (auto d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
std::vector<int> lms_map(n + 1, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms_map[i] = m++;
}
}
std::vector<int> lms;
lms.reserve(m);
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms.push_back(i);
}
}
induce(lms);
if (m) {
std::vector<int> sorted_lms;
sorted_lms.reserve(m);
for (int v : sa) {
if (lms_map[v] != -1)
sorted_lms.push_back(v);
}
std::vector<int> rec_s(m);
int rec_upper = 0;
rec_s[lms_map[sorted_lms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sorted_lms[i - 1], r = sorted_lms[i];
int end_l = (lms_map[l] + 1 < m) ? lms[lms_map[l] + 1] : n;
int end_r = (lms_map[r] + 1 < m) ? lms[lms_map[r] + 1] : n;
bool same = true;
if (end_l - l != end_r - r) {
same = false;
} else {
while (l < end_l) {
if (s[l] != s[r]) {
break;
}
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same)
rec_upper++;
rec_s[lms_map[sorted_lms[i]]] = rec_upper;
}
auto rec_sa = sa_is<THRESHOLD_NAIVE, THRESHOLD_DOUBLING>(rec_s, rec_upper);
for (int i = 0; i < m; i++) {
sorted_lms[i] = lms[rec_sa[i]];
}
induce(sorted_lms);
}
return sa;
}
} // namespace internal
std::vector<int> suffix_array(const std::vector<int> &s, int upper) {
assert(0 <= upper);
for (int d : s) {
assert(0 <= d && d <= upper);
}
auto sa = internal::sa_is(s, upper);
return sa;
}
template <class T> std::vector<int> suffix_array(const std::vector<T> &s) {
int n = int(s.size());
std::vector<int> idx(n);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(), [&](int l, int r) { return s[l] < s[r]; });
std::vector<int> s2(n);
int now = 0;
for (int i = 0; i < n; i++) {
if (i && s[idx[i - 1]] != s[idx[i]])
now++;
s2[idx[i]] = now;
}
return internal::sa_is(s2, now);
}
std::vector<int> suffix_array(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return internal::sa_is(s2, 255);
}
// Reference:
// T. Kasai, G. Lee, H. Arimura, S. Arikawa, and K. Park,
// Linear-Time Longest-Common-Prefix Computation in Suffix Arrays and Its
// Applications
template <class T>
std::vector<int> lcp_array(const std::vector<T> &s,
const std::vector<int> &sa) {
int n = int(s.size());
assert(n >= 1);
std::vector<int> rnk(n);
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
std::vector<int> lcp(n - 1);
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0)
continue;
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
std::vector<int> lcp_array(const std::string &s, const std::vector<int> &sa) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcp_array(s2, sa);
}
// Reference:
// D. Gusfield,
// Algorithms on Strings, Trees, and Sequences: Computer Science and
// Computational Biology
template <class T> std::vector<int> z_algorithm(const std::vector<T> &s) {
int n = int(s.size());
if (n == 0)
return {};
std::vector<int> z(n);
z[0] = 0;
for (int i = 1, j = 0; i < n; i++) {
int &k = z[i];
k = (j + z[j] <= i) ? 0 : std::min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
std::vector<int> z_algorithm(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return z_algorithm(s2);
}
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference:
// B. Aspvall, M. Plass, and R. Tarjan,
// A Linear-Time Algorithm for Testing the Truth of Certain Quantified Boolean
// Formulas
struct two_sat {
public:
two_sat() : _n(0), scc(0) {}
two_sat(int n) : _n(n), _answer(n), scc(2 * n) {}
void add_clause(int i, bool f, int j, bool g) {
assert(0 <= i && i < _n);
assert(0 <= j && j < _n);
scc.add_edge(2 * i + (f ? 0 : 1), 2 * j + (g ? 1 : 0));
scc.add_edge(2 * j + (g ? 0 : 1), 2 * i + (f ? 1 : 0));
}
bool satisfiable() {
auto id = scc.scc_ids().second;
for (int i = 0; i < _n; i++) {
if (id[2 * i] == id[2 * i + 1])
return false;
_answer[i] = id[2 * i] < id[2 * i + 1];
}
return true;
}
std::vector<bool> answer() { return _answer; }
private:
int _n;
std::vector<bool> _answer;
internal::scc_graph scc;
};
} // namespace atcoder
using namespace atcoder;
int op(int l, int r) { return max(l, r); }
int e() { return 0; }
int main() {
int n, k;
cin >> n >> k;
segtree<int, op, e> seg(300'005);
rep(i, n) {
int in;
cin >> in;
in--;
int res = seg.prod(max(0, in - k), min(300'005, in + k + 1));
res++;
seg.set(in, res);
}
int ans = seg.all_prod();
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(ri, n) for (int ri = (int)(n - 1); ri >= 0; ri--)
#define rep2(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri, x, n) for (int ri = (int)(n - 1); ri >= (int)(x); ri--)
#define repit(itr, x) for (auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr, x) for (auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
#include <algorithm>
#include <array>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value, __uint128_t,
unsigned __int128>;
template <class T>
using is_integral =
typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_signed_int =
typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value, make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned =
typename std::conditional<is_signed_int<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)> * = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0)
x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
static_modint(bool v) { _v = ((unsigned int)(v) % umod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v -= rhs._v;
if (_v >= umod())
_v += umod();
return *this;
}
mint &operator*=(const mint &rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0)
x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
dynamic_modint(bool v) { _v = ((unsigned int)(v) % mod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v += mod() - rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator*=(const mint &rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt = 998244353;
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <type_traits>
#include <vector>
namespace atcoder {
namespace internal {
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now;
now *= ies[i];
}
}
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p] * now;
a[i + offset] = l + r;
a[i + offset + p] = l - r;
}
now *= sum_e[bsf(~(unsigned int)(s))];
}
}
}
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly_inv(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_ie[30]; // sum_ie[i] = es[0] * ... * es[i - 1] * ies[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now;
now *= es[i];
}
}
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p];
a[i + offset] = l + r;
a[i + offset + p] =
(unsigned long long)(mint::mod() + l.val() - r.val()) * inow.val();
}
inow *= sum_ie[bsf(~(unsigned int)(s))];
}
}
}
} // namespace internal
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
std::vector<mint> convolution(std::vector<mint> a, std::vector<mint> b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
if (std::min(n, m) <= 60) {
if (n < m) {
std::swap(n, m);
std::swap(a, b);
}
std::vector<mint> ans(n + m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[i + j] += a[i] * b[j];
}
}
return ans;
}
int z = 1 << internal::ceil_pow2(n + m - 1);
a.resize(z);
internal::butterfly(a);
b.resize(z);
internal::butterfly(b);
for (int i = 0; i < z; i++) {
a[i] *= b[i];
}
internal::butterfly_inv(a);
a.resize(n + m - 1);
mint iz = mint(z).inv();
for (int i = 0; i < n + m - 1; i++)
a[i] *= iz;
return a;
}
template <unsigned int mod = 998244353, class T,
std::enable_if_t<internal::is_integral<T>::value> * = nullptr>
std::vector<T> convolution(const std::vector<T> &a, const std::vector<T> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
using mint = static_modint<mod>;
std::vector<mint> a2(n), b2(m);
for (int i = 0; i < n; i++) {
a2[i] = mint(a[i]);
}
for (int i = 0; i < m; i++) {
b2[i] = mint(b[i]);
}
auto c2 = convolution(move(a2), move(b2));
std::vector<T> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
c[i] = c2[i].val();
}
return c;
}
std::vector<long long> convolution_ll(const std::vector<long long> &a,
const std::vector<long long> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
static constexpr unsigned long long MOD1 = 754974721; // 2^24
static constexpr unsigned long long MOD2 = 167772161; // 2^25
static constexpr unsigned long long MOD3 = 469762049; // 2^26
static constexpr unsigned long long M2M3 = MOD2 * MOD3;
static constexpr unsigned long long M1M3 = MOD1 * MOD3;
static constexpr unsigned long long M1M2 = MOD1 * MOD2;
static constexpr unsigned long long M1M2M3 = MOD1 * MOD2 * MOD3;
static constexpr unsigned long long i1 =
internal::inv_gcd(MOD2 * MOD3, MOD1).second;
static constexpr unsigned long long i2 =
internal::inv_gcd(MOD1 * MOD3, MOD2).second;
static constexpr unsigned long long i3 =
internal::inv_gcd(MOD1 * MOD2, MOD3).second;
auto c1 = convolution<MOD1>(a, b);
auto c2 = convolution<MOD2>(a, b);
auto c3 = convolution<MOD3>(a, b);
std::vector<long long> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
unsigned long long x = 0;
x += (c1[i] * i1) % MOD1 * M2M3;
x += (c2[i] * i2) % MOD2 * M1M3;
x += (c3[i] * i3) % MOD3 * M1M2;
// B = 2^63, -B <= x, r(real value) < B
// (x, x - M, x - 2M, or x - 3M) = r (mod 2B)
// r = c1[i] (mod MOD1)
// focus on MOD1
// r = x, x - M', x - 2M', x - 3M' (M' = M % 2^64) (mod 2B)
// r = x,
// x - M' + (0 or 2B),
// x - 2M' + (0, 2B or 4B),
// x - 3M' + (0, 2B, 4B or 6B) (without mod!)
// (r - x) = 0, (0)
// - M' + (0 or 2B), (1)
// -2M' + (0 or 2B or 4B), (2)
// -3M' + (0 or 2B or 4B or 6B) (3) (mod MOD1)
// we checked that
// ((1) mod MOD1) mod 5 = 2
// ((2) mod MOD1) mod 5 = 3
// ((3) mod MOD1) mod 5 = 4
long long diff =
c1[i] - internal::safe_mod((long long)(x), (long long)(MOD1));
if (diff < 0)
diff += MOD1;
static constexpr unsigned long long offset[5] = {0, 0, M1M2M3, 2 * M1M2M3,
3 * M1M2M3};
x -= offset[diff % 5];
c[i] = x;
}
return c;
}
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y)
return x;
if (-parent_or_size[x] < -parent_or_size[y])
std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0)
return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int> &v) { return v.empty(); }),
result.end());
return result;
}
private:
int _n;
// root node: -1 * component size
// otherwise: parent
std::vector<int> parent_or_size;
};
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference: https://en.wikipedia.org/wiki/Fenwick_tree
template <class T> struct fenwick_tree {
using U = internal::to_unsigned_t<T>;
public:
fenwick_tree() : _n(0) {}
fenwick_tree(int n) : _n(n), data(n) {}
void add(int p, T x) {
assert(0 <= p && p < _n);
p++;
while (p <= _n) {
data[p - 1] += U(x);
p += p & -p;
}
}
T sum(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
return sum(r) - sum(l);
}
private:
int _n;
std::vector<U> data;
U sum(int r) {
U s = 0;
while (r > 0) {
s += data[r - 1];
r -= r & -r;
}
return s;
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
#include <algorithm>
#include <vector>
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T &t) { payload.push_back(t); }
T &front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap> struct mf_graph {
public:
mf_graph() : _n(0) {}
mf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result;
for (int i = 0; i < m; i++) {
result.push_back(get_edge(i));
}
return result;
}
void change_edge(int i, Cap new_cap, Cap new_flow) {
int m = int(pos.size());
assert(0 <= i && i < m);
assert(0 <= new_flow && new_flow <= new_cap);
auto &_e = g[pos[i].first][pos[i].second];
auto &_re = g[_e.to][_e.rev];
_e.cap = new_cap - new_flow;
_re.cap = new_flow;
}
Cap flow(int s, int t) { return flow(s, t, std::numeric_limits<Cap>::max()); }
Cap flow(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
std::vector<int> level(_n), iter(_n);
internal::simple_queue<int> que;
auto bfs = [&]() {
std::fill(level.begin(), level.end(), -1);
level[s] = 0;
que.clear();
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto e : g[v]) {
if (e.cap == 0 || level[e.to] >= 0)
continue;
level[e.to] = level[v] + 1;
if (e.to == t)
return;
que.push(e.to);
}
}
};
auto dfs = [&](auto self, int v, Cap up) {
if (v == s)
return up;
Cap res = 0;
int level_v = level[v];
for (int &i = iter[v]; i < int(g[v].size()); i++) {
_edge &e = g[v][i];
if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0)
continue;
Cap d = self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
if (d <= 0)
continue;
g[v][i].cap += d;
g[e.to][e.rev].cap -= d;
res += d;
if (res == up)
break;
}
return res;
};
Cap flow = 0;
while (flow < flow_limit) {
bfs();
if (level[t] == -1)
break;
std::fill(iter.begin(), iter.end(), 0);
while (flow < flow_limit) {
Cap f = dfs(dfs, t, flow_limit - flow);
if (!f)
break;
flow += f;
}
}
return flow;
}
std::vector<bool> min_cut(int s) {
std::vector<bool> visited(_n);
internal::simple_queue<int> que;
que.push(s);
while (!que.empty()) {
int p = que.front();
que.pop();
visited[p] = true;
for (auto e : g[p]) {
if (e.cap && !visited[e.to]) {
visited[e.to] = true;
que.push(e.to);
}
}
}
return visited;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap, class Cost> struct mcf_graph {
public:
mcf_graph() {}
mcf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap, cost});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result(m);
for (int i = 0; i < m; i++) {
result[i] = get_edge(i);
}
return result;
}
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
std::vector<Cost> dual(_n, 0), dist(_n);
std::vector<int> pv(_n), pe(_n);
std::vector<bool> vis(_n);
auto dual_ref = [&]() {
std::fill(dist.begin(), dist.end(), std::numeric_limits<Cost>::max());
std::fill(pv.begin(), pv.end(), -1);
std::fill(pe.begin(), pe.end(), -1);
std::fill(vis.begin(), vis.end(), false);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::priority_queue<Q> que;
dist[s] = 0;
que.push(Q{0, s});
while (!que.empty()) {
int v = que.top().to;
que.pop();
if (vis[v])
continue;
vis[v] = true;
if (v == t)
break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
for (int i = 0; i < int(g[v].size()); i++) {
auto e = g[v][i];
if (vis[e.to] || !e.cap)
continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
que.push(Q{dist[e.to], e.to});
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v])
continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
// (shortest(s, v) + dual[s] - dual[v]) = - shortest(s, t) +
// dual[t] + shortest(s, v) = shortest(s, v) - shortest(s, t) >=
// 0 - (n-1)C
dual[v] -= dist[t] - dist[v];
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost = -1;
std::vector<std::pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (!dual_ref())
break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = pv[v]) {
c = std::min(c, g[pv[v]][pe[v]].cap);
}
for (int v = t; v != s; v = pv[v]) {
auto &e = g[pv[v]][pe[v]];
e.cap -= c;
g[v][e.rev].cap += c;
}
Cost d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost = cost;
}
return result;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <algorithm>
#include <utility>
#include <vector>
namespace atcoder {
namespace internal {
template <class E> struct csr {
std::vector<int> start;
std::vector<E> elist;
csr(int n, const std::vector<std::pair<int, E>> &edges)
: start(n + 1), elist(edges.size()) {
for (auto e : edges) {
start[e.first + 1]++;
}
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
auto counter = start;
for (auto e : edges) {
elist[counter[e.first]++] = e.second;
}
}
};
// Reference:
// R. Tarjan,
// Depth-First Search and Linear Graph Algorithms
struct scc_graph {
public:
scc_graph(int n) : _n(n) {}
int num_vertices() { return _n; }
void add_edge(int from, int to) { edges.push_back({from, {to}}); }
// @return pair of (# of scc, scc id)
std::pair<int, std::vector<int>> scc_ids() {
auto g = csr<edge>(_n, edges);
int now_ord = 0, group_num = 0;
std::vector<int> visited, low(_n), ord(_n, -1), ids(_n);
visited.reserve(_n);
auto dfs = [&](auto self, int v) -> void {
low[v] = ord[v] = now_ord++;
visited.push_back(v);
for (int i = g.start[v]; i < g.start[v + 1]; i++) {
auto to = g.elist[i].to;
if (ord[to] == -1) {
self(self, to);
low[v] = std::min(low[v], low[to]);
} else {
low[v] = std::min(low[v], ord[to]);
}
}
if (low[v] == ord[v]) {
while (true) {
int u = visited.back();
visited.pop_back();
ord[u] = _n;
ids[u] = group_num;
if (u == v)
break;
}
group_num++;
}
};
for (int i = 0; i < _n; i++) {
if (ord[i] == -1)
dfs(dfs, i);
}
for (auto &x : ids) {
x = group_num - 1 - x;
}
return {group_num, ids};
}
std::vector<std::vector<int>> scc() {
auto ids = scc_ids();
int group_num = ids.first;
std::vector<int> counts(group_num);
for (auto x : ids.second)
counts[x]++;
std::vector<std::vector<int>> groups(ids.first);
for (int i = 0; i < group_num; i++) {
groups[i].reserve(counts[i]);
}
for (int i = 0; i < _n; i++) {
groups[ids.second[i]].push_back(i);
}
return groups;
}
private:
int _n;
struct edge {
int to;
};
std::vector<std::pair<int, edge>> edges;
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
struct scc_graph {
public:
scc_graph() : internal(0) {}
scc_graph(int n) : internal(n) {}
void add_edge(int from, int to) {
int n = internal.num_vertices();
assert(0 <= from && from < n);
assert(0 <= to && to < n);
internal.add_edge(from, to);
}
std::vector<std::vector<int>> scc() { return internal.scc(); }
private:
internal::scc_graph internal;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <numeric>
#include <string>
#include <vector>
namespace atcoder {
namespace internal {
std::vector<int> sa_naive(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n);
std::iota(sa.begin(), sa.end(), 0);
std::sort(sa.begin(), sa.end(), [&](int l, int r) {
if (l == r)
return false;
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] < s[r];
l++;
r++;
}
return l == n;
});
return sa;
}
std::vector<int> sa_doubling(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n), rnk = s, tmp(n);
std::iota(sa.begin(), sa.end(), 0);
for (int k = 1; k < n; k *= 2) {
auto cmp = [&](int x, int y) {
if (rnk[x] != rnk[y])
return rnk[x] < rnk[y];
int rx = x + k < n ? rnk[x + k] : -1;
int ry = y + k < n ? rnk[y + k] : -1;
return rx < ry;
};
std::sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp(sa[i - 1], sa[i]) ? 1 : 0);
}
std::swap(tmp, rnk);
}
return sa;
}
// SA-IS, linear-time suffix array construction
// Reference:
// G. Nong, S. Zhang, and W. H. Chan,
// Two Efficient Algorithms for Linear Time Suffix Array Construction
template <int THRESHOLD_NAIVE = 10, int THRESHOLD_DOUBLING = 40>
std::vector<int> sa_is(const std::vector<int> &s, int upper) {
int n = int(s.size());
if (n == 0)
return {};
if (n == 1)
return {0};
if (n == 2) {
if (s[0] < s[1]) {
return {0, 1};
} else {
return {1, 0};
}
}
if (n < THRESHOLD_NAIVE) {
return sa_naive(s);
}
if (n < THRESHOLD_DOUBLING) {
return sa_doubling(s);
}
std::vector<int> sa(n);
std::vector<bool> ls(n);
for (int i = n - 2; i >= 0; i--) {
ls[i] = (s[i] == s[i + 1]) ? ls[i + 1] : (s[i] < s[i + 1]);
}
std::vector<int> sum_l(upper + 1), sum_s(upper + 1);
for (int i = 0; i < n; i++) {
if (!ls[i]) {
sum_s[s[i]]++;
} else {
sum_l[s[i] + 1]++;
}
}
for (int i = 0; i <= upper; i++) {
sum_s[i] += sum_l[i];
if (i < upper)
sum_l[i + 1] += sum_s[i];
}
auto induce = [&](const std::vector<int> &lms) {
std::fill(sa.begin(), sa.end(), -1);
std::vector<int> buf(upper + 1);
std::copy(sum_s.begin(), sum_s.end(), buf.begin());
for (auto d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
std::vector<int> lms_map(n + 1, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms_map[i] = m++;
}
}
std::vector<int> lms;
lms.reserve(m);
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms.push_back(i);
}
}
induce(lms);
if (m) {
std::vector<int> sorted_lms;
sorted_lms.reserve(m);
for (int v : sa) {
if (lms_map[v] != -1)
sorted_lms.push_back(v);
}
std::vector<int> rec_s(m);
int rec_upper = 0;
rec_s[lms_map[sorted_lms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sorted_lms[i - 1], r = sorted_lms[i];
int end_l = (lms_map[l] + 1 < m) ? lms[lms_map[l] + 1] : n;
int end_r = (lms_map[r] + 1 < m) ? lms[lms_map[r] + 1] : n;
bool same = true;
if (end_l - l != end_r - r) {
same = false;
} else {
while (l < end_l) {
if (s[l] != s[r]) {
break;
}
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same)
rec_upper++;
rec_s[lms_map[sorted_lms[i]]] = rec_upper;
}
auto rec_sa = sa_is<THRESHOLD_NAIVE, THRESHOLD_DOUBLING>(rec_s, rec_upper);
for (int i = 0; i < m; i++) {
sorted_lms[i] = lms[rec_sa[i]];
}
induce(sorted_lms);
}
return sa;
}
} // namespace internal
std::vector<int> suffix_array(const std::vector<int> &s, int upper) {
assert(0 <= upper);
for (int d : s) {
assert(0 <= d && d <= upper);
}
auto sa = internal::sa_is(s, upper);
return sa;
}
template <class T> std::vector<int> suffix_array(const std::vector<T> &s) {
int n = int(s.size());
std::vector<int> idx(n);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(), [&](int l, int r) { return s[l] < s[r]; });
std::vector<int> s2(n);
int now = 0;
for (int i = 0; i < n; i++) {
if (i && s[idx[i - 1]] != s[idx[i]])
now++;
s2[idx[i]] = now;
}
return internal::sa_is(s2, now);
}
std::vector<int> suffix_array(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return internal::sa_is(s2, 255);
}
// Reference:
// T. Kasai, G. Lee, H. Arimura, S. Arikawa, and K. Park,
// Linear-Time Longest-Common-Prefix Computation in Suffix Arrays and Its
// Applications
template <class T>
std::vector<int> lcp_array(const std::vector<T> &s,
const std::vector<int> &sa) {
int n = int(s.size());
assert(n >= 1);
std::vector<int> rnk(n);
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
std::vector<int> lcp(n - 1);
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0)
continue;
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
std::vector<int> lcp_array(const std::string &s, const std::vector<int> &sa) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcp_array(s2, sa);
}
// Reference:
// D. Gusfield,
// Algorithms on Strings, Trees, and Sequences: Computer Science and
// Computational Biology
template <class T> std::vector<int> z_algorithm(const std::vector<T> &s) {
int n = int(s.size());
if (n == 0)
return {};
std::vector<int> z(n);
z[0] = 0;
for (int i = 1, j = 0; i < n; i++) {
int &k = z[i];
k = (j + z[j] <= i) ? 0 : std::min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
std::vector<int> z_algorithm(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return z_algorithm(s2);
}
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference:
// B. Aspvall, M. Plass, and R. Tarjan,
// A Linear-Time Algorithm for Testing the Truth of Certain Quantified Boolean
// Formulas
struct two_sat {
public:
two_sat() : _n(0), scc(0) {}
two_sat(int n) : _n(n), _answer(n), scc(2 * n) {}
void add_clause(int i, bool f, int j, bool g) {
assert(0 <= i && i < _n);
assert(0 <= j && j < _n);
scc.add_edge(2 * i + (f ? 0 : 1), 2 * j + (g ? 1 : 0));
scc.add_edge(2 * j + (g ? 0 : 1), 2 * i + (f ? 1 : 0));
}
bool satisfiable() {
auto id = scc.scc_ids().second;
for (int i = 0; i < _n; i++) {
if (id[2 * i] == id[2 * i + 1])
return false;
_answer[i] = id[2 * i] < id[2 * i + 1];
}
return true;
}
std::vector<bool> answer() { return _answer; }
private:
int _n;
std::vector<bool> _answer;
internal::scc_graph scc;
};
} // namespace atcoder
using namespace atcoder;
int op(int l, int r) { return max(l, r); }
int e() { return 0; }
int main() {
int n, k;
cin >> n >> k;
segtree<int, op, e> seg(300'005);
rep(i, n) {
int in;
cin >> in;
int res = seg.prod(max(0, in - k), min(300'005, in + k + 1));
res++;
seg.set(in, res);
}
int ans = seg.all_prod();
cout << ans << endl;
return 0;
}
| delete | 2,174 | 2,175 | 2,174 | 2,174 | 0 | |
p02537 | Python | Runtime Error | # 0-index segment tree
class SegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(0-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num - 1 + i] = init_val[i]
# 構築していく
for i in range(self.num - 2, -1, -1):
self.tree[i] = self.segfunc(self.tree[2 * i + 1], self.tree[2 * i + 2])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num - 1
# self.tree[k] = x <- when updated
# self.tree[k] += x <- when added
self.tree[k] = x
while k > 0:
k = (k - 1) // 2
self.tree[k] = self.segfunc(self.tree[2 * k + 1], self.tree[2 * k + 2])
def query(self, left, right):
if left >= right:
print("left must be smaller than right")
exit(0)
if right > self.num:
print("right must be smaller than self.num")
exit(0)
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
left += self.num - 1
right += self.num - 1
while left < right:
if left & 1 == 0:
res = self.segfunc(res, self.tree[left])
if right & 1 == 0:
right -= 1
res = self.segfunc(res, self.tree[right])
left >>= 1
right >>= 1
return res
MAX_NUM = 10
n, k = map(int, input().split())
a = []
for i in range(n):
a.append(int(input()))
dp = [0] * (MAX_NUM + 5)
segfunc = max
ide_ele = -float("inf")
st = SegmentTree(dp, segfunc, ide_ele)
for num in a:
left = max(0, num - k)
right = min(MAX_NUM, num + k) + 1
st.update(num, st.query(left, right) + 1)
print(st.query(0, MAX_NUM + 1))
| # 0-index segment tree
class SegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(0-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num - 1 + i] = init_val[i]
# 構築していく
for i in range(self.num - 2, -1, -1):
self.tree[i] = self.segfunc(self.tree[2 * i + 1], self.tree[2 * i + 2])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num - 1
# self.tree[k] = x <- when updated
# self.tree[k] += x <- when added
self.tree[k] = x
while k > 0:
k = (k - 1) // 2
self.tree[k] = self.segfunc(self.tree[2 * k + 1], self.tree[2 * k + 2])
def query(self, left, right):
if left >= right:
print("left must be smaller than right")
exit(0)
if right > self.num:
print("right must be smaller than self.num")
exit(0)
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
left += self.num - 1
right += self.num - 1
while left < right:
if left & 1 == 0:
res = self.segfunc(res, self.tree[left])
if right & 1 == 0:
right -= 1
res = self.segfunc(res, self.tree[right])
left >>= 1
right >>= 1
return res
MAX_NUM = 300000
n, k = map(int, input().split())
a = []
for i in range(n):
a.append(int(input()))
dp = [0] * (MAX_NUM + 5)
segfunc = max
ide_ele = -float("inf")
st = SegmentTree(dp, segfunc, ide_ele)
for num in a:
left = max(0, num - k)
right = min(MAX_NUM, num + k) + 1
st.update(num, st.query(left, right) + 1)
print(st.query(0, MAX_NUM + 1))
| replace | 74 | 75 | 74 | 75 | 0 | |
p02538 | C++ | Runtime Error |
// Problem : E - Replace Digits
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_e
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// Macros
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define db long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define sz(x) (int)x.size()
#define mod 998244353
#define EPS 1e-9
#define inf 1e10
#define PI acos(-1.0)
#define int long long
#define N 100005
// Solution
int n, q;
int binpow(int x, int y) {
x %= mod;
int res = 1;
while (y) {
if (y & 1)
res = (res * x) % mod;
x = (x * x) % mod;
y = y / 2;
}
return res;
}
int inv(int a) { return binpow(a, mod - 2); }
int INV = inv(9);
int f(int l, int r, int d) {
int cur = binpow(10, n - r - 1);
cur *= (binpow(10, r - l + 1) - 1 + mod) % mod;
cur %= mod;
cur *= d;
cur %= mod;
cur *= INV;
cur %= mod;
return cur;
}
int t[4 * N], lazy[4 * N];
void push(int v, int tl, int tr) {
int tm = (tl + tr) / 2;
if (lazy[v]) {
t[v * 2] = f(tl, tm, lazy[v]);
lazy[v * 2] = lazy[v];
t[v * 2 + 1] = f(tm + 1, tr, lazy[v]);
lazy[v * 2 + 1] = lazy[v];
lazy[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int d) {
if (l > r)
return;
if (tl >= l && tr <= r) {
t[v] = f(tl, tr, d);
lazy[v] = d;
} else {
push(v, tl, tr);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(tm, r), d);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, d);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl)
return 0;
if (tl >= l && tr <= r)
return t[v];
push(v, tl, tr);
int tm = (tl + tr) / 2;
int ret = 0;
if (l <= tm) {
ret += get(v * 2, tl, tm, l, r);
ret %= mod;
}
if (r > tm) {
ret += get(v * 2 + 1, tm + 1, tr, l, r);
ret %= mod;
}
return ret;
}
void solve() {
cin >> n >> q;
int ans = f(0, n - 1, 1);
update(1, 0, n - 1, 0, n - 1, 1);
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l--, r--;
int sum = get(1, 0, n - 1, l, r);
int now = f(l, r, d);
update(1, 0, n - 1, l, r, d);
ans = (ans - sum + mod) % mod;
ans = (ans + now) % mod;
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
int tests;
tests = 1;
// cin>>tests;
for (int test = 1; test <= tests; test++) {
// cout<<"Case #"<<test<<": ";
solve();
}
return 0;
} |
// Problem : E - Replace Digits
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_e
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// Macros
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define db long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define sz(x) (int)x.size()
#define mod 998244353
#define EPS 1e-9
#define inf 1e10
#define PI acos(-1.0)
#define int long long
#define N 200005
// Solution
int n, q;
int binpow(int x, int y) {
x %= mod;
int res = 1;
while (y) {
if (y & 1)
res = (res * x) % mod;
x = (x * x) % mod;
y = y / 2;
}
return res;
}
int inv(int a) { return binpow(a, mod - 2); }
int INV = inv(9);
int f(int l, int r, int d) {
int cur = binpow(10, n - r - 1);
cur *= (binpow(10, r - l + 1) - 1 + mod) % mod;
cur %= mod;
cur *= d;
cur %= mod;
cur *= INV;
cur %= mod;
return cur;
}
int t[4 * N], lazy[4 * N];
void push(int v, int tl, int tr) {
int tm = (tl + tr) / 2;
if (lazy[v]) {
t[v * 2] = f(tl, tm, lazy[v]);
lazy[v * 2] = lazy[v];
t[v * 2 + 1] = f(tm + 1, tr, lazy[v]);
lazy[v * 2 + 1] = lazy[v];
lazy[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int d) {
if (l > r)
return;
if (tl >= l && tr <= r) {
t[v] = f(tl, tr, d);
lazy[v] = d;
} else {
push(v, tl, tr);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(tm, r), d);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, d);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl)
return 0;
if (tl >= l && tr <= r)
return t[v];
push(v, tl, tr);
int tm = (tl + tr) / 2;
int ret = 0;
if (l <= tm) {
ret += get(v * 2, tl, tm, l, r);
ret %= mod;
}
if (r > tm) {
ret += get(v * 2 + 1, tm + 1, tr, l, r);
ret %= mod;
}
return ret;
}
void solve() {
cin >> n >> q;
int ans = f(0, n - 1, 1);
update(1, 0, n - 1, 0, n - 1, 1);
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l--, r--;
int sum = get(1, 0, n - 1, l, r);
int now = f(l, r, d);
update(1, 0, n - 1, l, r, d);
ans = (ans - sum + mod) % mod;
ans = (ans + now) % mod;
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
int tests;
tests = 1;
// cin>>tests;
for (int test = 1; test <= tests; test++) {
// cout<<"Case #"<<test<<": ";
solve();
}
return 0;
} | replace | 37 | 38 | 37 | 38 | 0 | |
p02538 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define re register
#define ls (o << 1)
#define m (l + r) / 2
#define rs (o << 1 | 1)
#define pb push_back
const double PI = acos(-1.0);
const int M = 1e5 + 7;
/*
int head[M],cnt=1;
void init(int n){cnt=1;for(int i=0;i<=n;i++)head[i]=0;}
struct EDGE{int to,nxt,w;}ee[M*2];
void add(int x,int y,int
w){ee[++cnt].nxt=head[x],ee[cnt].w=w,ee[cnt].to=y,head[x]=cnt;}
*/
const int mod = 998244353;
struct node {
ll val, len;
};
ll s[M], qp[M];
ll sm[M << 2]; // 区间数字组成的数的值。
ll tg[M << 2];
void bd(int o, int l, int r) {
if (l == r) {
sm[o] = 1;
return;
}
bd(ls, l, m);
bd(rs, m + 1, r);
sm[o] = (sm[ls] * qp[r - m] % mod + sm[rs]) % mod;
}
void pd(int o, int l, int r) {
if (tg[o] == 0)
return;
sm[ls] = s[m - l + 1] * tg[o] % mod;
sm[rs] = s[r - m] * tg[o] % mod;
tg[ls] = tg[rs] = tg[o];
tg[o] = 0;
}
void up(int o, int l, int r, int x, int y, ll d) // 区间覆盖
{
if (x <= l && r <= y) {
sm[o] = s[r - l + 1] * d % mod;
tg[o] = d;
return;
}
pd(o, l, r);
if (x <= m)
up(ls, l, m, x, y, d);
if (y > m)
up(rs, m + 1, r, x, y, d);
sm[o] = (sm[ls] * qp[r - m] % mod + sm[rs]) % mod;
// cout<<" = = "<<l<<" "<<r<<" "<<sm[ls]<<" "<<sm[rs]<<" "<<sm[o]<<endl;
}
node qu(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
return node{sm[o], r - l + 1};
}
pd(o, l, r);
node a = node{0, 0}, b = node{0, 0};
if (x <= m)
a = qu(ls, l, m, x, y);
if (y > m)
b = qu(rs, m + 1, r, x, y);
// cout<<l<<" "<<r<<" = "<<a.val<<" "<<a.len<<" b: "<<b.val<<" "
//<<b.len<<endl;
return node{a.val * qp[b.len] % mod + b.val, a.len + b.len};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
s[1] = qp[0] = 1;
qp[1] = 10;
for (int i = 2; i <= n; i++)
s[i] = (s[i - 1] + qp[i - 1]) % mod, qp[i] = qp[i - 1] * 10 % mod;
bd(1, 1, n);
while (q--) {
int l, r, opt;
ll d;
cin >> l >> r >> d;
up(1, 1, n, l, r, d);
cout << qu(1, 1, n, 1, n).val << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define re register
#define ls (o << 1)
#define m (l + r) / 2
#define rs (o << 1 | 1)
#define pb push_back
const double PI = acos(-1.0);
const int M = 1e6 + 7;
/*
int head[M],cnt=1;
void init(int n){cnt=1;for(int i=0;i<=n;i++)head[i]=0;}
struct EDGE{int to,nxt,w;}ee[M*2];
void add(int x,int y,int
w){ee[++cnt].nxt=head[x],ee[cnt].w=w,ee[cnt].to=y,head[x]=cnt;}
*/
const int mod = 998244353;
struct node {
ll val, len;
};
ll s[M], qp[M];
ll sm[M << 2]; // 区间数字组成的数的值。
ll tg[M << 2];
void bd(int o, int l, int r) {
if (l == r) {
sm[o] = 1;
return;
}
bd(ls, l, m);
bd(rs, m + 1, r);
sm[o] = (sm[ls] * qp[r - m] % mod + sm[rs]) % mod;
}
void pd(int o, int l, int r) {
if (tg[o] == 0)
return;
sm[ls] = s[m - l + 1] * tg[o] % mod;
sm[rs] = s[r - m] * tg[o] % mod;
tg[ls] = tg[rs] = tg[o];
tg[o] = 0;
}
void up(int o, int l, int r, int x, int y, ll d) // 区间覆盖
{
if (x <= l && r <= y) {
sm[o] = s[r - l + 1] * d % mod;
tg[o] = d;
return;
}
pd(o, l, r);
if (x <= m)
up(ls, l, m, x, y, d);
if (y > m)
up(rs, m + 1, r, x, y, d);
sm[o] = (sm[ls] * qp[r - m] % mod + sm[rs]) % mod;
// cout<<" = = "<<l<<" "<<r<<" "<<sm[ls]<<" "<<sm[rs]<<" "<<sm[o]<<endl;
}
node qu(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
return node{sm[o], r - l + 1};
}
pd(o, l, r);
node a = node{0, 0}, b = node{0, 0};
if (x <= m)
a = qu(ls, l, m, x, y);
if (y > m)
b = qu(rs, m + 1, r, x, y);
// cout<<l<<" "<<r<<" = "<<a.val<<" "<<a.len<<" b: "<<b.val<<" "
//<<b.len<<endl;
return node{a.val * qp[b.len] % mod + b.val, a.len + b.len};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
s[1] = qp[0] = 1;
qp[1] = 10;
for (int i = 2; i <= n; i++)
s[i] = (s[i - 1] + qp[i - 1]) % mod, qp[i] = qp[i - 1] * 10 % mod;
bd(1, 1, n);
while (q--) {
int l, r, opt;
ll d;
cin >> l >> r >> d;
up(1, 1, n, l, r, d);
cout << qu(1, 1, n, 1, n).val << endl;
}
return 0;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02538 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5 + 10;
const int mod = 998244353;
ll n, q, l, r, k;
ll num[N], all_1[N];
struct A {
ll l, r, num, lazy;
} a[4 * N];
void f(int root, int k) {
a[root].lazy = k;
a[root].num = (k * all_1[a[root].r - a[root].l + 1]) % mod;
}
void pushback(int root) {
int l = a[root].l;
int r = a[root].r;
ll mid = (l + r) >> 1;
if (a[root].lazy != 0) {
f(root << 1, a[root].lazy);
f(root << 1 | 1, a[root].lazy);
}
a[root].lazy = 0;
}
void pushup(int root) {
a[root].num = (a[root << 1].num * num[a[root << 1 | 1].r - a[root << 1].r] +
a[root << 1 | 1].num) %
mod;
}
void buid(int l, int r, int root) {
a[root].l = l;
a[root].r = r;
if (l == r) {
a[root].num = 1;
return;
}
ll mid = (l + r) >> 1;
buid(l, mid, root << 1);
buid(mid + 1, r, root << 1 | 1);
pushup(root);
}
void update(ll l, ll r, ll root, ll d) {
pushback(root);
if (a[root].r <= r && a[root].l >= l) {
f(root, d);
return;
}
ll mid = (a[root].l + a[root].r) >> 1;
if (mid >= l) {
update(l, r, root << 1, d);
}
if (mid < r) {
update(l, r, root << 1 | 1, d);
}
pushup(root);
}
ll quary(ll l, ll r, ll root) {
pushback(root);
if (a[root].l >= l && a[root].r <= r) {
return a[root].num;
}
int mid = (a[root].r + a[root].l) / 2;
ll lso = 0, rso = 0;
if (mid >= l) {
lso = quary(l, r, root << 1);
}
if (mid < r) {
rso = quary(l, r, root << 1 | 1);
}
ll sum = (lso * (n - a[root << 1].r) + rso) % mod;
return sum;
}
int main() {
cin >> n >> q;
num[0] = 1;
for (int i = 1; i <= n; i++)
num[i] = (num[i - 1] * 10) % mod;
all_1[1] = 1;
for (int i = 2; i <= n; i++)
all_1[i] = (all_1[i - 1] * 10 + 1) % mod;
buid(1, n, 1);
while (q--) {
cin >> l >> r >> k;
update(l, r, 1, k);
cout << quary(1, n, 1) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5 + 10;
const int mod = 998244353;
ll n, q, l, r, k;
ll num[N], all_1[N];
struct A {
ll l, r, num, lazy;
} a[2000005];
void f(int root, int k) {
a[root].lazy = k;
a[root].num = (k * all_1[a[root].r - a[root].l + 1]) % mod;
}
void pushback(int root) {
int l = a[root].l;
int r = a[root].r;
ll mid = (l + r) >> 1;
if (a[root].lazy != 0) {
f(root << 1, a[root].lazy);
f(root << 1 | 1, a[root].lazy);
}
a[root].lazy = 0;
}
void pushup(int root) {
a[root].num = (a[root << 1].num * num[a[root << 1 | 1].r - a[root << 1].r] +
a[root << 1 | 1].num) %
mod;
}
void buid(int l, int r, int root) {
a[root].l = l;
a[root].r = r;
if (l == r) {
a[root].num = 1;
return;
}
ll mid = (l + r) >> 1;
buid(l, mid, root << 1);
buid(mid + 1, r, root << 1 | 1);
pushup(root);
}
void update(ll l, ll r, ll root, ll d) {
pushback(root);
if (a[root].r <= r && a[root].l >= l) {
f(root, d);
return;
}
ll mid = (a[root].l + a[root].r) >> 1;
if (mid >= l) {
update(l, r, root << 1, d);
}
if (mid < r) {
update(l, r, root << 1 | 1, d);
}
pushup(root);
}
ll quary(ll l, ll r, ll root) {
pushback(root);
if (a[root].l >= l && a[root].r <= r) {
return a[root].num;
}
int mid = (a[root].r + a[root].l) / 2;
ll lso = 0, rso = 0;
if (mid >= l) {
lso = quary(l, r, root << 1);
}
if (mid < r) {
rso = quary(l, r, root << 1 | 1);
}
ll sum = (lso * (n - a[root << 1].r) + rso) % mod;
return sum;
}
int main() {
cin >> n >> q;
num[0] = 1;
for (int i = 1; i <= n; i++)
num[i] = (num[i - 1] * 10) % mod;
all_1[1] = 1;
for (int i = 2; i <= n; i++)
all_1[i] = (all_1[i - 1] * 10 + 1) % mod;
buid(1, n, 1);
while (q--) {
cin >> l >> r >> k;
update(l, r, 1, k);
cout << quary(1, n, 1) << endl;
}
return 0;
}
| replace | 9 | 10 | 9 | 10 | 0 | |
p02538 | C++ | Runtime Error |
// Problem : E - Replace Digits
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_e
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define db double
#define mod 998244353
#define pb push_back
#define pp pair<int, int>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repe(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = b; i >= a; i--)
#define N 200005
#define ss second
#define ff first
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
int inv(int a, int b) { return 1 < a ? b - inv(b % a, a) * b / a : 1; }
int n, q;
int st[N * 4], lazy[N * 4], po[N];
void build(int p, int l, int r) {
if (l == r) {
st[p] = po[l];
return;
}
int m = (l + r) / 2;
build(2 * p, l, m);
build(2 * p + 1, m + 1, r);
st[p] = st[2 * p] + st[2 * p + 1];
}
void fun() {
int s = 1;
for (int i = 0; i < N; i++) {
po[i] = s;
s *= 10;
s %= mod;
}
}
int cal(int l, int r, int d) {
int a = d * po[l];
a %= mod;
int len = r - l + 1;
a *= (po[len] - 1);
a %= mod;
int t = inv(9, mod);
a *= t;
a %= mod;
return a;
}
void push(int p, int l, int r) {
if (lazy[p] == 0)
return;
int m = (l + r) / 2;
lazy[2 * p] = lazy[p];
lazy[2 * p + 1] = lazy[p];
int d = lazy[p];
lazy[p] = 0;
st[2 * p] = cal(l, m, d);
st[2 * p + 1] = cal(m + 1, r, d);
}
int query(int p, int l, int r, int i, int j) {
if (i > r || j < l)
return 0;
push(p, l, r);
if (i <= l and r <= j)
return st[p];
int m = (l + r) / 2;
return (query(2 * p, l, m, i, j) + query(2 * p + 1, m + 1, r, i, j)) % mod;
}
void update(int p, int l, int r, int i, int j, int d) {
if (i > r || j < l)
return;
push(p, l, r);
if (i <= l and r <= j) {
st[p] = cal(l, r, d);
lazy[p] = d;
return;
}
int m = (l + r) / 2;
update(2 * p, l, m, i, j, d);
update(2 * p + 1, m + 1, r, i, j, d);
st[p] = (st[2 * p] + st[2 * p + 1]) % mod;
}
void solve() {
fun();
cin >> n;
build(1, 0, n - 1);
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l = n - l;
r = n - r;
swap(l, r);
int num = st[1];
int diff = query(1, 0, n - 1, l, r);
num -= diff;
num %= mod;
num += mod;
num %= mod;
num += cal(l, r, d);
num %= mod;
cout << num << "\n";
update(1, 0, n - 1, l, r, d);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
}
|
// Problem : E - Replace Digits
// Contest : AtCoder - ACL Beginner Contest
// URL : https://atcoder.jp/contests/abl/tasks/abl_e
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define db double
#define mod 998244353
#define pb push_back
#define pp pair<int, int>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repe(i, a, b) for (int i = a; i <= b; i++)
#define repr(i, a, b) for (int i = b; i >= a; i--)
#define N 300005
#define ss second
#define ff first
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
int inv(int a, int b) { return 1 < a ? b - inv(b % a, a) * b / a : 1; }
int n, q;
int st[N * 4], lazy[N * 4], po[N];
void build(int p, int l, int r) {
if (l == r) {
st[p] = po[l];
return;
}
int m = (l + r) / 2;
build(2 * p, l, m);
build(2 * p + 1, m + 1, r);
st[p] = st[2 * p] + st[2 * p + 1];
}
void fun() {
int s = 1;
for (int i = 0; i < N; i++) {
po[i] = s;
s *= 10;
s %= mod;
}
}
int cal(int l, int r, int d) {
int a = d * po[l];
a %= mod;
int len = r - l + 1;
a *= (po[len] - 1);
a %= mod;
int t = inv(9, mod);
a *= t;
a %= mod;
return a;
}
void push(int p, int l, int r) {
if (lazy[p] == 0)
return;
int m = (l + r) / 2;
lazy[2 * p] = lazy[p];
lazy[2 * p + 1] = lazy[p];
int d = lazy[p];
lazy[p] = 0;
st[2 * p] = cal(l, m, d);
st[2 * p + 1] = cal(m + 1, r, d);
}
int query(int p, int l, int r, int i, int j) {
if (i > r || j < l)
return 0;
push(p, l, r);
if (i <= l and r <= j)
return st[p];
int m = (l + r) / 2;
return (query(2 * p, l, m, i, j) + query(2 * p + 1, m + 1, r, i, j)) % mod;
}
void update(int p, int l, int r, int i, int j, int d) {
if (i > r || j < l)
return;
push(p, l, r);
if (i <= l and r <= j) {
st[p] = cal(l, r, d);
lazy[p] = d;
return;
}
int m = (l + r) / 2;
update(2 * p, l, m, i, j, d);
update(2 * p + 1, m + 1, r, i, j, d);
st[p] = (st[2 * p] + st[2 * p + 1]) % mod;
}
void solve() {
fun();
cin >> n;
build(1, 0, n - 1);
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l = n - l;
r = n - r;
swap(l, r);
int num = st[1];
int diff = query(1, 0, n - 1, l, r);
num -= diff;
num %= mod;
num += mod;
num %= mod;
num += cal(l, r, d);
num %= mod;
cout << num << "\n";
update(1, 0, n - 1, l, r, d);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p02538 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rp1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define rp0(i, n) for ((i) = 0; (i) < (n); (i)++)
using namespace std;
const int mod = 998244353;
int n, q, f[800005], tag[800005], s[800005], lst = 1;
void build(int x, int l, int r) {
tag[x] = 0;
if (l == r) {
f[x] = s[x] = lst;
lst = 10ll * lst % mod;
return;
}
int mid = (l + r) / 2;
build(x + x + 1, mid + 1, r);
build(x + x, l, mid);
s[x] = f[x] = (f[x + x] + f[x + x + 1]) % mod;
}
void update(int x, int l, int r, int ll, int rr, int c) {
if (l == r) {
tag[x] = c;
s[x] = 1ll * f[x] * c % mod;
return;
}
if (tag[x]) {
tag[x + x] = tag[x + x + 1] = tag[x];
s[x + x] = 1ll * f[x + x] * tag[x] % mod;
s[x + x + 1] = 1ll * f[x + x + 1] * tag[x] % mod;
tag[x] = 0;
}
int mid = (l + r) / 2;
if (ll <= mid)
update(x + x, l, mid, ll, rr, c);
if (rr > mid)
update(x + x + 1, mid + 1, r, ll, rr, c);
s[x] = (s[x + x] + s[x + x + 1]) % mod;
}
int main() {
cin >> n >> q;
int i;
build(1, 1, n);
rp0(i, q) {
int l, r, d;
cin >> l >> r >> d;
update(1, 1, n, l, r, d);
cout << s[1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rp1(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define rp0(i, n) for ((i) = 0; (i) < (n); (i)++)
using namespace std;
const int mod = 998244353;
int n, q, f[800005], tag[800005], s[800005], lst = 1;
void build(int x, int l, int r) {
tag[x] = 0;
if (l == r) {
f[x] = s[x] = lst;
lst = 10ll * lst % mod;
return;
}
int mid = (l + r) / 2;
build(x + x + 1, mid + 1, r);
build(x + x, l, mid);
s[x] = f[x] = (f[x + x] + f[x + x + 1]) % mod;
}
void update(int x, int l, int r, int ll, int rr, int c) {
if (ll <= l && r <= rr) {
tag[x] = c;
s[x] = 1ll * f[x] * c % mod;
return;
}
if (tag[x]) {
tag[x + x] = tag[x + x + 1] = tag[x];
s[x + x] = 1ll * f[x + x] * tag[x] % mod;
s[x + x + 1] = 1ll * f[x + x + 1] * tag[x] % mod;
tag[x] = 0;
}
int mid = (l + r) / 2;
if (ll <= mid)
update(x + x, l, mid, ll, rr, c);
if (rr > mid)
update(x + x + 1, mid + 1, r, ll, rr, c);
s[x] = (s[x + x] + s[x + x + 1]) % mod;
}
int main() {
cin >> n >> q;
int i;
build(1, 1, n);
rp0(i, q) {
int l, r, d;
cin >> l >> r >> d;
update(1, 1, n, l, r, d);
cout << s[1] << endl;
}
return 0;
} | replace | 19 | 20 | 19 | 20 | TLE | |
p02538 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {0, 0, 1, -1, 1, 1, -1, -1, 0};
const ll dx[9] = {1, -1, 0, 0, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename X, typename M>
struct
SegTreeLazy { // 遅延セグ木 単位元に注意(updateなら選ばれない数、affineなら(1,0))
using FX = function<X(X, X)>;
using FA = function<X(X, M)>;
using FM = function<M(M, M)>;
int n;
FX fx;
FA fa;
FM fm;
const X ex;
const M em;
vector<X> dat;
vector<M> lazy;
SegTreeLazy(int n_, FX fx_, FA fa_, FM fm_, X ex_, M em_)
: n(), fx(fx_), fa(fa_), fm(fm_), ex(ex_), em(em_), dat(n_ * 4, ex),
lazy(n_ * 4, em) {
int x = 1;
while (n_ > x)
x *= 2;
n = x;
}
void set(int i, X x) { dat[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--)
dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
/* lazy eval */
void eval(int k, int len) {
if (lazy[k] == em)
return; // 更新するものが無ければ終了
if (k < n - 1) { // 葉でなければ子に伝搬
lazy[k * 2 + 1] = fm(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = fm(lazy[k * 2 + 2], lazy[k]);
}
// 自身を更新
dat[k] = fa(dat[k], lazy[k]); // fa(dat[k], fp(lazy[k], len));
lazy[k] = em;
}
void update(int a, int b, M x, int k, int l, int r) {
eval(k, r - l);
if (a <= l && r <= b) { // 完全に内側の時
lazy[k] = fm(lazy[k], x);
eval(k, r - l);
} else if (a < r && l < b) { // 一部区間が被る時
update(a, b, x, k * 2 + 1, l, (l + r) / 2); // 左の子
update(a, b, x, k * 2 + 2, (l + r) / 2, r); // 右の子
dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
void update(int a, int b, M x) { update(a, b, x, 0, 0, n); }
X query_sub(int a, int b, int k, int l, int r) {
eval(k, r - l);
if (r <= a || b <= l) { // 完全に外側の時
return ex;
} else if (a <= l && r <= b) { // 完全に内側の時
return dat[k];
} else { // 一部区間が被る時
X vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
X vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
X query(int a, int b) { return query_sub(a, b, 0, 0, n); }
X operator[](int i) { return query(i, i + 1); }
};
const int mod = MOD9;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
bool operator==(const mint &p) const { return x == p.x; }
bool operator!=(const mint &p) const { return x != p.x; }
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
using pm = pair<mint, int>;
vector<mint> tenpow(200010);
int main() {
ll n, q;
cin >> n >> q;
tenpow[0] = 1;
rep(i, 200009) tenpow[i + 1] = tenpow[i] * 10;
auto fx = [](pm a, pm b) {
a.fi *= tenpow[b.se];
a.fi += b.fi;
a.se += b.se;
return a;
};
auto fa = [](pm a, int d) {
a.fi = tenpow[a.se] - 1;
a.fi /= 9;
a.fi *= d;
return a;
};
auto fm = [](int a, int b) { return b; };
SegTreeLazy<pm, int> st(n, fx, fa, fm, {0, 0}, 0);
rep(i, n) st.set(i, {1, 1});
st.build();
while (q--) {
int l, r, d;
scanf("%d", &l);
scanf("%d", &r);
scanf("%d", &d);
l--;
st.update(l, r, d);
// cout << st.dat[0].fi <<endl;
printf("%lld\n", st.dat[0].fi.x);
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {0, 0, 1, -1, 1, 1, -1, -1, 0};
const ll dx[9] = {1, -1, 0, 0, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename X, typename M>
struct
SegTreeLazy { // 遅延セグ木 単位元に注意(updateなら選ばれない数、affineなら(1,0))
using FX = function<X(X, X)>;
using FA = function<X(X, M)>;
using FM = function<M(M, M)>;
int n;
FX fx;
FA fa;
FM fm;
const X ex;
const M em;
vector<X> dat;
vector<M> lazy;
SegTreeLazy(int n_, FX fx_, FA fa_, FM fm_, X ex_, M em_)
: n(), fx(fx_), fa(fa_), fm(fm_), ex(ex_), em(em_), dat(n_ * 4, ex),
lazy(n_ * 4, em) {
int x = 1;
while (n_ > x)
x *= 2;
n = x;
}
void set(int i, X x) { dat[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--)
dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
/* lazy eval */
void eval(int k, int len) {
if (lazy[k] == em)
return; // 更新するものが無ければ終了
if (k < n - 1) { // 葉でなければ子に伝搬
lazy[k * 2 + 1] = fm(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = fm(lazy[k * 2 + 2], lazy[k]);
}
// 自身を更新
dat[k] = fa(dat[k], lazy[k]); // fa(dat[k], fp(lazy[k], len));
lazy[k] = em;
}
void update(int a, int b, M x, int k, int l, int r) {
eval(k, r - l);
if (a <= l && r <= b) { // 完全に内側の時
lazy[k] = fm(lazy[k], x);
eval(k, r - l);
} else if (a < r && l < b) { // 一部区間が被る時
update(a, b, x, k * 2 + 1, l, (l + r) / 2); // 左の子
update(a, b, x, k * 2 + 2, (l + r) / 2, r); // 右の子
dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
void update(int a, int b, M x) { update(a, b, x, 0, 0, n); }
X query_sub(int a, int b, int k, int l, int r) {
eval(k, r - l);
if (r <= a || b <= l) { // 完全に外側の時
return ex;
} else if (a <= l && r <= b) { // 完全に内側の時
return dat[k];
} else { // 一部区間が被る時
X vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
X vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
X query(int a, int b) { return query_sub(a, b, 0, 0, n); }
X operator[](int i) { return query(i, i + 1); }
};
const int mod = MOD9;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
bool operator==(const mint &p) const { return x == p.x; }
bool operator!=(const mint &p) const { return x != p.x; }
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
using pm = pair<mint, int>;
vector<mint> tenpow(200010);
int main() {
ll n, q;
cin >> n >> q;
tenpow[0] = 1;
rep(i, 200009) tenpow[i + 1] = tenpow[i] * 10;
auto fx = [](pm a, pm b) {
a.fi *= tenpow[b.se];
a.fi += b.fi;
a.se += b.se;
return a;
};
auto fa = [](pm a, int d) {
a.fi = tenpow[a.se] - 1;
a.fi *= 443664157;
a.fi *= d;
return a;
};
auto fm = [](int a, int b) { return b; };
SegTreeLazy<pm, int> st(n, fx, fa, fm, {0, 0}, 0);
rep(i, n) st.set(i, {1, 1});
st.build();
while (q--) {
int l, r, d;
scanf("%d", &l);
scanf("%d", &r);
scanf("%d", &d);
l--;
st.update(l, r, d);
// cout << st.dat[0].fi <<endl;
printf("%lld\n", st.dat[0].fi.x);
}
}
| replace | 165 | 166 | 165 | 166 | TLE | |
p02538 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5 + 3;
const int mod = 998244353;
ll n, q, l, r, k;
ll num[N], all_1[N];
struct A {
ll l, r, num, lazy;
} a[N];
void f(int root, int k) {
a[root].lazy = k;
a[root].num = (k * all_1[a[root].r - a[root].l + 1]) % mod;
}
void pushback(int root) {
int l = a[root].l;
int r = a[root].r;
ll mid = (l + r) >> 1;
if (a[root].lazy != 0) {
f(root << 1, a[root].lazy);
f(root << 1 | 1, a[root].lazy);
}
a[root].lazy = 0;
}
void pushup(int root) {
a[root].num = (a[root << 1].num * num[a[root << 1 | 1].r - a[root << 1].r] +
a[root << 1 | 1].num) %
mod;
}
void buid(int l, int r, int root) {
a[root].l = l;
a[root].r = r;
if (l == r) {
a[root].num = 1;
return;
}
ll mid = (l + r) >> 1;
buid(l, mid, root << 1);
buid(mid + 1, r, root << 1 | 1);
pushup(root);
}
void update(ll l, ll r, ll root, ll d) {
pushback(root);
if (a[root].r <= r && a[root].l >= l) {
f(root, d);
return;
}
ll mid = (a[root].l + a[root].r) >> 1;
if (mid >= l) {
update(l, r, root << 1, d);
}
if (mid < r) {
update(l, r, root << 1 | 1, d);
}
pushup(root);
}
ll quary(ll l, ll r, ll root) {
pushback(root);
if (a[root].l >= l && a[root].r <= r) {
return a[root].num;
}
int mid = (a[root].r + a[root].l) / 2;
ll lso = 0, rso = 0;
if (mid >= l) {
lso = quary(l, r, root << 1);
}
if (mid < r) {
rso = quary(l, r, root << 1 | 1);
}
ll sum = (lso * (n - a[root << 1].r) + rso) % mod;
return sum;
}
int main() {
cin >> n >> q;
num[0] = 1;
for (int i = 1; i <= n; i++)
num[i] = (num[i - 1] * 10) % mod;
all_1[1] = 1;
for (int i = 2; i <= n; i++)
all_1[i] = (all_1[i - 1] * 10 + 1) % mod;
buid(1, n, 1);
while (q--) {
cin >> l >> r >> k;
update(l, r, 1, k);
cout << quary(1, n, 1) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e6 + 3;
const int mod = 998244353;
ll n, q, l, r, k;
ll num[N], all_1[N];
struct A {
ll l, r, num, lazy;
} a[N];
void f(int root, int k) {
a[root].lazy = k;
a[root].num = (k * all_1[a[root].r - a[root].l + 1]) % mod;
}
void pushback(int root) {
int l = a[root].l;
int r = a[root].r;
ll mid = (l + r) >> 1;
if (a[root].lazy != 0) {
f(root << 1, a[root].lazy);
f(root << 1 | 1, a[root].lazy);
}
a[root].lazy = 0;
}
void pushup(int root) {
a[root].num = (a[root << 1].num * num[a[root << 1 | 1].r - a[root << 1].r] +
a[root << 1 | 1].num) %
mod;
}
void buid(int l, int r, int root) {
a[root].l = l;
a[root].r = r;
if (l == r) {
a[root].num = 1;
return;
}
ll mid = (l + r) >> 1;
buid(l, mid, root << 1);
buid(mid + 1, r, root << 1 | 1);
pushup(root);
}
void update(ll l, ll r, ll root, ll d) {
pushback(root);
if (a[root].r <= r && a[root].l >= l) {
f(root, d);
return;
}
ll mid = (a[root].l + a[root].r) >> 1;
if (mid >= l) {
update(l, r, root << 1, d);
}
if (mid < r) {
update(l, r, root << 1 | 1, d);
}
pushup(root);
}
ll quary(ll l, ll r, ll root) {
pushback(root);
if (a[root].l >= l && a[root].r <= r) {
return a[root].num;
}
int mid = (a[root].r + a[root].l) / 2;
ll lso = 0, rso = 0;
if (mid >= l) {
lso = quary(l, r, root << 1);
}
if (mid < r) {
rso = quary(l, r, root << 1 | 1);
}
ll sum = (lso * (n - a[root << 1].r) + rso) % mod;
return sum;
}
int main() {
cin >> n >> q;
num[0] = 1;
for (int i = 1; i <= n; i++)
num[i] = (num[i - 1] * 10) % mod;
all_1[1] = 1;
for (int i = 2; i <= n; i++)
all_1[i] = (all_1[i - 1] * 10 + 1) % mod;
buid(1, n, 1);
while (q--) {
cin >> l >> r >> k;
update(l, r, 1, k);
cout << quary(1, n, 1) << endl;
}
return 0;
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p02538 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl '\n'
// #define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define BIT(n) (1LL << (n))
#define TOUPPER(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define TOLOWER(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
#define FILLZERO(s, n) \
do { \
ostringstream os; \
os << setw(n) << setfill('0') << s; \
s = os.str(); \
} while (0);
#define UNIQUE(v) \
v.erase(unique(v.begin(), v.end()), v.end()) // sortしてからつかうこと
#define INIT \
std::cin.tie(nullptr); \
std::ios_base::sync_with_stdio(false); \
cout << std::fixed << std::setprecision(10);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using pi = pair<int, int>;
template <typename T> using Pq = priority_queue<T>;
template <typename T> using pQ = priority_queue<T, vector<T>, greater<T>>;
template <typename T> vector<T> make_vec(size_t a, T n) {
return vector<T>(a, n);
}
template <typename T, typename... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <long long mod> class Fp {
private:
long long val;
public:
Fp() { val = 0; }
Fp(long long v) : val(v % mod) {
if (val < 0)
val += mod;
}
Fp getVal() { return val; }
Fp operator+=(const Fp &in) {
val += in.val;
if (val >= mod)
val -= mod;
return *this;
}
Fp operator+(const Fp &in) const { return Fp(*this) += in; }
Fp &operator-=(const Fp &in) {
val -= in.val;
if (val < 0)
val += mod;
return *this;
}
Fp operator-(const Fp &in) const { return Fp(*this) -= in; }
Fp &operator*=(const Fp &in) {
val = val * in.val % mod;
return *this;
}
Fp operator*(const Fp &in) const { return Fp(*this) *= in; }
friend Fp operator*(const long long n, const Fp &in) { return in * n; }
Fp &operator/=(const Fp &in) {
*this *= in.modpow(mod - 2);
return *this;
}
Fp operator/(const Fp &in) const { return Fp(*this) /= in; }
bool operator==(const Fp &in) const { return val == in.val; }
bool operator!=(const Fp &in) const { return val != in.val; }
Fp modpow(long long n) const {
if (n == 0)
return 1;
if (n & 1) {
return (*this) * ((*this) * (*this)).modpow(n / 2);
} else {
return ((*this) * (*this)).modpow(n / 2);
}
}
friend istream &operator>>(istream &is, Fp &fp) {
long long res;
is >> res;
fp = res;
return is;
}
friend ostream &operator<<(ostream &os, Fp &fp) {
os << fp.val;
return os;
}
friend ostream &operator<<(ostream &os, Fp &&fp) {
os << fp.val;
return os;
}
};
// using mint = Fp<1000000007>;
using mint = Fp<998244353>;
mint modpow(const mint &in, const long long n) { return in.modpow(n); }
mint modpow(const ll a, const long long n) { return mint(a).modpow(n); }
class Factorial {
public:
vector<mint> fact, finv;
Factorial(long long n) : fact(n + 1, mint(1)), finv(n + 1, mint(1)) {
for (int i = 2; i <= n; i++) {
mint tmp(i);
fact[i] = fact[i - 1] * tmp;
finv[i] = finv[i - 1] / tmp;
}
}
mint perm(const long long n, const long long k) {
return fact[n] * finv[n - k];
}
mint com(const long long n, const long long k) {
if (n < k || n < 0 || k < 0)
return mint(0);
return fact[n] * finv[k] * finv[n - k];
}
};
template <class X, X (*fxx)(X, X), X (*iex)(), class Y, Y (*fyy)(Y, Y),
Y (*iey)(), X (*fxy)(X, Y)>
class LazySegmentTree {
public:
vector<X> data;
vector<Y> lazy;
int orgSize;
int size;
LazySegmentTree(int n) : orgSize(n) {
auto v = vector<X>(n, iex());
initialize(v);
}
LazySegmentTree(vector<X> &v) : orgSize((int)v.size()) { initialize(v); }
LazySegmentTree(vector<X> &&v) : LazySegmentTree(v) {}
void initialize(vector<X> &v) {
size = 1;
while (size < orgSize)
size *= 2;
data.resize(2 * size - 1, iex());
lazy.resize(2 * size - 1, iey());
for (int i = 0; i < orgSize; i++)
data[i + size - 1] = v[i];
for (int i = size - 2; i >= 0; i--)
data[i] = fxx(data[i * 2 + 1], data[i * 2 + 2]);
}
void lazyEvaluate(int k) {
if (lazy[k] != iey()) {
data[k] = fxy(data[k], lazy[k]);
if (k < size - 1) {
lazy[k * 2 + 1] = fyy(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = fyy(lazy[k * 2 + 2], lazy[k]);
}
lazy[k] = iey();
}
}
void apply(int index) { return apply(index, index + 1); }
void apply(int a, int b, Y y, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = size;
lazyEvaluate(k);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = fyy(lazy[k], y);
lazyEvaluate(k);
} else {
apply(a, b, y, 2 * k + 1, l, (l + r) / 2);
apply(a, b, y, 2 * k + 2, (l + r) / 2, r);
data[k] = fxx(data[2 * k + 1], data[2 * k + 2]);
}
}
X query(int index) { return query(index, index + 1); }
X query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = size;
lazyEvaluate(k);
// dump(a, b, l, r, k, data[k]);
if (b <= l || r <= a)
return iex();
if (a <= l && r <= b)
return data[k];
X vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
X vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
// dump(a, b, l, r, k, data[k], vl, vr);
return fxx(vl, vr);
}
void debug() {
#ifdef LOCAL
cout << "debug : ";
for (int i = 0; i < orgSize; i++) {
cout << query(i) << (i != orgSize - 1 ? " " : "");
}
cout << endl;
#endif
}
void debugALL() {
#ifdef LOCAL
cout << "--------start--------" << endl;
for (int i = 0; i < 2 * size - 1; i++)
lazyEvaluate(i);
long long cnt = 1;
for (int i = 0; i < 2 * size - 1; i++) {
cout << data[i];
if (i == cnt - 1) {
cout << endl;
cnt = cnt * 2 + 1;
} else {
cout << " ";
}
}
cout << "---------end---------" << endl;
#endif
}
};
// Range Minimum Query and Range Update Apply
namespace RMQRUA {
using X = int;
X iex() { return numeric_limits<X>::max(); }
X fxx(X x1, X x2) { return min(x1, x2); }
using Y = int;
Y iey() { return numeric_limits<Y>::max(); }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return y1; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RMQRUA
// Range Minimum Query and Range Add Apply
namespace RMQRAA {
using X = int;
X iex() { return numeric_limits<X>::max(); }
X fxx(X x1, X x2) { return min(x1, x2); }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y1 + y2; }
X fxy(X x1, Y y1) {
if (x1 == iex())
return x1;
return x1 + y1;
}
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RMQRAA
// Range Sum Query and Range Update Apply
namespace RSQRUA {
using X = int;
X iex() { return 0; }
X fxx(X x1, X x2) { return x1 + x2; }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return y1; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RSQRUA
// Range Sum Query and Range Add Apply
namespace RSQRAA {
using X = pair<int, int>;
X iex() { return {0, 1}; }
X fxx(X x1, X x2) { return {x1.first + x2.first, x1.second + x2.second}; }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y1 + y2; }
X fxy(X x1, Y y1) { return {x1.first + x1.second * y1, x1.second}; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RSQRAA
ostream &operator<<(ostream &os, RSQRAA::X x) {
os << x.first;
return os;
}
vector<mint> a(20010);
namespace solve {
using X = pair<mint, int>;
X iex() { return {0, 0}; }
X fxx(X x1, X x2) {
return {x1.first * modpow(10, x2.second) + x2.first, x1.second + x2.second};
}
using Y = mint;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return {a[x1.second] * y1, x1.second}; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace solve
signed main() {
INIT;
REP(i, a.size()) { a[i + 1] = a[i] * 10 + 1; }
cin >> N >> Q;
vector<solve::X> v(N, {1, 1});
solve::LST seg(v);
REP(_, Q) {
cin >> L >> R >> D;
seg.apply(L - 1, R, D);
cout << seg.query(0, N).first << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl '\n'
// #define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define BIT(n) (1LL << (n))
#define TOUPPER(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define TOLOWER(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
#define FILLZERO(s, n) \
do { \
ostringstream os; \
os << setw(n) << setfill('0') << s; \
s = os.str(); \
} while (0);
#define UNIQUE(v) \
v.erase(unique(v.begin(), v.end()), v.end()) // sortしてからつかうこと
#define INIT \
std::cin.tie(nullptr); \
std::ios_base::sync_with_stdio(false); \
cout << std::fixed << std::setprecision(10);
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using pi = pair<int, int>;
template <typename T> using Pq = priority_queue<T>;
template <typename T> using pQ = priority_queue<T, vector<T>, greater<T>>;
template <typename T> vector<T> make_vec(size_t a, T n) {
return vector<T>(a, n);
}
template <typename T, typename... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <long long mod> class Fp {
private:
long long val;
public:
Fp() { val = 0; }
Fp(long long v) : val(v % mod) {
if (val < 0)
val += mod;
}
Fp getVal() { return val; }
Fp operator+=(const Fp &in) {
val += in.val;
if (val >= mod)
val -= mod;
return *this;
}
Fp operator+(const Fp &in) const { return Fp(*this) += in; }
Fp &operator-=(const Fp &in) {
val -= in.val;
if (val < 0)
val += mod;
return *this;
}
Fp operator-(const Fp &in) const { return Fp(*this) -= in; }
Fp &operator*=(const Fp &in) {
val = val * in.val % mod;
return *this;
}
Fp operator*(const Fp &in) const { return Fp(*this) *= in; }
friend Fp operator*(const long long n, const Fp &in) { return in * n; }
Fp &operator/=(const Fp &in) {
*this *= in.modpow(mod - 2);
return *this;
}
Fp operator/(const Fp &in) const { return Fp(*this) /= in; }
bool operator==(const Fp &in) const { return val == in.val; }
bool operator!=(const Fp &in) const { return val != in.val; }
Fp modpow(long long n) const {
if (n == 0)
return 1;
if (n & 1) {
return (*this) * ((*this) * (*this)).modpow(n / 2);
} else {
return ((*this) * (*this)).modpow(n / 2);
}
}
friend istream &operator>>(istream &is, Fp &fp) {
long long res;
is >> res;
fp = res;
return is;
}
friend ostream &operator<<(ostream &os, Fp &fp) {
os << fp.val;
return os;
}
friend ostream &operator<<(ostream &os, Fp &&fp) {
os << fp.val;
return os;
}
};
// using mint = Fp<1000000007>;
using mint = Fp<998244353>;
mint modpow(const mint &in, const long long n) { return in.modpow(n); }
mint modpow(const ll a, const long long n) { return mint(a).modpow(n); }
class Factorial {
public:
vector<mint> fact, finv;
Factorial(long long n) : fact(n + 1, mint(1)), finv(n + 1, mint(1)) {
for (int i = 2; i <= n; i++) {
mint tmp(i);
fact[i] = fact[i - 1] * tmp;
finv[i] = finv[i - 1] / tmp;
}
}
mint perm(const long long n, const long long k) {
return fact[n] * finv[n - k];
}
mint com(const long long n, const long long k) {
if (n < k || n < 0 || k < 0)
return mint(0);
return fact[n] * finv[k] * finv[n - k];
}
};
template <class X, X (*fxx)(X, X), X (*iex)(), class Y, Y (*fyy)(Y, Y),
Y (*iey)(), X (*fxy)(X, Y)>
class LazySegmentTree {
public:
vector<X> data;
vector<Y> lazy;
int orgSize;
int size;
LazySegmentTree(int n) : orgSize(n) {
auto v = vector<X>(n, iex());
initialize(v);
}
LazySegmentTree(vector<X> &v) : orgSize((int)v.size()) { initialize(v); }
LazySegmentTree(vector<X> &&v) : LazySegmentTree(v) {}
void initialize(vector<X> &v) {
size = 1;
while (size < orgSize)
size *= 2;
data.resize(2 * size - 1, iex());
lazy.resize(2 * size - 1, iey());
for (int i = 0; i < orgSize; i++)
data[i + size - 1] = v[i];
for (int i = size - 2; i >= 0; i--)
data[i] = fxx(data[i * 2 + 1], data[i * 2 + 2]);
}
void lazyEvaluate(int k) {
if (lazy[k] != iey()) {
data[k] = fxy(data[k], lazy[k]);
if (k < size - 1) {
lazy[k * 2 + 1] = fyy(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = fyy(lazy[k * 2 + 2], lazy[k]);
}
lazy[k] = iey();
}
}
void apply(int index) { return apply(index, index + 1); }
void apply(int a, int b, Y y, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = size;
lazyEvaluate(k);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = fyy(lazy[k], y);
lazyEvaluate(k);
} else {
apply(a, b, y, 2 * k + 1, l, (l + r) / 2);
apply(a, b, y, 2 * k + 2, (l + r) / 2, r);
data[k] = fxx(data[2 * k + 1], data[2 * k + 2]);
}
}
X query(int index) { return query(index, index + 1); }
X query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = size;
lazyEvaluate(k);
// dump(a, b, l, r, k, data[k]);
if (b <= l || r <= a)
return iex();
if (a <= l && r <= b)
return data[k];
X vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
X vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
// dump(a, b, l, r, k, data[k], vl, vr);
return fxx(vl, vr);
}
void debug() {
#ifdef LOCAL
cout << "debug : ";
for (int i = 0; i < orgSize; i++) {
cout << query(i) << (i != orgSize - 1 ? " " : "");
}
cout << endl;
#endif
}
void debugALL() {
#ifdef LOCAL
cout << "--------start--------" << endl;
for (int i = 0; i < 2 * size - 1; i++)
lazyEvaluate(i);
long long cnt = 1;
for (int i = 0; i < 2 * size - 1; i++) {
cout << data[i];
if (i == cnt - 1) {
cout << endl;
cnt = cnt * 2 + 1;
} else {
cout << " ";
}
}
cout << "---------end---------" << endl;
#endif
}
};
// Range Minimum Query and Range Update Apply
namespace RMQRUA {
using X = int;
X iex() { return numeric_limits<X>::max(); }
X fxx(X x1, X x2) { return min(x1, x2); }
using Y = int;
Y iey() { return numeric_limits<Y>::max(); }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return y1; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RMQRUA
// Range Minimum Query and Range Add Apply
namespace RMQRAA {
using X = int;
X iex() { return numeric_limits<X>::max(); }
X fxx(X x1, X x2) { return min(x1, x2); }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y1 + y2; }
X fxy(X x1, Y y1) {
if (x1 == iex())
return x1;
return x1 + y1;
}
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RMQRAA
// Range Sum Query and Range Update Apply
namespace RSQRUA {
using X = int;
X iex() { return 0; }
X fxx(X x1, X x2) { return x1 + x2; }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return y1; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RSQRUA
// Range Sum Query and Range Add Apply
namespace RSQRAA {
using X = pair<int, int>;
X iex() { return {0, 1}; }
X fxx(X x1, X x2) { return {x1.first + x2.first, x1.second + x2.second}; }
using Y = int;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y1 + y2; }
X fxy(X x1, Y y1) { return {x1.first + x1.second * y1, x1.second}; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace RSQRAA
ostream &operator<<(ostream &os, RSQRAA::X x) {
os << x.first;
return os;
}
vector<mint> a(200100);
namespace solve {
using X = pair<mint, int>;
X iex() { return {0, 0}; }
X fxx(X x1, X x2) {
return {x1.first * modpow(10, x2.second) + x2.first, x1.second + x2.second};
}
using Y = mint;
Y iey() { return 0; }
Y fyy(Y y1, Y y2) { return y2; }
X fxy(X x1, Y y1) { return {a[x1.second] * y1, x1.second}; }
using LST = LazySegmentTree<X, fxx, iex, Y, fyy, iey, fxy>;
} // namespace solve
signed main() {
INIT;
REP(i, a.size()) { a[i + 1] = a[i] * 10 + 1; }
cin >> N >> Q;
vector<solve::X> v(N, {1, 1});
solve::LST seg(v);
REP(_, Q) {
cin >> L >> R >> D;
seg.apply(L - 1, R, D);
cout << seg.query(0, N).first << endl;
}
} | replace | 328 | 329 | 328 | 329 | 0 | |
p02538 | C++ | Time Limit Exceeded | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
// #pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<char> Vc;
typedef vector<P> VP;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
typedef vector<vector<char>> VVc;
typedef vector<vector<vector<ll>>> VVV;
typedef vector<vector<vector<vector<ll>>>> VVVV;
#define endl '\n'
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define PER(i, a, b) for (ll i = (a); i >= (b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF = 1e18 + 18;
const ll MOD = 998244353;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define rEach(i, mp) for (auto i = mp.rbegin(); i != mp.rend(); ++i)
#ifdef LOCAL
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) \
cerr << #mp << ":" << endl; \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cerr << i->first << ":" << i->second << endl; \
}
#define dbgset(st) \
cerr << #st << ":" << endl; \
for (auto i = st.begin(); i != st.end(); ++i) { \
cerr << *i << " "; \
} \
cerr << endl;
#define dbgarr(n, m, arr) \
rep(i, n) { \
rep(j, m) { cerr << arr[i][j] << " "; } \
cerr << endl; \
}
#define dbgdp(n, arr) \
rep(i, n) { cerr << arr[i] << " "; } \
cerr << endl;
#else
#define dbg(...)
#define dbgmap(...)
#define dbgset(...)
#define dbgarr(...)
#define dbgdp(...)
#endif
#define out(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define vout(v) \
rep(i, v.size()) { cout << v[i] << " "; } \
cout << endl
#define Uniq(v) v.erase(unique(v.begin(), v.end()), v.end())
#define fi first
#define se second
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T> istream &operator>>(istream &i, vector<T> &v) {
rep(j, v.size()) i >> v[j];
return i;
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
// mint
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint &a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
typedef vector<mint> Vmint;
typedef vector<vector<mint>> VVmint;
typedef vector<vector<vector<mint>>> VVVmint;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < MOD);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
void debug(ll n) {
#ifdef LOCAL
Vmint segv;
rep(i, n) { segv.pb(prod(i, i + 1).value); }
dbg(segv);
#endif
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
mint ten[200100];
mint elev[200100];
using S = pair<mint, int>;
using F = int;
const F ID = int(2e9);
S op(S a, S b) { return mp(a.fi * ten[b.se] + b.fi, a.se + b.se); }
S e() { return {0, 0}; }
S mapping(F f, S x) {
if (f != ID) {
x.fi = (ten[x.se] - 1) / 9 * f;
}
return x;
}
F composition(F f, F g) { return (f == ID ? g : f); }
F id() { return ID; }
int solve() {
ll n, Q;
cin >> n >> Q;
ll tenmx = 200001;
ten[0] = 1;
elev[0] = 0;
REP(i, 1, 200001) {
ten[i] = ten[i - 1] * 10;
elev[i] = elev[i - 1] * 10 + 1;
}
lazy_segtree<S, op, e, F, mapping, composition, id> seg(n);
rep(i, n) {
seg.set(i, {
1,
1,
});
}
// dbg(seg.all_prod().value);
// seg.debug(8);
rep(i, Q) {
ll l, r, d;
cin >> l >> r >> d;
l--;
seg.apply(l, r, d);
out(seg.all_prod().fi);
// seg.debug(8);
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
// ll T;
// cin>>T;
// while(T--)
solve();
}
| #ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
// #pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<char> Vc;
typedef vector<P> VP;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
typedef vector<vector<char>> VVc;
typedef vector<vector<vector<ll>>> VVV;
typedef vector<vector<vector<vector<ll>>>> VVVV;
#define endl '\n'
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define PER(i, a, b) for (ll i = (a); i >= (b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF = 1e18 + 18;
const ll MOD = 998244353;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define rEach(i, mp) for (auto i = mp.rbegin(); i != mp.rend(); ++i)
#ifdef LOCAL
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) \
cerr << #mp << ":" << endl; \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cerr << i->first << ":" << i->second << endl; \
}
#define dbgset(st) \
cerr << #st << ":" << endl; \
for (auto i = st.begin(); i != st.end(); ++i) { \
cerr << *i << " "; \
} \
cerr << endl;
#define dbgarr(n, m, arr) \
rep(i, n) { \
rep(j, m) { cerr << arr[i][j] << " "; } \
cerr << endl; \
}
#define dbgdp(n, arr) \
rep(i, n) { cerr << arr[i] << " "; } \
cerr << endl;
#else
#define dbg(...)
#define dbgmap(...)
#define dbgset(...)
#define dbgarr(...)
#define dbgdp(...)
#endif
#define out(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define vout(v) \
rep(i, v.size()) { cout << v[i] << " "; } \
cout << endl
#define Uniq(v) v.erase(unique(v.begin(), v.end()), v.end())
#define fi first
#define se second
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T> istream &operator>>(istream &i, vector<T> &v) {
rep(j, v.size()) i >> v[j];
return i;
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
// mint
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD)
x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll n) const {
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
// for prime MOD
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint &a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
typedef vector<mint> Vmint;
typedef vector<vector<mint>> VVmint;
typedef vector<vector<vector<mint>>> VVVmint;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < MOD);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
void debug(ll n) {
#ifdef LOCAL
Vmint segv;
rep(i, n) { segv.pb(prod(i, i + 1).value); }
dbg(segv);
#endif
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
mint ten[200100];
mint elev[200100];
using S = pair<mint, int>;
using F = int;
const F ID = int(2e9);
S op(S a, S b) { return mp(a.fi * ten[b.se] + b.fi, a.se + b.se); }
S e() { return {0, 0}; }
S mapping(F f, S x) {
if (f != ID) {
x.fi = (ten[x.se] - 1) / 9 * f;
}
return x;
}
F composition(F f, F g) { return (f == ID ? g : f); }
F id() { return ID; }
int solve() {
ll n, Q;
cin >> n >> Q;
ll tenmx = 200001;
ten[0] = 1;
elev[0] = 0;
REP(i, 1, 200001) {
ten[i] = ten[i - 1] * 10;
elev[i] = elev[i - 1] * 10 + 1;
}
lazy_segtree<S, op, e, F, mapping, composition, id> seg(n);
rep(i, n) {
seg.set(i, {
1,
1,
});
}
// dbg(seg.all_prod().value);
// seg.debug(8);
rep(i, Q) {
ll l, r, d;
cin >> l >> r >> d;
l--;
seg.apply(l, r, d);
out(seg.all_prod().fi);
// seg.debug(8);
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
// ll T;
// cin>>T;
// while(T--)
solve();
}
| replace | 142 | 150 | 142 | 151 | TLE | |
p02538 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <queue>
using namespace std;
#define what_is(x) cout << #x << " is " << x << endl;
#define PI acos(-1)
#define hell 1000000007
#define HELL 998244353
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define fix(n) cout << fixed << setprecision(n)
#define mset(a, n) memset(a, n, sizeof a)
#define rep(i, a, b) for (__typeof((b)) i = (a); i < (b); i++)
#define repp(i, a, b, p) for (__typeof((b)) i = (a); i < (b); i += p)
#define ren(i, a, b) for (__typeof((a)) i = (a); i >= (b); i--)
#define renn(i, a, b, p) for(__typeof((a) i=(a);i>=(b);i-=p)
#define ADD(a, b, c) ((a) % c + (b) % c) % c
#define SUB(a, b, c) ((a) % c - (b) % c + c) % c
#define MUL(a, b, c) (((a) % c) * ((b) % c)) % c
#define lbd lower_bound
#define ubd upper_bound
#define ll long long
#define ld long double
#define pb push_back
#define fi first
#define se second
#define vll vector<ll>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define all(v) (v).begin(), (v).end()
#define sz(x) (ll) x.size()
// #define out(n) cout<<n<<" "
#define outl(n) cout << n << endl
#define bug(n) \
{ \
outl(n); \
return; \
}
#define pii pair<int, int>
#define lim 9223372036854775806
#define ninf -9223372036854775802
#define M 998244353
#define eps 1e-9
#define MAX 2
#define N 12
#define db(a) \
for (auto it : a) { \
cout << it << " "; \
} \
cout << endl;
ll prime[MAX];
ll fact[MAX];
const long long INF64 = 1e18;
ll vpow(ll a, ll b, ll p) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll temp = vpow(a, b / 2, p);
temp *= temp;
temp %= p;
if (b % 2 == 0)
return temp;
temp = temp * a;
temp %= p;
return temp;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll inverseMod(ll a, ll b, ll p) {
if (b == 0)
return 1;
ll temp = vpow(b, p - 2, p);
ll ans = temp * a;
ans %= p;
return ans;
}
void sieve() {
prime[0] = prime[1] = 1;
for (ll i = 2; i < MAX; i++) {
if (prime[i] == 0) {
for (int j = i * 2; j < MAX; j += i) {
if (prime[j] == 0) {
prime[j] = i;
}
}
prime[i] = i;
}
}
}
void factorial() {
fact[0] = 1;
fact[1] = 1;
rep(i, 2, MAX) {
fact[i] = (fact[i - 1] * i);
fact[i] %= M;
}
}
ll bit[N];
ll seg[4 * N];
ll lazy[4 * N];
void pre() {
bit[0] = 1;
rep(i, 1, N) {
bit[i] = 10 * bit[i - 1] + 1;
bit[i] %= M;
// what_is(bit[i]);
}
}
void display(ll ind, ll left, ll right) {
if (lazy[ind] == -1)
cout << "Val = " << seg[ind] << " at " << left << " to " << right << endl;
else
cout << "Val to be updated by " << lazy[ind] << " from " << left << " to "
<< right << endl;
}
void build(ll ind, ll left, ll right) {
if (left > right)
return;
if (left == right) {
seg[ind] = bit[right];
if (left > 0)
seg[ind] -= bit[left - 1];
if (seg[ind] < 0)
seg[ind] += M;
lazy[ind] = -1;
// display(ind,left,right);
return;
}
ll mid = left + (right - left) / 2;
build(2 * ind, left, mid);
build(2 * ind + 1, mid + 1, right);
seg[ind] = seg[2 * ind] + seg[2 * ind + 1];
seg[ind] %= M;
lazy[ind] = -1;
// display(ind,left,right);
}
void update(ll ind, ll left, ll right, ll l, ll r, ll d) {
if (left > right)
return;
if (lazy[ind] != -1) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * lazy[ind]) % M;
if (left != right) {
// cout<<"Transfering "<<lazy[ind]<<" to child of "<<left<<"
// "<<right<<endl;
lazy[2 * ind] = lazy[ind];
lazy[2 * ind + 1] = lazy[ind];
}
lazy[ind] = -1;
}
if (r < left || right < l)
return;
if (l <= left && right <= r) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * d) % M;
if (left != right) {
// cout<<"Transfering "<<d<<" to child of "<<left<<" "<<right<<endl;
lazy[2 * ind] = d;
lazy[2 * ind + 1] = d;
}
lazy[ind] = -1;
// cout<<"Inside range "<<endl;
// display(ind,left,right);
return;
}
ll mid = left + (right - left) / 2;
update(2 * ind, left, mid, l, r, d);
update(2 * ind + 1, mid + 1, right, l, r, d);
seg[ind] = seg[2 * ind] + seg[2 * ind + 1];
seg[ind] %= M;
// display(ind,left,right);
return;
}
ll get(ll ind, ll left, ll right, ll l, ll r) {
if (left > right)
return 0;
if (lazy[ind] != -1) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * lazy[ind]) % M;
if (left != right) {
lazy[2 * ind] = lazy[ind];
lazy[2 * ind + 1] = lazy[ind];
}
lazy[ind] = -1;
}
if (r < left || right < l)
return 0;
if (l <= left && right <= r) {
return seg[ind];
}
ll mid = left + (right - left) / 2;
seg[ind] =
get(2 * ind, left, mid, l, r) + get(2 * ind + 1, mid + 1, right, l, r);
seg[ind] %= M;
return seg[ind];
}
void displayTree(ll ind, ll left, ll right) {
if (left > right)
return;
if (left == right) {
display(ind, left, right);
return;
}
ll mid = left + (right - left) / 2;
displayTree(2 * ind, left, mid);
displayTree(2 * ind + 1, mid + 1, right);
display(ind, left, right);
}
void solve(ll test) {
ll n, q;
cin >> n >> q;
build(1, 0, n - 1);
ll ans;
// ans=get(1,0,n-1,0,n-1);
// cout<<ans<<endl;
while (q--) {
ll l, r, d;
cin >> l >> r >> d;
l--;
r--;
ll nl = n - r - 1;
ll nr = n - l - 1;
swap(nr, nl);
l = nr;
r = nl;
// what_is(l);
// what_is(r);
// cout<<"Updating to "<<d<<endl;
update(1, 0, n - 1, l, r, d);
// cout<<"After update "<<endl<<endl;
// displayTree(1,0,n-1);
// cout<<"Tree Finished "<<endl<<endl;
ans = get(1, 0, n - 1, 0, n - 1);
cout << ans << endl;
}
}
int main() {
io;
// sieve();
pre();
// cout<<"Re is calculated "<<endl;
// factorial();
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
// freopen("output1.txt","w",stdout);
#endif
ll t = 1;
// cin >> t;
fix(12);
rep(q, 1, t + 1) {
// cout<<"Test case : "<<q<<endl;
solve(q);
// solve2();
}
return 0;
}
| #include <bits/stdc++.h>
#include <queue>
using namespace std;
#define what_is(x) cout << #x << " is " << x << endl;
#define PI acos(-1)
#define hell 1000000007
#define HELL 998244353
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define fix(n) cout << fixed << setprecision(n)
#define mset(a, n) memset(a, n, sizeof a)
#define rep(i, a, b) for (__typeof((b)) i = (a); i < (b); i++)
#define repp(i, a, b, p) for (__typeof((b)) i = (a); i < (b); i += p)
#define ren(i, a, b) for (__typeof((a)) i = (a); i >= (b); i--)
#define renn(i, a, b, p) for(__typeof((a) i=(a);i>=(b);i-=p)
#define ADD(a, b, c) ((a) % c + (b) % c) % c
#define SUB(a, b, c) ((a) % c - (b) % c + c) % c
#define MUL(a, b, c) (((a) % c) * ((b) % c)) % c
#define lbd lower_bound
#define ubd upper_bound
#define ll long long
#define ld long double
#define pb push_back
#define fi first
#define se second
#define vll vector<ll>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define all(v) (v).begin(), (v).end()
#define sz(x) (ll) x.size()
// #define out(n) cout<<n<<" "
#define outl(n) cout << n << endl
#define bug(n) \
{ \
outl(n); \
return; \
}
#define pii pair<int, int>
#define lim 9223372036854775806
#define ninf -9223372036854775802
#define M 998244353
#define eps 1e-9
#define MAX 2
#define N 200001
#define db(a) \
for (auto it : a) { \
cout << it << " "; \
} \
cout << endl;
ll prime[MAX];
ll fact[MAX];
const long long INF64 = 1e18;
ll vpow(ll a, ll b, ll p) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll temp = vpow(a, b / 2, p);
temp *= temp;
temp %= p;
if (b % 2 == 0)
return temp;
temp = temp * a;
temp %= p;
return temp;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll inverseMod(ll a, ll b, ll p) {
if (b == 0)
return 1;
ll temp = vpow(b, p - 2, p);
ll ans = temp * a;
ans %= p;
return ans;
}
void sieve() {
prime[0] = prime[1] = 1;
for (ll i = 2; i < MAX; i++) {
if (prime[i] == 0) {
for (int j = i * 2; j < MAX; j += i) {
if (prime[j] == 0) {
prime[j] = i;
}
}
prime[i] = i;
}
}
}
void factorial() {
fact[0] = 1;
fact[1] = 1;
rep(i, 2, MAX) {
fact[i] = (fact[i - 1] * i);
fact[i] %= M;
}
}
ll bit[N];
ll seg[4 * N];
ll lazy[4 * N];
void pre() {
bit[0] = 1;
rep(i, 1, N) {
bit[i] = 10 * bit[i - 1] + 1;
bit[i] %= M;
// what_is(bit[i]);
}
}
void display(ll ind, ll left, ll right) {
if (lazy[ind] == -1)
cout << "Val = " << seg[ind] << " at " << left << " to " << right << endl;
else
cout << "Val to be updated by " << lazy[ind] << " from " << left << " to "
<< right << endl;
}
void build(ll ind, ll left, ll right) {
if (left > right)
return;
if (left == right) {
seg[ind] = bit[right];
if (left > 0)
seg[ind] -= bit[left - 1];
if (seg[ind] < 0)
seg[ind] += M;
lazy[ind] = -1;
// display(ind,left,right);
return;
}
ll mid = left + (right - left) / 2;
build(2 * ind, left, mid);
build(2 * ind + 1, mid + 1, right);
seg[ind] = seg[2 * ind] + seg[2 * ind + 1];
seg[ind] %= M;
lazy[ind] = -1;
// display(ind,left,right);
}
void update(ll ind, ll left, ll right, ll l, ll r, ll d) {
if (left > right)
return;
if (lazy[ind] != -1) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * lazy[ind]) % M;
if (left != right) {
// cout<<"Transfering "<<lazy[ind]<<" to child of "<<left<<"
// "<<right<<endl;
lazy[2 * ind] = lazy[ind];
lazy[2 * ind + 1] = lazy[ind];
}
lazy[ind] = -1;
}
if (r < left || right < l)
return;
if (l <= left && right <= r) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * d) % M;
if (left != right) {
// cout<<"Transfering "<<d<<" to child of "<<left<<" "<<right<<endl;
lazy[2 * ind] = d;
lazy[2 * ind + 1] = d;
}
lazy[ind] = -1;
// cout<<"Inside range "<<endl;
// display(ind,left,right);
return;
}
ll mid = left + (right - left) / 2;
update(2 * ind, left, mid, l, r, d);
update(2 * ind + 1, mid + 1, right, l, r, d);
seg[ind] = seg[2 * ind] + seg[2 * ind + 1];
seg[ind] %= M;
// display(ind,left,right);
return;
}
ll get(ll ind, ll left, ll right, ll l, ll r) {
if (left > right)
return 0;
if (lazy[ind] != -1) {
ll temp = bit[right];
if (left > 0)
temp -= bit[left - 1];
if (temp < 0)
temp += M;
seg[ind] = (temp * lazy[ind]) % M;
if (left != right) {
lazy[2 * ind] = lazy[ind];
lazy[2 * ind + 1] = lazy[ind];
}
lazy[ind] = -1;
}
if (r < left || right < l)
return 0;
if (l <= left && right <= r) {
return seg[ind];
}
ll mid = left + (right - left) / 2;
seg[ind] =
get(2 * ind, left, mid, l, r) + get(2 * ind + 1, mid + 1, right, l, r);
seg[ind] %= M;
return seg[ind];
}
void displayTree(ll ind, ll left, ll right) {
if (left > right)
return;
if (left == right) {
display(ind, left, right);
return;
}
ll mid = left + (right - left) / 2;
displayTree(2 * ind, left, mid);
displayTree(2 * ind + 1, mid + 1, right);
display(ind, left, right);
}
void solve(ll test) {
ll n, q;
cin >> n >> q;
build(1, 0, n - 1);
ll ans;
// ans=get(1,0,n-1,0,n-1);
// cout<<ans<<endl;
while (q--) {
ll l, r, d;
cin >> l >> r >> d;
l--;
r--;
ll nl = n - r - 1;
ll nr = n - l - 1;
swap(nr, nl);
l = nr;
r = nl;
// what_is(l);
// what_is(r);
// cout<<"Updating to "<<d<<endl;
update(1, 0, n - 1, l, r, d);
// cout<<"After update "<<endl<<endl;
// displayTree(1,0,n-1);
// cout<<"Tree Finished "<<endl<<endl;
ans = get(1, 0, n - 1, 0, n - 1);
cout << ans << endl;
}
}
int main() {
io;
// sieve();
pre();
// cout<<"Re is calculated "<<endl;
// factorial();
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
// freopen("output1.txt","w",stdout);
#endif
ll t = 1;
// cin >> t;
fix(12);
rep(q, 1, t + 1) {
// cout<<"Test case : "<<q<<endl;
solve(q);
// solve2();
}
return 0;
}
| replace | 46 | 47 | 46 | 47 | -11 | |
p02538 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#define N1 200005
#define ll long long
#define inf 0x3f3f3f3f
#define mod 998244353
using namespace std;
int n, Q;
ll val[10][N1], m10[N1];
struct SEG {
ll sum[N1 << 2];
int tag[N1];
void pushup(int len, int rt) {
sum[rt] = (sum[rt << 1] * m10[len] % mod + sum[rt << 1 | 1]) % mod;
}
void pushdown(int l, int r, int mid, int rt) {
if (!tag[rt])
return;
int w = tag[rt];
sum[rt << 1] = val[w][mid - l + 1];
tag[rt << 1] = w;
sum[rt << 1 | 1] = val[w][r - mid];
tag[rt << 1 | 1] = w;
tag[rt] = 0;
}
void upd(int L, int R, int l, int r, int rt, int w) {
if (L <= l && r <= R) {
sum[rt] = val[w][r - l + 1];
tag[rt] = w;
return;
}
int mid = (l + r) >> 1;
pushdown(l, r, mid, rt);
if (L <= mid)
upd(L, R, l, mid, rt << 1, w);
if (R > mid)
upd(L, R, mid + 1, r, rt << 1 | 1, w);
pushup(r - mid, rt);
}
/*ll query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R) return sum[rt];
int mid=(l+r)>>1; ll ans=0;
if(L<=mid) ans=query(L,R,l,mid,rt<<1)*m10[r-mid]%mod;
if(R>mid) ans=ans+query(L,R,mid+1,r,rt<<1|1);
pushup(mid-l+1,rt);
return ans%mod;
}*/
} s;
void pro() {
m10[0] = 1;
for (int i = 1; i <= n; i++)
m10[i] = m10[i - 1] * 10 % mod;
for (int j = 1; j <= 9; j++) {
val[j][0] = 0;
for (int i = 1; i <= n; i++) {
val[j][i] = (val[j][i - 1] * 10 % mod + j) % mod;
}
}
s.upd(1, n, 1, n, 1, 1);
}
int main() {
// freopen("e.txt","r",stdin);
scanf("%d%d", &n, &Q);
pro();
int l, r, w;
for (int i = 1; i <= Q; i++) {
scanf("%d%d%d", &l, &r, &w);
s.upd(l, r, 1, n, 1, w);
printf("%lld\n", s.sum[1]);
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#define N1 200005
#define ll long long
#define inf 0x3f3f3f3f
#define mod 998244353
using namespace std;
int n, Q;
ll val[10][N1], m10[N1];
struct SEG {
ll sum[N1 << 2];
int tag[N1 << 2];
void pushup(int len, int rt) {
sum[rt] = (sum[rt << 1] * m10[len] % mod + sum[rt << 1 | 1]) % mod;
}
void pushdown(int l, int r, int mid, int rt) {
if (!tag[rt])
return;
int w = tag[rt];
sum[rt << 1] = val[w][mid - l + 1];
tag[rt << 1] = w;
sum[rt << 1 | 1] = val[w][r - mid];
tag[rt << 1 | 1] = w;
tag[rt] = 0;
}
void upd(int L, int R, int l, int r, int rt, int w) {
if (L <= l && r <= R) {
sum[rt] = val[w][r - l + 1];
tag[rt] = w;
return;
}
int mid = (l + r) >> 1;
pushdown(l, r, mid, rt);
if (L <= mid)
upd(L, R, l, mid, rt << 1, w);
if (R > mid)
upd(L, R, mid + 1, r, rt << 1 | 1, w);
pushup(r - mid, rt);
}
/*ll query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R) return sum[rt];
int mid=(l+r)>>1; ll ans=0;
if(L<=mid) ans=query(L,R,l,mid,rt<<1)*m10[r-mid]%mod;
if(R>mid) ans=ans+query(L,R,mid+1,r,rt<<1|1);
pushup(mid-l+1,rt);
return ans%mod;
}*/
} s;
void pro() {
m10[0] = 1;
for (int i = 1; i <= n; i++)
m10[i] = m10[i - 1] * 10 % mod;
for (int j = 1; j <= 9; j++) {
val[j][0] = 0;
for (int i = 1; i <= n; i++) {
val[j][i] = (val[j][i - 1] * 10 % mod + j) % mod;
}
}
s.upd(1, n, 1, n, 1, 1);
}
int main() {
// freopen("e.txt","r",stdin);
scanf("%d%d", &n, &Q);
pro();
int l, r, w;
for (int i = 1; i <= Q; i++) {
scanf("%d%d%d", &l, &r, &w);
s.upd(l, r, 1, n, 1, w);
printf("%lld\n", s.sum[1]);
}
return 0;
}
| replace | 17 | 18 | 17 | 18 | 0 | |
p02538 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define INF 10000000
#define MOD 998244353
#define MID (l + r) / 2
#define HASHMOD 2305843009213693951
#define ll long long
#define ull unsigned long long
#define F first
#define S second
typedef pair<ll, ll> ii;
typedef pair<ii, int> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef map<int, int> mii;
#define EPS 1e-6
#define FOR(i, n) for (int i = 0; i < ((int)(n)); i++)
#define FORi(i, a, b) for (int i = ((int)(a)); i < ((int)(b)); i++)
#define FOA(v, a) for (auto v : a)
int t, n;
vi a, b;
ll mpow(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll z = mpow(a, b / 2);
z *= z;
z %= MOD;
if (b % 2)
z *= a;
return z % MOD;
}
long long inv(int s) { return mpow(s, MOD - 2); }
template <typename T> struct seg_tree {
struct node {
T val;
T laz;
int left = -1;
int right = -1;
node() { val = 0, laz = 0, left = -1, right = -1; }
node(T v) { val = v, laz = 0, right = -1, left = -1; }
};
vector<node> seg;
static inline int N;
const int RAND_VALUE = 0;
seg_tree(int n) { N = n, seg.assign(1, node()); }
inline node merge(node par, node a, node b, int lw) {
// cout<<a.val<<" "<<b.val<<endl;
node ret;
ret.left = par.left, ret.right = par.right;
ret.val = ((a.val * mpow(10, lw)) % MOD + b.val) % MOD;
assert(!par.laz);
return ret;
}
inline void update_node(int ind, int val, int l, int r) {
// cout<<"U"<<val<<" "<<l<<" "<<r<<" "<<ind<<" "<<endl;
seg[ind].val = ((val * (mpow(10, r - l + 1) - 1)) % MOD * inv(9)) % MOD;
seg[ind].laz = val;
assert(seg[ind].laz);
// cout<<seg[ind].laz<<endl;
}
inline void down(int ind, int l, int r) {
node par = seg[ind];
// cout<<l<<" "<<r<<" "<<ind<<" "<<par.laz<<endl;
if (par.laz) {
// cout<<"bla\n";
seg[par.left].val =
((par.laz * (mpow(10, MID - l + 1) - 1)) % MOD * inv(9)) % MOD;
seg[par.right].val =
((par.laz * (mpow(10, r - MID) - 1)) % MOD * inv(9)) % MOD;
seg[par.left].laz = par.laz;
seg[par.right].laz = par.laz;
}
seg[ind].laz = 0;
}
inline void create_children(int ind) {
node par = seg[ind];
if (par.left == -1) {
// cout<<"left\n";
par.left = seg.size(), seg.push_back(node());
}
if (par.right == -1)
par.right = seg.size(), seg.push_back(node());
seg[ind] = par;
}
void build(int l = 0, int r = N - 1, int ind = 0) {
if (l == r)
seg[ind] = node(1);
else {
create_children(ind);
build(l, MID, seg[ind].left);
build(MID + 1, r, seg[ind].right);
seg[ind] =
merge(seg[ind], seg[seg[ind].left], seg[seg[ind].right], (r - MID));
}
}
void update(int rl, int rr, int val, int l = 0, int r = N - 1, int ind = 0) {
if (rl <= l && r <= rr)
update_node(ind, val, l, r);
else if (rr < l || r < rl)
return;
else {
create_children(ind);
down(ind, l, r);
assert(seg[ind].laz == 0);
update(rl, rr, val, l, MID, seg[ind].left);
update(rl, rr, val, MID + 1, r, seg[ind].right);
seg[ind] =
merge(seg[ind], seg[seg[ind].left], seg[seg[ind].right], (r - MID));
}
}
node _query(int rl, int rr, int l = 0, int r = N - 1, int ind = 0) {
if (rl <= l && r <= rr)
return seg[ind];
else if (rl > r || l > rr)
return RAND_VALUE;
else {
create_children(ind);
down(ind, l, r);
return merge(seg[ind], _query(rl, rr, l, MID, seg[ind].left),
_query(rl, rr, MID + 1, r, seg[ind].right), (r - MID));
}
}
T query(int l, int r) { return _query(l, r).val % MOD; }
};
int main() {
int q;
cin >> n >> q;
seg_tree<long long> seg(n);
seg.build();
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l--, r--;
seg.update(l, r, d);
cout << seg.query(0, n - 1) << endl;
}
}
| #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define INF 10000000
#define MOD 998244353
#define MID (l + r) / 2
#define HASHMOD 2305843009213693951
#define ll long long
#define ull unsigned long long
#define F first
#define S second
typedef pair<ll, ll> ii;
typedef pair<ii, int> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef map<int, int> mii;
#define EPS 1e-6
#define FOR(i, n) for (int i = 0; i < ((int)(n)); i++)
#define FORi(i, a, b) for (int i = ((int)(a)); i < ((int)(b)); i++)
#define FOA(v, a) for (auto v : a)
int t, n;
vi a, b;
ll mpow(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll z = mpow(a, b / 2);
z *= z;
z %= MOD;
if (b % 2)
z *= a;
return z % MOD;
}
#define inv(v) (443664157ll)
template <typename T> struct seg_tree {
struct node {
T val;
T laz;
int left = -1;
int right = -1;
node() { val = 0, laz = 0, left = -1, right = -1; }
node(T v) { val = v, laz = 0, right = -1, left = -1; }
};
vector<node> seg;
static inline int N;
const int RAND_VALUE = 0;
seg_tree(int n) { N = n, seg.assign(1, node()); }
inline node merge(node par, node a, node b, int lw) {
// cout<<a.val<<" "<<b.val<<endl;
node ret;
ret.left = par.left, ret.right = par.right;
ret.val = ((a.val * mpow(10, lw)) % MOD + b.val) % MOD;
assert(!par.laz);
return ret;
}
inline void update_node(int ind, int val, int l, int r) {
// cout<<"U"<<val<<" "<<l<<" "<<r<<" "<<ind<<" "<<endl;
seg[ind].val = ((val * (mpow(10, r - l + 1) - 1)) % MOD * inv(9)) % MOD;
seg[ind].laz = val;
assert(seg[ind].laz);
// cout<<seg[ind].laz<<endl;
}
inline void down(int ind, int l, int r) {
node par = seg[ind];
// cout<<l<<" "<<r<<" "<<ind<<" "<<par.laz<<endl;
if (par.laz) {
// cout<<"bla\n";
seg[par.left].val =
((par.laz * (mpow(10, MID - l + 1) - 1)) % MOD * inv(9)) % MOD;
seg[par.right].val =
((par.laz * (mpow(10, r - MID) - 1)) % MOD * inv(9)) % MOD;
seg[par.left].laz = par.laz;
seg[par.right].laz = par.laz;
}
seg[ind].laz = 0;
}
inline void create_children(int ind) {
node par = seg[ind];
if (par.left == -1) {
// cout<<"left\n";
par.left = seg.size(), seg.push_back(node());
}
if (par.right == -1)
par.right = seg.size(), seg.push_back(node());
seg[ind] = par;
}
void build(int l = 0, int r = N - 1, int ind = 0) {
if (l == r)
seg[ind] = node(1);
else {
create_children(ind);
build(l, MID, seg[ind].left);
build(MID + 1, r, seg[ind].right);
seg[ind] =
merge(seg[ind], seg[seg[ind].left], seg[seg[ind].right], (r - MID));
}
}
void update(int rl, int rr, int val, int l = 0, int r = N - 1, int ind = 0) {
if (rl <= l && r <= rr)
update_node(ind, val, l, r);
else if (rr < l || r < rl)
return;
else {
create_children(ind);
down(ind, l, r);
assert(seg[ind].laz == 0);
update(rl, rr, val, l, MID, seg[ind].left);
update(rl, rr, val, MID + 1, r, seg[ind].right);
seg[ind] =
merge(seg[ind], seg[seg[ind].left], seg[seg[ind].right], (r - MID));
}
}
node _query(int rl, int rr, int l = 0, int r = N - 1, int ind = 0) {
if (rl <= l && r <= rr)
return seg[ind];
else if (rl > r || l > rr)
return RAND_VALUE;
else {
create_children(ind);
down(ind, l, r);
return merge(seg[ind], _query(rl, rr, l, MID, seg[ind].left),
_query(rl, rr, MID + 1, r, seg[ind].right), (r - MID));
}
}
T query(int l, int r) { return _query(l, r).val % MOD; }
};
int main() {
int q;
cin >> n >> q;
seg_tree<long long> seg(n);
seg.build();
while (q--) {
int l, r, d;
cin >> l >> r >> d;
l--, r--;
seg.update(l, r, d);
cout << seg.query(0, n - 1) << endl;
}
}
| replace | 40 | 42 | 40 | 41 | TLE | |
p02539 | C++ | Runtime Error | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
const int MOD = 998244353;
const int mod = MOD;
typedef long long ll;
typedef long long LL;
const int maxn = 5e4 + 5;
ll pre[maxn], inv[maxn], prei[maxn];
void build(int n) {
pre[1] = pre[0] = inv[1] = inv[0] = prei[1] = prei[0] = 1;
for (int i = 2; i <= n; i++) {
pre[i] = pre[i - 1] * i % mod;
inv[i] = (mod - mod / i * inv[mod % i] % mod) % mod;
prei[i] = prei[i - 1] * inv[i] % mod;
}
}
ll PP(int n, int k) { return pre[n] * prei[n - k] % mod; }
int fpow(int a, int n, int P) {
int r = 1;
while (n) {
if (n & 1)
r = 1ll * r * a % P;
a = 1ll * a * a % P;
n >>= 1;
}
return r;
}
const int P = 998244353, R = 3, MAXN = (1 << 23);
struct Poly : vector<int> {
int n;
Poly(int n) : n(n) { this->resize(n); }
int extend(int x) {
int N = 1;
while (N < x)
N <<= 1;
return N;
}
Poly operator*(const Poly &rhs) {
Poly a = *this, b = rhs;
int N = extend(n + rhs.n - 1);
a.resize(a.n = N);
a.ntt(1);
b.resize(b.n = N);
b.ntt(1);
for (int i = 0; i < N; i++)
a[i] = 1ll * a[i] * b[i] % P;
return a.ntt(-1), a.n = n + rhs.n, a;
}
void ntt(int op) {
static Poly r(MAXN);
for (int i = 0; i < n; i++) {
r[i] = (i & 1) * (n >> 1) + (r[i >> 1] >> 1);
if (r[i] < i)
std::swap(at(i), at(r[i]));
}
for (int m = 2; m <= n; m <<= 1) {
int k = m >> 1, gn = fpow(R, (P - 1) / m, P);
for (int i = 0; i < n; i += m) {
int g = 1;
for (int j = 0; j < k; j++, g = 1ll * g * gn % P) {
int tmp = 1ll * at(i + j + k) * g % P;
at(i + j + k) = (at(i + j) - tmp + P) % P;
at(i + j) = (at(i + j) + tmp) % P;
}
}
}
if (op == -1) {
reverse(begin() + 1, end());
int inv = fpow(n, P - 2, P);
for (int i = 0; i < n; i++)
at(i) = 1ll * at(i) * inv % P;
}
}
bool operator<(const Poly &rhs) const { return n > rhs.n; }
};
typedef pair<int, int> pii;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
build(maxn - 1);
int n;
cin >> n;
map<int, int> cnt;
for (int i = 0; i < 2 * n; i++) {
int v;
cin >> v;
cnt[v]++;
}
n *= 2;
priority_queue<Poly> pq;
for (auto &p : cnt) {
int k = p.S / 2;
Poly poly(k + 1);
for (int i = 0; i <= k; i++) {
poly[i] = PP(p.S, 2 * i) * fpow(fpow(2, i, MOD), MOD - 2, MOD) % MOD *
prei[i] % MOD;
}
// cout << p.F << ' ' << p.S << ": ";
// for (int i = 0 ; i <= k ; i++)
// cout << poly[i] << ' ';
// cout << '\n';
pq.push(poly);
}
while (pq.size() > 1) {
auto a = pq.top();
pq.pop();
auto b = pq.top();
pq.pop();
pq.push(a * b);
}
auto res = pq.top();
pq.pop();
// for (int i = 0 ; i < res.n ; i++)
// cout << res[i] << ' ';
// cout << '\n';
LL ans = 0;
for (int i = 0; i <= n / 2; i++) {
// cout << i << ": " << res[i] * pre[n - 2 * i] % MOD * fpow(fpow(2,
// n / 2 - i, MOD), MOD - 2, MOD) % MOD * prei[n / 2 - i] % MOD <<
// '\n'; cout << "!: " << pre[n - 2 * i] << '\n'; cout << "/2**k: "
// << fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) << '\n'; cout <<
// "/n!: " << prei[n / 2 - i] << '\n';
if (i % 2 == 0) {
ans += res[i] * pre[n - 2 * i] % MOD *
fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) % MOD *
prei[n / 2 - i] % MOD;
ans %= MOD;
} else {
ans -= res[i] * pre[n - 2 * i] % MOD *
fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) % MOD *
prei[n / 2 - i] % MOD;
ans += MOD;
ans %= MOD;
}
}
cout << ans << '\n';
}
| #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
const int MOD = 998244353;
const int mod = MOD;
typedef long long ll;
typedef long long LL;
const int maxn = 2e5 + 5;
ll pre[maxn], inv[maxn], prei[maxn];
void build(int n) {
pre[1] = pre[0] = inv[1] = inv[0] = prei[1] = prei[0] = 1;
for (int i = 2; i <= n; i++) {
pre[i] = pre[i - 1] * i % mod;
inv[i] = (mod - mod / i * inv[mod % i] % mod) % mod;
prei[i] = prei[i - 1] * inv[i] % mod;
}
}
ll PP(int n, int k) { return pre[n] * prei[n - k] % mod; }
int fpow(int a, int n, int P) {
int r = 1;
while (n) {
if (n & 1)
r = 1ll * r * a % P;
a = 1ll * a * a % P;
n >>= 1;
}
return r;
}
const int P = 998244353, R = 3, MAXN = (1 << 23);
struct Poly : vector<int> {
int n;
Poly(int n) : n(n) { this->resize(n); }
int extend(int x) {
int N = 1;
while (N < x)
N <<= 1;
return N;
}
Poly operator*(const Poly &rhs) {
Poly a = *this, b = rhs;
int N = extend(n + rhs.n - 1);
a.resize(a.n = N);
a.ntt(1);
b.resize(b.n = N);
b.ntt(1);
for (int i = 0; i < N; i++)
a[i] = 1ll * a[i] * b[i] % P;
return a.ntt(-1), a.n = n + rhs.n, a;
}
void ntt(int op) {
static Poly r(MAXN);
for (int i = 0; i < n; i++) {
r[i] = (i & 1) * (n >> 1) + (r[i >> 1] >> 1);
if (r[i] < i)
std::swap(at(i), at(r[i]));
}
for (int m = 2; m <= n; m <<= 1) {
int k = m >> 1, gn = fpow(R, (P - 1) / m, P);
for (int i = 0; i < n; i += m) {
int g = 1;
for (int j = 0; j < k; j++, g = 1ll * g * gn % P) {
int tmp = 1ll * at(i + j + k) * g % P;
at(i + j + k) = (at(i + j) - tmp + P) % P;
at(i + j) = (at(i + j) + tmp) % P;
}
}
}
if (op == -1) {
reverse(begin() + 1, end());
int inv = fpow(n, P - 2, P);
for (int i = 0; i < n; i++)
at(i) = 1ll * at(i) * inv % P;
}
}
bool operator<(const Poly &rhs) const { return n > rhs.n; }
};
typedef pair<int, int> pii;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
build(maxn - 1);
int n;
cin >> n;
map<int, int> cnt;
for (int i = 0; i < 2 * n; i++) {
int v;
cin >> v;
cnt[v]++;
}
n *= 2;
priority_queue<Poly> pq;
for (auto &p : cnt) {
int k = p.S / 2;
Poly poly(k + 1);
for (int i = 0; i <= k; i++) {
poly[i] = PP(p.S, 2 * i) * fpow(fpow(2, i, MOD), MOD - 2, MOD) % MOD *
prei[i] % MOD;
}
// cout << p.F << ' ' << p.S << ": ";
// for (int i = 0 ; i <= k ; i++)
// cout << poly[i] << ' ';
// cout << '\n';
pq.push(poly);
}
while (pq.size() > 1) {
auto a = pq.top();
pq.pop();
auto b = pq.top();
pq.pop();
pq.push(a * b);
}
auto res = pq.top();
pq.pop();
// for (int i = 0 ; i < res.n ; i++)
// cout << res[i] << ' ';
// cout << '\n';
LL ans = 0;
for (int i = 0; i <= n / 2; i++) {
// cout << i << ": " << res[i] * pre[n - 2 * i] % MOD * fpow(fpow(2,
// n / 2 - i, MOD), MOD - 2, MOD) % MOD * prei[n / 2 - i] % MOD <<
// '\n'; cout << "!: " << pre[n - 2 * i] << '\n'; cout << "/2**k: "
// << fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) << '\n'; cout <<
// "/n!: " << prei[n / 2 - i] << '\n';
if (i % 2 == 0) {
ans += res[i] * pre[n - 2 * i] % MOD *
fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) % MOD *
prei[n / 2 - i] % MOD;
ans %= MOD;
} else {
ans -= res[i] * pre[n - 2 * i] % MOD *
fpow(fpow(2, n / 2 - i, MOD), MOD - 2, MOD) % MOD *
prei[n / 2 - i] % MOD;
ans += MOD;
ans %= MOD;
}
}
cout << ans << '\n';
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p02539 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// using namespace atcoder;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
{ \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl; \
}
#define mdebug(m) \
{ \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
} \
}
#define pb push_back
#define fi first
#define se second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void chOut(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using v_bool = vector<bool>;
using v_Pii = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
// const int mod = 1000000007;
const int mod = 998244353;
template <long long MOD> struct ModInt {
using ll = long long;
ll val;
void setval(ll v) { val = v % MOD; };
ModInt() : val(0) {}
ModInt(ll v) { setval(v); };
ModInt operator+(const ModInt &x) const { return ModInt(val + x.val); }
ModInt operator-(const ModInt &x) const { return ModInt(val - x.val + MOD); }
ModInt operator*(const ModInt &x) const { return ModInt(val * x.val); }
ModInt operator/(const ModInt &x) const { return *this * x.inv(); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt operator+=(const ModInt &x) { return *this = *this + x; }
ModInt operator-=(const ModInt &x) { return *this = *this - x; }
ModInt operator*=(const ModInt &x) { return *this = *this * x; }
ModInt operator/=(const ModInt &x) { return *this = *this / x; }
bool operator==(const ModInt &x) const { return (*this).val == x.val; }
friend ostream &operator<<(ostream &os, const ModInt &x) {
os << x.val;
return os;
}
friend istream &operator>>(istream &is, ModInt &x) {
is >> x.val;
x.val = (x.val % MOD + MOD) % MOD;
return is;
}
ModInt pow(ll n) const {
ModInt a = 1;
if (n == 0)
return a;
int i0 = 64 - __builtin_clzll(n);
for (int i = i0 - 1; i >= 0; i--) {
a = a * a;
if ((n >> i) & 1)
a *= (*this);
}
return a;
}
ModInt inv() const { return this->pow(MOD - 2); }
};
using mint = ModInt<mod>;
mint pow(mint x, long long n) { return x.pow(n); }
// using mint = double; //for debug
using mvec = vector<mint>;
using mmat = vector<mvec>;
struct Combination {
vector<mint> fact, invfact;
Combination(int N) {
fact = vector<mint>({mint(1)});
invfact = vector<mint>({mint(1)});
fact_initialize(N);
}
void fact_initialize(int N) {
int i0 = fact.size();
if (i0 >= N + 1)
return;
fact.resize(N + 1);
invfact.resize(N + 1);
for (int i = i0; i <= N; i++)
fact[i] = fact[i - 1] * i;
invfact[N] = (mint)1 / fact[N];
for (int i = N - 1; i >= i0; i--)
invfact[i] = invfact[i + 1] * (i + 1);
}
mint nCr(int n, int r) {
if (n < 0 || r < 0 || r > n)
return mint(0);
if (fact.size() < n + 1)
fact_initialize(n);
return fact[n] * invfact[r] * invfact[n - r];
}
mint nPr(int n, int r) {
if (n < 0 || r < 0 || r > n)
return mint(0);
if (fact.size() < n + 1)
fact_initialize(n);
return fact[n] * invfact[n - r];
}
mint Catalan(int n) {
if (n < 0)
return 0;
else if (n == 0)
return 1;
if (fact.size() < 2 * n + 1)
fact_initialize(2 * n);
return fact[2 * n] * invfact[n + 1] * invfact[n];
}
};
template <long long MOD> class NTT {
private:
vector<ModInt<MOD>> f, f_tmp;
void init() {
n = 31 - __builtin_clz((signed)N);
assert(N == (1 << n));
assert((e.pow(N)).val == 1);
pow_e.resize(N + 1);
pow_e[0] = 1;
bool e_valid = true;
FOR(i, 1, N) {
pow_e[i] = pow_e[i - 1] * e;
if (pow_e[i].val == 1)
e_valid = false;
}
pow_e[N] = 1;
assert(e_valid);
inv_N = ((ModInt<MOD>)N).inv();
f.resize(N);
f_tmp.resize(N);
}
void forward_exec(int l, int r, int t) {
if (t == n)
return;
int sz = (r - l) >> 1;
REP(i, sz) {
f_tmp[l + i] = f[l + 2 * i];
f_tmp[l + sz + i] = f[l + 2 * i + 1];
}
FOR(i, l, r) f[i] = f_tmp[i];
forward_exec(l, l + sz, t + 1);
forward_exec(l + sz, r, t + 1);
REP(i, sz) f_tmp[l + i] = f[l + i] + f[l + sz + i] * pow_e[i << t];
REP(i, sz)
f_tmp[l + sz + i] = f[l + i] + f[l + sz + i] * pow_e[(sz + i) << t];
FOR(i, l, r) f[i] = f_tmp[i];
}
void inverse_exec(int l, int r, int t) {
if (t == n)
return;
int sz = (r - l) / 2;
REP(i, sz) {
f_tmp[l + i] = f[l + 2 * i];
f_tmp[l + sz + i] = f[l + 2 * i + 1];
}
FOR(i, l, r) f[i] = f_tmp[i];
inverse_exec(l, l + sz, t + 1);
inverse_exec(l + sz, r, t + 1);
REP(i, sz) f_tmp[l + i] = f[l + i] + f[l + sz + i] * pow_e[N - (i << t)];
REP(i, sz)
f_tmp[l + sz + i] = f[l + i] + f[l + sz + i] * pow_e[N - ((sz + i) << t)];
FOR(i, l, r) f[i] = f_tmp[i];
}
public:
int N, n;
ModInt<MOD> e, inv_N;
vector<ModInt<MOD>> pow_e;
// array size M is converted to N = 2^n (>=M)
// only for MOD = 924844033, 998244353, 1012924417
NTT(int M) {
N = 1;
while (M > N)
N <<= 1;
ModInt<MOD> x;
if (MOD == 924844033)
x = 5;
else if (MOD == 998244353)
x = 3;
else if (MOD == 1012924417)
x = 5;
else
assert(false);
assert((MOD - 1) % N == 0);
e = x.pow((MOD - 1) / N);
init();
}
// N=2^n, e^N=1, e^k!=1 (k<N) must be satisfied
NTT(int N, ModInt<MOD> e) : N(N), e(e) { init(); }
void exec(vector<ModInt<MOD>> &F, bool inverse = false) {
assert(F.size() == N);
f.swap(F);
if (!inverse)
forward_exec(0, N, 0);
else
inverse_exec(0, N, 0);
F.swap(f);
if (inverse) {
REP(i, N) F[i] *= inv_N;
}
}
// if resize_result is true, the array size of the result becomes A.size() +
// B.size() - 1 array size must be equal to N if negetive indices are included
vector<ModInt<MOD>> convolution(vector<ModInt<MOD>> A, vector<ModInt<MOD>> B,
bool resize_result = false) {
int sA = A.size(), sB = B.size();
assert(sA <= N && sB <= N);
A.resize(N);
B.resize(N);
exec(A);
exec(B);
vector<ModInt<MOD>> C(N);
REP(i, N) C[i] = A[i] * B[i];
exec(C, true);
if (resize_result)
C.resize(sA + sB - 1);
return C;
}
};
signed main() {
int N;
cin >> N;
vec h(2 * N);
cin >> h;
const int M = 100000;
vec cnt(M);
REP(i, 2 * N) cnt[h[i] - 1]++;
Combination C(M);
mvec G(M + 1);
G[0] = 1;
FOR(i, 2, M + 1) if (i % 2 == 0) G[i] = G[i - 2] * (i - 1);
mmat S;
priority_queue<Pii, vector<Pii>, greater<Pii>> que;
int id = 0;
REP(i, M) if (cnt[i] >= 2) {
mvec tmp(cnt[i] / 2 + 1);
REP(n, cnt[i] / 2 + 1) tmp[n] = C.nCr(cnt[i], 2 * n) * G[2 * n];
S.pb(tmp);
que.push(Pii(SZ(tmp), id));
id++;
}
while (que.size() >= 2) {
Pii p1 = que.top();
que.pop();
Pii p2 = que.top();
que.pop();
NTT<mod> ntt(p1.fi + p2.fi - 1);
mvec tmp = ntt.convolution(S[p1.se], S[p2.se], true);
S.pb(tmp);
que.push(Pii(SZ(tmp), id));
id++;
}
mint ans = 0;
mvec num = S.back();
REP(i, SZ(num)) {
if (i % 2 == 0)
ans += G[2 * (N - i)] * num[i];
else
ans -= G[2 * (N - i)] * num[i];
}
Out(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// using namespace atcoder;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
{ \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl; \
}
#define mdebug(m) \
{ \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
} \
}
#define pb push_back
#define fi first
#define se second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void chOut(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using v_bool = vector<bool>;
using v_Pii = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
// const int mod = 1000000007;
const int mod = 998244353;
template <long long MOD> struct ModInt {
using ll = long long;
ll val;
void setval(ll v) { val = v % MOD; };
ModInt() : val(0) {}
ModInt(ll v) { setval(v); };
ModInt operator+(const ModInt &x) const { return ModInt(val + x.val); }
ModInt operator-(const ModInt &x) const { return ModInt(val - x.val + MOD); }
ModInt operator*(const ModInt &x) const { return ModInt(val * x.val); }
ModInt operator/(const ModInt &x) const { return *this * x.inv(); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt operator+=(const ModInt &x) { return *this = *this + x; }
ModInt operator-=(const ModInt &x) { return *this = *this - x; }
ModInt operator*=(const ModInt &x) { return *this = *this * x; }
ModInt operator/=(const ModInt &x) { return *this = *this / x; }
bool operator==(const ModInt &x) const { return (*this).val == x.val; }
friend ostream &operator<<(ostream &os, const ModInt &x) {
os << x.val;
return os;
}
friend istream &operator>>(istream &is, ModInt &x) {
is >> x.val;
x.val = (x.val % MOD + MOD) % MOD;
return is;
}
ModInt pow(ll n) const {
ModInt a = 1;
if (n == 0)
return a;
int i0 = 64 - __builtin_clzll(n);
for (int i = i0 - 1; i >= 0; i--) {
a = a * a;
if ((n >> i) & 1)
a *= (*this);
}
return a;
}
ModInt inv() const { return this->pow(MOD - 2); }
};
using mint = ModInt<mod>;
mint pow(mint x, long long n) { return x.pow(n); }
// using mint = double; //for debug
using mvec = vector<mint>;
using mmat = vector<mvec>;
struct Combination {
vector<mint> fact, invfact;
Combination(int N) {
fact = vector<mint>({mint(1)});
invfact = vector<mint>({mint(1)});
fact_initialize(N);
}
void fact_initialize(int N) {
int i0 = fact.size();
if (i0 >= N + 1)
return;
fact.resize(N + 1);
invfact.resize(N + 1);
for (int i = i0; i <= N; i++)
fact[i] = fact[i - 1] * i;
invfact[N] = (mint)1 / fact[N];
for (int i = N - 1; i >= i0; i--)
invfact[i] = invfact[i + 1] * (i + 1);
}
mint nCr(int n, int r) {
if (n < 0 || r < 0 || r > n)
return mint(0);
if (fact.size() < n + 1)
fact_initialize(n);
return fact[n] * invfact[r] * invfact[n - r];
}
mint nPr(int n, int r) {
if (n < 0 || r < 0 || r > n)
return mint(0);
if (fact.size() < n + 1)
fact_initialize(n);
return fact[n] * invfact[n - r];
}
mint Catalan(int n) {
if (n < 0)
return 0;
else if (n == 0)
return 1;
if (fact.size() < 2 * n + 1)
fact_initialize(2 * n);
return fact[2 * n] * invfact[n + 1] * invfact[n];
}
};
template <long long MOD> class NTT {
private:
vector<ModInt<MOD>> f, f_tmp;
void init() {
n = 31 - __builtin_clz((signed)N);
assert(N == (1 << n));
assert((e.pow(N)).val == 1);
pow_e.resize(N + 1);
pow_e[0] = 1;
bool e_valid = true;
FOR(i, 1, N) {
pow_e[i] = pow_e[i - 1] * e;
if (pow_e[i].val == 1)
e_valid = false;
}
pow_e[N] = 1;
assert(e_valid);
inv_N = ((ModInt<MOD>)N).inv();
f.resize(N);
f_tmp.resize(N);
}
void forward_exec(int l, int r, int t) {
if (t == n)
return;
int sz = (r - l) >> 1;
REP(i, sz) {
f_tmp[l + i] = f[l + 2 * i];
f_tmp[l + sz + i] = f[l + 2 * i + 1];
}
FOR(i, l, r) f[i] = f_tmp[i];
forward_exec(l, l + sz, t + 1);
forward_exec(l + sz, r, t + 1);
REP(i, sz) f_tmp[l + i] = f[l + i] + f[l + sz + i] * pow_e[i << t];
REP(i, sz)
f_tmp[l + sz + i] = f[l + i] + f[l + sz + i] * pow_e[(sz + i) << t];
FOR(i, l, r) f[i] = f_tmp[i];
}
void inverse_exec(int l, int r, int t) {
if (t == n)
return;
int sz = (r - l) / 2;
REP(i, sz) {
f_tmp[l + i] = f[l + 2 * i];
f_tmp[l + sz + i] = f[l + 2 * i + 1];
}
FOR(i, l, r) f[i] = f_tmp[i];
inverse_exec(l, l + sz, t + 1);
inverse_exec(l + sz, r, t + 1);
REP(i, sz) f_tmp[l + i] = f[l + i] + f[l + sz + i] * pow_e[N - (i << t)];
REP(i, sz)
f_tmp[l + sz + i] = f[l + i] + f[l + sz + i] * pow_e[N - ((sz + i) << t)];
FOR(i, l, r) f[i] = f_tmp[i];
}
public:
int N, n;
ModInt<MOD> e, inv_N;
vector<ModInt<MOD>> pow_e;
// array size M is converted to N = 2^n (>=M)
// only for MOD = 924844033, 998244353, 1012924417
NTT(int M) {
N = 1;
while (M > N)
N <<= 1;
ModInt<MOD> x;
if (MOD == 924844033)
x = 5;
else if (MOD == 998244353)
x = 3;
else if (MOD == 1012924417)
x = 5;
else
assert(false);
assert((MOD - 1) % N == 0);
e = x.pow((MOD - 1) / N);
init();
}
// N=2^n, e^N=1, e^k!=1 (k<N) must be satisfied
NTT(int N, ModInt<MOD> e) : N(N), e(e) { init(); }
void exec(vector<ModInt<MOD>> &F, bool inverse = false) {
assert(F.size() == N);
f.swap(F);
if (!inverse)
forward_exec(0, N, 0);
else
inverse_exec(0, N, 0);
F.swap(f);
if (inverse) {
REP(i, N) F[i] *= inv_N;
}
}
// if resize_result is true, the array size of the result becomes A.size() +
// B.size() - 1 array size must be equal to N if negetive indices are included
vector<ModInt<MOD>> convolution(vector<ModInt<MOD>> A, vector<ModInt<MOD>> B,
bool resize_result = false) {
int sA = A.size(), sB = B.size();
assert(sA <= N && sB <= N);
A.resize(N);
B.resize(N);
exec(A);
exec(B);
vector<ModInt<MOD>> C(N);
REP(i, N) C[i] = A[i] * B[i];
exec(C, true);
if (resize_result)
C.resize(sA + sB - 1);
return C;
}
};
signed main() {
int N;
cin >> N;
vec h(2 * N);
cin >> h;
const int M = 100000;
vec cnt(M);
REP(i, 2 * N) cnt[h[i] - 1]++;
Combination C(M);
mvec G(M + 1);
G[0] = 1;
FOR(i, 2, M + 1) if (i % 2 == 0) G[i] = G[i - 2] * (i - 1);
mmat S;
priority_queue<Pii, vector<Pii>, greater<Pii>> que;
int id = 0;
REP(i, M) if (cnt[i] >= 2) {
mvec tmp(cnt[i] / 2 + 1);
REP(n, cnt[i] / 2 + 1) tmp[n] = C.nCr(cnt[i], 2 * n) * G[2 * n];
S.pb(tmp);
que.push(Pii(SZ(tmp), id));
id++;
}
while (que.size() >= 2) {
Pii p1 = que.top();
que.pop();
Pii p2 = que.top();
que.pop();
NTT<mod> ntt(p1.fi + p2.fi - 1);
mvec tmp = ntt.convolution(S[p1.se], S[p2.se], true);
S.pb(tmp);
que.push(Pii(SZ(tmp), id));
id++;
}
mint ans = 0;
if (SZ(S)) {
mvec num = S.back();
REP(i, SZ(num)) {
if (i % 2 == 0)
ans += G[2 * (N - i)] * num[i];
else
ans -= G[2 * (N - i)] * num[i];
}
} else {
ans = G[2 * N];
}
Out(ans);
return 0;
}
| replace | 352 | 358 | 352 | 362 | 0 | |
p02539 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(obj) (obj).begin(), (obj).end()
template <class T>
using priority_queue_reverse = priority_queue<T, vector<T>, greater<T>>;
constexpr long long MOD = 1'000'000'000LL + 7;
constexpr long long MOD2 = 998244353;
constexpr long long HIGHINF = (long long)1e18;
constexpr long long LOWINF = (long long)1e15;
constexpr long double PI = 3.1415926535897932384626433L;
template <class T> vector<T> multivector(size_t N, T init) {
return vector<T>(N, init);
}
template <class... T> auto multivector(size_t N, T... t) {
return vector<decltype(multivector(t...))>(N, multivector(t...));
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max(a, b); }
template <class T> void chmin(T &a, const T b) { a = min(a, b); }
vector<string> split(const string &str, const char delemiter) {
vector<string> res;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, delemiter))
res.push_back(buffer);
return res;
}
int msb(int x) { return x ? 31 - __builtin_clz(x) : -1; }
void YN(bool flg) { cout << (flg ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << (flg ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << (flg ? "yes" : "no") << endl; }
/*
* @title ModInt
* @docs md/util/ModInt.md
*/
template <long long mod> class ModInt {
public:
long long x;
constexpr ModInt() : x(0) {}
constexpr ModInt(long long y)
: x(y >= 0 ? (y % mod) : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator+=(const long long y) {
ModInt p(y);
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator+=(const int y) {
ModInt p(y);
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const long long y) {
ModInt p(y);
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const int y) {
ModInt p(y);
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (x * p.x % mod);
return *this;
}
ModInt &operator*=(const long long y) {
ModInt p(y);
x = (x * p.x % mod);
return *this;
}
ModInt &operator*=(const int y) {
ModInt p(y);
x = (x * p.x % mod);
return *this;
}
ModInt &operator^=(const ModInt &p) {
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator^=(const long long y) {
ModInt p(y);
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator^=(const int y) {
ModInt p(y);
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inv();
return *this;
}
ModInt &operator/=(const long long y) {
ModInt p(y);
*this *= p.inv();
return *this;
}
ModInt &operator/=(const int y) {
ModInt p(y);
*this *= p.inv();
return *this;
}
ModInt operator=(const int y) {
ModInt p(y);
*this = p;
return *this;
}
ModInt operator=(const long long y) {
ModInt p(y);
*this = p;
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator++() {
x++;
if (x >= mod)
x -= mod;
return *this;
}
ModInt operator--() {
x--;
if (x < 0)
x += mod;
return *this;
}
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
ModInt operator^(const ModInt &p) const { return ModInt(*this) ^= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inv() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(long long n) const {
ModInt ret(1), mul(x);
for (; n > 0; mul *= mul, n >>= 1)
if (n & 1)
ret *= mul;
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
long long t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
};
using modint = ModInt<MOD2>;
/*
* @title FormalPowerSeries - 形式的冪級数
* @docs md/math/FormalPowerSeries.md
*/
template <int mod> struct FormalPowerSeries : public vector<ModInt<mod>> {
inline static constexpr int prime1 = 1004535809;
inline static constexpr int prime2 = 998244353;
inline static constexpr int prime3 = 985661441;
inline static constexpr int inv21 = 332747959; // ModInt<mod2>(mod1).inv().x;
inline static constexpr int inv31 = 766625513; // ModInt<mod3>(mod1).inv().x;
inline static constexpr int inv32 = 657107549; // ModInt<mod3>(mod2).inv().x;
inline static constexpr int prime12 = (1002772198720536577LL) % mod;
inline static constexpr array<int, 26> pow2 = {
1, 2, 4, 8, 16, 32, 64,
128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536, 131072, 262144, 524288, 1048576,
2097152, 4194304, 8388608, 16777216, 33554432};
using vector<ModInt<mod>>::vector;
using Mint = ModInt<mod>;
using Mint1 = ModInt<prime1>;
using Mint2 = ModInt<prime2>;
using Mint3 = ModInt<prime3>;
using Fps = FormalPowerSeries<mod>;
Fps even(void) const {
Fps ret;
for (int i = 0; i < this->size(); i += 2)
ret.push_back((*this)[i]);
return ret;
}
Fps odd(void) const {
Fps ret;
for (int i = 1; i < this->size(); i += 2)
ret.push_back((*this)[i]);
return ret;
}
Fps minus_x(void) const {
Fps ret(this->size());
for (int i = 0; i < ret.size(); ++i)
ret[i] = (*this)[i] * (i & 1 ? -1 : 1);
return ret;
}
inline Mint garner(const Mint1 &b1, const Mint2 &b2, const Mint3 &b3) {
Mint2 t2 = (b2 - b1.x) * inv21;
Mint3 t3 = ((b3 - b1.x) * inv31 - t2.x) * inv32;
return Mint(prime12 * t3.x + b1.x + prime1 * t2.x);
}
template <int prime> inline void ntt(vector<ModInt<prime>> &f) {
const int N = f.size(), M = N >> 1;
const int log2N = __builtin_ctz(N);
ModInt<prime> h(3);
vector<ModInt<prime>> g(N), base(log2N);
for (int i = 0; i < log2N; ++i)
base[i] = h.pow((prime - 1) / pow2[i + 1]);
for (int n = 0; n < log2N; ++n) {
const int &p = pow2[log2N - n - 1];
ModInt<prime> w = 1;
for (int i = 0, k = 0; i < M; i += p, k = i << 1, w *= base[n]) {
for (int j = 0; j < p; ++j) {
ModInt<prime> l = f[k | j], r = w * f[k | j | p];
g[i | j] = l + r;
g[i | j | M] = l - r;
}
}
swap(f, g);
}
}
template <int prime = mod>
inline vector<ModInt<prime>> convolution_friendrymod(const vector<Mint> &a,
const vector<Mint> &b) {
if (min(a.size(), b.size()) <= 60) {
vector<ModInt<prime>> f(a.size() + b.size() - 1);
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < b.size(); j++)
f[i + j] += a[i].x * b[j].x;
return f;
}
int N, M = a.size() + b.size() - 1;
for (N = 1; N < M; N *= 2)
;
ModInt<prime> inverse(N);
inverse = inverse.inv();
vector<ModInt<prime>> g(N, 0), h(N, 0);
for (int i = 0; i < a.size(); ++i)
g[i] = a[i].x;
for (int i = 0; i < b.size(); ++i)
h[i] = b[i].x;
ntt<prime>(g);
ntt<prime>(h);
for (int i = 0; i < N; ++i)
g[i] *= h[i] * inverse;
reverse(g.begin() + 1, g.end());
ntt<prime>(g);
return g;
}
inline vector<Mint> convolution_arbitrarymod(const vector<Mint> &g,
const vector<Mint> &h) {
auto f1 = convolution_friendrymod<prime1>(g, h);
auto f2 = convolution_friendrymod<prime2>(g, h);
auto f3 = convolution_friendrymod<prime3>(g, h);
vector<Mint> f(f1.size());
for (int i = 0; i < f1.size(); ++i)
f[i] = garner(f1[i], f2[i], f3[i]);
return f;
}
inline vector<ModInt<998244353>>
convolution(const vector<ModInt<998244353>> &g,
const vector<ModInt<998244353>> &h) {
return convolution_friendrymod<998244353>(g, h);
}
inline vector<ModInt<1000000007>>
convolution(const vector<ModInt<1000000007>> &g,
const vector<ModInt<1000000007>> &h) {
return convolution_arbitrarymod(g, h);
}
static inline Mint nth_term_impl(long long n, Fps numerator,
Fps denominator) {
while (n) {
numerator *= denominator.minus_x();
numerator = ((n & 1) ? numerator.odd() : numerator.even());
denominator *= denominator.minus_x();
denominator = denominator.even();
n >>= 1;
}
return numerator[0];
}
public:
// a0 + a_1*x^1 + a_2*x^2 + ... + a_(n-1)*x^(n-1)
inline static Mint nth_term(long long n, const Fps &numerator,
const Fps &denominator) {
return nth_term_impl(n, numerator, denominator);
}
FormalPowerSeries(vector<Mint> v) {
*this = FormalPowerSeries(v.size());
for (int i = 0; i < v.size(); ++i)
(*this)[i] = v[i];
}
Fps operator*(const Fps &r) const { return Fps(*this) *= r; }
Fps &operator*=(const Fps &r) { return *this = convolution(*this, r); }
Fps operator*(const int r) const { return Fps(*this) *= r; }
Fps &operator*=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator*(const long long int r) const { return Fps(*this) *= r; }
Fps &operator*=(const long long int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator*(const Mint r) const { return Fps(*this) *= r; }
Fps &operator*=(const Mint r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator/(const int r) const { return Fps(*this) /= r; }
Fps &operator/=(const int r) { return (*this) *= Mint(r).inv(); }
Fps operator+(const Fps &r) const { return Fps(*this) += r; }
Fps &operator+=(const Fps &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < r.size(); i++)
(*this)[i] += r[i];
return *this;
}
Fps operator+(const int r) const { return Fps(*this) += r; }
Fps &operator+=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] += r;
return *this;
}
Fps operator-(void) const { return Fps(*this) *= (-1); }
Fps operator-(const Fps &r) const { return Fps(*this) -= r; }
Fps &operator-=(const Fps &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < r.size(); i++)
(*this)[i] -= r[i];
return *this;
}
Fps operator-(const int r) const { return Fps(*this) -= r; }
Fps &operator-=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] -= r;
return *this;
}
Fps prefix(size_t n) const {
return Fps(this->begin(), this->begin() + min(n, this->size()));
}
Fps pow(long long k, size_t n) const {
Fps ret(n, 0);
for (size_t i = 0; i < min(n, this->size()) && i * k < n; ++i) {
if ((*this)[i].x == 0)
continue;
Mint t0 = (*this)[i], t0_inv = t0.inv();
Fps tmp(n - i);
for (int j = i; j < min(n, this->size()); ++j)
tmp[j - i] = (*this)[j] * t0_inv;
tmp = (tmp.log(n) * k).exp(n) * (t0.pow(k));
for (int j = 0; j + i * k < n; ++j)
ret[j + i * k] = tmp[j];
break;
}
return ret;
}
Fps pow(long long k) const { return pow(k, this->size()); }
Fps inv(size_t n) const {
Fps ret({Mint(1) / (*this)[0]});
for (size_t i = 1; i < n; i <<= 1)
ret = (ret * 2 - ret * (ret * (this->prefix(i << 1))).prefix(i << 1))
.prefix(i << 1);
return ret.prefix(n);
}
Fps inv(void) const { return inv(this->size()); }
Fps diff(void) const {
Fps ret(max(0, int(this->size()) - 1));
for (int i = 0; i < ret.size(); ++i)
ret[i] = (*this)[i + 1] * (i + 1);
return ret;
}
Fps intg(void) const {
Fps ret(this->size() + 1);
for (int i = 1; i < ret.size(); ++i)
ret[i] = (*this)[i - 1] / i;
return ret;
}
Fps log(size_t n) const {
return (this->diff() * this->inv(n)).intg().prefix(n);
}
Fps log(void) const { return log(this->size()); }
Fps exp(size_t n) const {
Fps ret(1, 1);
for (size_t i = 1; i < n; i <<= 1)
ret = (ret * (this->prefix(i << 1) + Fps(1, 1) - ret.log(i << 1)))
.prefix(i << 1);
return ret.prefix(n);
}
Fps exp(void) const { return exp(this->size()); }
friend ostream &operator<<(ostream &os, const Fps &fps) {
os << "{" << fps[0];
for (int i = 1; i < fps.size(); ++i)
os << ", " << fps[i];
return os << "}";
}
};
using fps = FormalPowerSeries<MOD2>;
/*
* @title CombinationMod - mod上の二項係数・階乗
* @docs md/math/CombinationMod.md
*/
template <long long mod> class CombinationMod {
vector<long long> fac, finv, inv;
public:
CombinationMod(int N) : fac(N + 1), finv(N + 1), inv(N + 1) {
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i <= N; ++i) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
inline long long binom(int n, int k) {
return ((n < 0 || k < 0 || n < k)
? 0
: fac[n] * (finv[k] * finv[n - k] % mod) % mod);
}
inline long long factorial(int n) { return fac[n]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int M = 100000;
vector<int> cnt(M + 1, 0);
for (int i = 0; i < 2 * N; ++i) {
int h;
cin >> h;
cnt[h]++;
}
vector<modint> fact_odd(2 * N, 0);
fact_odd[1] = 1;
for (int i = 3; i < 2 * N; i += 2)
fact_odd[i] = fact_odd[i - 2] * i;
CombinationMod<MOD2> CM(2 * N);
vector<fps> vf;
priority_queue_reverse<pair<int, int>> pq;
for (int i = 1; i <= M; ++i) {
if (!cnt[i])
continue;
int n = cnt[i];
int m = n / 2;
fps f(m + 1, 0);
f[0] = 1;
for (int j = 1; j <= m; ++j) {
// n人から2j人選ぶ-> n_C_2j
// 2j人からjペア作る-> (2j-1)*(2j-3)*...*3*1;
f[j] = fact_odd[2 * j - 1] * CM.binom(n, 2 * j);
}
vf.push_back(f);
pq.push({f.size(), vf.size() - 1});
}
while (pq.size() >= 2) {
auto l = pq.top().second;
pq.pop();
auto r = pq.top().second;
pq.pop();
auto f = vf[l] * vf[r];
vf.push_back(f);
pq.push({f.size(), vf.size() - 1});
}
modint ans = 0;
{
auto c = pq.top().second;
pq.pop();
auto f = vf[c];
for (int i = 0; i < f.size(); ++i)
f[i] *= fact_odd[2 * (N - i) - 1];
for (int i = 0; i < f.size(); ++i)
ans += f[i] * (1 - 2 * (i % 2));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(obj) (obj).begin(), (obj).end()
template <class T>
using priority_queue_reverse = priority_queue<T, vector<T>, greater<T>>;
constexpr long long MOD = 1'000'000'000LL + 7;
constexpr long long MOD2 = 998244353;
constexpr long long HIGHINF = (long long)1e18;
constexpr long long LOWINF = (long long)1e15;
constexpr long double PI = 3.1415926535897932384626433L;
template <class T> vector<T> multivector(size_t N, T init) {
return vector<T>(N, init);
}
template <class... T> auto multivector(size_t N, T... t) {
return vector<decltype(multivector(t...))>(N, multivector(t...));
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max(a, b); }
template <class T> void chmin(T &a, const T b) { a = min(a, b); }
vector<string> split(const string &str, const char delemiter) {
vector<string> res;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, delemiter))
res.push_back(buffer);
return res;
}
int msb(int x) { return x ? 31 - __builtin_clz(x) : -1; }
void YN(bool flg) { cout << (flg ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << (flg ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << (flg ? "yes" : "no") << endl; }
/*
* @title ModInt
* @docs md/util/ModInt.md
*/
template <long long mod> class ModInt {
public:
long long x;
constexpr ModInt() : x(0) {}
constexpr ModInt(long long y)
: x(y >= 0 ? (y % mod) : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator+=(const long long y) {
ModInt p(y);
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator+=(const int y) {
ModInt p(y);
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const long long y) {
ModInt p(y);
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const int y) {
ModInt p(y);
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (x * p.x % mod);
return *this;
}
ModInt &operator*=(const long long y) {
ModInt p(y);
x = (x * p.x % mod);
return *this;
}
ModInt &operator*=(const int y) {
ModInt p(y);
x = (x * p.x % mod);
return *this;
}
ModInt &operator^=(const ModInt &p) {
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator^=(const long long y) {
ModInt p(y);
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator^=(const int y) {
ModInt p(y);
x = (x ^ p.x) % mod;
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inv();
return *this;
}
ModInt &operator/=(const long long y) {
ModInt p(y);
*this *= p.inv();
return *this;
}
ModInt &operator/=(const int y) {
ModInt p(y);
*this *= p.inv();
return *this;
}
ModInt operator=(const int y) {
ModInt p(y);
*this = p;
return *this;
}
ModInt operator=(const long long y) {
ModInt p(y);
*this = p;
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator++() {
x++;
if (x >= mod)
x -= mod;
return *this;
}
ModInt operator--() {
x--;
if (x < 0)
x += mod;
return *this;
}
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
ModInt operator^(const ModInt &p) const { return ModInt(*this) ^= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inv() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(long long n) const {
ModInt ret(1), mul(x);
for (; n > 0; mul *= mul, n >>= 1)
if (n & 1)
ret *= mul;
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
long long t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
};
using modint = ModInt<MOD2>;
/*
* @title FormalPowerSeries - 形式的冪級数
* @docs md/math/FormalPowerSeries.md
*/
template <int mod> struct FormalPowerSeries : public vector<ModInt<mod>> {
inline static constexpr int prime1 = 1004535809;
inline static constexpr int prime2 = 998244353;
inline static constexpr int prime3 = 985661441;
inline static constexpr int inv21 = 332747959; // ModInt<mod2>(mod1).inv().x;
inline static constexpr int inv31 = 766625513; // ModInt<mod3>(mod1).inv().x;
inline static constexpr int inv32 = 657107549; // ModInt<mod3>(mod2).inv().x;
inline static constexpr int prime12 = (1002772198720536577LL) % mod;
inline static constexpr array<int, 26> pow2 = {
1, 2, 4, 8, 16, 32, 64,
128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536, 131072, 262144, 524288, 1048576,
2097152, 4194304, 8388608, 16777216, 33554432};
using vector<ModInt<mod>>::vector;
using Mint = ModInt<mod>;
using Mint1 = ModInt<prime1>;
using Mint2 = ModInt<prime2>;
using Mint3 = ModInt<prime3>;
using Fps = FormalPowerSeries<mod>;
Fps even(void) const {
Fps ret;
for (int i = 0; i < this->size(); i += 2)
ret.push_back((*this)[i]);
return ret;
}
Fps odd(void) const {
Fps ret;
for (int i = 1; i < this->size(); i += 2)
ret.push_back((*this)[i]);
return ret;
}
Fps minus_x(void) const {
Fps ret(this->size());
for (int i = 0; i < ret.size(); ++i)
ret[i] = (*this)[i] * (i & 1 ? -1 : 1);
return ret;
}
inline Mint garner(const Mint1 &b1, const Mint2 &b2, const Mint3 &b3) {
Mint2 t2 = (b2 - b1.x) * inv21;
Mint3 t3 = ((b3 - b1.x) * inv31 - t2.x) * inv32;
return Mint(prime12 * t3.x + b1.x + prime1 * t2.x);
}
template <int prime> inline void ntt(vector<ModInt<prime>> &f) {
const int N = f.size(), M = N >> 1;
const int log2N = __builtin_ctz(N);
ModInt<prime> h(3);
vector<ModInt<prime>> g(N), base(log2N);
for (int i = 0; i < log2N; ++i)
base[i] = h.pow((prime - 1) / pow2[i + 1]);
for (int n = 0; n < log2N; ++n) {
const int &p = pow2[log2N - n - 1];
ModInt<prime> w = 1;
for (int i = 0, k = 0; i < M; i += p, k = i << 1, w *= base[n]) {
for (int j = 0; j < p; ++j) {
ModInt<prime> l = f[k | j], r = w * f[k | j | p];
g[i | j] = l + r;
g[i | j | M] = l - r;
}
}
swap(f, g);
}
}
template <int prime = mod>
inline vector<ModInt<prime>> convolution_friendrymod(const vector<Mint> &a,
const vector<Mint> &b) {
if (min(a.size(), b.size()) <= 60) {
vector<ModInt<prime>> f(a.size() + b.size() - 1);
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < b.size(); j++)
f[i + j] += a[i].x * b[j].x;
return f;
}
int N, M = a.size() + b.size() - 1;
for (N = 1; N < M; N *= 2)
;
ModInt<prime> inverse(N);
inverse = inverse.inv();
vector<ModInt<prime>> g(N, 0), h(N, 0);
for (int i = 0; i < a.size(); ++i)
g[i] = a[i].x;
for (int i = 0; i < b.size(); ++i)
h[i] = b[i].x;
ntt<prime>(g);
ntt<prime>(h);
for (int i = 0; i < N; ++i)
g[i] *= h[i] * inverse;
reverse(g.begin() + 1, g.end());
ntt<prime>(g);
return g;
}
inline vector<Mint> convolution_arbitrarymod(const vector<Mint> &g,
const vector<Mint> &h) {
auto f1 = convolution_friendrymod<prime1>(g, h);
auto f2 = convolution_friendrymod<prime2>(g, h);
auto f3 = convolution_friendrymod<prime3>(g, h);
vector<Mint> f(f1.size());
for (int i = 0; i < f1.size(); ++i)
f[i] = garner(f1[i], f2[i], f3[i]);
return f;
}
inline vector<ModInt<998244353>>
convolution(const vector<ModInt<998244353>> &g,
const vector<ModInt<998244353>> &h) {
return convolution_friendrymod<998244353>(g, h);
}
inline vector<ModInt<1000000007>>
convolution(const vector<ModInt<1000000007>> &g,
const vector<ModInt<1000000007>> &h) {
return convolution_arbitrarymod(g, h);
}
static inline Mint nth_term_impl(long long n, Fps numerator,
Fps denominator) {
while (n) {
numerator *= denominator.minus_x();
numerator = ((n & 1) ? numerator.odd() : numerator.even());
denominator *= denominator.minus_x();
denominator = denominator.even();
n >>= 1;
}
return numerator[0];
}
public:
// a0 + a_1*x^1 + a_2*x^2 + ... + a_(n-1)*x^(n-1)
inline static Mint nth_term(long long n, const Fps &numerator,
const Fps &denominator) {
return nth_term_impl(n, numerator, denominator);
}
FormalPowerSeries(vector<Mint> v) {
*this = FormalPowerSeries(v.size());
for (int i = 0; i < v.size(); ++i)
(*this)[i] = v[i];
}
Fps operator*(const Fps &r) const { return Fps(*this) *= r; }
Fps &operator*=(const Fps &r) { return *this = convolution(*this, r); }
Fps operator*(const int r) const { return Fps(*this) *= r; }
Fps &operator*=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator*(const long long int r) const { return Fps(*this) *= r; }
Fps &operator*=(const long long int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator*(const Mint r) const { return Fps(*this) *= r; }
Fps &operator*=(const Mint r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] *= r;
return *this;
}
Fps operator/(const int r) const { return Fps(*this) /= r; }
Fps &operator/=(const int r) { return (*this) *= Mint(r).inv(); }
Fps operator+(const Fps &r) const { return Fps(*this) += r; }
Fps &operator+=(const Fps &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < r.size(); i++)
(*this)[i] += r[i];
return *this;
}
Fps operator+(const int r) const { return Fps(*this) += r; }
Fps &operator+=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] += r;
return *this;
}
Fps operator-(void) const { return Fps(*this) *= (-1); }
Fps operator-(const Fps &r) const { return Fps(*this) -= r; }
Fps &operator-=(const Fps &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < r.size(); i++)
(*this)[i] -= r[i];
return *this;
}
Fps operator-(const int r) const { return Fps(*this) -= r; }
Fps &operator-=(const int r) {
for (int i = 0; i < this->size(); ++i)
(*this)[i] -= r;
return *this;
}
Fps prefix(size_t n) const {
return Fps(this->begin(), this->begin() + min(n, this->size()));
}
Fps pow(long long k, size_t n) const {
Fps ret(n, 0);
for (size_t i = 0; i < min(n, this->size()) && i * k < n; ++i) {
if ((*this)[i].x == 0)
continue;
Mint t0 = (*this)[i], t0_inv = t0.inv();
Fps tmp(n - i);
for (int j = i; j < min(n, this->size()); ++j)
tmp[j - i] = (*this)[j] * t0_inv;
tmp = (tmp.log(n) * k).exp(n) * (t0.pow(k));
for (int j = 0; j + i * k < n; ++j)
ret[j + i * k] = tmp[j];
break;
}
return ret;
}
Fps pow(long long k) const { return pow(k, this->size()); }
Fps inv(size_t n) const {
Fps ret({Mint(1) / (*this)[0]});
for (size_t i = 1; i < n; i <<= 1)
ret = (ret * 2 - ret * (ret * (this->prefix(i << 1))).prefix(i << 1))
.prefix(i << 1);
return ret.prefix(n);
}
Fps inv(void) const { return inv(this->size()); }
Fps diff(void) const {
Fps ret(max(0, int(this->size()) - 1));
for (int i = 0; i < ret.size(); ++i)
ret[i] = (*this)[i + 1] * (i + 1);
return ret;
}
Fps intg(void) const {
Fps ret(this->size() + 1);
for (int i = 1; i < ret.size(); ++i)
ret[i] = (*this)[i - 1] / i;
return ret;
}
Fps log(size_t n) const {
return (this->diff() * this->inv(n)).intg().prefix(n);
}
Fps log(void) const { return log(this->size()); }
Fps exp(size_t n) const {
Fps ret(1, 1);
for (size_t i = 1; i < n; i <<= 1)
ret = (ret * (this->prefix(i << 1) + Fps(1, 1) - ret.log(i << 1)))
.prefix(i << 1);
return ret.prefix(n);
}
Fps exp(void) const { return exp(this->size()); }
friend ostream &operator<<(ostream &os, const Fps &fps) {
os << "{" << fps[0];
for (int i = 1; i < fps.size(); ++i)
os << ", " << fps[i];
return os << "}";
}
};
using fps = FormalPowerSeries<MOD2>;
/*
* @title CombinationMod - mod上の二項係数・階乗
* @docs md/math/CombinationMod.md
*/
template <long long mod> class CombinationMod {
vector<long long> fac, finv, inv;
public:
CombinationMod(int N) : fac(N + 1), finv(N + 1), inv(N + 1) {
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1;
for (int i = 2; i <= N; ++i) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
inline long long binom(int n, int k) {
return ((n < 0 || k < 0 || n < k)
? 0
: fac[n] * (finv[k] * finv[n - k] % mod) % mod);
}
inline long long factorial(int n) { return fac[n]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int M = 100000;
vector<int> cnt(M + 1, 0);
for (int i = 0; i < 2 * N; ++i) {
int h;
cin >> h;
cnt[h]++;
}
vector<modint> fact_odd(2 * N, 0);
fact_odd[1] = 1;
for (int i = 3; i < 2 * N; i += 2)
fact_odd[i] = fact_odd[i - 2] * i;
CombinationMod<MOD2> CM(2 * N);
vector<fps> vf;
priority_queue_reverse<pair<int, int>> pq;
for (int i = 1; i <= M; ++i) {
if (!cnt[i])
continue;
int n = cnt[i];
int m = n / 2;
fps f(m + 1, 0);
f[0] = 1;
for (int j = 1; j <= m; ++j) {
// n人から2j人選ぶ-> n_C_2j
// 2j人からjペア作る-> (2j-1)*(2j-3)*...*3*1;
f[j] = fact_odd[2 * j - 1] * CM.binom(n, 2 * j);
}
vf.push_back(f);
pq.push({f.size(), vf.size() - 1});
}
while (pq.size() >= 2) {
auto l = pq.top().second;
pq.pop();
auto r = pq.top().second;
pq.pop();
auto f = vf[l] * vf[r];
vf.push_back(f);
pq.push({f.size(), vf.size() - 1});
}
modint ans = 0;
{
auto c = pq.top().second;
pq.pop();
auto f = vf[c];
int m = min(int(f.size()), N + 1);
for (int i = 0; i < m; ++i)
f[i] *= (i == N ? 1 : fact_odd[2 * (N - i) - 1]);
for (int i = 0; i < m; ++i)
ans += f[i] * (1 - 2 * (i % 2));
}
cout << ans << endl;
return 0;
}
| replace | 553 | 556 | 553 | 557 | 0 | |
p02539 | C++ | Runtime Error | #include <iostream>
using i64 = long long;
template <i64 M> struct modint {
i64 a;
constexpr modint(const i64 x = 0) : a((x % M + M) % M) {}
constexpr i64 value() const { return a; }
constexpr modint inv() const { return this->pow(M - 2); }
constexpr modint pow(i64 r) const {
modint ans(1);
modint aa = *this;
while (r) {
if (r & 1)
ans *= aa;
aa *= aa;
r >>= 1;
}
return ans;
}
constexpr modint &operator=(const i64 r) {
a = (r % M + M) % M;
return *this;
}
constexpr modint &operator+=(const modint r) {
a += r.a;
if (a >= M)
a -= M;
return *this;
}
constexpr modint &operator-=(const modint r) {
a -= r.a;
if (a < 0)
a += M;
return *this;
}
constexpr modint &operator*=(const modint r) {
a = a * r.a % M;
return *this;
}
constexpr modint &operator/=(const modint r) {
(*this) *= r.inv();
return *this;
}
constexpr modint operator+(const modint r) const {
return modint(*this) += r;
}
constexpr modint operator-(const modint r) const {
return modint(*this) -= r;
}
constexpr modint operator*(const modint r) const {
return modint(*this) *= r;
}
constexpr modint operator/(const modint r) const {
return modint(*this) /= r;
}
constexpr bool operator==(const modint r) const {
return this->value() == r.value();
}
constexpr bool operator!=(const modint r) const {
return this->value() != r.value();
}
};
template <const i64 M>
std::ostream &operator<<(std::ostream &os, const modint<M> &m) {
os << m.value();
return os;
}
#include <vector>
using namespace std;
constexpr i64 NTT_PRIMES[][2] = {
{1224736769, 3}, // 2^24 * 73 + 1,
{1053818881, 7}, // 2^20 * 3 * 5 * 67 + 1
{1051721729, 6}, // 2^20 * 17 * 59 + 1
{1045430273, 3}, // 2^20 * 997 + 1
{1012924417, 5}, // 2^21 * 3 * 7 * 23 + 1
{1007681537, 3}, // 2^20 * 31^2 + 1
{1004535809, 3}, // 2^21 * 479 + 1
{998244353, 3}, // 2^23 * 7 * 17 + 1
{985661441, 3}, // 2^22 * 5 * 47 + 1
{976224257, 3}, // 2^20 * 7^2 * 19 + 1
{975175681, 17}, // 2^21 * 3 * 5 * 31 + 1
{962592769, 7}, // 2^21 * 3^3 * 17 + 1
{950009857, 7}, // 2^21 * 4 * 151 + 1
{943718401, 7}, // 2^22 * 3^2 * 5^2 + 1
{935329793, 3}, // 2^22 * 223 + 1
{924844033, 5}, // 2^21 * 3^2 * 7^2 + 1
{469762049, 3}, // 2^26 * 7 + 1
{167772161, 3}, // 2^25 * 5 + 1
};
template <const i64 mod, const i64 primitive>
vector<modint<mod>> number_theoretic_transform(vector<modint<mod>> a) {
i64 n = a.size();
for (i64 s = n >> 1; s >= 1; s >>= 1) {
modint<mod> zeta = modint<mod>(primitive).pow((mod - 1) / (s << 1));
for (i64 i = 0; i < n; i += (s << 1)) {
modint<mod> zi = 1;
for (i64 j = 0; j < s; j++) {
modint<mod> t = a[i + j] - a[s + i + j];
a[i + j] += a[s + i + j];
a[s + i + j] = t * zi;
zi = zi * zeta;
}
}
}
return a;
}
template <const i64 mod, const i64 primitive>
vector<modint<mod>> inverse_number_theoretic_transform(vector<modint<mod>> a) {
i64 n = a.size();
for (i64 s = 1; s < n; s <<= 1) {
modint<mod> zeta =
modint<mod>(primitive).pow((mod - 1) / (s << 1)).pow(mod - 2);
for (i64 i = 0; i < n; i += (s << 1)) {
modint<mod> zi = 1;
for (i64 j = 0; j < s; j++) {
modint<mod> t = a[s + i + j] * zi;
a[s + i + j] = a[i + j] - t;
a[i + j] = a[i + j] + t;
zi = zi * zeta;
}
}
}
auto inv_n = modint<mod>(n).pow(mod - 2);
for (int i = 0; i < n; i++)
a[i] *= inv_n;
return a;
}
template <const i64 mod, const i64 primitive> struct fps_ntt_multiply {
using fps_type = modint<mod>;
using conv_type = modint<mod>;
static std::vector<conv_type> dft(std::vector<fps_type> arr) {
return number_theoretic_transform<mod, primitive>(std::move(arr));
}
static std::vector<fps_type> idft(std::vector<conv_type> arr) {
return inverse_number_theoretic_transform<mod, primitive>(std::move(arr));
}
static std::vector<conv_type> multiply(std::vector<conv_type> a,
std::vector<conv_type> b) {
for (int i = 0; i < a.size(); i++)
a[i] *= b[i];
return a;
}
};
template <class T, class fps_multiply> struct FPS {
std::vector<T> coef;
static std::size_t bound_pow2(std::size_t sz) {
return 1ll << (__lg(sz - 1) + 1);
}
FPS(const std::vector<T> &arr) : coef(arr) {}
size_t size() const { return coef.size(); }
void bound_resize() { this->coef.resize(bound_pow2(this->size())); }
void resize_zero() {
while (coef.size() > 1 && coef.back() == T(0)) {
coef.pop_back();
}
}
T operator[](int i) const {
if (i < coef.size())
return coef[i];
else
return T();
}
T &operator[](int i) { return coef[i]; }
FPS pre(int n) const {
std::vector<T> nex(n);
for (int i = 0; i < coef.size() && i < n; i++)
nex[i] = coef[i];
return FPS(nex);
}
// F(0) must not be 0
FPS inv() const {
FPS g = FPS(std::vector<T>{T(1) / (*this)[0]});
this->bound_resize();
i64 n = this->size();
for (int i = 1; i < n; i <<= 1) {
g = g.pre(i << 1);
auto gdft = fps_multiply::dft(g.coef);
auto e = fps_multiply::idft(fps_multiply::multiply(
fps_multiply::dft(this->pre(i << 1).coef), gdft));
for (int j = 0; j < i; j++) {
e[j] = T(0);
e[j + i] = e[j + i] * T(-1);
}
auto f = fps_multiply::idft(
fps_multiply::multiply(fps_multiply::dft(e), std::move(gdft)));
for (int j = 0; j < i; j++) {
f[j] = g[j];
}
g.coef = std::move(f);
}
return g.pre(n);
}
FPS diff() const {
FPS res(vector<T>(this->size() - 1, T(0)));
for (i64 i = 1; i < this->size(); i++)
res[i - 1] = coef[i] * T(i);
return res;
}
FPS integral() const {
FPS res(vector<T>(this->size() + 1, T(0)));
for (i64 i = 0; i < this->size(); i++)
res[i + 1] = coef[i] / T(i + 1);
return res;
}
// F(0) must be 0
FPS log() const {
return (this->diff() * this->inv()).integral().pre(this->size());
}
FPS exp() const {
FPS f(vector<T>{T(1)});
FPS g = *this;
g.bound_resize();
g[0] += T(1);
for (i64 i = 1; i < size(); i <<= 1) {
f = (f * (g.pre(i << 1) - f.pre(i << 1).log())).pre(i << 1);
}
return f;
}
FPS operator+(const FPS &rhs) {
i64 n = std::max(this->size(), rhs.size());
std::vector<T> ans(n);
for (int i = 0; i < n; i++)
ans[i] = (*this)[i] + rhs[i];
return FPS(ans);
}
FPS operator-(const FPS &rhs) {
i64 n = std::max(this->size(), rhs.size());
std::vector<T> ans(n);
for (int i = 0; i < n; i++)
ans[i] = (*this)[i] - rhs[i];
return FPS(ans);
}
FPS operator*(const FPS &rhs) {
i64 m = this->size() + rhs.size() - 1;
i64 n = bound_pow2(m);
auto res = fps_multiply::idft(
fps_multiply::multiply(fps_multiply::dft(this->pre(n).coef),
fps_multiply::dft(rhs.pre(n).coef)));
res.resize(m);
return res;
}
bool operator<(const FPS &rhs) const { return this->size() < rhs.size(); }
bool operator>(const FPS &rhs) const { return this->size() > rhs.size(); }
};
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)
#define PREFIX "#" TOSTRING(__LINE__) "| "
#define debug(x) \
{ std::cout << PREFIX << #x << " = " << x << std::endl; }
std::ostream &output_indent(std::ostream &os, int ind) {
for (int i = 0; i < ind; i++)
os << " ";
return os;
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p);
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v);
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return (os << "(" << p.first << ", " << p.second << ")");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); i++)
os << v[i] << ", ";
return (os << "]");
}
template <class T> static inline std::vector<T> ndvec(size_t &&n, T val) {
return std::vector<T>(n, std::forward<T>(val));
}
template <class... Tail> static inline auto ndvec(size_t &&n, Tail &&...tail) {
return std::vector<decltype(ndvec(std::forward<Tail>(tail)...))>(
n, ndvec(std::forward<Tail>(tail)...));
}
template <class Cond> struct chain {
Cond cond;
chain(Cond cond) : cond(cond) {}
template <class T> bool operator()(T &a, const T &b) const {
if (cond(a, b)) {
a = b;
return true;
}
return false;
}
};
template <class Cond> chain<Cond> make_chain(Cond cond) {
return chain<Cond>(cond);
}
#include <tuple>
#include <vector>
using i64 = long long;
template <class T>
std::tuple<std::vector<T>, std::vector<T>, std::vector<T>>
build_factorial(int N) {
std::vector<T> fact(N);
std::vector<T> finv(N);
std::vector<T> inv(N);
fact[0] = T(1);
for (int i = 1; i < N; i++) {
fact[i] = fact[i - 1] * T(i);
}
finv[N - 1] = T(1) / fact[N - 1];
for (int i = N - 1; i-- > 0;) {
finv[i] = finv[i + 1] * T(i + 1);
}
for (int i = 0; i < N; i++) {
inv[i] = fact[i - 1] * finv[i];
}
return std::make_tuple(std::move(fact), std::move(finv), std::move(inv));
}
using fp = modint<998244353>;
using fps = FPS<fp, fps_ntt_multiply<998244353, 3>>;
int main() {
i64 N;
cin >> N;
vector<i64> cnt(101010);
rep(i, 0, N * 2) {
i64 a;
cin >> a;
cnt[a - 1]++;
}
auto [fact, finv, inv] = build_factorial<fp>(101010);
fps meth(vector<fp>{fp(1)});
vector<fp> setting;
{
fp now(1);
setting.push_back(now);
rep(i, 1, N + 1) {
now *= fact[i * 2] * finv[i * 2 - 2] * finv[2];
setting.push_back(now);
}
}
priority_queue<fps, vector<fps>, greater<fps>> que;
rep(x, 0, 101010) {
if (cnt[x] <= 1)
continue;
vector<fp> vec;
i64 c = cnt[x];
for (i64 i = 0; i * 2 <= c; i++) {
vec.push_back(fact[c] * finv[i * 2] * finv[c - i * 2] * setting[i] *
finv[i]);
}
que.push(fps(vec));
}
while (que.size() > 1) {
auto f = que.top();
que.pop();
auto g = que.top();
que.pop();
que.push(f * g);
}
meth = que.top();
fp ans(0);
rep(i, 0, meth.size()) {
if (i > N)
break;
fp res = meth[i] * setting[N - i] * finv[N - i];
if (i % 2 == 0) {
ans += res;
} else {
ans -= res;
}
}
cout << ans.value() << endl;
}
| #include <iostream>
using i64 = long long;
template <i64 M> struct modint {
i64 a;
constexpr modint(const i64 x = 0) : a((x % M + M) % M) {}
constexpr i64 value() const { return a; }
constexpr modint inv() const { return this->pow(M - 2); }
constexpr modint pow(i64 r) const {
modint ans(1);
modint aa = *this;
while (r) {
if (r & 1)
ans *= aa;
aa *= aa;
r >>= 1;
}
return ans;
}
constexpr modint &operator=(const i64 r) {
a = (r % M + M) % M;
return *this;
}
constexpr modint &operator+=(const modint r) {
a += r.a;
if (a >= M)
a -= M;
return *this;
}
constexpr modint &operator-=(const modint r) {
a -= r.a;
if (a < 0)
a += M;
return *this;
}
constexpr modint &operator*=(const modint r) {
a = a * r.a % M;
return *this;
}
constexpr modint &operator/=(const modint r) {
(*this) *= r.inv();
return *this;
}
constexpr modint operator+(const modint r) const {
return modint(*this) += r;
}
constexpr modint operator-(const modint r) const {
return modint(*this) -= r;
}
constexpr modint operator*(const modint r) const {
return modint(*this) *= r;
}
constexpr modint operator/(const modint r) const {
return modint(*this) /= r;
}
constexpr bool operator==(const modint r) const {
return this->value() == r.value();
}
constexpr bool operator!=(const modint r) const {
return this->value() != r.value();
}
};
template <const i64 M>
std::ostream &operator<<(std::ostream &os, const modint<M> &m) {
os << m.value();
return os;
}
#include <vector>
using namespace std;
constexpr i64 NTT_PRIMES[][2] = {
{1224736769, 3}, // 2^24 * 73 + 1,
{1053818881, 7}, // 2^20 * 3 * 5 * 67 + 1
{1051721729, 6}, // 2^20 * 17 * 59 + 1
{1045430273, 3}, // 2^20 * 997 + 1
{1012924417, 5}, // 2^21 * 3 * 7 * 23 + 1
{1007681537, 3}, // 2^20 * 31^2 + 1
{1004535809, 3}, // 2^21 * 479 + 1
{998244353, 3}, // 2^23 * 7 * 17 + 1
{985661441, 3}, // 2^22 * 5 * 47 + 1
{976224257, 3}, // 2^20 * 7^2 * 19 + 1
{975175681, 17}, // 2^21 * 3 * 5 * 31 + 1
{962592769, 7}, // 2^21 * 3^3 * 17 + 1
{950009857, 7}, // 2^21 * 4 * 151 + 1
{943718401, 7}, // 2^22 * 3^2 * 5^2 + 1
{935329793, 3}, // 2^22 * 223 + 1
{924844033, 5}, // 2^21 * 3^2 * 7^2 + 1
{469762049, 3}, // 2^26 * 7 + 1
{167772161, 3}, // 2^25 * 5 + 1
};
template <const i64 mod, const i64 primitive>
vector<modint<mod>> number_theoretic_transform(vector<modint<mod>> a) {
i64 n = a.size();
for (i64 s = n >> 1; s >= 1; s >>= 1) {
modint<mod> zeta = modint<mod>(primitive).pow((mod - 1) / (s << 1));
for (i64 i = 0; i < n; i += (s << 1)) {
modint<mod> zi = 1;
for (i64 j = 0; j < s; j++) {
modint<mod> t = a[i + j] - a[s + i + j];
a[i + j] += a[s + i + j];
a[s + i + j] = t * zi;
zi = zi * zeta;
}
}
}
return a;
}
template <const i64 mod, const i64 primitive>
vector<modint<mod>> inverse_number_theoretic_transform(vector<modint<mod>> a) {
i64 n = a.size();
for (i64 s = 1; s < n; s <<= 1) {
modint<mod> zeta =
modint<mod>(primitive).pow((mod - 1) / (s << 1)).pow(mod - 2);
for (i64 i = 0; i < n; i += (s << 1)) {
modint<mod> zi = 1;
for (i64 j = 0; j < s; j++) {
modint<mod> t = a[s + i + j] * zi;
a[s + i + j] = a[i + j] - t;
a[i + j] = a[i + j] + t;
zi = zi * zeta;
}
}
}
auto inv_n = modint<mod>(n).pow(mod - 2);
for (int i = 0; i < n; i++)
a[i] *= inv_n;
return a;
}
template <const i64 mod, const i64 primitive> struct fps_ntt_multiply {
using fps_type = modint<mod>;
using conv_type = modint<mod>;
static std::vector<conv_type> dft(std::vector<fps_type> arr) {
return number_theoretic_transform<mod, primitive>(std::move(arr));
}
static std::vector<fps_type> idft(std::vector<conv_type> arr) {
return inverse_number_theoretic_transform<mod, primitive>(std::move(arr));
}
static std::vector<conv_type> multiply(std::vector<conv_type> a,
std::vector<conv_type> b) {
for (int i = 0; i < a.size(); i++)
a[i] *= b[i];
return a;
}
};
template <class T, class fps_multiply> struct FPS {
std::vector<T> coef;
static std::size_t bound_pow2(std::size_t sz) {
return 1ll << (__lg(sz - 1) + 1);
}
FPS(const std::vector<T> &arr) : coef(arr) {}
size_t size() const { return coef.size(); }
void bound_resize() { this->coef.resize(bound_pow2(this->size())); }
void resize_zero() {
while (coef.size() > 1 && coef.back() == T(0)) {
coef.pop_back();
}
}
T operator[](int i) const {
if (i < coef.size())
return coef[i];
else
return T();
}
T &operator[](int i) { return coef[i]; }
FPS pre(int n) const {
std::vector<T> nex(n);
for (int i = 0; i < coef.size() && i < n; i++)
nex[i] = coef[i];
return FPS(nex);
}
// F(0) must not be 0
FPS inv() const {
FPS g = FPS(std::vector<T>{T(1) / (*this)[0]});
this->bound_resize();
i64 n = this->size();
for (int i = 1; i < n; i <<= 1) {
g = g.pre(i << 1);
auto gdft = fps_multiply::dft(g.coef);
auto e = fps_multiply::idft(fps_multiply::multiply(
fps_multiply::dft(this->pre(i << 1).coef), gdft));
for (int j = 0; j < i; j++) {
e[j] = T(0);
e[j + i] = e[j + i] * T(-1);
}
auto f = fps_multiply::idft(
fps_multiply::multiply(fps_multiply::dft(e), std::move(gdft)));
for (int j = 0; j < i; j++) {
f[j] = g[j];
}
g.coef = std::move(f);
}
return g.pre(n);
}
FPS diff() const {
FPS res(vector<T>(this->size() - 1, T(0)));
for (i64 i = 1; i < this->size(); i++)
res[i - 1] = coef[i] * T(i);
return res;
}
FPS integral() const {
FPS res(vector<T>(this->size() + 1, T(0)));
for (i64 i = 0; i < this->size(); i++)
res[i + 1] = coef[i] / T(i + 1);
return res;
}
// F(0) must be 0
FPS log() const {
return (this->diff() * this->inv()).integral().pre(this->size());
}
FPS exp() const {
FPS f(vector<T>{T(1)});
FPS g = *this;
g.bound_resize();
g[0] += T(1);
for (i64 i = 1; i < size(); i <<= 1) {
f = (f * (g.pre(i << 1) - f.pre(i << 1).log())).pre(i << 1);
}
return f;
}
FPS operator+(const FPS &rhs) {
i64 n = std::max(this->size(), rhs.size());
std::vector<T> ans(n);
for (int i = 0; i < n; i++)
ans[i] = (*this)[i] + rhs[i];
return FPS(ans);
}
FPS operator-(const FPS &rhs) {
i64 n = std::max(this->size(), rhs.size());
std::vector<T> ans(n);
for (int i = 0; i < n; i++)
ans[i] = (*this)[i] - rhs[i];
return FPS(ans);
}
FPS operator*(const FPS &rhs) {
i64 m = this->size() + rhs.size() - 1;
i64 n = bound_pow2(m);
auto res = fps_multiply::idft(
fps_multiply::multiply(fps_multiply::dft(this->pre(n).coef),
fps_multiply::dft(rhs.pre(n).coef)));
res.resize(m);
return res;
}
bool operator<(const FPS &rhs) const { return this->size() < rhs.size(); }
bool operator>(const FPS &rhs) const { return this->size() > rhs.size(); }
};
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)
#define PREFIX "#" TOSTRING(__LINE__) "| "
#define debug(x) \
{ std::cout << PREFIX << #x << " = " << x << std::endl; }
std::ostream &output_indent(std::ostream &os, int ind) {
for (int i = 0; i < ind; i++)
os << " ";
return os;
}
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p);
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v);
template <class S, class T>
std::ostream &operator<<(std::ostream &os, const std::pair<S, T> &p) {
return (os << "(" << p.first << ", " << p.second << ")");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); i++)
os << v[i] << ", ";
return (os << "]");
}
template <class T> static inline std::vector<T> ndvec(size_t &&n, T val) {
return std::vector<T>(n, std::forward<T>(val));
}
template <class... Tail> static inline auto ndvec(size_t &&n, Tail &&...tail) {
return std::vector<decltype(ndvec(std::forward<Tail>(tail)...))>(
n, ndvec(std::forward<Tail>(tail)...));
}
template <class Cond> struct chain {
Cond cond;
chain(Cond cond) : cond(cond) {}
template <class T> bool operator()(T &a, const T &b) const {
if (cond(a, b)) {
a = b;
return true;
}
return false;
}
};
template <class Cond> chain<Cond> make_chain(Cond cond) {
return chain<Cond>(cond);
}
#include <tuple>
#include <vector>
using i64 = long long;
template <class T>
std::tuple<std::vector<T>, std::vector<T>, std::vector<T>>
build_factorial(int N) {
std::vector<T> fact(N);
std::vector<T> finv(N);
std::vector<T> inv(N);
fact[0] = T(1);
for (int i = 1; i < N; i++) {
fact[i] = fact[i - 1] * T(i);
}
finv[N - 1] = T(1) / fact[N - 1];
for (int i = N - 1; i-- > 0;) {
finv[i] = finv[i + 1] * T(i + 1);
}
for (int i = 0; i < N; i++) {
inv[i] = fact[i - 1] * finv[i];
}
return std::make_tuple(std::move(fact), std::move(finv), std::move(inv));
}
using fp = modint<998244353>;
using fps = FPS<fp, fps_ntt_multiply<998244353, 3>>;
int main() {
i64 N;
cin >> N;
vector<i64> cnt(101010);
rep(i, 0, N * 2) {
i64 a;
cin >> a;
cnt[a - 1]++;
}
auto [fact, finv, inv] = build_factorial<fp>(101010);
fps meth(vector<fp>{fp(1)});
vector<fp> setting;
{
fp now(1);
setting.push_back(now);
rep(i, 1, N + 1) {
now *= fact[i * 2] * finv[i * 2 - 2] * finv[2];
setting.push_back(now);
}
}
priority_queue<fps, vector<fps>, greater<fps>> que;
rep(x, 0, 101010) {
if (cnt[x] <= 1)
continue;
vector<fp> vec;
i64 c = cnt[x];
for (i64 i = 0; i * 2 <= c; i++) {
vec.push_back(fact[c] * finv[i * 2] * finv[c - i * 2] * setting[i] *
finv[i]);
}
que.push(fps(vec));
}
que.push(meth);
while (que.size() > 1) {
auto f = que.top();
que.pop();
auto g = que.top();
que.pop();
que.push(f * g);
}
meth = que.top();
fp ans(0);
rep(i, 0, meth.size()) {
if (i > N)
break;
fp res = meth[i] * setting[N - i] * finv[N - i];
if (i % 2 == 0) {
ans += res;
} else {
ans -= res;
}
}
cout << ans.value() << endl;
}
| replace | 378 | 379 | 378 | 379 | 0 | |
p02539 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3f;
/*
#include <atcoder/segtree>
using namespace atcoder;
*/
ll ppow(ll a, ll b) {
a %= MOD;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
class Fact {
vector<ll> fact;
vector<ll> inv;
public:
Fact() {}
Fact(int n) {
n = n * 2 + 10;
fact = inv = vector<ll>(n);
fact[0] = inv[0] = 1;
for (int i = 1; i < n; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
inv[n - 1] = ppow(fact[n - 1], MOD - 2);
for (int i = n - 2; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % MOD;
}
}
ll get(int n) { return fact[n]; }
ll get_inv(int n) { return inv[n]; }
ll nPr(int n, int r) { return fact[n] * inv[n - r] % MOD; }
ll nCr(int n, int r) { return nPr(n, r) * inv[r] % MOD; }
ll nrP(int n, int r) { return nPr(n + r, n); }
ll nrC(int n, int r) { return nCr(n + r, n); }
};
const int r = 3;
void dft(vector<ll> &f, bool inv = false) {
int n = f.size();
rep(i, n) {
int b = 31 - __builtin_clz(n);
int j = 0;
rep(k, b) {
if (i >> k & 1)
j |= 1 << (b - k - 1);
}
if (i < j)
swap(f[i], f[j]);
}
for (int i = 2; i <= n; i <<= 1) {
ll w = ppow(r, (MOD - 1) / i);
if (inv)
w = ppow(w, MOD - 2);
for (int k = 0; k < n; k += i) {
ll x = 1;
rep(j, i / 2) {
ll t = x * f[k + j + i / 2] % MOD, u = f[k + j];
f[k + j] = (u + t) % MOD;
f[k + j + i / 2] = (u + MOD - t) % MOD;
(x *= w) %= MOD;
}
}
}
if (inv) {
ll n_inv = ppow(n, MOD - 2);
rep(i, n)(f[i] *= n_inv) %= MOD;
}
}
vector<ll> multiply(vector<ll> A, vector<ll> B) {
int m = A.size() + B.size();
int N = 1;
while (N < A.size() + B.size())
N <<= 1;
A.resize(N);
B.resize(N);
dft(A, 0);
dft(B, 0);
vector<ll> f(N);
rep(i, N) f[i] = A[i] * B[i] % MOD;
dft(f, 1);
f.erase(f.begin() + m - 1, f.end());
return f;
}
int h[200000];
int d[200000];
int main() {
int n;
cin >> n;
rep(i, 2 * n) {
scanf("%d", &h[i]);
d[h[i]]++;
}
Fact fac(2 * n);
vector<ll> v(1);
v[0] = 1;
vector<vector<ll>> bs;
bs.push_back(v);
rep(i, 100001) {
if (d[i] == 0)
continue;
vector<ll> B;
rep(j, d[i] / 2 + 1) {
ll X = fac.nCr(d[i], j * 2) * fac.get(2 * j) % MOD * fac.get_inv(j) % MOD;
B.push_back(X);
}
bs.push_back(B);
v = multiply(v, B);
}
while (bs.size() > 1) {
vector<vector<ll>> nbs;
for (int i = 0; i < bs.size(); i += 2) {
if (i + 1 >= bs.size())
nbs.push_back(bs[i]);
else {
nbs.push_back(multiply(bs[i], bs[i + 1]));
}
}
bs = nbs;
}
v = bs[0];
ll U = 0;
for (ll i = 0; i <= min(n, (int)v.size() - 1); i++) {
ll X = v[i] * fac.nCr(n, i) % MOD * fac.get(i) % MOD *
fac.get(2 * n - 2 * i) % MOD;
//~ cout<<"X: "<<X<<endl;
if (i % 2 == 0)
(U += X) %= MOD;
else
(U += MOD - X) %= MOD;
}
//~ cout<<U<<endl;
ll ans = U * fac.get_inv(n) % MOD * ppow(ppow(2, n), MOD - 2) % MOD;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3f;
/*
#include <atcoder/segtree>
using namespace atcoder;
*/
ll ppow(ll a, ll b) {
a %= MOD;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
class Fact {
vector<ll> fact;
vector<ll> inv;
public:
Fact() {}
Fact(int n) {
n = n * 2 + 10;
fact = inv = vector<ll>(n);
fact[0] = inv[0] = 1;
for (int i = 1; i < n; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
inv[n - 1] = ppow(fact[n - 1], MOD - 2);
for (int i = n - 2; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % MOD;
}
}
ll get(int n) { return fact[n]; }
ll get_inv(int n) { return inv[n]; }
ll nPr(int n, int r) { return fact[n] * inv[n - r] % MOD; }
ll nCr(int n, int r) { return nPr(n, r) * inv[r] % MOD; }
ll nrP(int n, int r) { return nPr(n + r, n); }
ll nrC(int n, int r) { return nCr(n + r, n); }
};
const int r = 3;
void dft(vector<ll> &f, bool inv = false) {
int n = f.size();
rep(i, n) {
int b = 31 - __builtin_clz(n);
int j = 0;
rep(k, b) {
if (i >> k & 1)
j |= 1 << (b - k - 1);
}
if (i < j)
swap(f[i], f[j]);
}
for (int i = 2; i <= n; i <<= 1) {
ll w = ppow(r, (MOD - 1) / i);
if (inv)
w = ppow(w, MOD - 2);
for (int k = 0; k < n; k += i) {
ll x = 1;
rep(j, i / 2) {
ll t = x * f[k + j + i / 2] % MOD, u = f[k + j];
f[k + j] = (u + t) % MOD;
f[k + j + i / 2] = (u + MOD - t) % MOD;
(x *= w) %= MOD;
}
}
}
if (inv) {
ll n_inv = ppow(n, MOD - 2);
rep(i, n)(f[i] *= n_inv) %= MOD;
}
}
vector<ll> multiply(vector<ll> A, vector<ll> B) {
int m = A.size() + B.size();
int N = 1;
while (N < A.size() + B.size())
N <<= 1;
A.resize(N);
B.resize(N);
dft(A, 0);
dft(B, 0);
vector<ll> f(N);
rep(i, N) f[i] = A[i] * B[i] % MOD;
dft(f, 1);
f.erase(f.begin() + m - 1, f.end());
return f;
}
int h[200000];
int d[200000];
int main() {
int n;
cin >> n;
rep(i, 2 * n) {
scanf("%d", &h[i]);
d[h[i]]++;
}
Fact fac(2 * n);
vector<ll> v(1);
v[0] = 1;
vector<vector<ll>> bs;
bs.push_back(v);
rep(i, 100001) {
if (d[i] == 0)
continue;
vector<ll> B;
rep(j, d[i] / 2 + 1) {
ll X = fac.nCr(d[i], j * 2) * fac.get(2 * j) % MOD * fac.get_inv(j) % MOD;
B.push_back(X);
}
bs.push_back(B);
}
while (bs.size() > 1) {
vector<vector<ll>> nbs;
for (int i = 0; i < bs.size(); i += 2) {
if (i + 1 >= bs.size())
nbs.push_back(bs[i]);
else {
nbs.push_back(multiply(bs[i], bs[i + 1]));
}
}
bs = nbs;
}
v = bs[0];
ll U = 0;
for (ll i = 0; i <= min(n, (int)v.size() - 1); i++) {
ll X = v[i] * fac.nCr(n, i) % MOD * fac.get(i) % MOD *
fac.get(2 * n - 2 * i) % MOD;
//~ cout<<"X: "<<X<<endl;
if (i % 2 == 0)
(U += X) %= MOD;
else
(U += MOD - X) %= MOD;
}
//~ cout<<U<<endl;
ll ans = U * fac.get_inv(n) % MOD * ppow(ppow(2, n), MOD - 2) % MOD;
cout << ans << endl;
} | delete | 127 | 128 | 127 | 127 | TLE | |
p02539 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int N = 100005;
class Comb {
public:
vector<int> fac;
vector<int> inv;
vector<int> facinv;
int P;
Comb() {}
Comb(int N, int P) : fac(N + 1), inv(N + 1), facinv(N + 1), P(P) {
fac[0] = 1;
for (int i = 1; i <= N; ++i) {
fac[i] = 1LL * fac[i - 1] * i % P;
}
inv[1] = 1;
for (int i = 2; i <= N; ++i) {
inv[i] = 1LL * (P - P / i) * inv[P % i] % P;
}
facinv[0] = 1;
for (int i = 1; i <= N; ++i) {
facinv[i] = 1LL * facinv[i - 1] * inv[i] % P;
}
}
int C(int n, int m) {
if (n < m) {
return 0;
}
return 1LL * fac[n] * facinv[m] % P * facinv[n - m] % P;
}
int Inv(int n) { return inv[n]; }
};
namespace poly { // method : use c = multiply(a, b)
vector<int> rev = {0, 1};
vector<int> Root = {0, 1};
const int P = 998244353;
const int G = 3;
int power(int x, int t) {
int ret = 1;
for (; t; t >>= 1, x = 1LL * x * x % P) {
if (t & 1) {
ret = 1LL * ret * x % P;
}
}
return ret;
}
void init(int n) {
if (n <= Root.size()) {
return;
}
rev.resize(n);
for (int i = 0; i < n; ++i) {
rev[i] = (rev[i >> 1] | ((i & 1) * n)) >> 1;
}
if ((int)Root.size() < n) {
int k = __builtin_ctz(Root.size());
Root.resize(n);
while ((1 << k) < n) {
int z = power(G, (P - 1) >> (k + 1));
for (int i = 1 << (k - 1); i < (1 << k); ++i) {
Root[2 * i] = Root[i];
Root[2 * i + 1] = 1LL * Root[i] * z % P;
}
k += 1;
}
}
}
void dft(vector<int> &a, int n) {
init(n);
int s = __builtin_ctz(rev.size() / n);
for (int i = 0; i < n; ++i) {
if (i < rev[i] >> s) {
swap(a[i], a[rev[i] >> s]);
}
}
for (int k = 1; k < n; k = k * 2) {
for (int i = 0; i < n; i = i + k * 2) {
for (int j = 0; j < k; ++j) {
int t = 1LL * Root[j + k] * a[i + j + k] % P;
a[i + j + k] = (a[i + j] - t + P) % P;
a[i + j] = (a[i + j] + t) % P;
}
}
}
}
void idft(vector<int> &a, int n) {
reverse(a.begin() + 1, a.end());
dft(a, n);
int inv = power(n, P - 2);
for (int i = 0; i < n; ++i) {
a[i] = 1LL * a[i] * inv % P;
}
}
vector<int> multiply(vector<int> a,
vector<int> b) { // return a * b size = sz(a) + sz(b)
int s = a.size() + b.size() - 1;
if (s <= 0) {
return {};
}
int L = s > 1 ? 32 - __builtin_clz(s - 1) : 0;
int n = 1 << L;
a.resize(n);
dft(a, n);
b.resize(n);
dft(b, n);
for (int i = 0; i < n; ++i) {
a[i] = 1LL * a[i] * b[i] % P;
}
idft(a, n);
a.resize(s);
return a;
}
} // namespace poly
long long power(long long x, long long t) {
long long ret = 1;
for (; t; t >>= 1, x = x * x % P) {
if (t & 1) {
ret = ret * x % P;
}
}
return ret;
}
class Poly {
public:
vector<int> a;
Poly() {}
Poly(const vector<int> &_a) : a(_a) {}
bool friend operator<(const Poly &a, const Poly &b) {
return a.a.size() > b.a.size();
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> h(n * 2);
for (int i = 0; i < n * 2; ++i) {
cin >> h[i];
}
Comb C(n * 2, P);
vector<int> cnt(N);
for (int i : h) {
cnt[i] += 1;
}
int sum = 0;
priority_queue<Poly> q;
auto calc = [&](int n) {
long long tmp = power(2, n);
return 1LL * C.fac[2 * n] * C.facinv[n] % P * power(tmp, P - 2) % P;
};
for (int i = 0; i < N; ++i) {
if (cnt[i] >= 2) {
Poly tmp;
tmp.a.resize(cnt[i] / 2 + 1);
for (int j = 0; j + j <= cnt[i]; ++j) {
long long x = C.C(cnt[i], j * 2);
tmp.a[j] = x * calc(j) % P;
}
q.emplace(tmp);
}
}
while (q.size() > 1) {
Poly a = q.top();
q.pop();
Poly b = q.top();
q.pop();
Poly c;
c.a = poly::multiply(a.a, b.a);
q.emplace(c);
}
vector<int> dp = q.top().a;
for (int i = 0; i < min(n + 1, (int)dp.size()); ++i) {
dp[i] = 1LL * dp[i] * calc(n - i) % P;
}
long long ans = 0;
for (int i = 0; i < dp.size(); ++i) {
ans = (ans + 1LL * (i % 2 == 0 ? 1 : -1) * dp[i] + P) % P;
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int N = 100005;
class Comb {
public:
vector<int> fac;
vector<int> inv;
vector<int> facinv;
int P;
Comb() {}
Comb(int N, int P) : fac(N + 1), inv(N + 1), facinv(N + 1), P(P) {
fac[0] = 1;
for (int i = 1; i <= N; ++i) {
fac[i] = 1LL * fac[i - 1] * i % P;
}
inv[1] = 1;
for (int i = 2; i <= N; ++i) {
inv[i] = 1LL * (P - P / i) * inv[P % i] % P;
}
facinv[0] = 1;
for (int i = 1; i <= N; ++i) {
facinv[i] = 1LL * facinv[i - 1] * inv[i] % P;
}
}
int C(int n, int m) {
if (n < m) {
return 0;
}
return 1LL * fac[n] * facinv[m] % P * facinv[n - m] % P;
}
int Inv(int n) { return inv[n]; }
};
namespace poly { // method : use c = multiply(a, b)
vector<int> rev = {0, 1};
vector<int> Root = {0, 1};
const int P = 998244353;
const int G = 3;
int power(int x, int t) {
int ret = 1;
for (; t; t >>= 1, x = 1LL * x * x % P) {
if (t & 1) {
ret = 1LL * ret * x % P;
}
}
return ret;
}
void init(int n) {
if (n <= Root.size()) {
return;
}
rev.resize(n);
for (int i = 0; i < n; ++i) {
rev[i] = (rev[i >> 1] | ((i & 1) * n)) >> 1;
}
if ((int)Root.size() < n) {
int k = __builtin_ctz(Root.size());
Root.resize(n);
while ((1 << k) < n) {
int z = power(G, (P - 1) >> (k + 1));
for (int i = 1 << (k - 1); i < (1 << k); ++i) {
Root[2 * i] = Root[i];
Root[2 * i + 1] = 1LL * Root[i] * z % P;
}
k += 1;
}
}
}
void dft(vector<int> &a, int n) {
init(n);
int s = __builtin_ctz(rev.size() / n);
for (int i = 0; i < n; ++i) {
if (i < rev[i] >> s) {
swap(a[i], a[rev[i] >> s]);
}
}
for (int k = 1; k < n; k = k * 2) {
for (int i = 0; i < n; i = i + k * 2) {
for (int j = 0; j < k; ++j) {
int t = 1LL * Root[j + k] * a[i + j + k] % P;
a[i + j + k] = (a[i + j] - t + P) % P;
a[i + j] = (a[i + j] + t) % P;
}
}
}
}
void idft(vector<int> &a, int n) {
reverse(a.begin() + 1, a.end());
dft(a, n);
int inv = power(n, P - 2);
for (int i = 0; i < n; ++i) {
a[i] = 1LL * a[i] * inv % P;
}
}
vector<int> multiply(vector<int> a,
vector<int> b) { // return a * b size = sz(a) + sz(b)
int s = a.size() + b.size() - 1;
if (s <= 0) {
return {};
}
int L = s > 1 ? 32 - __builtin_clz(s - 1) : 0;
int n = 1 << L;
a.resize(n);
dft(a, n);
b.resize(n);
dft(b, n);
for (int i = 0; i < n; ++i) {
a[i] = 1LL * a[i] * b[i] % P;
}
idft(a, n);
a.resize(s);
return a;
}
} // namespace poly
long long power(long long x, long long t) {
long long ret = 1;
for (; t; t >>= 1, x = x * x % P) {
if (t & 1) {
ret = ret * x % P;
}
}
return ret;
}
class Poly {
public:
vector<int> a;
Poly() {}
Poly(const vector<int> &_a) : a(_a) {}
bool friend operator<(const Poly &a, const Poly &b) {
return a.a.size() > b.a.size();
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> h(n * 2);
for (int i = 0; i < n * 2; ++i) {
cin >> h[i];
}
Comb C(n * 2, P);
vector<int> cnt(N);
for (int i : h) {
cnt[i] += 1;
}
int sum = 0;
priority_queue<Poly> q;
auto calc = [&](int n) {
long long tmp = power(2, n);
return 1LL * C.fac[2 * n] * C.facinv[n] % P * power(tmp, P - 2) % P;
};
for (int i = 0; i < N; ++i) {
if (cnt[i] >= 2) {
Poly tmp;
tmp.a.resize(cnt[i] / 2 + 1);
for (int j = 0; j + j <= cnt[i]; ++j) {
long long x = C.C(cnt[i], j * 2);
tmp.a[j] = x * calc(j) % P;
}
q.emplace(tmp);
}
}
while (q.size() > 1) {
Poly a = q.top();
q.pop();
Poly b = q.top();
q.pop();
Poly c;
c.a = poly::multiply(a.a, b.a);
q.emplace(c);
}
if (q.size() == 0) {
cout << calc(n) << '\n';
exit(0);
}
vector<int> dp = q.top().a;
for (int i = 0; i < min(n + 1, (int)dp.size()); ++i) {
dp[i] = 1LL * dp[i] * calc(n - i) % P;
}
long long ans = 0;
for (int i = 0; i < dp.size(); ++i) {
ans = (ans + 1LL * (i % 2 == 0 ? 1 : -1) * dp[i] + P) % P;
}
cout << ans << '\n';
return 0;
}
| insert | 199 | 199 | 199 | 204 | 0 | |
p02539 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18;
const int mod = 998244353;
const int root = 3;
int lim, rev[N], w[N], wn[N], inv_lim;
void reduce(int &x) { x = (x + mod) % mod; }
int POW(int x, int y, int ans = 1) {
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1)
ans = (long long)ans * x % mod;
return ans;
}
void precompute(int len) {
lim = wn[0] = 1;
int s = -1;
while (lim < len)
lim <<= 1, ++s;
for (int i = 0; i < lim; ++i)
rev[i] = rev[i >> 1] >> 1 | (i & 1) << s;
const int g = POW(root, (mod - 1) / lim);
inv_lim = POW(lim, mod - 2);
for (int i = 1; i < lim; ++i)
wn[i] = (long long)wn[i - 1] * g % mod;
}
void ntt(vector<int> &a, int typ) {
for (int i = 0; i < lim; ++i)
if (i < rev[i])
swap(a[i], a[rev[i]]);
for (int i = 1; i < lim; i <<= 1) {
for (int j = 0, t = lim / i / 2; j < i; ++j)
w[j] = wn[j * t];
for (int j = 0; j < lim; j += i << 1)
for (int k = 0; k < i; ++k) {
const int x = a[k + j], y = (long long)a[k + j + i] * w[k] % mod;
reduce(a[k + j] += y - mod), reduce(a[k + j + i] = x - y);
}
}
if (!typ) {
reverse(a.begin() + 1, a.begin() + lim);
for (int i = 0; i < lim; ++i)
a[i] = (long long)a[i] * inv_lim % mod;
}
}
vector<int> multiply(vector<int> f, vector<int> g) {
int n = (int)f.size() + (int)g.size() - 1;
precompute(n);
vector<int> a = f, b = g;
a.resize(lim);
b.resize(lim);
ntt(a, 1), ntt(b, 1);
for (int i = 0; i < lim; ++i)
a[i] = (long long)a[i] * b[i] % mod;
ntt(a, 0);
// while((int)a.size() && a.back() == 0) a.pop_back();
return a;
}
template <const int32_t MOD> struct modint {
int32_t value;
modint() = default;
modint(int32_t value_) : value(value_) {}
inline modint<MOD> operator+(modint<MOD> other) const {
int32_t c = this->value + other.value;
return modint<MOD>(c >= MOD ? c - MOD : c);
}
inline modint<MOD> operator-(modint<MOD> other) const {
int32_t c = this->value - other.value;
return modint<MOD>(c < 0 ? c + MOD : c);
}
inline modint<MOD> operator*(modint<MOD> other) const {
int32_t c = (int64_t)this->value * other.value % MOD;
return modint<MOD>(c < 0 ? c + MOD : c);
}
inline modint<MOD> &operator+=(modint<MOD> other) {
this->value += other.value;
if (this->value >= MOD)
this->value -= MOD;
return *this;
}
inline modint<MOD> &operator-=(modint<MOD> other) {
this->value -= other.value;
if (this->value < 0)
this->value += MOD;
return *this;
}
inline modint<MOD> &operator*=(modint<MOD> other) {
this->value = (int64_t)this->value * other.value % MOD;
if (this->value < 0)
this->value += MOD;
return *this;
}
inline modint<MOD> operator-() const {
return modint<MOD>(this->value ? MOD - this->value : 0);
}
modint<MOD> pow(uint64_t k) const {
modint<MOD> x = *this, y = 1;
for (; k; k >>= 1) {
if (k & 1)
y *= x;
x *= x;
}
return y;
}
modint<MOD> inv() const { return pow(MOD - 2); } // MOD must be a prime
inline modint<MOD> operator/(modint<MOD> other) const {
return *this * other.inv();
}
inline modint<MOD> operator/=(modint<MOD> other) {
return *this *= other.inv();
}
inline bool operator==(modint<MOD> other) const {
return value == other.value;
}
inline bool operator!=(modint<MOD> other) const {
return value != other.value;
}
inline bool operator<(modint<MOD> other) const { return value < other.value; }
inline bool operator>(modint<MOD> other) const { return value > other.value; }
};
template <int32_t MOD> modint<MOD> operator*(int64_t value, modint<MOD> n) {
return modint<MOD>(value) * n;
}
template <int32_t MOD> modint<MOD> operator*(int32_t value, modint<MOD> n) {
return modint<MOD>(value % MOD) * n;
}
template <int32_t MOD> istream &operator>>(istream &in, modint<MOD> &n) {
return in >> n.value;
}
template <int32_t MOD> ostream &operator<<(ostream &out, modint<MOD> n) {
return out << n.value;
}
using mint = modint<mod>;
struct Combi {
int n;
vector<mint> facts, finvs, invs;
Combi(int _n) : n(_n), facts(_n), finvs(_n), invs(_n) {
facts[0] = finvs[0] = 1;
invs[1] = 1;
for (int i = 2; i < n; i++)
invs[i] = invs[mod % i] * (-mod / i);
for (int i = 1; i < n; i++) {
facts[i] = facts[i - 1] * i;
finvs[i] = finvs[i - 1] * invs[i];
}
}
inline mint fact(int n) { return facts[n]; }
inline mint finv(int n) { return finvs[n]; }
inline mint inv(int n) { return invs[n]; }
inline mint ncr(int n, int k) {
return n < k ? 0 : facts[n] * finvs[k] * finvs[n - k];
}
};
Combi C(N);
int a[N];
mint f[N];
vector<int> c[N];
vector<int> yo(int l, int r) {
if (l == r)
return c[l];
int mid = l + r >> 1;
return multiply(yo(l, mid), yo(mid + 1, r));
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
n *= 2;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
a[k]++;
}
f[0] = 1;
for (int i = 2; i < N; i += 2) {
f[i] = C.fact(i) / C.fact(i / 2) / mint(2).pow(i / 2);
}
for (int i = 1; i < N; i++) {
c[i] = vector<int>(a[i] + 1, 0);
c[i][0] = 1;
for (int k = 2; k <= a[i]; k += 2) {
c[i][k] = (C.ncr(a[i], k) * f[k]).value;
}
}
auto cnt = yo(1, 100000);
cnt.resize(n + 1);
mint ans = 0;
for (int i = 0; i <= n; i += 2) {
mint sgn = (i / 2) & 1 ? mod - 1 : 1;
ans += sgn * f[n - i] * cnt[i];
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18;
const int mod = 998244353;
const int root = 3;
int lim, rev[N], w[N], wn[N], inv_lim;
void reduce(int &x) { x = (x + mod) % mod; }
int POW(int x, int y, int ans = 1) {
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1)
ans = (long long)ans * x % mod;
return ans;
}
void precompute(int len) {
lim = wn[0] = 1;
int s = -1;
while (lim < len)
lim <<= 1, ++s;
for (int i = 0; i < lim; ++i)
rev[i] = rev[i >> 1] >> 1 | (i & 1) << s;
const int g = POW(root, (mod - 1) / lim);
inv_lim = POW(lim, mod - 2);
for (int i = 1; i < lim; ++i)
wn[i] = (long long)wn[i - 1] * g % mod;
}
void ntt(vector<int> &a, int typ) {
for (int i = 0; i < lim; ++i)
if (i < rev[i])
swap(a[i], a[rev[i]]);
for (int i = 1; i < lim; i <<= 1) {
for (int j = 0, t = lim / i / 2; j < i; ++j)
w[j] = wn[j * t];
for (int j = 0; j < lim; j += i << 1)
for (int k = 0; k < i; ++k) {
const int x = a[k + j], y = (long long)a[k + j + i] * w[k] % mod;
reduce(a[k + j] += y - mod), reduce(a[k + j + i] = x - y);
}
}
if (!typ) {
reverse(a.begin() + 1, a.begin() + lim);
for (int i = 0; i < lim; ++i)
a[i] = (long long)a[i] * inv_lim % mod;
}
}
vector<int> multiply(vector<int> f, vector<int> g) {
if (f.size() > 100000)
f.resize(100001);
if (g.size() > 100000)
g.resize(100001);
int n = (int)f.size() + (int)g.size() - 1;
precompute(n);
vector<int> a = f, b = g;
a.resize(lim);
b.resize(lim);
ntt(a, 1), ntt(b, 1);
for (int i = 0; i < lim; ++i)
a[i] = (long long)a[i] * b[i] % mod;
ntt(a, 0);
// while((int)a.size() && a.back() == 0) a.pop_back();
return a;
}
template <const int32_t MOD> struct modint {
int32_t value;
modint() = default;
modint(int32_t value_) : value(value_) {}
inline modint<MOD> operator+(modint<MOD> other) const {
int32_t c = this->value + other.value;
return modint<MOD>(c >= MOD ? c - MOD : c);
}
inline modint<MOD> operator-(modint<MOD> other) const {
int32_t c = this->value - other.value;
return modint<MOD>(c < 0 ? c + MOD : c);
}
inline modint<MOD> operator*(modint<MOD> other) const {
int32_t c = (int64_t)this->value * other.value % MOD;
return modint<MOD>(c < 0 ? c + MOD : c);
}
inline modint<MOD> &operator+=(modint<MOD> other) {
this->value += other.value;
if (this->value >= MOD)
this->value -= MOD;
return *this;
}
inline modint<MOD> &operator-=(modint<MOD> other) {
this->value -= other.value;
if (this->value < 0)
this->value += MOD;
return *this;
}
inline modint<MOD> &operator*=(modint<MOD> other) {
this->value = (int64_t)this->value * other.value % MOD;
if (this->value < 0)
this->value += MOD;
return *this;
}
inline modint<MOD> operator-() const {
return modint<MOD>(this->value ? MOD - this->value : 0);
}
modint<MOD> pow(uint64_t k) const {
modint<MOD> x = *this, y = 1;
for (; k; k >>= 1) {
if (k & 1)
y *= x;
x *= x;
}
return y;
}
modint<MOD> inv() const { return pow(MOD - 2); } // MOD must be a prime
inline modint<MOD> operator/(modint<MOD> other) const {
return *this * other.inv();
}
inline modint<MOD> operator/=(modint<MOD> other) {
return *this *= other.inv();
}
inline bool operator==(modint<MOD> other) const {
return value == other.value;
}
inline bool operator!=(modint<MOD> other) const {
return value != other.value;
}
inline bool operator<(modint<MOD> other) const { return value < other.value; }
inline bool operator>(modint<MOD> other) const { return value > other.value; }
};
template <int32_t MOD> modint<MOD> operator*(int64_t value, modint<MOD> n) {
return modint<MOD>(value) * n;
}
template <int32_t MOD> modint<MOD> operator*(int32_t value, modint<MOD> n) {
return modint<MOD>(value % MOD) * n;
}
template <int32_t MOD> istream &operator>>(istream &in, modint<MOD> &n) {
return in >> n.value;
}
template <int32_t MOD> ostream &operator<<(ostream &out, modint<MOD> n) {
return out << n.value;
}
using mint = modint<mod>;
struct Combi {
int n;
vector<mint> facts, finvs, invs;
Combi(int _n) : n(_n), facts(_n), finvs(_n), invs(_n) {
facts[0] = finvs[0] = 1;
invs[1] = 1;
for (int i = 2; i < n; i++)
invs[i] = invs[mod % i] * (-mod / i);
for (int i = 1; i < n; i++) {
facts[i] = facts[i - 1] * i;
finvs[i] = finvs[i - 1] * invs[i];
}
}
inline mint fact(int n) { return facts[n]; }
inline mint finv(int n) { return finvs[n]; }
inline mint inv(int n) { return invs[n]; }
inline mint ncr(int n, int k) {
return n < k ? 0 : facts[n] * finvs[k] * finvs[n - k];
}
};
Combi C(N);
int a[N];
mint f[N];
vector<int> c[N];
vector<int> yo(int l, int r) {
if (l == r)
return c[l];
int mid = l + r >> 1;
return multiply(yo(l, mid), yo(mid + 1, r));
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
n *= 2;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
a[k]++;
}
f[0] = 1;
for (int i = 2; i < N; i += 2) {
f[i] = C.fact(i) / C.fact(i / 2) / mint(2).pow(i / 2);
}
for (int i = 1; i < N; i++) {
c[i] = vector<int>(a[i] + 1, 0);
c[i][0] = 1;
for (int k = 2; k <= a[i]; k += 2) {
c[i][k] = (C.ncr(a[i], k) * f[k]).value;
}
}
auto cnt = yo(1, 100000);
cnt.resize(n + 1);
mint ans = 0;
for (int i = 0; i <= n; i += 2) {
mint sgn = (i / 2) & 1 ? mod - 1 : 1;
ans += sgn * f[n - i] * cnt[i];
}
cout << ans << '\n';
return 0;
} | insert | 46 | 46 | 46 | 50 | 0 | |
p02539 | C++ | Runtime Error | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// constexpr long long int MOD = 1000000007;
// constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-5;
// int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
template <int mod> struct NumberTheoreticTransform {
vector<int> rev, rts;
int base, max_base, root;
NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} {
assert(mod >= 3 && mod % 2 == 1);
auto tmp = mod - 1;
max_base = 0;
while (tmp % 2 == 0)
tmp >>= 1, max_base++;
root = 2;
while (mod_pow(root, (mod - 1) >> 1) == 1)
++root;
assert(mod_pow(root, mod - 1) == 1);
root = mod_pow(root, (mod - 1) >> max_base);
}
inline int mod_pow(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1)
ret = mul(ret, x);
x = mul(x, x);
n >>= 1;
}
return ret;
}
inline int inverse(int x) { return mod_pow(x, mod - 2); }
inline unsigned add(unsigned x, unsigned y) {
x += y;
if (x >= mod)
x -= mod;
return x;
}
inline unsigned mul(unsigned a, unsigned b) {
return 1ull * a * b % (unsigned long long)mod;
}
void ensure_base(int nbase) {
if (nbase <= base)
return;
rev.resize(1 << nbase);
rts.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); i++) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
}
assert(nbase <= max_base);
while (base < nbase) {
int z = mod_pow(root, 1 << (max_base - 1 - base));
for (int i = 1 << (base - 1); i < (1 << base); i++) {
rts[i << 1] = rts[i];
rts[(i << 1) + 1] = mul(rts[i], z);
}
++base;
}
}
void ntt(vector<int> &a) {
const int n = (int)a.size();
assert((n & (n - 1)) == 0);
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; i++) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
int z = mul(a[i + j + k], rts[j + k]);
a[i + j + k] = add(a[i + j], mod - z);
a[i + j] = add(a[i + j], z);
}
}
}
}
vector<int> multiply(vector<int> a, vector<int> b) {
int need = a.size() + b.size() - 1;
int nbase = 1;
while ((1 << nbase) < need)
nbase++;
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz, 0);
b.resize(sz, 0);
ntt(a);
ntt(b);
int inv_sz = inverse(sz);
for (int i = 0; i < sz; i++) {
a[i] = mul(a[i], mul(b[i], inv_sz));
}
reverse(a.begin() + 1, a.end());
ntt(a);
a.resize(need);
return a;
}
};
long long int power(long long int x, long long int n, long long int M) {
long long int ret = 1;
long long int by = x;
while (n) {
if (n & 1) {
ret *= by;
ret %= M;
}
by *= by;
by %= M;
n >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<int> num(100001);
for (int i = 0; i < 2 * N; i++) {
cin >> M;
num[M]++;
}
NumberTheoreticTransform<998244353> ntt;
vector<vector<int>> box(100001);
vector<long long int> by(200001, 1);
vector<long long int> rev(200001, 1);
for (int i = 1; i <= 200000; i++) {
by[i] = by[i - 1] * i % MOD;
rev[i] = power(by[i], MOD - 2, MOD);
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
PQ;
for (int i = 1; i <= 100000; i++) {
if (num[i] / 2 == 0)
continue;
vector<int> v(num[i] / 2 + 1, 1);
for (int j = 1; j <= num[i] / 2; j++) {
v[j] = by[num[i]] * rev[num[i] - 2 * j] % MOD * rev[j] % MOD *
power(rev[2], j, MOD) % MOD;
;
}
box[i] = v;
PQ.push({num[i] / 2, i});
}
if (!PQ.empty()) {
cout << by[N * 2] % MOD * rev[N] % MOD * power(rev[2], N, MOD) % MOD
<< endl;
return 0;
}
while (PQ.size() > 1) {
auto a = PQ.top();
PQ.pop();
auto b = PQ.top();
PQ.pop();
box[a.second] = ntt.multiply(box[a.second], box[b.second]);
PQ.push({box[a.second].size() - 1, a.second});
}
long long int ans = 0;
for (int i = 0; i <= PQ.top().first; i++) {
if (i & 1) {
ans += MOD - box[PQ.top().second][i] * by[N * 2 - i * 2] % MOD *
rev[N - i] % MOD * power(rev[2], N - i, MOD) % MOD;
} else {
ans += box[PQ.top().second][i] * by[N * 2 - i * 2] % MOD * rev[N - i] %
MOD * power(rev[2], N - i, MOD) % MOD;
}
}
cout << ans % MOD << endl;
}
| #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// constexpr long long int MOD = 1000000007;
// constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-5;
// int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
template <int mod> struct NumberTheoreticTransform {
vector<int> rev, rts;
int base, max_base, root;
NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} {
assert(mod >= 3 && mod % 2 == 1);
auto tmp = mod - 1;
max_base = 0;
while (tmp % 2 == 0)
tmp >>= 1, max_base++;
root = 2;
while (mod_pow(root, (mod - 1) >> 1) == 1)
++root;
assert(mod_pow(root, mod - 1) == 1);
root = mod_pow(root, (mod - 1) >> max_base);
}
inline int mod_pow(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1)
ret = mul(ret, x);
x = mul(x, x);
n >>= 1;
}
return ret;
}
inline int inverse(int x) { return mod_pow(x, mod - 2); }
inline unsigned add(unsigned x, unsigned y) {
x += y;
if (x >= mod)
x -= mod;
return x;
}
inline unsigned mul(unsigned a, unsigned b) {
return 1ull * a * b % (unsigned long long)mod;
}
void ensure_base(int nbase) {
if (nbase <= base)
return;
rev.resize(1 << nbase);
rts.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); i++) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
}
assert(nbase <= max_base);
while (base < nbase) {
int z = mod_pow(root, 1 << (max_base - 1 - base));
for (int i = 1 << (base - 1); i < (1 << base); i++) {
rts[i << 1] = rts[i];
rts[(i << 1) + 1] = mul(rts[i], z);
}
++base;
}
}
void ntt(vector<int> &a) {
const int n = (int)a.size();
assert((n & (n - 1)) == 0);
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; i++) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
int z = mul(a[i + j + k], rts[j + k]);
a[i + j + k] = add(a[i + j], mod - z);
a[i + j] = add(a[i + j], z);
}
}
}
}
vector<int> multiply(vector<int> a, vector<int> b) {
int need = a.size() + b.size() - 1;
int nbase = 1;
while ((1 << nbase) < need)
nbase++;
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz, 0);
b.resize(sz, 0);
ntt(a);
ntt(b);
int inv_sz = inverse(sz);
for (int i = 0; i < sz; i++) {
a[i] = mul(a[i], mul(b[i], inv_sz));
}
reverse(a.begin() + 1, a.end());
ntt(a);
a.resize(need);
return a;
}
};
long long int power(long long int x, long long int n, long long int M) {
long long int ret = 1;
long long int by = x;
while (n) {
if (n & 1) {
ret *= by;
ret %= M;
}
by *= by;
by %= M;
n >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<int> num(100001);
for (int i = 0; i < 2 * N; i++) {
cin >> M;
num[M]++;
}
NumberTheoreticTransform<998244353> ntt;
vector<vector<int>> box(100001);
vector<long long int> by(200001, 1);
vector<long long int> rev(200001, 1);
for (int i = 1; i <= 200000; i++) {
by[i] = by[i - 1] * i % MOD;
rev[i] = power(by[i], MOD - 2, MOD);
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
PQ;
for (int i = 1; i <= 100000; i++) {
if (num[i] / 2 == 0)
continue;
vector<int> v(num[i] / 2 + 1, 1);
for (int j = 1; j <= num[i] / 2; j++) {
v[j] = by[num[i]] * rev[num[i] - 2 * j] % MOD * rev[j] % MOD *
power(rev[2], j, MOD) % MOD;
;
}
box[i] = v;
PQ.push({num[i] / 2, i});
}
if (PQ.empty()) {
cout << by[N * 2] % MOD * rev[N] % MOD * power(rev[2], N, MOD) % MOD
<< endl;
return 0;
}
while (PQ.size() > 1) {
auto a = PQ.top();
PQ.pop();
auto b = PQ.top();
PQ.pop();
box[a.second] = ntt.multiply(box[a.second], box[b.second]);
PQ.push({box[a.second].size() - 1, a.second});
}
long long int ans = 0;
for (int i = 0; i <= PQ.top().first; i++) {
if (i & 1) {
ans += MOD - box[PQ.top().second][i] * by[N * 2 - i * 2] % MOD *
rev[N - i] % MOD * power(rev[2], N - i, MOD) % MOD;
} else {
ans += box[PQ.top().second][i] * by[N * 2 - i * 2] % MOD * rev[N - i] %
MOD * power(rev[2], N - i, MOD) % MOD;
}
}
cout << ans % MOD << endl;
}
| replace | 185 | 186 | 185 | 186 | 0 | |
p02539 | C++ | Time Limit Exceeded | #include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MOD = 998244353;
long long modPow(long long a, long long p) {
if (p == 0)
return 1;
auto res = modPow(a, p / 2);
res = (res * res) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
long long calcInv(long long a) { return modPow(a, MOD - 2); }
void ntt(vector<long long> &v, int inv) {
const int n = v.size();
auto w = modPow(3, (MOD - 1) / n);
if (inv == -1)
w = calcInv(w);
int rev = 0;
for (int i = 1; i < n - 1; i++) {
for (int j = n / 2; j > (rev ^= j); j /= 2)
;
if (i < rev)
swap(v[i], v[rev]);
}
for (int m = 1; m < n; m *= 2) {
auto cur = 1;
auto rot = modPow(w, n / (2 * m));
for (int i = 0; i < m; i++) {
for (int j = i; j < n; j += 2 * m) {
auto p = v[j];
auto q = v[j + m] * cur % MOD;
v[j] = (p + q) % MOD;
v[j + m] = (p + MOD - q) % MOD;
}
cur = (cur * rot) % MOD;
}
}
}
vector<long long> convolution(const vector<long long> &a,
const vector<long long> &b) {
int _n = a.size() + b.size();
int n = 1;
while (n < _n)
n *= 2;
vector<long long> na(n, 0), nb(n, 0);
for (int i = 0; i < a.size(); i++)
na[i] = a[i];
for (int i = 0; i < b.size(); i++)
nb[i] = b[i];
ntt(na, 1);
ntt(nb, 1);
for (int i = 0; i < n; i++)
na[i] = na[i] * nb[i] % MOD;
ntt(na, -1);
auto inv = calcInv(n);
for (int i = 0; i < n; i++)
na[i] = na[i] * inv % MOD;
na.resize(a.size() + b.size() - 1);
return na;
}
bool op(const vector<long long> &a, const vector<long long> &b) {
return a.size() < b.size();
}
int main() {
const int maxSize = 100001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
auto perm = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD;
};
vector<long long> inv2pow(maxSize);
inv2pow[0] = 1;
for (int i = 1; i < maxSize; i++)
inv2pow[i] = inv2pow[i - 1] * inv[2] % MOD;
int N;
cin >> N;
vector<int> cnt(100001, 0);
for (int i = 0; i < 2 * N; i++) {
int h;
cin >> h;
cnt[h]++;
}
vector<vector<long long>> p(100001);
priority_queue<int, vector<int>, function<bool(int, int)>> qu(
[&](int a, int b) { return p[a].size() < p[b].size(); });
p[0].push_back(1);
qu.push(0);
for (int i = 0; i < cnt.size(); i++) {
int t = cnt[i];
if (t < 2)
continue;
vector<long long> v(t / 2 + 1);
v[0] = 1;
for (int i = 1; i < v.size(); i++) {
v[i] = perm(t, 2 * i) * inv2pow[i] % MOD * factInv[i] % MOD;
}
p[i] = v;
qu.emplace(i);
}
while (qu.size() >= 2) {
auto a = qu.top();
qu.pop();
auto b = qu.top();
qu.pop();
p[a] = convolution(p[a], p[b]);
qu.emplace(a);
}
long long res = 0;
auto &v = p[qu.top()];
for (int i = 0; i < v.size(); i++) {
long long rest = N - i;
long long cur = perm(2 * rest, rest) * inv2pow[rest] % MOD;
if (i % 2) {
res = (res + MOD - cur * v[i] % MOD) % MOD;
} else {
res = (res + cur * v[i]) % MOD;
}
}
cout << res << endl;
} | #include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MOD = 998244353;
long long modPow(long long a, long long p) {
if (p == 0)
return 1;
auto res = modPow(a, p / 2);
res = (res * res) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
long long calcInv(long long a) { return modPow(a, MOD - 2); }
void ntt(vector<long long> &v, int inv) {
const int n = v.size();
auto w = modPow(3, (MOD - 1) / n);
if (inv == -1)
w = calcInv(w);
int rev = 0;
for (int i = 1; i < n - 1; i++) {
for (int j = n / 2; j > (rev ^= j); j /= 2)
;
if (i < rev)
swap(v[i], v[rev]);
}
for (int m = 1; m < n; m *= 2) {
auto cur = 1;
auto rot = modPow(w, n / (2 * m));
for (int i = 0; i < m; i++) {
for (int j = i; j < n; j += 2 * m) {
auto p = v[j];
auto q = v[j + m] * cur % MOD;
v[j] = (p + q) % MOD;
v[j + m] = (p + MOD - q) % MOD;
}
cur = (cur * rot) % MOD;
}
}
}
vector<long long> convolution(const vector<long long> &a,
const vector<long long> &b) {
int _n = a.size() + b.size();
int n = 1;
while (n < _n)
n *= 2;
vector<long long> na(n, 0), nb(n, 0);
for (int i = 0; i < a.size(); i++)
na[i] = a[i];
for (int i = 0; i < b.size(); i++)
nb[i] = b[i];
ntt(na, 1);
ntt(nb, 1);
for (int i = 0; i < n; i++)
na[i] = na[i] * nb[i] % MOD;
ntt(na, -1);
auto inv = calcInv(n);
for (int i = 0; i < n; i++)
na[i] = na[i] * inv % MOD;
na.resize(a.size() + b.size() - 1);
return na;
}
bool op(const vector<long long> &a, const vector<long long> &b) {
return a.size() < b.size();
}
int main() {
const int maxSize = 100001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
auto perm = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD;
};
vector<long long> inv2pow(maxSize);
inv2pow[0] = 1;
for (int i = 1; i < maxSize; i++)
inv2pow[i] = inv2pow[i - 1] * inv[2] % MOD;
int N;
cin >> N;
vector<int> cnt(100001, 0);
for (int i = 0; i < 2 * N; i++) {
int h;
cin >> h;
cnt[h]++;
}
vector<vector<long long>> p(100001);
priority_queue<int, vector<int>, function<bool(int, int)>> qu(
[&](int a, int b) { return p[a].size() > p[b].size(); });
p[0].push_back(1);
qu.push(0);
for (int i = 0; i < cnt.size(); i++) {
int t = cnt[i];
if (t < 2)
continue;
vector<long long> v(t / 2 + 1);
v[0] = 1;
for (int i = 1; i < v.size(); i++) {
v[i] = perm(t, 2 * i) * inv2pow[i] % MOD * factInv[i] % MOD;
}
p[i] = v;
qu.emplace(i);
}
while (qu.size() >= 2) {
auto a = qu.top();
qu.pop();
auto b = qu.top();
qu.pop();
p[a] = convolution(p[a], p[b]);
qu.emplace(a);
}
long long res = 0;
auto &v = p[qu.top()];
for (int i = 0; i < v.size(); i++) {
long long rest = N - i;
long long cur = perm(2 * rest, rest) * inv2pow[rest] % MOD;
if (i % 2) {
res = (res + MOD - cur * v[i] % MOD) % MOD;
} else {
res = (res + cur * v[i]) % MOD;
}
}
cout << res << endl;
} | replace | 111 | 112 | 111 | 112 | TLE | |
p02539 | C++ | Runtime Error | // #define LOCAL
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
typedef long long int64;
typedef pair<int, int> ii;
#define SZ(x) (int)((x).size())
const int INF = 1 << 29;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x; }
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
};
} fast_ios_;
const int MOD = 998244353; // prime, 2^23*7*17+1
typedef int atom;
const int G = 3;
int64 power_mod(int64 a, int64 n, int p = MOD) {
int64 ret = 1;
for (; n; n >>= 1) {
if (n & 1)
ret = ret * a % p;
a = a * a % p;
}
return ret;
}
int64 inv_mod(int64 a) { return power_mod(a, MOD - 2); }
void bit_reverse(vector<atom> &a) {
int n = a.size();
for (int i = 1, j = n / 2; i < n - 1; ++i) {
if (i < j)
swap(a[i], a[j]);
int k = n / 2;
while (j >= k)
j -= k, k /= 2;
if (j < k)
j += k;
}
}
void fft(vector<atom> &a, int flag) {
int n = a.size();
bit_reverse(a);
vector<atom> wn(n);
wn[0] = 1;
wn[1] = power_mod(G, flag == 1 ? (MOD - 1) / n : MOD - 1 - (MOD - 1) / n);
for (int i = 2; i < n; ++i)
wn[i] = (int64)wn[i - 1] * wn[1] % MOD;
for (int k = 2; k <= n; k <<= 1) {
for (int i = 0; i < n; i += k) {
int wi = 0, step = n / k;
for (int j = i; j < i + k / 2; ++j) {
atom u = a[j];
atom v = (int64)wn[wi] * a[j + k / 2] % MOD;
a[j] = (u + v) % MOD;
a[j + k / 2] = (u + MOD - v) % MOD;
wi += step;
}
}
}
if (flag < 0) {
int64 inv_n = inv_mod(n);
for (int i = 0; i < n; ++i)
a[i] = a[i] * inv_n % MOD;
}
}
namespace polynomial {
vector<int> mul(const vector<int> &f, const vector<int> &g, int cap = INF) {
int n = f.size(), m = g.size();
int len = 1;
while (len < n + m - 1)
len <<= 1;
vector<atom> x(len), y(len);
copy(f.begin(), f.end(), x.begin());
copy(g.begin(), g.end(), y.begin());
fft(x, 1);
fft(y, 1);
for (int i = 0; i < len; ++i)
x[i] = (int64)x[i] * y[i] % MOD;
fft(x, -1);
cap = min(cap, n + m - 1);
x.resize(cap);
return x;
}
} // namespace polynomial
using namespace polynomial;
const int N = 1e5 + 10;
int fact[N], ifact[N], inv[N];
struct comb_init {
comb_init() {
inv[1] = 1;
for (int i = 2; i < N; ++i) {
inv[i] = (MOD - MOD / i) * (int64)inv[MOD % i] % MOD;
}
fact[0] = ifact[0] = 1;
for (int i = 1; i < N; ++i) {
fact[i] = (int64)fact[i - 1] * i % MOD;
ifact[i] = (int64)ifact[i - 1] * inv[i] % MOD;
}
}
} comb_init_;
int64 comb(int n, int m) {
if (n < m || m < 0)
return 0;
return (int64)fact[n] * ifact[m] % MOD * ifact[n - m] % MOD;
}
void add(int &x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
}
vector<int> solve(const vector<vector<int>> &gs, int L, int R) {
if (L + 1 == R)
return gs[L];
int mid = (L + R) / 2;
auto u = solve(gs, L, mid);
auto v = solve(gs, mid, R);
return mul(u, v);
}
int main() {
int n;
cin >> n;
vector<int> ip2(N), p2(N);
ip2[0] = p2[0] = 1;
for (int i = 1; i < N; ++i) {
ip2[i] = 1LL * ip2[i - 1] * inv[2] % MOD;
p2[i] = 1LL * p2[i - 1] * 2 % MOD;
}
vector<int> a(n * 2);
for (int i = 0; i < n * 2; ++i)
cin >> a[i];
sort(a.begin(), a.end());
vector<vector<int>> gs;
for (int i = 0, j; i < n * 2; i = j) {
for (j = i; j < n * 2 && a[j] == a[i]; ++j)
;
int k = j - i;
if (k == 1)
continue;
vector<int> g(k / 2 + 1);
for (int u = 0; u <= k / 2; ++u) {
g[u] = 1LL * fact[k] * ifact[k - 2 * u] % MOD * ifact[u] % MOD * ip2[u] %
MOD;
}
gs.push_back(g);
}
auto f = solve(gs, 0, SZ(gs));
trace(f);
int ret = 0;
for (int k = 0; k <= n && k < SZ(f); ++k) {
int cur = f[k] % MOD;
int cnt = 1LL * fact[2 * n - 2 * k] * ifact[n - k] % MOD * ip2[n - k] % MOD;
cur = 1LL * cur * cnt % MOD;
trace(k, cur);
if (k % 2)
cur = MOD - cur;
add(ret, cur);
// break;
}
cout << ret << '\n';
return 0;
}
| // #define LOCAL
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream &operator<<(ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
ostream &operator<<(ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream &operator<<(ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
typedef long long int64;
typedef pair<int, int> ii;
#define SZ(x) (int)((x).size())
const int INF = 1 << 29;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x; }
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
};
} fast_ios_;
const int MOD = 998244353; // prime, 2^23*7*17+1
typedef int atom;
const int G = 3;
int64 power_mod(int64 a, int64 n, int p = MOD) {
int64 ret = 1;
for (; n; n >>= 1) {
if (n & 1)
ret = ret * a % p;
a = a * a % p;
}
return ret;
}
int64 inv_mod(int64 a) { return power_mod(a, MOD - 2); }
void bit_reverse(vector<atom> &a) {
int n = a.size();
for (int i = 1, j = n / 2; i < n - 1; ++i) {
if (i < j)
swap(a[i], a[j]);
int k = n / 2;
while (j >= k)
j -= k, k /= 2;
if (j < k)
j += k;
}
}
void fft(vector<atom> &a, int flag) {
int n = a.size();
bit_reverse(a);
vector<atom> wn(n);
wn[0] = 1;
wn[1] = power_mod(G, flag == 1 ? (MOD - 1) / n : MOD - 1 - (MOD - 1) / n);
for (int i = 2; i < n; ++i)
wn[i] = (int64)wn[i - 1] * wn[1] % MOD;
for (int k = 2; k <= n; k <<= 1) {
for (int i = 0; i < n; i += k) {
int wi = 0, step = n / k;
for (int j = i; j < i + k / 2; ++j) {
atom u = a[j];
atom v = (int64)wn[wi] * a[j + k / 2] % MOD;
a[j] = (u + v) % MOD;
a[j + k / 2] = (u + MOD - v) % MOD;
wi += step;
}
}
}
if (flag < 0) {
int64 inv_n = inv_mod(n);
for (int i = 0; i < n; ++i)
a[i] = a[i] * inv_n % MOD;
}
}
namespace polynomial {
vector<int> mul(const vector<int> &f, const vector<int> &g, int cap = INF) {
int n = f.size(), m = g.size();
int len = 1;
while (len < n + m - 1)
len <<= 1;
vector<atom> x(len), y(len);
copy(f.begin(), f.end(), x.begin());
copy(g.begin(), g.end(), y.begin());
fft(x, 1);
fft(y, 1);
for (int i = 0; i < len; ++i)
x[i] = (int64)x[i] * y[i] % MOD;
fft(x, -1);
cap = min(cap, n + m - 1);
x.resize(cap);
return x;
}
} // namespace polynomial
using namespace polynomial;
const int N = 1e5 + 10;
int fact[N], ifact[N], inv[N];
struct comb_init {
comb_init() {
inv[1] = 1;
for (int i = 2; i < N; ++i) {
inv[i] = (MOD - MOD / i) * (int64)inv[MOD % i] % MOD;
}
fact[0] = ifact[0] = 1;
for (int i = 1; i < N; ++i) {
fact[i] = (int64)fact[i - 1] * i % MOD;
ifact[i] = (int64)ifact[i - 1] * inv[i] % MOD;
}
}
} comb_init_;
int64 comb(int n, int m) {
if (n < m || m < 0)
return 0;
return (int64)fact[n] * ifact[m] % MOD * ifact[n - m] % MOD;
}
void add(int &x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
}
vector<int> solve(const vector<vector<int>> &gs, int L, int R) {
if (L == R)
return {1};
if (L + 1 == R)
return gs[L];
int mid = (L + R) / 2;
auto u = solve(gs, L, mid);
auto v = solve(gs, mid, R);
return mul(u, v);
}
int main() {
int n;
cin >> n;
vector<int> ip2(N), p2(N);
ip2[0] = p2[0] = 1;
for (int i = 1; i < N; ++i) {
ip2[i] = 1LL * ip2[i - 1] * inv[2] % MOD;
p2[i] = 1LL * p2[i - 1] * 2 % MOD;
}
vector<int> a(n * 2);
for (int i = 0; i < n * 2; ++i)
cin >> a[i];
sort(a.begin(), a.end());
vector<vector<int>> gs;
for (int i = 0, j; i < n * 2; i = j) {
for (j = i; j < n * 2 && a[j] == a[i]; ++j)
;
int k = j - i;
if (k == 1)
continue;
vector<int> g(k / 2 + 1);
for (int u = 0; u <= k / 2; ++u) {
g[u] = 1LL * fact[k] * ifact[k - 2 * u] % MOD * ifact[u] % MOD * ip2[u] %
MOD;
}
gs.push_back(g);
}
auto f = solve(gs, 0, SZ(gs));
trace(f);
int ret = 0;
for (int k = 0; k <= n && k < SZ(f); ++k) {
int cur = f[k] % MOD;
int cnt = 1LL * fact[2 * n - 2 * k] * ifact[n - k] % MOD * ip2[n - k] % MOD;
cur = 1LL * cur * cnt % MOD;
trace(k, cur);
if (k % 2)
cur = MOD - cur;
add(ret, cur);
// break;
}
cout << ret << '\n';
return 0;
}
| insert | 221 | 221 | 221 | 223 | 0 | |
p02539 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct Z_p {
using Type = typename decay<decltype(T::value)>::type;
static vector<Type> mod_inv;
constexpr Z_p() : value() {}
template <typename U> Z_p(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; }
Z_p &operator+=(const Z_p &otr) {
if ((value += otr.value) >= mod())
value -= mod();
return *this;
}
Z_p &operator-=(const Z_p &otr) {
if ((value -= otr.value) < 0)
value += mod();
return *this;
}
template <typename U> Z_p &operator+=(const U &otr) {
return *this += Z_p(otr);
}
template <typename U> Z_p &operator-=(const U &otr) {
return *this -= Z_p(otr);
}
Z_p &operator++() { return *this += 1; }
Z_p &operator--() { return *this -= 1; }
Z_p operator++(int) {
Z_p result(*this);
*this += 1;
return result;
}
Z_p operator--(int) {
Z_p result(*this);
*this -= 1;
return result;
}
Z_p operator-() const { return Z_p(-value); }
template <typename U = T>
typename enable_if<is_same<typename Z_p<U>::Type, int>::value, Z_p>::type &
operator*=(const Z_p &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Z_p<U>::Type, int64_t>::value, Z_p>::type
&
operator*=(const Z_p &rhs) {
int64_t q = static_cast<int64_t>(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 Z_p<U>::Type>::value, Z_p>::type &
operator*=(const Z_p &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Z_p operator^(long long e) const {
Z_p b = *this, res = 1;
if (e < 0)
b = 1 / b, e = -e;
for (; e; b *= b, e >>= 1)
if (e & 1)
res *= b;
return res;
}
Z_p &operator^=(const long long &e) { return *this = *this ^ e; }
Z_p &operator/=(const Z_p &otr) {
Type a = otr.value, m = mod(), u = 0, v = 1;
if (a < int(mod_inv.size()))
return *this *= mod_inv[a];
while (a) {
Type t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return *this *= u;
}
template <typename U> friend const Z_p<U> &abs(const Z_p<U> &v) { return v; }
template <typename U>
friend bool operator==(const Z_p<U> &lhs, const Z_p<U> &rhs);
template <typename U>
friend bool operator<(const Z_p<U> &lhs, const Z_p<U> &rhs);
template <typename U> friend istream &operator>>(istream &in, Z_p<U> &number);
Type value;
};
template <typename T> bool operator==(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator==(const Z_p<T> &lhs, U rhs) {
return lhs == Z_p<T>(rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator==(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) == rhs;
}
template <typename T> bool operator!=(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator!=(const Z_p<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator!=(U lhs, const Z_p<T> &rhs) {
return !(lhs == rhs);
}
template <typename T> bool operator<(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T> Z_p<T> operator+(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator+(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator+(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T> Z_p<T> operator-(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator-(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator-(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T> Z_p<T> operator*(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator*(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator*(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T> Z_p<T> operator/(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator/(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator/(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T> istream &operator>>(istream &in, Z_p<T> &number) {
typename common_type<typename Z_p<T>::Type, int64_t>::type x;
in >> x;
number.value = Z_p<T>::normalize(x);
return in;
}
template <typename T> ostream &operator<<(ostream &out, const Z_p<T> &number) {
return out << number();
}
/*
using ModType = int;
struct VarMod{ static ModType value; };
ModType VarMod::value;
ModType &mod = VarMod::value;
using Zp = Z_p<VarMod>;
*/
constexpr int mod = (119 << 23) + 1;
using Zp = Z_p<integral_constant<decay<decltype(mod)>::type, mod>>;
template <typename T> vector<typename Z_p<T>::Type> Z_p<T>::mod_inv;
template <typename T = integral_constant<decay<decltype(mod)>::type, mod>>
void precalc_inverse(size_t SZ) {
auto &inv = Z_p<T>::mod_inv;
if (inv.empty())
inv.assign(2, 1);
for (; inv.size() <= SZ;)
inv.push_back(
(mod - 1LL * mod / int(inv.size()) * inv[mod % int(inv.size())] % mod) %
mod);
}
// Requires Z_p
template <int SZ, typename T = Zp> struct combinatorics {
vector<T> inv, fact, invfact;
vector<vector<T>> stir1, stir2;
combinatorics()
: inv(SZ << 1 | 1, 1), fact(SZ << 1 | 1, 1), invfact(SZ << 1 | 1, 1) {
for (int i = 1; i <= SZ << 1; ++i)
fact[i] = fact[i - 1] * i;
invfact[SZ << 1] = 1 / fact[SZ << 1];
for (int i = (SZ << 1) - 1; i >= 0; --i) {
invfact[i] = invfact[i + 1] * (i + 1);
inv[i + 1] = invfact[i + 1] * fact[i];
}
} // O(SZ)
T C(int n, int k) {
return n < k ? 0 : fact[n] * invfact[k] * invfact[n - k];
}
T P(int n, int k) { return n < k ? 0 : fact[n] * invfact[n - k]; }
T H(int n, int k) { return C(n + k - 1, k); }
vector<T> precalc_power(int base, int n = SZ << 1) {
vector<T> res(n + 1, 1);
for (int i = 1; i <= n; ++i)
res[i] = res[i - 1] * base;
return res;
}
T naive_C(long long n, long long k) {
if (n < k)
return 0;
T res = 1;
k = min(k, n - k);
for (long long i = n; i > n - k; --i)
res *= i;
return res * invfact[k];
}
T naive_P(long long n, int k) {
if (n < k)
return 0;
T res = 1;
for (long long i = n; i > n - k; --i)
res *= i;
return res;
}
T naive_H(long long n, long long k) { return naive_C(n + k - 1, k); }
bool parity_C(long long n, long long k) { return n < k ? 0 : k & n - k ^ 1; }
// Catalan's Trapzoids
// # of bitstrings of n Xs and k Ys such that in each initial segment, (# of
// X) + m > (# of Y)
T Cat(int n, int k, int m = 1) {
if (m <= 0)
return 0;
else if (k >= 0 && k < m)
return C(n + k, k);
else if (k < n + m)
return C(n + k, k) - C(n + k, k - m);
else
return 0;
}
// Stirling number
// First kind (unsigned): # of n-permutations with k disjoint cycles
// Also the coefficient of x^k for x_n =
// x(x+1)...(x+n-1)
// Second kind: # of ways to partition a set of size n into r non-empty sets
// Satisfies sum{k=0~n}(x_k) = x^n
array<bool, 2> pre{};
template <bool FIRST = true> void precalc_stir(int n, int k) {
auto &s = FIRST ? stir1 : stir2;
pre[!FIRST] = true;
s.resize(n + 1, vector<T>(k + 1, 1));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= k; ++j) {
s[i][j] = (FIRST ? i - 1 : j) * s[i - 1][j] + s[i - 1][j - 1];
}
}
// unsigned
T Stir1(int n, int k) {
if (n < k)
return 0;
assert(pre[0]);
return stir1[n][k];
}
T Stir2(long long n, int k) {
if (n < k)
return 0;
if (pre[1] && n < int(stir2.size()))
return stir2[n][k];
T res = 0;
for (int i = 0, sign = 1; i <= k; ++i, sign *= -1)
res += sign * C(k, i) * (Zp(k - i) ^ n);
return res * invfact[k];
}
bool parity_Stir2(long long n, long long k) {
return n < k ? 0 : k ? !(n - k & k - 1 >> 1) : 0;
}
};
// Requires modular
template <int root = 15311432, int root_pw = 1 << 23, int inv_root = 469870224,
typename IT = vector<Zp>::iterator>
void number_theoric_transform(IT begin, IT end, const bool invert = false) {
int n = end - begin;
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j & bit; bit >>= 1)
j ^= bit;
j ^= bit;
if (i < j)
swap(*(begin + i), *(begin + j));
}
for (int len = 1; len < n; len <<= 1) {
typename iterator_traits<IT>::value_type wlen = invert ? inv_root : root;
for (int i = len << 1; i < root_pw; i <<= 1)
wlen *= wlen;
for (int i = 0; i < n; i += len << 1) {
typename iterator_traits<IT>::value_type w = 1;
for (int j = 0; j < len; ++j) {
auto u = *(begin + i + j), v = *(begin + i + j + len) * w;
*(begin + i + j) = u + v;
*(begin + i + j + len) = u - v;
w *= wlen;
}
}
}
if (invert) {
auto inv_n = typename iterator_traits<IT>::value_type(1) / n;
for (auto it = begin; it != end; ++it)
*it *= inv_n;
}
}
const size_t magic_constant = 250;
template <typename Poly> void convolute(Poly &a, Poly b) {
if (min(a.size(), b.size()) < magic_constant) {
Poly res((int)a.size() + (int)b.size() - 1);
for (size_t i = 0; i < a.size(); ++i)
for (size_t j = 0; j < b.size(); ++j)
res[i + j] += a[i] * b[j];
a = move(res);
return;
}
int n = max((int)a.size() + (int)b.size() - 1, 1);
if (__builtin_popcount(n) != 1)
n = 1 << __lg(n) + 1;
a.resize(n), b.resize(n);
number_theoric_transform(a.begin(), a.end()),
number_theoric_transform(b.begin(), b.end());
for (int i = 0; i < n; ++i)
a[i] *= b[i];
number_theoric_transform(a.begin(), a.end(), 1);
while (!a.empty() && !a.back())
a.pop_back();
}
// DEBUG BEGIN
#ifdef LOCAL
template <typename L, typename R>
ostream &operator<<(ostream &out, const pair<L, R> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <typename Tuple, size_t N> struct TuplePrinter {
static ostream &print(ostream &out, const Tuple &t) {
return TuplePrinter<Tuple, N - 1>::print(out, t) << ", " << get<N - 1>(t);
}
};
template <typename Tuple> struct TuplePrinter<Tuple, 1> {
static ostream &print(ostream &out, const Tuple &t) {
return out << get<0>(t);
}
};
template <typename... Args>
ostream &print_tuple(ostream &out, const tuple<Args...> &t) {
return TuplePrinter<decltype(t), sizeof...(Args)>::print(out << "(", t)
<< ")";
}
template <typename... Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
return print_tuple(out, t);
}
template <typename T>
ostream &operator<<(enable_if_t<!is_same<T, string>::value, ostream> &out,
const T &arr) {
out << "{";
for (auto &x : arr)
out << x << ", ";
return out << (arr.size() ? "\b\b" : "") << "}";
}
template <size_t S> ostream &operator<<(ostream &out, const bitset<S> &b) {
for (int i = 0; i < S; ++i)
out << b[i];
return out;
}
void debug_out() { cerr << "\b\b " << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << H << ", ", debug_out(T...);
}
void debug2_out() { cerr << "-----DEBUG END-----\n"; }
template <typename Head, typename... Tail> void debug2_out(Head H, Tail... T) {
cerr << "\n";
for (auto x : H)
cerr << x << "\n";
debug2_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#define debug2(...) \
cerr << "----DEBUG BEGIN----\n[" << #__VA_ARGS__ << "]:", \
debug2_out(__VA_ARGS__)
#else
#define debug(...) 42
#define debug2(...) 42
#endif
// DEBUG END
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
combinatorics<100000> C;
auto invp = C.precalc_power((Zp(1) / 2).value);
int n;
cin >> n;
const int mx = 1e5;
vector<int> cnt(mx);
for (auto i = 0; i < 2 * n; ++i) {
int x;
cin >> x, --x;
++cnt[x];
}
auto calc = [&](int tot, int sub) {
assert(2 * sub <= tot);
return C.fact[tot] * C.invfact[sub] * invp[sub] * C.invfact[tot - 2 * sub];
};
vector<vector<Zp>> poly(mx);
priority_queue<array<int, 2>, vector<array<int, 2>>, greater<>> pq;
for (auto i = 0; i < mx; ++i) {
if (cnt[i] > 1) {
for (auto x = 0; x <= cnt[i] / 2; ++x) {
poly[i].push_back(calc(cnt[i], x));
}
pq.push({(int)poly.size(), i});
}
}
if (pq.empty()) {
cout << calc(2 * n, n) << "\n";
return 0;
}
while ((int)pq.size() > 1) {
int i = pq.top()[1];
pq.pop();
int j = pq.top()[1];
pq.pop();
debug(i, j);
convolute(poly[i], poly[j]);
debug((int)poly[i].size(), i);
pq.push({(int)poly[i].size(), i});
}
int i = pq.top()[1];
Zp res = 0;
for (auto j = 0, sign = 1; j < (int)poly[i].size(); ++j, sign = -sign) {
res += sign * calc(2 * n - 2 * j, n - j) * poly[i][j];
}
cout << res << "\n";
return 0;
}
/*
*/
////////////////////////////////////////////////////////////////////////////////////////
// //
// Coded by Aeren //
// //
//////////////////////////////////////////////////////////////////////////////////////// | #include <bits/stdc++.h>
using namespace std;
template <typename T> struct Z_p {
using Type = typename decay<decltype(T::value)>::type;
static vector<Type> mod_inv;
constexpr Z_p() : value() {}
template <typename U> Z_p(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; }
Z_p &operator+=(const Z_p &otr) {
if ((value += otr.value) >= mod())
value -= mod();
return *this;
}
Z_p &operator-=(const Z_p &otr) {
if ((value -= otr.value) < 0)
value += mod();
return *this;
}
template <typename U> Z_p &operator+=(const U &otr) {
return *this += Z_p(otr);
}
template <typename U> Z_p &operator-=(const U &otr) {
return *this -= Z_p(otr);
}
Z_p &operator++() { return *this += 1; }
Z_p &operator--() { return *this -= 1; }
Z_p operator++(int) {
Z_p result(*this);
*this += 1;
return result;
}
Z_p operator--(int) {
Z_p result(*this);
*this -= 1;
return result;
}
Z_p operator-() const { return Z_p(-value); }
template <typename U = T>
typename enable_if<is_same<typename Z_p<U>::Type, int>::value, Z_p>::type &
operator*=(const Z_p &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Z_p<U>::Type, int64_t>::value, Z_p>::type
&
operator*=(const Z_p &rhs) {
int64_t q = static_cast<int64_t>(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 Z_p<U>::Type>::value, Z_p>::type &
operator*=(const Z_p &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Z_p operator^(long long e) const {
Z_p b = *this, res = 1;
if (e < 0)
b = 1 / b, e = -e;
for (; e; b *= b, e >>= 1)
if (e & 1)
res *= b;
return res;
}
Z_p &operator^=(const long long &e) { return *this = *this ^ e; }
Z_p &operator/=(const Z_p &otr) {
Type a = otr.value, m = mod(), u = 0, v = 1;
if (a < int(mod_inv.size()))
return *this *= mod_inv[a];
while (a) {
Type t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return *this *= u;
}
template <typename U> friend const Z_p<U> &abs(const Z_p<U> &v) { return v; }
template <typename U>
friend bool operator==(const Z_p<U> &lhs, const Z_p<U> &rhs);
template <typename U>
friend bool operator<(const Z_p<U> &lhs, const Z_p<U> &rhs);
template <typename U> friend istream &operator>>(istream &in, Z_p<U> &number);
Type value;
};
template <typename T> bool operator==(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator==(const Z_p<T> &lhs, U rhs) {
return lhs == Z_p<T>(rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator==(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) == rhs;
}
template <typename T> bool operator!=(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator!=(const Z_p<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
bool operator!=(U lhs, const Z_p<T> &rhs) {
return !(lhs == rhs);
}
template <typename T> bool operator<(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T> Z_p<T> operator+(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator+(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator+(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) += rhs;
}
template <typename T> Z_p<T> operator-(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator-(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator-(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) -= rhs;
}
template <typename T> Z_p<T> operator*(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator*(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator*(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) *= rhs;
}
template <typename T> Z_p<T> operator/(const Z_p<T> &lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator/(const Z_p<T> &lhs, U rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T, typename U,
typename enable_if<is_integral<U>::value>::type * = nullptr>
Z_p<T> operator/(U lhs, const Z_p<T> &rhs) {
return Z_p<T>(lhs) /= rhs;
}
template <typename T> istream &operator>>(istream &in, Z_p<T> &number) {
typename common_type<typename Z_p<T>::Type, int64_t>::type x;
in >> x;
number.value = Z_p<T>::normalize(x);
return in;
}
template <typename T> ostream &operator<<(ostream &out, const Z_p<T> &number) {
return out << number();
}
/*
using ModType = int;
struct VarMod{ static ModType value; };
ModType VarMod::value;
ModType &mod = VarMod::value;
using Zp = Z_p<VarMod>;
*/
constexpr int mod = (119 << 23) + 1;
using Zp = Z_p<integral_constant<decay<decltype(mod)>::type, mod>>;
template <typename T> vector<typename Z_p<T>::Type> Z_p<T>::mod_inv;
template <typename T = integral_constant<decay<decltype(mod)>::type, mod>>
void precalc_inverse(size_t SZ) {
auto &inv = Z_p<T>::mod_inv;
if (inv.empty())
inv.assign(2, 1);
for (; inv.size() <= SZ;)
inv.push_back(
(mod - 1LL * mod / int(inv.size()) * inv[mod % int(inv.size())] % mod) %
mod);
}
// Requires Z_p
template <int SZ, typename T = Zp> struct combinatorics {
vector<T> inv, fact, invfact;
vector<vector<T>> stir1, stir2;
combinatorics()
: inv(SZ << 1 | 1, 1), fact(SZ << 1 | 1, 1), invfact(SZ << 1 | 1, 1) {
for (int i = 1; i <= SZ << 1; ++i)
fact[i] = fact[i - 1] * i;
invfact[SZ << 1] = 1 / fact[SZ << 1];
for (int i = (SZ << 1) - 1; i >= 0; --i) {
invfact[i] = invfact[i + 1] * (i + 1);
inv[i + 1] = invfact[i + 1] * fact[i];
}
} // O(SZ)
T C(int n, int k) {
return n < k ? 0 : fact[n] * invfact[k] * invfact[n - k];
}
T P(int n, int k) { return n < k ? 0 : fact[n] * invfact[n - k]; }
T H(int n, int k) { return C(n + k - 1, k); }
vector<T> precalc_power(int base, int n = SZ << 1) {
vector<T> res(n + 1, 1);
for (int i = 1; i <= n; ++i)
res[i] = res[i - 1] * base;
return res;
}
T naive_C(long long n, long long k) {
if (n < k)
return 0;
T res = 1;
k = min(k, n - k);
for (long long i = n; i > n - k; --i)
res *= i;
return res * invfact[k];
}
T naive_P(long long n, int k) {
if (n < k)
return 0;
T res = 1;
for (long long i = n; i > n - k; --i)
res *= i;
return res;
}
T naive_H(long long n, long long k) { return naive_C(n + k - 1, k); }
bool parity_C(long long n, long long k) { return n < k ? 0 : k & n - k ^ 1; }
// Catalan's Trapzoids
// # of bitstrings of n Xs and k Ys such that in each initial segment, (# of
// X) + m > (# of Y)
T Cat(int n, int k, int m = 1) {
if (m <= 0)
return 0;
else if (k >= 0 && k < m)
return C(n + k, k);
else if (k < n + m)
return C(n + k, k) - C(n + k, k - m);
else
return 0;
}
// Stirling number
// First kind (unsigned): # of n-permutations with k disjoint cycles
// Also the coefficient of x^k for x_n =
// x(x+1)...(x+n-1)
// Second kind: # of ways to partition a set of size n into r non-empty sets
// Satisfies sum{k=0~n}(x_k) = x^n
array<bool, 2> pre{};
template <bool FIRST = true> void precalc_stir(int n, int k) {
auto &s = FIRST ? stir1 : stir2;
pre[!FIRST] = true;
s.resize(n + 1, vector<T>(k + 1, 1));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= k; ++j) {
s[i][j] = (FIRST ? i - 1 : j) * s[i - 1][j] + s[i - 1][j - 1];
}
}
// unsigned
T Stir1(int n, int k) {
if (n < k)
return 0;
assert(pre[0]);
return stir1[n][k];
}
T Stir2(long long n, int k) {
if (n < k)
return 0;
if (pre[1] && n < int(stir2.size()))
return stir2[n][k];
T res = 0;
for (int i = 0, sign = 1; i <= k; ++i, sign *= -1)
res += sign * C(k, i) * (Zp(k - i) ^ n);
return res * invfact[k];
}
bool parity_Stir2(long long n, long long k) {
return n < k ? 0 : k ? !(n - k & k - 1 >> 1) : 0;
}
};
// Requires modular
template <int root = 15311432, int root_pw = 1 << 23, int inv_root = 469870224,
typename IT = vector<Zp>::iterator>
void number_theoric_transform(IT begin, IT end, const bool invert = false) {
int n = end - begin;
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j & bit; bit >>= 1)
j ^= bit;
j ^= bit;
if (i < j)
swap(*(begin + i), *(begin + j));
}
for (int len = 1; len < n; len <<= 1) {
typename iterator_traits<IT>::value_type wlen = invert ? inv_root : root;
for (int i = len << 1; i < root_pw; i <<= 1)
wlen *= wlen;
for (int i = 0; i < n; i += len << 1) {
typename iterator_traits<IT>::value_type w = 1;
for (int j = 0; j < len; ++j) {
auto u = *(begin + i + j), v = *(begin + i + j + len) * w;
*(begin + i + j) = u + v;
*(begin + i + j + len) = u - v;
w *= wlen;
}
}
}
if (invert) {
auto inv_n = typename iterator_traits<IT>::value_type(1) / n;
for (auto it = begin; it != end; ++it)
*it *= inv_n;
}
}
const size_t magic_constant = 250;
template <typename Poly> void convolute(Poly &a, Poly b) {
if (min(a.size(), b.size()) < magic_constant) {
Poly res((int)a.size() + (int)b.size() - 1);
for (size_t i = 0; i < a.size(); ++i)
for (size_t j = 0; j < b.size(); ++j)
res[i + j] += a[i] * b[j];
a = move(res);
return;
}
int n = max((int)a.size() + (int)b.size() - 1, 1);
if (__builtin_popcount(n) != 1)
n = 1 << __lg(n) + 1;
a.resize(n), b.resize(n);
number_theoric_transform(a.begin(), a.end()),
number_theoric_transform(b.begin(), b.end());
for (int i = 0; i < n; ++i)
a[i] *= b[i];
number_theoric_transform(a.begin(), a.end(), 1);
while (!a.empty() && !a.back())
a.pop_back();
}
// DEBUG BEGIN
#ifdef LOCAL
template <typename L, typename R>
ostream &operator<<(ostream &out, const pair<L, R> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <typename Tuple, size_t N> struct TuplePrinter {
static ostream &print(ostream &out, const Tuple &t) {
return TuplePrinter<Tuple, N - 1>::print(out, t) << ", " << get<N - 1>(t);
}
};
template <typename Tuple> struct TuplePrinter<Tuple, 1> {
static ostream &print(ostream &out, const Tuple &t) {
return out << get<0>(t);
}
};
template <typename... Args>
ostream &print_tuple(ostream &out, const tuple<Args...> &t) {
return TuplePrinter<decltype(t), sizeof...(Args)>::print(out << "(", t)
<< ")";
}
template <typename... Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
return print_tuple(out, t);
}
template <typename T>
ostream &operator<<(enable_if_t<!is_same<T, string>::value, ostream> &out,
const T &arr) {
out << "{";
for (auto &x : arr)
out << x << ", ";
return out << (arr.size() ? "\b\b" : "") << "}";
}
template <size_t S> ostream &operator<<(ostream &out, const bitset<S> &b) {
for (int i = 0; i < S; ++i)
out << b[i];
return out;
}
void debug_out() { cerr << "\b\b " << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << H << ", ", debug_out(T...);
}
void debug2_out() { cerr << "-----DEBUG END-----\n"; }
template <typename Head, typename... Tail> void debug2_out(Head H, Tail... T) {
cerr << "\n";
for (auto x : H)
cerr << x << "\n";
debug2_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#define debug2(...) \
cerr << "----DEBUG BEGIN----\n[" << #__VA_ARGS__ << "]:", \
debug2_out(__VA_ARGS__)
#else
#define debug(...) 42
#define debug2(...) 42
#endif
// DEBUG END
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
combinatorics<100000> C;
auto invp = C.precalc_power((Zp(1) / 2).value);
int n;
cin >> n;
const int mx = 1e5;
vector<int> cnt(mx);
for (auto i = 0; i < 2 * n; ++i) {
int x;
cin >> x, --x;
++cnt[x];
}
auto calc = [&](int tot, int sub) {
assert(2 * sub <= tot);
return C.fact[tot] * C.invfact[sub] * invp[sub] * C.invfact[tot - 2 * sub];
};
vector<vector<Zp>> poly(mx);
priority_queue<array<int, 2>, vector<array<int, 2>>, greater<>> pq;
for (auto i = 0; i < mx; ++i) {
if (cnt[i] > 1) {
for (auto x = 0; x <= cnt[i] / 2; ++x) {
poly[i].push_back(calc(cnt[i], x));
}
pq.push({(int)poly[i].size(), i});
}
}
if (pq.empty()) {
cout << calc(2 * n, n) << "\n";
return 0;
}
while ((int)pq.size() > 1) {
int i = pq.top()[1];
pq.pop();
int j = pq.top()[1];
pq.pop();
debug(i, j);
convolute(poly[i], poly[j]);
debug((int)poly[i].size(), i);
pq.push({(int)poly[i].size(), i});
}
int i = pq.top()[1];
Zp res = 0;
for (auto j = 0, sign = 1; j < (int)poly[i].size(); ++j, sign = -sign) {
res += sign * calc(2 * n - 2 * j, n - j) * poly[i][j];
}
cout << res << "\n";
return 0;
}
/*
*/
////////////////////////////////////////////////////////////////////////////////////////
// //
// Coded by Aeren //
// //
//////////////////////////////////////////////////////////////////////////////////////// | replace | 463 | 464 | 463 | 464 | TLE | |
p02539 | C++ | Runtime Error | #pragma region kyopro_template
#define Nyaan_template
#include <bits/stdc++.h>
#include <immintrin.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define inc(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define die(...) \
do { \
out(__VA_ARGS__); \
return; \
} while (0)
using namespace std;
using ll = long long;
template <class T> using V = vector<T>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename T, typename U> inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U> inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++)
os << (i ? " " : "") << v[i];
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
void in() {}
template <typename T, class... U> void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U> void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u))
cout << " ";
out(u...);
}
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << #__VA_ARGS__ << " = "; \
dbg_out(__VA_ARGS__); \
} while (0)
#define trca(v, N) \
do { \
cerr << #v << " = "; \
array_out(v, N); \
} while (0)
#define trcc(v) \
do { \
cerr << #v << " = {"; \
each(x, v) { cerr << " " << x << ","; } \
cerr << "}" << endl; \
} while (0)
template <typename T> void _cout(const T &c) { cerr << c; }
void _cout(const int &c) {
if (c == 1001001001)
cerr << "inf";
else if (c == -1001001001)
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned int &c) {
if (c == 1001001001)
cerr << "inf";
else
cerr << c;
}
void _cout(const long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else if (c == -1001001001 || c == -((1LL << 61) - 1))
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else
cerr << c;
}
template <typename T, typename U> void _cout(const pair<T, U> &p) {
cerr << "{ ";
_cout(p.fi);
cerr << ", ";
_cout(p.se);
cerr << " } ";
}
template <typename T> void _cout(const vector<T> &v) {
int s = v.size();
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } ";
}
template <typename T> void _cout(const vector<vector<T>> &v) {
cerr << "[ ";
for (const auto &x : v) {
cerr << endl;
_cout(x);
cerr << ", ";
}
cerr << endl << " ] ";
}
void dbg_out() { cerr << endl; }
template <typename T, class... U> void dbg_out(const T &t, const U &...u) {
_cout(t);
if (sizeof...(u))
cerr << ", ";
dbg_out(u...);
}
template <typename T> void array_out(const T &v, int s) {
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } " << endl;
}
template <typename T> void array_out(const T &v, int H, int W) {
cerr << "[ ";
for (int i = 0; i < H; i++) {
cerr << (i ? ", " : "");
array_out(v[i], W);
}
cerr << " ] " << endl;
}
#else
#define trc(...)
#define trca(...)
#define trcc(...)
#endif
inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename T> inline int getbit(T a, int i) { return (a >> i) & 1; }
template <typename T> inline void setbit(T &a, int i) { a |= (1LL << i); }
template <typename T> inline void delbit(T &a, int i) { a &= ~(1LL << i); }
template <typename T> int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int btw(T a, T x, T b) { return a <= x && x < b; }
template <typename T, typename U> T ceil(T a, U b) { return (a + b - 1) / b; }
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
while (n) {
if (n & 1)
ret *= x;
x *= x;
n >>= 1;
}
return ret;
}
template <typename T> vector<T> mkrui(const vector<T> &v) {
vector<T> ret(v.size() + 1);
for (int i = 0; i < int(v.size()); i++)
ret[i + 1] = ret[i] + v[i];
return ret;
};
template <typename T> vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T = int> vector<T> mkiota(int N) {
vector<T> ret(N);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T> vector<int> mkinv(vector<T> &v) {
vector<int> inv(v.size());
for (int i = 0; i < (int)v.size(); i++)
inv[v[i]] = i;
return inv;
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
void solve();
int main() { solve(); }
#pragma endregion
using namespace std;
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;
// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
UnweightedGraph g(N);
if (M == -1)
M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
if (is_1origin)
x--, y--;
g[x].push_back(y);
if (!is_directed)
g[y].push_back(x);
}
return g;
}
// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
WeightedGraph<T> g(N);
if (M == -1)
M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
cin >> c;
if (is_1origin)
x--, y--;
g[x].eb(x, y, c);
if (!is_directed)
g[y].eb(y, x, c);
}
return g;
}
// Input of Edges
template <typename T>
Edges<T> esgraph(int N, int M, int is_weighted = true, bool is_1origin = true) {
Edges<T> es;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin)
x--, y--;
es.emplace_back(x, y, c);
}
return es;
}
// Input of Adjacency Matrix
template <typename T>
vector<vector<T>> adjgraph(int N, int M, T INF, int is_weighted = true,
bool is_directed = false, bool is_1origin = true) {
vector<vector<T>> d(N, vector<T>(N, INF));
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin)
x--, y--;
d[x][y] = c;
if (!is_directed)
d[y][x] = c;
}
return d;
}
using namespace std;
template <uint32_t mod> struct LazyMontgomeryModInt {
using mint = LazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static constexpr u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i)
ret *= 2 - mod * ret;
return ret;
}
static constexpr u32 r = get_r();
static constexpr u32 n2 = -u64(mod) % mod;
static_assert(r * mod == 1, "invalid, r * mod != 1");
static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
u32 a;
constexpr LazyMontgomeryModInt() : a(0) {}
constexpr LazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static constexpr u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
constexpr mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0)
a += 2 * mod;
return *this;
}
constexpr mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0)
a += 2 * mod;
return *this;
}
constexpr mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
constexpr mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
constexpr bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
constexpr bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
constexpr mint operator-() const { return mint() - mint(*this); }
constexpr mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
constexpr mint inverse() const { return pow(mod - 2); }
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = LazyMontgomeryModInt<mod>(t);
return (is);
}
constexpr u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static constexpr u32 get_mod() { return mod; }
};
template <uint32_t MOD> using Mint = LazyMontgomeryModInt<MOD>;
using namespace std;
template <typename T> struct Binomial {
vector<T> fac_, finv_, inv_;
Binomial(int MAX) : fac_(MAX + 10), finv_(MAX + 10), inv_(MAX + 10) {
MAX += 9;
fac_[0] = finv_[0] = inv_[0] = 1;
for (int i = 1; i <= MAX; i++)
fac_[i] = fac_[i - 1] * i;
finv_[MAX] = fac_[MAX].inverse();
for (int i = MAX - 1; i > 0; i--)
finv_[i] = finv_[i + 1] * (i + 1);
for (int i = 1; i <= MAX; i++)
inv_[i] = finv_[i] * fac_[i - 1];
}
inline T fac(int i) const { return fac_[i]; }
inline T finv(int i) const { return finv_[i]; }
inline T inv(int i) const { return inv_[i]; }
T C(int n, int r) const {
if (n < r || r < 0)
return T(0);
return fac_[n] * finv_[n - r] * finv_[r];
}
T C_naive(int n, int r) const {
if (n < r || r < 0)
return T(0);
T ret = 1;
for (T i = 1; i <= r; i += T(1)) {
ret *= n--;
ret *= i.inverse();
}
return ret;
}
T P(int n, int r) const {
if (n < r || r < 0)
return T(0);
return fac_[n] * finv_[n - r];
}
T H(int n, int r) const {
if (n < 0 || r < 0)
return (0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
using namespace std;
using namespace std;
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
my128_mullo_epu32(const __m128i &a, const __m128i &b) {
return _mm_mullo_epi32(a, b);
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
my128_mulhi_epu32(const __m128i &a, const __m128i &b) {
__m128i a13 = _mm_shuffle_epi32(a, 0xF5);
__m128i b13 = _mm_shuffle_epi32(b, 0xF5);
__m128i prod02 = _mm_mul_epu32(a, b);
__m128i prod13 = _mm_mul_epu32(a13, b13);
__m128i prod = _mm_unpackhi_epi64(_mm_unpacklo_epi32(prod02, prod13),
_mm_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_mul_128(const __m128i &a, const __m128i &b, const __m128i &r,
const __m128i &m1) {
return _mm_sub_epi32(
_mm_add_epi32(my128_mulhi_epu32(a, b), m1),
my128_mulhi_epu32(my128_mullo_epu32(my128_mullo_epu32(a, b), r), m1));
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_add_128(const __m128i &a, const __m128i &b, const __m128i &m2,
const __m128i &m0) {
__m128i ret = _mm_sub_epi32(_mm_add_epi32(a, b), m2);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_sub_128(const __m128i &a, const __m128i &b, const __m128i &m2,
const __m128i &m0) {
__m128i ret = _mm_sub_epi32(a, b);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
my256_mullo_epu32(const __m256i &a, const __m256i &b) {
return _mm256_mullo_epi32(a, b);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
my256_mulhi_epu32(const __m256i &a, const __m256i &b) {
__m256i a13 = _mm256_shuffle_epi32(a, 0xF5);
__m256i b13 = _mm256_shuffle_epi32(b, 0xF5);
__m256i prod02 = _mm256_mul_epu32(a, b);
__m256i prod13 = _mm256_mul_epu32(a13, b13);
__m256i prod = _mm256_unpackhi_epi64(_mm256_unpacklo_epi32(prod02, prod13),
_mm256_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_mul_256(const __m256i &a, const __m256i &b, const __m256i &r,
const __m256i &m1) {
return _mm256_sub_epi32(
_mm256_add_epi32(my256_mulhi_epu32(a, b), m1),
my256_mulhi_epu32(my256_mullo_epu32(my256_mullo_epu32(a, b), r), m1));
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_add_256(const __m256i &a, const __m256i &b, const __m256i &m2,
const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(_mm256_add_epi32(a, b), m2);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_sub_256(const __m256i &a, const __m256i &b, const __m256i &m2,
const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(a, b);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
constexpr int SZ = 1 << 19;
uint32_t buf1_[SZ * 2] __attribute__((aligned(64)));
uint32_t buf2_[SZ * 2] __attribute__((aligned(64)));
template <typename mint> struct NTT {
static constexpr uint32_t get_pr() {
uint32_t mod = mint::get_mod();
using u64 = uint64_t;
u64 ds[32] = {};
int idx = 0;
u64 m = mod - 1;
for (u64 i = 2; i * i <= m; ++i) {
if (m % i == 0) {
ds[idx++] = i;
while (m % i == 0)
m /= i;
}
}
if (m != 1)
ds[idx++] = m;
uint32_t pr = 2;
while (1) {
int flg = 1;
for (int i = 0; i < idx; ++i) {
u64 a = pr, b = (mod - 1) / ds[i], r = 1;
while (b) {
if (b & 1)
r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
if (r == 1) {
flg = 0;
break;
}
}
if (flg == 1)
break;
++pr;
}
return pr;
};
static constexpr uint32_t mod = mint::get_mod();
static constexpr uint32_t pr = get_pr();
static constexpr int level = __builtin_ctzll(mod - 1);
mint dw[level], dy[level];
mint *buf1, *buf2;
constexpr NTT() {
setwy(level);
buf1 = reinterpret_cast<mint *>(::buf1_);
buf2 = reinterpret_cast<mint *>(::buf2_);
}
constexpr void setwy(int k) {
mint w[level], y[level];
w[k - 1] = mint(pr).pow((mod - 1) / (1 << k));
y[k - 1] = w[k - 1].inverse();
for (int i = k - 2; i > 0; --i)
w[i] = w[i + 1] * w[i + 1], y[i] = y[i + 1] * y[i + 1];
dw[0] = dy[0] = w[1] * w[1];
dw[1] = w[1], dy[1] = y[1], dw[2] = w[2], dy[2] = y[2];
for (int i = 3; i < k; ++i) {
dw[i] = dw[i - 1] * y[i - 2] * w[i];
dy[i] = dy[i - 1] * w[i - 2] * y[i];
}
}
__attribute__((target("avx2"))) void ntt(mint *a, int n) {
int k = n ? __builtin_ctz(n) : 0;
if (k == 0)
return;
if (k == 1) {
mint a1 = a[1];
a[1] = a[0] - a[1];
a[0] = a[0] + a1;
return;
}
if (k & 1) {
int v = 1 << (k - 1);
if (v < 8) {
for (int j = 0; j < v; ++j) {
mint ajv = a[j + v];
a[j + v] = a[j] - ajv;
a[j] += ajv;
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
int j0 = 0;
int j1 = v;
for (; j0 < v; j0 += 8, j1 += 8) {
__m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
__m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
__m256i naj = montgomery_add_256(T0, T1, m2, m0);
__m256i najv = montgomery_sub_256(T0, T1, m2, m0);
_mm256_storeu_si256((__m256i *)(a + j0), naj);
_mm256_storeu_si256((__m256i *)(a + j1), najv);
}
}
}
int u = 1 << (2 + (k & 1));
int v = 1 << (k - 2 - (k & 1));
mint one = mint(1);
mint imag = dw[1];
while (v) {
if (v == 1) {
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
ww = xx * xx, wx = ww * xx;
mint t0 = a[jh + 0], t1 = a[jh + 1] * xx;
mint t2 = a[jh + 2] * ww, t3 = a[jh + 3] * wx;
mint t0p2 = t0 + t2, t1p3 = t1 + t3;
mint t0m2 = t0 - t2, t1m3 = (t1 - t3) * imag;
a[jh + 0] = t0p2 + t1p3, a[jh + 1] = t0p2 - t1p3;
a[jh + 2] = t0m2 + t1m3, a[jh + 3] = t0m2 - t1m3;
xx *= dw[__builtin_ctz((jh += 4))];
}
} else if (v == 4) {
const __m128i m0 = _mm_set1_epi32(0);
const __m128i m1 = _mm_set1_epi32(mod);
const __m128i m2 = _mm_set1_epi32(mod + mod);
const __m128i r = _mm_set1_epi32(mint::r);
const __m128i Imag = _mm_set1_epi32(imag.a);
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = v;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P2 = montgomery_add_128(T0, T2, m2, m0);
const __m128i T1P3 = montgomery_add_128(T1, T3, m2, m0);
const __m128i T0M2 = montgomery_sub_128(T0, T2, m2, m0);
const __m128i T1M3 = montgomery_mul_128(
montgomery_sub_128(T1, T3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_sub_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_add_128(T0M2, T1M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M2, T1M3, m2, m0));
}
} else {
ww = xx * xx, wx = ww * xx;
const __m128i WW = _mm_set1_epi32(ww.a);
const __m128i WX = _mm_set1_epi32(wx.a);
const __m128i XX = _mm_set1_epi32(xx.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i MT1 = montgomery_mul_128(T1, XX, r, m1);
const __m128i MT2 = montgomery_mul_128(T2, WW, r, m1);
const __m128i MT3 = montgomery_mul_128(T3, WX, r, m1);
const __m128i T0P2 = montgomery_add_128(T0, MT2, m2, m0);
const __m128i T1P3 = montgomery_add_128(MT1, MT3, m2, m0);
const __m128i T0M2 = montgomery_sub_128(T0, MT2, m2, m0);
const __m128i T1M3 = montgomery_mul_128(
montgomery_sub_128(MT1, MT3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_sub_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_add_128(T0M2, T1M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M2, T1M3, m2, m0));
}
}
xx *= dw[__builtin_ctz((jh += 4))];
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i Imag = _mm256_set1_epi32(imag.a);
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = v;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P2 = montgomery_add_256(T0, T2, m2, m0);
const __m256i T1P3 = montgomery_add_256(T1, T3, m2, m0);
const __m256i T0M2 = montgomery_sub_256(T0, T2, m2, m0);
const __m256i T1M3 = montgomery_mul_256(
montgomery_sub_256(T1, T3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_sub_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_add_256(T0M2, T1M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M2, T1M3, m2, m0));
}
} else {
ww = xx * xx, wx = ww * xx;
const __m256i WW = _mm256_set1_epi32(ww.a);
const __m256i WX = _mm256_set1_epi32(wx.a);
const __m256i XX = _mm256_set1_epi32(xx.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i MT1 = montgomery_mul_256(T1, XX, r, m1);
const __m256i MT2 = montgomery_mul_256(T2, WW, r, m1);
const __m256i MT3 = montgomery_mul_256(T3, WX, r, m1);
const __m256i T0P2 = montgomery_add_256(T0, MT2, m2, m0);
const __m256i T1P3 = montgomery_add_256(MT1, MT3, m2, m0);
const __m256i T0M2 = montgomery_sub_256(T0, MT2, m2, m0);
const __m256i T1M3 = montgomery_mul_256(
montgomery_sub_256(MT1, MT3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_sub_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_add_256(T0M2, T1M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M2, T1M3, m2, m0));
}
}
xx *= dw[__builtin_ctz((jh += 4))];
}
}
u <<= 2;
v >>= 2;
}
}
__attribute__((target("avx2"))) void intt(mint *a, int n,
int normalize = true) {
int k = n ? __builtin_ctz(n) : 0;
if (k == 0)
return;
if (k == 1) {
mint a1 = a[1];
a[1] = a[0] - a[1];
a[0] = a[0] + a1;
if (normalize) {
a[0] *= mint(2).inverse();
a[1] *= mint(2).inverse();
}
return;
}
int u = 1 << (k - 2);
int v = 1;
mint one = mint(1);
mint imag = dy[1];
while (u) {
if (v == 1) {
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
ww = xx * xx, yy = xx * imag;
mint t0 = a[jh + 0], t1 = a[jh + 1];
mint t2 = a[jh + 2], t3 = a[jh + 3];
mint t0p1 = t0 + t1, t2p3 = t2 + t3;
mint t0m1 = (t0 - t1) * xx, t2m3 = (t2 - t3) * yy;
a[jh + 0] = t0p1 + t2p3, a[jh + 2] = (t0p1 - t2p3) * ww;
a[jh + 1] = t0m1 + t2m3, a[jh + 3] = (t0m1 - t2m3) * ww;
xx *= dy[__builtin_ctz(jh += 4)];
}
} else if (v == 4) {
const __m128i m0 = _mm_set1_epi32(0);
const __m128i m1 = _mm_set1_epi32(mod);
const __m128i m2 = _mm_set1_epi32(mod + mod);
const __m128i r = _mm_set1_epi32(mint::r);
const __m128i Imag = _mm_set1_epi32(imag.a);
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = v + v;
int j3 = j2 + v;
for (; j0 < v; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P1 = montgomery_add_128(T0, T1, m2, m0);
const __m128i T2P3 = montgomery_add_128(T2, T3, m2, m0);
const __m128i T0M1 = montgomery_sub_128(T0, T1, m2, m0);
const __m128i T2M3 = montgomery_mul_128(
montgomery_sub_128(T2, T3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_sub_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_add_128(T0M1, T2M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M1, T2M3, m2, m0));
}
} else {
ww = xx * xx, yy = xx * imag;
const __m128i WW = _mm_set1_epi32(ww.a);
const __m128i XX = _mm_set1_epi32(xx.a);
const __m128i YY = _mm_set1_epi32(yy.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P1 = montgomery_add_128(T0, T1, m2, m0);
const __m128i T2P3 = montgomery_add_128(T2, T3, m2, m0);
const __m128i T0M1 = montgomery_mul_128(
montgomery_sub_128(T0, T1, m2, m0), XX, r, m1);
__m128i T2M3 = montgomery_mul_128(
montgomery_sub_128(T2, T3, m2, m0), YY, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128(
(__m128i *)(a + j2),
montgomery_mul_128(montgomery_sub_128(T0P1, T2P3, m2, m0), WW,
r, m1));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_add_128(T0M1, T2M3, m2, m0));
_mm_storeu_si128(
(__m128i *)(a + j3),
montgomery_mul_128(montgomery_sub_128(T0M1, T2M3, m2, m0), WW,
r, m1));
}
}
xx *= dy[__builtin_ctz(jh += 4)];
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i Imag = _mm256_set1_epi32(imag.a);
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = v + v;
int j3 = j2 + v;
for (; j0 < v; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P1 = montgomery_add_256(T0, T1, m2, m0);
const __m256i T2P3 = montgomery_add_256(T2, T3, m2, m0);
const __m256i T0M1 = montgomery_sub_256(T0, T1, m2, m0);
const __m256i T2M3 = montgomery_mul_256(
montgomery_sub_256(T2, T3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_sub_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_add_256(T0M1, T2M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M1, T2M3, m2, m0));
}
} else {
ww = xx * xx, yy = xx * imag;
const __m256i WW = _mm256_set1_epi32(ww.a);
const __m256i XX = _mm256_set1_epi32(xx.a);
const __m256i YY = _mm256_set1_epi32(yy.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P1 = montgomery_add_256(T0, T1, m2, m0);
const __m256i T2P3 = montgomery_add_256(T2, T3, m2, m0);
const __m256i T0M1 = montgomery_mul_256(
montgomery_sub_256(T0, T1, m2, m0), XX, r, m1);
const __m256i T2M3 = montgomery_mul_256(
montgomery_sub_256(T2, T3, m2, m0), YY, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256(
(__m256i *)(a + j2),
montgomery_mul_256(montgomery_sub_256(T0P1, T2P3, m2, m0), WW,
r, m1));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_add_256(T0M1, T2M3, m2, m0));
_mm256_storeu_si256(
(__m256i *)(a + j3),
montgomery_mul_256(montgomery_sub_256(T0M1, T2M3, m2, m0), WW,
r, m1));
}
}
xx *= dy[__builtin_ctz(jh += 4)];
}
}
u >>= 4;
v <<= 2;
}
if (k & 1) {
v = 1 << (k - 1);
if (v < 8) {
for (int j = 0; j < v; ++j) {
mint ajv = a[j] - a[j + v];
a[j] += a[j + v];
a[j + v] = ajv;
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
int j0 = 0;
int j1 = v;
for (; j0 < v; j0 += 8, j1 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
__m256i naj = montgomery_add_256(T0, T1, m2, m0);
__m256i najv = montgomery_sub_256(T0, T1, m2, m0);
_mm256_storeu_si256((__m256i *)(a + j0), naj);
_mm256_storeu_si256((__m256i *)(a + j1), najv);
}
}
}
if (normalize) {
mint invn = mint(n).inverse();
for (int i = 0; i < n; i++)
a[i] *= invn;
}
}
__attribute__((target("avx2"))) void
inplace_multiply(int l1, int l2, int zero_padding = true) {
int l = l1 + l2 - 1;
int M = 4;
while (M < l)
M <<= 1;
if (zero_padding) {
for (int i = l1; i < M; i++)
buf1_[i] = 0;
for (int i = l2; i < M; i++)
buf2_[i] = 0;
}
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i N2 = _mm256_set1_epi32(mint::n2);
for (int i = 0; i < l1; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = montgomery_mul_256(a, N2, r, m1);
_mm256_storeu_si256((__m256i *)(buf1_ + i), b);
}
for (int i = 0; i < l2; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf2_ + i));
__m256i b = montgomery_mul_256(a, N2, r, m1);
_mm256_storeu_si256((__m256i *)(buf2_ + i), b);
}
ntt(buf1, M);
ntt(buf2, M);
for (int i = 0; i < M; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = _mm256_loadu_si256((__m256i *)(buf2_ + i));
__m256i c = montgomery_mul_256(a, b, r, m1);
_mm256_storeu_si256((__m256i *)(buf1_ + i), c);
}
intt(buf1, M, false);
const __m256i INVM = _mm256_set1_epi32((mint(M).inverse()).a);
for (int i = 0; i < l; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = montgomery_mul_256(a, INVM, r, m1);
__m256i c = my256_mulhi_epu32(my256_mullo_epu32(b, r), m1);
__m256i d = _mm256_and_si256(_mm256_cmpgt_epi32(c, m0), m1);
__m256i e = _mm256_sub_epi32(d, c);
_mm256_storeu_si256((__m256i *)(buf1_ + i), e);
}
}
void ntt(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
ntt(buf1, M);
for (int i = 0; i < M; i++)
a[i].a = buf1[i].a;
}
void intt(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
intt(buf1, M, true);
for (int i = 0; i < M; i++)
a[i].a = buf1[i].a;
}
vector<mint> multiply(const vector<mint> &a, const vector<mint> &b) {
if (a.size() == 0 && b.size() == 0)
return vector<mint>{};
int l = a.size() + b.size() - 1;
if (min<int>(a.size(), b.size()) <= 40) {
vector<mint> s(l);
for (int i = 0; i < (int)a.size(); ++i)
for (int j = 0; j < (int)b.size(); ++j)
s[i + j] += a[i] * b[j];
return s;
}
int M = 4;
while (M < l)
M <<= 1;
for (int i = 0; i < (int)a.size(); ++i)
buf1[i].a = a[i].a;
for (int i = (int)a.size(); i < M; ++i)
buf1[i].a = 0;
for (int i = 0; i < (int)b.size(); ++i)
buf2[i].a = b[i].a;
for (int i = (int)b.size(); i < M; ++i)
buf2[i].a = 0;
ntt(buf1, M);
ntt(buf2, M);
for (int i = 0; i < M; ++i)
buf1[i].a = mint::reduce(uint64_t(buf1[i].a) * buf2[i].a);
intt(buf1, M, false);
vector<mint> s(l);
mint invm = mint(M).inverse();
for (int i = 0; i < l; ++i)
s[i] = buf1[i] * invm;
return s;
}
void ntt_doubling(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
intt(buf1, M);
mint r = 1, zeta = mint(pr).pow((mint::get_mod() - 1) / (M << 1));
for (int i = 0; i < M; i++)
buf1[i] *= r, r *= zeta;
ntt(buf1, M);
a.resize(2 * M);
for (int i = 0; i < M; i++)
a[M + i].a = buf1[i].a;
}
};
using namespace std;
using namespace std;
template <typename mint> struct FormalPowerSeries : vector<mint> {
using vector<mint>::vector;
using FPS = FormalPowerSeries;
FPS &operator+=(const FPS &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < (int)r.size(); i++)
(*this)[i] += r[i];
return *this;
}
FPS &operator+=(const mint &r) {
if (this->empty())
this->resize(1);
(*this)[0] += r;
return *this;
}
FPS &operator-=(const FPS &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < (int)r.size(); i++)
(*this)[i] -= r[i];
return *this;
}
FPS &operator-=(const mint &r) {
if (this->empty())
this->resize(1);
(*this)[0] -= r;
return *this;
}
FPS &operator*=(const mint &v) {
for (int k = 0; k < (int)this->size(); k++)
(*this)[k] *= v;
return *this;
}
FPS &operator/=(const FPS &r) {
if (this->size() < r.size()) {
this->clear();
return *this;
}
int n = this->size() - r.size() + 1;
if ((int)r.size() <= 64) {
FPS f(*this), g(r);
g.shrink();
mint coeff = g.back().inverse();
for (auto &x : g)
x *= coeff;
int deg = (int)f.size() - (int)g.size() + 1;
int gs = g.size();
FPS quo(deg);
for (int i = deg - 1; i >= 0; i--) {
quo[i] = f[i + gs - 1];
for (int j = 0; j < gs; j++)
f[i + j] -= quo[i] * g[j];
}
*this = quo * coeff;
this->resize(n, mint(0));
return *this;
}
return *this = ((*this).rev().pre(n) * r.rev().inv(n)).pre(n).rev();
}
FPS &operator%=(const FPS &r) {
*this -= *this / r * r;
shrink();
return *this;
}
FPS operator+(const FPS &r) const { return FPS(*this) += r; }
FPS operator+(const mint &v) const { return FPS(*this) += v; }
FPS operator-(const FPS &r) const { return FPS(*this) -= r; }
FPS operator-(const mint &v) const { return FPS(*this) -= v; }
FPS operator*(const FPS &r) const { return FPS(*this) *= r; }
FPS operator*(const mint &v) const { return FPS(*this) *= v; }
FPS operator/(const FPS &r) const { return FPS(*this) /= r; }
FPS operator%(const FPS &r) const { return FPS(*this) %= r; }
FPS operator-() const {
FPS ret(this->size());
for (int i = 0; i < (int)this->size(); i++)
ret[i] = -(*this)[i];
return ret;
}
void shrink() {
while (this->size() && this->back() == mint(0))
this->pop_back();
}
FPS rev() const {
FPS ret(*this);
reverse(begin(ret), end(ret));
return ret;
}
FPS dot(FPS r) const {
FPS ret(min(this->size(), r.size()));
for (int i = 0; i < (int)ret.size(); i++)
ret[i] = (*this)[i] * r[i];
return ret;
}
FPS pre(int sz) const {
return FPS(begin(*this), begin(*this) + min((int)this->size(), sz));
}
FPS operator>>(int sz) const {
if ((int)this->size() <= sz)
return {};
FPS ret(*this);
ret.erase(ret.begin(), ret.begin() + sz);
return ret;
}
FPS operator<<(int sz) const {
FPS ret(*this);
ret.insert(ret.begin(), sz, mint(0));
return ret;
}
FPS diff() const {
const int n = (int)this->size();
FPS ret(max(0, n - 1));
mint one(1), coeff(1);
for (int i = 1; i < n; i++) {
ret[i - 1] = (*this)[i] * coeff;
coeff += one;
}
return ret;
}
FPS integral() const {
const int n = (int)this->size();
FPS ret(n + 1);
ret[0] = mint(0);
if (n > 0)
ret[1] = mint(1);
auto mod = mint::get_mod();
for (int i = 2; i <= n; i++)
ret[i] = (-ret[mod % i]) * (mod / i);
for (int i = 0; i < n; i++)
ret[i + 1] *= (*this)[i];
return ret;
}
mint eval(mint x) const {
mint r = 0, w = 1;
for (auto &v : *this)
r += w * v, w *= x;
return r;
}
FPS log(int deg = -1) const {
assert((*this)[0] == mint(1));
if (deg == -1)
deg = (int)this->size();
return (this->diff() * this->inv(deg)).pre(deg - 1).integral();
}
FPS pow(int64_t k, int deg = -1) const {
const int n = (int)this->size();
if (deg == -1)
deg = n;
for (int i = 0; i < n; i++) {
if ((*this)[i] != mint(0)) {
if (i * k > deg)
return FPS(deg, mint(0));
mint rev = mint(1) / (*this)[i];
FPS ret = (((*this * rev) >> i).log() * k).exp() * ((*this)[i].pow(k));
ret = (ret << (i * k)).pre(deg);
if ((int)ret.size() < deg)
ret.resize(deg, mint(0));
return ret;
}
}
return FPS(deg, mint(0));
}
static void *ntt_ptr;
static void set_fft();
FPS &operator*=(const FPS &r);
void ntt();
void intt();
void ntt_doubling();
static int ntt_pr();
FPS inv(int deg = -1) const;
FPS exp(int deg = -1) const;
};
template <typename mint> void *FormalPowerSeries<mint>::ntt_ptr = nullptr;
/**
* @brief 多項式/形式的冪級数ライブラリ
* @docs docs/fps/formal-power-series.md
*/
template <typename mint> void FormalPowerSeries<mint>::set_fft() {
if (!ntt_ptr)
ntt_ptr = new NTT<mint>;
}
template <typename mint>
FormalPowerSeries<mint> &
FormalPowerSeries<mint>::operator*=(const FormalPowerSeries<mint> &r) {
if (this->empty() || r.empty()) {
this->clear();
return *this;
}
set_fft();
auto ret = static_cast<NTT<mint> *>(ntt_ptr)->multiply(*this, r);
return *this = FormalPowerSeries<mint>(ret.begin(), ret.end());
}
template <typename mint> void FormalPowerSeries<mint>::ntt() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->ntt(*this);
}
template <typename mint> void FormalPowerSeries<mint>::intt() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->intt(*this);
}
template <typename mint> void FormalPowerSeries<mint>::ntt_doubling() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->ntt_doubling(*this);
}
template <typename mint> int FormalPowerSeries<mint>::ntt_pr() {
set_fft();
return static_cast<NTT<mint> *>(ntt_ptr)->pr;
}
template <typename mint>
FormalPowerSeries<mint> FormalPowerSeries<mint>::inv(int deg) const {
assert((*this)[0] != mint(0));
if (deg == -1)
deg = (int)this->size();
FormalPowerSeries<mint> res(deg);
res[0] = {mint(1) / (*this)[0]};
for (int d = 1; d < deg; d <<= 1) {
FormalPowerSeries<mint> f(2 * d), g(2 * d);
for (int j = 0; j < min((int)this->size(), 2 * d); j++)
f[j] = (*this)[j];
for (int j = 0; j < d; j++)
g[j] = res[j];
f.ntt();
g.ntt();
for (int j = 0; j < 2 * d; j++)
f[j] *= g[j];
f.intt();
for (int j = 0; j < d; j++)
f[j] = 0;
f.ntt();
for (int j = 0; j < 2 * d; j++)
f[j] *= g[j];
f.intt();
for (int j = d; j < min(2 * d, deg); j++)
res[j] = -f[j];
}
return res.pre(deg);
}
template <typename mint>
FormalPowerSeries<mint> FormalPowerSeries<mint>::exp(int deg) const {
using fps = FormalPowerSeries<mint>;
assert((*this).size() == 0 || (*this)[0] == mint(0));
if (deg == -1)
deg = this->size();
fps inv;
inv.reserve(deg + 1);
inv.push_back(mint(0));
inv.push_back(mint(1));
auto inplace_integral = [&](fps &F) -> void {
const int n = (int)F.size();
auto mod = mint::get_mod();
while ((int)inv.size() <= n) {
int i = inv.size();
inv.push_back((-inv[mod % i]) * (mod / i));
}
F.insert(begin(F), mint(0));
for (int i = 1; i <= n; i++)
F[i] *= inv[i];
};
auto inplace_diff = [](fps &F) -> void {
if (F.empty())
return;
F.erase(begin(F));
mint coeff = 1, one = 1;
for (int i = 0; i < (int)F.size(); i++) {
F[i] *= coeff;
coeff += one;
}
};
fps b{1, 1 < (int)this->size() ? (*this)[1] : 0}, c{1}, z1, z2{1, 1};
for (int m = 2; m < deg; m *= 2) {
auto y = b;
y.resize(2 * m);
y.ntt();
z1 = z2;
fps z(m);
for (int i = 0; i < m; ++i)
z[i] = y[i] * z1[i];
z.intt();
fill(begin(z), begin(z) + m / 2, mint(0));
z.ntt();
for (int i = 0; i < m; ++i)
z[i] *= -z1[i];
z.intt();
c.insert(end(c), begin(z) + m / 2, end(z));
z2 = c;
z2.resize(2 * m);
z2.ntt();
fps x(begin(*this), begin(*this) + min<int>(this->size(), m));
inplace_diff(x);
x.push_back(mint(0));
x.ntt();
for (int i = 0; i < m; ++i)
x[i] *= y[i];
x.intt();
x -= b.diff();
x.resize(2 * m);
for (int i = 0; i < m - 1; ++i)
x[m + i] = x[i], x[i] = mint(0);
x.ntt();
for (int i = 0; i < 2 * m; ++i)
x[i] *= z2[i];
x.intt();
x.pop_back();
inplace_integral(x);
for (int i = m; i < min<int>(this->size(), 2 * m); ++i)
x[i] += (*this)[i];
fill(begin(x), begin(x) + m, mint(0));
x.ntt();
for (int i = 0; i < 2 * m; ++i)
x[i] *= y[i];
x.intt();
b.insert(end(b), begin(x) + m, end(x));
}
return fps{begin(b), begin(b) + deg};
}
/**
* @brief NTT mod用FPSライブラリ
* @docs docs/fps/ntt-friendly-fps.md
*/
template <typename mint>
FormalPowerSeries<mint> Pi(vector<FormalPowerSeries<mint>> v) {
using fps = FormalPowerSeries<mint>;
sort(begin(v), end(v), [](fps &a, fps &b) { return a.size() < b.size(); });
vector<fps> w;
w.reserve(sz(v) / 2 + 1);
while ((int)v.size() > 1) {
for (int i = 0; i < (int)v.size(); i += 2) {
if (i + 1 == (int)v.size()) {
w.emplace_back(v.back());
} else {
w.emplace_back(v[i] * v[i + 1]);
}
}
swap(v, w);
w.clear();
}
return v[0];
}
template <typename mint>
void OGFtoEGF(FormalPowerSeries<mint> &f, const Binomial<mint> &C) {
for (int i = 0; i < (int)f.size(); i++)
f[i] *= C.finv(i);
}
template <typename mint>
void EGFtoOGF(FormalPowerSeries<mint> &f, const Binomial<mint> &C) {
for (int i = 0; i < (int)f.size(); i++)
f[i] *= C.fac(i);
}
template <typename mint>
FormalPowerSeries<mint> e_x(int deg, const Binomial<mint> &C) {
FormalPowerSeries<mint> ret{begin(C.finv_), begin(C.finv_) + deg};
return std::move(ret);
}
void solve() {
ini(N);
vl a(2 * N);
in(a);
vi cnt(100100);
each(x, a) cnt[x]++;
using mint = Mint<998244353>;
Binomial<mint> C(200200);
NTT<mint> ntt;
using vm = FormalPowerSeries<mint>;
// vm f{1};
V<vm> fs;
each(x, cnt) {
if (x < 2)
continue;
vm v(x / 2 + 1);
mint c = 1;
int n = x;
int m = 0;
rep(i, x / 2 + 1) {
if (i) {
c *= C.C(n, 2);
n -= 2;
m += 1;
}
v[i] = c * C.finv(m);
}
fs.push_back(v);
// f = ntt.multiply(f, v);
}
vm f = Pi<mint>(fs);
vm pre(N + 1);
{
int n = 2 * N;
int m = 0;
mint c = 1;
rep(i, N + 1) {
if (i) {
c *= C.C(i * 2, 2);
m += 1;
}
pre[i] = c * C.finv(m);
}
}
mint ans = 0;
rep(i, sz(f)) {
mint c = f[i];
c *= pre[N - i];
ans += (i & 1) ? -c : c;
}
out(ans);
} | #pragma region kyopro_template
#define Nyaan_template
#include <bits/stdc++.h>
#include <immintrin.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define inc(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define die(...) \
do { \
out(__VA_ARGS__); \
return; \
} while (0)
using namespace std;
using ll = long long;
template <class T> using V = vector<T>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename T, typename U> inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U> inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++)
os << (i ? " " : "") << v[i];
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
void in() {}
template <typename T, class... U> void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U> void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u))
cout << " ";
out(u...);
}
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << #__VA_ARGS__ << " = "; \
dbg_out(__VA_ARGS__); \
} while (0)
#define trca(v, N) \
do { \
cerr << #v << " = "; \
array_out(v, N); \
} while (0)
#define trcc(v) \
do { \
cerr << #v << " = {"; \
each(x, v) { cerr << " " << x << ","; } \
cerr << "}" << endl; \
} while (0)
template <typename T> void _cout(const T &c) { cerr << c; }
void _cout(const int &c) {
if (c == 1001001001)
cerr << "inf";
else if (c == -1001001001)
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned int &c) {
if (c == 1001001001)
cerr << "inf";
else
cerr << c;
}
void _cout(const long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else if (c == -1001001001 || c == -((1LL << 61) - 1))
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else
cerr << c;
}
template <typename T, typename U> void _cout(const pair<T, U> &p) {
cerr << "{ ";
_cout(p.fi);
cerr << ", ";
_cout(p.se);
cerr << " } ";
}
template <typename T> void _cout(const vector<T> &v) {
int s = v.size();
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } ";
}
template <typename T> void _cout(const vector<vector<T>> &v) {
cerr << "[ ";
for (const auto &x : v) {
cerr << endl;
_cout(x);
cerr << ", ";
}
cerr << endl << " ] ";
}
void dbg_out() { cerr << endl; }
template <typename T, class... U> void dbg_out(const T &t, const U &...u) {
_cout(t);
if (sizeof...(u))
cerr << ", ";
dbg_out(u...);
}
template <typename T> void array_out(const T &v, int s) {
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } " << endl;
}
template <typename T> void array_out(const T &v, int H, int W) {
cerr << "[ ";
for (int i = 0; i < H; i++) {
cerr << (i ? ", " : "");
array_out(v[i], W);
}
cerr << " ] " << endl;
}
#else
#define trc(...)
#define trca(...)
#define trcc(...)
#endif
inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename T> inline int getbit(T a, int i) { return (a >> i) & 1; }
template <typename T> inline void setbit(T &a, int i) { a |= (1LL << i); }
template <typename T> inline void delbit(T &a, int i) { a &= ~(1LL << i); }
template <typename T> int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int btw(T a, T x, T b) { return a <= x && x < b; }
template <typename T, typename U> T ceil(T a, U b) { return (a + b - 1) / b; }
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
while (n) {
if (n & 1)
ret *= x;
x *= x;
n >>= 1;
}
return ret;
}
template <typename T> vector<T> mkrui(const vector<T> &v) {
vector<T> ret(v.size() + 1);
for (int i = 0; i < int(v.size()); i++)
ret[i + 1] = ret[i] + v[i];
return ret;
};
template <typename T> vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T = int> vector<T> mkiota(int N) {
vector<T> ret(N);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T> vector<int> mkinv(vector<T> &v) {
vector<int> inv(v.size());
for (int i = 0; i < (int)v.size(); i++)
inv[v[i]] = i;
return inv;
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
void solve();
int main() { solve(); }
#pragma endregion
using namespace std;
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;
// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
UnweightedGraph g(N);
if (M == -1)
M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
if (is_1origin)
x--, y--;
g[x].push_back(y);
if (!is_directed)
g[y].push_back(x);
}
return g;
}
// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
WeightedGraph<T> g(N);
if (M == -1)
M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
cin >> c;
if (is_1origin)
x--, y--;
g[x].eb(x, y, c);
if (!is_directed)
g[y].eb(y, x, c);
}
return g;
}
// Input of Edges
template <typename T>
Edges<T> esgraph(int N, int M, int is_weighted = true, bool is_1origin = true) {
Edges<T> es;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin)
x--, y--;
es.emplace_back(x, y, c);
}
return es;
}
// Input of Adjacency Matrix
template <typename T>
vector<vector<T>> adjgraph(int N, int M, T INF, int is_weighted = true,
bool is_directed = false, bool is_1origin = true) {
vector<vector<T>> d(N, vector<T>(N, INF));
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin)
x--, y--;
d[x][y] = c;
if (!is_directed)
d[y][x] = c;
}
return d;
}
using namespace std;
template <uint32_t mod> struct LazyMontgomeryModInt {
using mint = LazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static constexpr u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i)
ret *= 2 - mod * ret;
return ret;
}
static constexpr u32 r = get_r();
static constexpr u32 n2 = -u64(mod) % mod;
static_assert(r * mod == 1, "invalid, r * mod != 1");
static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
u32 a;
constexpr LazyMontgomeryModInt() : a(0) {}
constexpr LazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static constexpr u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
constexpr mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0)
a += 2 * mod;
return *this;
}
constexpr mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0)
a += 2 * mod;
return *this;
}
constexpr mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
constexpr mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
constexpr bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
constexpr bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
constexpr mint operator-() const { return mint() - mint(*this); }
constexpr mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
constexpr mint inverse() const { return pow(mod - 2); }
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = LazyMontgomeryModInt<mod>(t);
return (is);
}
constexpr u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static constexpr u32 get_mod() { return mod; }
};
template <uint32_t MOD> using Mint = LazyMontgomeryModInt<MOD>;
using namespace std;
template <typename T> struct Binomial {
vector<T> fac_, finv_, inv_;
Binomial(int MAX) : fac_(MAX + 10), finv_(MAX + 10), inv_(MAX + 10) {
MAX += 9;
fac_[0] = finv_[0] = inv_[0] = 1;
for (int i = 1; i <= MAX; i++)
fac_[i] = fac_[i - 1] * i;
finv_[MAX] = fac_[MAX].inverse();
for (int i = MAX - 1; i > 0; i--)
finv_[i] = finv_[i + 1] * (i + 1);
for (int i = 1; i <= MAX; i++)
inv_[i] = finv_[i] * fac_[i - 1];
}
inline T fac(int i) const { return fac_[i]; }
inline T finv(int i) const { return finv_[i]; }
inline T inv(int i) const { return inv_[i]; }
T C(int n, int r) const {
if (n < r || r < 0)
return T(0);
return fac_[n] * finv_[n - r] * finv_[r];
}
T C_naive(int n, int r) const {
if (n < r || r < 0)
return T(0);
T ret = 1;
for (T i = 1; i <= r; i += T(1)) {
ret *= n--;
ret *= i.inverse();
}
return ret;
}
T P(int n, int r) const {
if (n < r || r < 0)
return T(0);
return fac_[n] * finv_[n - r];
}
T H(int n, int r) const {
if (n < 0 || r < 0)
return (0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
using namespace std;
using namespace std;
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
my128_mullo_epu32(const __m128i &a, const __m128i &b) {
return _mm_mullo_epi32(a, b);
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
my128_mulhi_epu32(const __m128i &a, const __m128i &b) {
__m128i a13 = _mm_shuffle_epi32(a, 0xF5);
__m128i b13 = _mm_shuffle_epi32(b, 0xF5);
__m128i prod02 = _mm_mul_epu32(a, b);
__m128i prod13 = _mm_mul_epu32(a13, b13);
__m128i prod = _mm_unpackhi_epi64(_mm_unpacklo_epi32(prod02, prod13),
_mm_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_mul_128(const __m128i &a, const __m128i &b, const __m128i &r,
const __m128i &m1) {
return _mm_sub_epi32(
_mm_add_epi32(my128_mulhi_epu32(a, b), m1),
my128_mulhi_epu32(my128_mullo_epu32(my128_mullo_epu32(a, b), r), m1));
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_add_128(const __m128i &a, const __m128i &b, const __m128i &m2,
const __m128i &m0) {
__m128i ret = _mm_sub_epi32(_mm_add_epi32(a, b), m2);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("sse4.2"))) __attribute__((always_inline)) __m128i
montgomery_sub_128(const __m128i &a, const __m128i &b, const __m128i &m2,
const __m128i &m0) {
__m128i ret = _mm_sub_epi32(a, b);
return _mm_add_epi32(_mm_and_si128(_mm_cmpgt_epi32(m0, ret), m2), ret);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
my256_mullo_epu32(const __m256i &a, const __m256i &b) {
return _mm256_mullo_epi32(a, b);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
my256_mulhi_epu32(const __m256i &a, const __m256i &b) {
__m256i a13 = _mm256_shuffle_epi32(a, 0xF5);
__m256i b13 = _mm256_shuffle_epi32(b, 0xF5);
__m256i prod02 = _mm256_mul_epu32(a, b);
__m256i prod13 = _mm256_mul_epu32(a13, b13);
__m256i prod = _mm256_unpackhi_epi64(_mm256_unpacklo_epi32(prod02, prod13),
_mm256_unpackhi_epi32(prod02, prod13));
return prod;
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_mul_256(const __m256i &a, const __m256i &b, const __m256i &r,
const __m256i &m1) {
return _mm256_sub_epi32(
_mm256_add_epi32(my256_mulhi_epu32(a, b), m1),
my256_mulhi_epu32(my256_mullo_epu32(my256_mullo_epu32(a, b), r), m1));
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_add_256(const __m256i &a, const __m256i &b, const __m256i &m2,
const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(_mm256_add_epi32(a, b), m2);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
__attribute__((target("avx2"))) __attribute__((always_inline)) __m256i
montgomery_sub_256(const __m256i &a, const __m256i &b, const __m256i &m2,
const __m256i &m0) {
__m256i ret = _mm256_sub_epi32(a, b);
return _mm256_add_epi32(_mm256_and_si256(_mm256_cmpgt_epi32(m0, ret), m2),
ret);
}
constexpr int SZ = 1 << 19;
uint32_t buf1_[SZ * 2] __attribute__((aligned(64)));
uint32_t buf2_[SZ * 2] __attribute__((aligned(64)));
template <typename mint> struct NTT {
static constexpr uint32_t get_pr() {
uint32_t mod = mint::get_mod();
using u64 = uint64_t;
u64 ds[32] = {};
int idx = 0;
u64 m = mod - 1;
for (u64 i = 2; i * i <= m; ++i) {
if (m % i == 0) {
ds[idx++] = i;
while (m % i == 0)
m /= i;
}
}
if (m != 1)
ds[idx++] = m;
uint32_t pr = 2;
while (1) {
int flg = 1;
for (int i = 0; i < idx; ++i) {
u64 a = pr, b = (mod - 1) / ds[i], r = 1;
while (b) {
if (b & 1)
r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
if (r == 1) {
flg = 0;
break;
}
}
if (flg == 1)
break;
++pr;
}
return pr;
};
static constexpr uint32_t mod = mint::get_mod();
static constexpr uint32_t pr = get_pr();
static constexpr int level = __builtin_ctzll(mod - 1);
mint dw[level], dy[level];
mint *buf1, *buf2;
constexpr NTT() {
setwy(level);
buf1 = reinterpret_cast<mint *>(::buf1_);
buf2 = reinterpret_cast<mint *>(::buf2_);
}
constexpr void setwy(int k) {
mint w[level], y[level];
w[k - 1] = mint(pr).pow((mod - 1) / (1 << k));
y[k - 1] = w[k - 1].inverse();
for (int i = k - 2; i > 0; --i)
w[i] = w[i + 1] * w[i + 1], y[i] = y[i + 1] * y[i + 1];
dw[0] = dy[0] = w[1] * w[1];
dw[1] = w[1], dy[1] = y[1], dw[2] = w[2], dy[2] = y[2];
for (int i = 3; i < k; ++i) {
dw[i] = dw[i - 1] * y[i - 2] * w[i];
dy[i] = dy[i - 1] * w[i - 2] * y[i];
}
}
__attribute__((target("avx2"))) void ntt(mint *a, int n) {
int k = n ? __builtin_ctz(n) : 0;
if (k == 0)
return;
if (k == 1) {
mint a1 = a[1];
a[1] = a[0] - a[1];
a[0] = a[0] + a1;
return;
}
if (k & 1) {
int v = 1 << (k - 1);
if (v < 8) {
for (int j = 0; j < v; ++j) {
mint ajv = a[j + v];
a[j + v] = a[j] - ajv;
a[j] += ajv;
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
int j0 = 0;
int j1 = v;
for (; j0 < v; j0 += 8, j1 += 8) {
__m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
__m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
__m256i naj = montgomery_add_256(T0, T1, m2, m0);
__m256i najv = montgomery_sub_256(T0, T1, m2, m0);
_mm256_storeu_si256((__m256i *)(a + j0), naj);
_mm256_storeu_si256((__m256i *)(a + j1), najv);
}
}
}
int u = 1 << (2 + (k & 1));
int v = 1 << (k - 2 - (k & 1));
mint one = mint(1);
mint imag = dw[1];
while (v) {
if (v == 1) {
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
ww = xx * xx, wx = ww * xx;
mint t0 = a[jh + 0], t1 = a[jh + 1] * xx;
mint t2 = a[jh + 2] * ww, t3 = a[jh + 3] * wx;
mint t0p2 = t0 + t2, t1p3 = t1 + t3;
mint t0m2 = t0 - t2, t1m3 = (t1 - t3) * imag;
a[jh + 0] = t0p2 + t1p3, a[jh + 1] = t0p2 - t1p3;
a[jh + 2] = t0m2 + t1m3, a[jh + 3] = t0m2 - t1m3;
xx *= dw[__builtin_ctz((jh += 4))];
}
} else if (v == 4) {
const __m128i m0 = _mm_set1_epi32(0);
const __m128i m1 = _mm_set1_epi32(mod);
const __m128i m2 = _mm_set1_epi32(mod + mod);
const __m128i r = _mm_set1_epi32(mint::r);
const __m128i Imag = _mm_set1_epi32(imag.a);
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = v;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P2 = montgomery_add_128(T0, T2, m2, m0);
const __m128i T1P3 = montgomery_add_128(T1, T3, m2, m0);
const __m128i T0M2 = montgomery_sub_128(T0, T2, m2, m0);
const __m128i T1M3 = montgomery_mul_128(
montgomery_sub_128(T1, T3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_sub_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_add_128(T0M2, T1M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M2, T1M3, m2, m0));
}
} else {
ww = xx * xx, wx = ww * xx;
const __m128i WW = _mm_set1_epi32(ww.a);
const __m128i WX = _mm_set1_epi32(wx.a);
const __m128i XX = _mm_set1_epi32(xx.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i MT1 = montgomery_mul_128(T1, XX, r, m1);
const __m128i MT2 = montgomery_mul_128(T2, WW, r, m1);
const __m128i MT3 = montgomery_mul_128(T3, WX, r, m1);
const __m128i T0P2 = montgomery_add_128(T0, MT2, m2, m0);
const __m128i T1P3 = montgomery_add_128(MT1, MT3, m2, m0);
const __m128i T0M2 = montgomery_sub_128(T0, MT2, m2, m0);
const __m128i T1M3 = montgomery_mul_128(
montgomery_sub_128(MT1, MT3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_sub_128(T0P2, T1P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_add_128(T0M2, T1M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M2, T1M3, m2, m0));
}
}
xx *= dw[__builtin_ctz((jh += 4))];
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i Imag = _mm256_set1_epi32(imag.a);
mint ww = one, xx = one, wx = one;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = v;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P2 = montgomery_add_256(T0, T2, m2, m0);
const __m256i T1P3 = montgomery_add_256(T1, T3, m2, m0);
const __m256i T0M2 = montgomery_sub_256(T0, T2, m2, m0);
const __m256i T1M3 = montgomery_mul_256(
montgomery_sub_256(T1, T3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_sub_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_add_256(T0M2, T1M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M2, T1M3, m2, m0));
}
} else {
ww = xx * xx, wx = ww * xx;
const __m256i WW = _mm256_set1_epi32(ww.a);
const __m256i WX = _mm256_set1_epi32(wx.a);
const __m256i XX = _mm256_set1_epi32(xx.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i MT1 = montgomery_mul_256(T1, XX, r, m1);
const __m256i MT2 = montgomery_mul_256(T2, WW, r, m1);
const __m256i MT3 = montgomery_mul_256(T3, WX, r, m1);
const __m256i T0P2 = montgomery_add_256(T0, MT2, m2, m0);
const __m256i T1P3 = montgomery_add_256(MT1, MT3, m2, m0);
const __m256i T0M2 = montgomery_sub_256(T0, MT2, m2, m0);
const __m256i T1M3 = montgomery_mul_256(
montgomery_sub_256(MT1, MT3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_sub_256(T0P2, T1P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_add_256(T0M2, T1M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M2, T1M3, m2, m0));
}
}
xx *= dw[__builtin_ctz((jh += 4))];
}
}
u <<= 2;
v >>= 2;
}
}
__attribute__((target("avx2"))) void intt(mint *a, int n,
int normalize = true) {
int k = n ? __builtin_ctz(n) : 0;
if (k == 0)
return;
if (k == 1) {
mint a1 = a[1];
a[1] = a[0] - a[1];
a[0] = a[0] + a1;
if (normalize) {
a[0] *= mint(2).inverse();
a[1] *= mint(2).inverse();
}
return;
}
int u = 1 << (k - 2);
int v = 1;
mint one = mint(1);
mint imag = dy[1];
while (u) {
if (v == 1) {
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
ww = xx * xx, yy = xx * imag;
mint t0 = a[jh + 0], t1 = a[jh + 1];
mint t2 = a[jh + 2], t3 = a[jh + 3];
mint t0p1 = t0 + t1, t2p3 = t2 + t3;
mint t0m1 = (t0 - t1) * xx, t2m3 = (t2 - t3) * yy;
a[jh + 0] = t0p1 + t2p3, a[jh + 2] = (t0p1 - t2p3) * ww;
a[jh + 1] = t0m1 + t2m3, a[jh + 3] = (t0m1 - t2m3) * ww;
xx *= dy[__builtin_ctz(jh += 4)];
}
} else if (v == 4) {
const __m128i m0 = _mm_set1_epi32(0);
const __m128i m1 = _mm_set1_epi32(mod);
const __m128i m2 = _mm_set1_epi32(mod + mod);
const __m128i r = _mm_set1_epi32(mint::r);
const __m128i Imag = _mm_set1_epi32(imag.a);
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = v + v;
int j3 = j2 + v;
for (; j0 < v; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P1 = montgomery_add_128(T0, T1, m2, m0);
const __m128i T2P3 = montgomery_add_128(T2, T3, m2, m0);
const __m128i T0M1 = montgomery_sub_128(T0, T1, m2, m0);
const __m128i T2M3 = montgomery_mul_128(
montgomery_sub_128(T2, T3, m2, m0), Imag, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j2),
montgomery_sub_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_add_128(T0M1, T2M3, m2, m0));
_mm_storeu_si128((__m128i *)(a + j3),
montgomery_sub_128(T0M1, T2M3, m2, m0));
}
} else {
ww = xx * xx, yy = xx * imag;
const __m128i WW = _mm_set1_epi32(ww.a);
const __m128i XX = _mm_set1_epi32(xx.a);
const __m128i YY = _mm_set1_epi32(yy.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 4, j1 += 4, j2 += 4, j3 += 4) {
const __m128i T0 = _mm_loadu_si128((__m128i *)(a + j0));
const __m128i T1 = _mm_loadu_si128((__m128i *)(a + j1));
const __m128i T2 = _mm_loadu_si128((__m128i *)(a + j2));
const __m128i T3 = _mm_loadu_si128((__m128i *)(a + j3));
const __m128i T0P1 = montgomery_add_128(T0, T1, m2, m0);
const __m128i T2P3 = montgomery_add_128(T2, T3, m2, m0);
const __m128i T0M1 = montgomery_mul_128(
montgomery_sub_128(T0, T1, m2, m0), XX, r, m1);
__m128i T2M3 = montgomery_mul_128(
montgomery_sub_128(T2, T3, m2, m0), YY, r, m1);
_mm_storeu_si128((__m128i *)(a + j0),
montgomery_add_128(T0P1, T2P3, m2, m0));
_mm_storeu_si128(
(__m128i *)(a + j2),
montgomery_mul_128(montgomery_sub_128(T0P1, T2P3, m2, m0), WW,
r, m1));
_mm_storeu_si128((__m128i *)(a + j1),
montgomery_add_128(T0M1, T2M3, m2, m0));
_mm_storeu_si128(
(__m128i *)(a + j3),
montgomery_mul_128(montgomery_sub_128(T0M1, T2M3, m2, m0), WW,
r, m1));
}
}
xx *= dy[__builtin_ctz(jh += 4)];
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i Imag = _mm256_set1_epi32(imag.a);
mint ww = one, xx = one, yy = one;
u <<= 2;
for (int jh = 0; jh < u;) {
if (jh == 0) {
int j0 = 0;
int j1 = v;
int j2 = v + v;
int j3 = j2 + v;
for (; j0 < v; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P1 = montgomery_add_256(T0, T1, m2, m0);
const __m256i T2P3 = montgomery_add_256(T2, T3, m2, m0);
const __m256i T0M1 = montgomery_sub_256(T0, T1, m2, m0);
const __m256i T2M3 = montgomery_mul_256(
montgomery_sub_256(T2, T3, m2, m0), Imag, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j2),
montgomery_sub_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_add_256(T0M1, T2M3, m2, m0));
_mm256_storeu_si256((__m256i *)(a + j3),
montgomery_sub_256(T0M1, T2M3, m2, m0));
}
} else {
ww = xx * xx, yy = xx * imag;
const __m256i WW = _mm256_set1_epi32(ww.a);
const __m256i XX = _mm256_set1_epi32(xx.a);
const __m256i YY = _mm256_set1_epi32(yy.a);
int j0 = jh * v;
int j1 = j0 + v;
int j2 = j1 + v;
int j3 = j2 + v;
int je = j1;
for (; j0 < je; j0 += 8, j1 += 8, j2 += 8, j3 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
const __m256i T2 = _mm256_loadu_si256((__m256i *)(a + j2));
const __m256i T3 = _mm256_loadu_si256((__m256i *)(a + j3));
const __m256i T0P1 = montgomery_add_256(T0, T1, m2, m0);
const __m256i T2P3 = montgomery_add_256(T2, T3, m2, m0);
const __m256i T0M1 = montgomery_mul_256(
montgomery_sub_256(T0, T1, m2, m0), XX, r, m1);
const __m256i T2M3 = montgomery_mul_256(
montgomery_sub_256(T2, T3, m2, m0), YY, r, m1);
_mm256_storeu_si256((__m256i *)(a + j0),
montgomery_add_256(T0P1, T2P3, m2, m0));
_mm256_storeu_si256(
(__m256i *)(a + j2),
montgomery_mul_256(montgomery_sub_256(T0P1, T2P3, m2, m0), WW,
r, m1));
_mm256_storeu_si256((__m256i *)(a + j1),
montgomery_add_256(T0M1, T2M3, m2, m0));
_mm256_storeu_si256(
(__m256i *)(a + j3),
montgomery_mul_256(montgomery_sub_256(T0M1, T2M3, m2, m0), WW,
r, m1));
}
}
xx *= dy[__builtin_ctz(jh += 4)];
}
}
u >>= 4;
v <<= 2;
}
if (k & 1) {
v = 1 << (k - 1);
if (v < 8) {
for (int j = 0; j < v; ++j) {
mint ajv = a[j] - a[j + v];
a[j] += a[j + v];
a[j + v] = ajv;
}
} else {
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m2 = _mm256_set1_epi32(mod + mod);
int j0 = 0;
int j1 = v;
for (; j0 < v; j0 += 8, j1 += 8) {
const __m256i T0 = _mm256_loadu_si256((__m256i *)(a + j0));
const __m256i T1 = _mm256_loadu_si256((__m256i *)(a + j1));
__m256i naj = montgomery_add_256(T0, T1, m2, m0);
__m256i najv = montgomery_sub_256(T0, T1, m2, m0);
_mm256_storeu_si256((__m256i *)(a + j0), naj);
_mm256_storeu_si256((__m256i *)(a + j1), najv);
}
}
}
if (normalize) {
mint invn = mint(n).inverse();
for (int i = 0; i < n; i++)
a[i] *= invn;
}
}
__attribute__((target("avx2"))) void
inplace_multiply(int l1, int l2, int zero_padding = true) {
int l = l1 + l2 - 1;
int M = 4;
while (M < l)
M <<= 1;
if (zero_padding) {
for (int i = l1; i < M; i++)
buf1_[i] = 0;
for (int i = l2; i < M; i++)
buf2_[i] = 0;
}
const __m256i m0 = _mm256_set1_epi32(0);
const __m256i m1 = _mm256_set1_epi32(mod);
const __m256i r = _mm256_set1_epi32(mint::r);
const __m256i N2 = _mm256_set1_epi32(mint::n2);
for (int i = 0; i < l1; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = montgomery_mul_256(a, N2, r, m1);
_mm256_storeu_si256((__m256i *)(buf1_ + i), b);
}
for (int i = 0; i < l2; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf2_ + i));
__m256i b = montgomery_mul_256(a, N2, r, m1);
_mm256_storeu_si256((__m256i *)(buf2_ + i), b);
}
ntt(buf1, M);
ntt(buf2, M);
for (int i = 0; i < M; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = _mm256_loadu_si256((__m256i *)(buf2_ + i));
__m256i c = montgomery_mul_256(a, b, r, m1);
_mm256_storeu_si256((__m256i *)(buf1_ + i), c);
}
intt(buf1, M, false);
const __m256i INVM = _mm256_set1_epi32((mint(M).inverse()).a);
for (int i = 0; i < l; i += 8) {
__m256i a = _mm256_loadu_si256((__m256i *)(buf1_ + i));
__m256i b = montgomery_mul_256(a, INVM, r, m1);
__m256i c = my256_mulhi_epu32(my256_mullo_epu32(b, r), m1);
__m256i d = _mm256_and_si256(_mm256_cmpgt_epi32(c, m0), m1);
__m256i e = _mm256_sub_epi32(d, c);
_mm256_storeu_si256((__m256i *)(buf1_ + i), e);
}
}
void ntt(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
ntt(buf1, M);
for (int i = 0; i < M; i++)
a[i].a = buf1[i].a;
}
void intt(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
intt(buf1, M, true);
for (int i = 0; i < M; i++)
a[i].a = buf1[i].a;
}
vector<mint> multiply(const vector<mint> &a, const vector<mint> &b) {
if (a.size() == 0 && b.size() == 0)
return vector<mint>{};
int l = a.size() + b.size() - 1;
if (min<int>(a.size(), b.size()) <= 40) {
vector<mint> s(l);
for (int i = 0; i < (int)a.size(); ++i)
for (int j = 0; j < (int)b.size(); ++j)
s[i + j] += a[i] * b[j];
return s;
}
int M = 4;
while (M < l)
M <<= 1;
for (int i = 0; i < (int)a.size(); ++i)
buf1[i].a = a[i].a;
for (int i = (int)a.size(); i < M; ++i)
buf1[i].a = 0;
for (int i = 0; i < (int)b.size(); ++i)
buf2[i].a = b[i].a;
for (int i = (int)b.size(); i < M; ++i)
buf2[i].a = 0;
ntt(buf1, M);
ntt(buf2, M);
for (int i = 0; i < M; ++i)
buf1[i].a = mint::reduce(uint64_t(buf1[i].a) * buf2[i].a);
intt(buf1, M, false);
vector<mint> s(l);
mint invm = mint(M).inverse();
for (int i = 0; i < l; ++i)
s[i] = buf1[i] * invm;
return s;
}
void ntt_doubling(vector<mint> &a) {
int M = (int)a.size();
for (int i = 0; i < M; i++)
buf1[i].a = a[i].a;
intt(buf1, M);
mint r = 1, zeta = mint(pr).pow((mint::get_mod() - 1) / (M << 1));
for (int i = 0; i < M; i++)
buf1[i] *= r, r *= zeta;
ntt(buf1, M);
a.resize(2 * M);
for (int i = 0; i < M; i++)
a[M + i].a = buf1[i].a;
}
};
using namespace std;
using namespace std;
template <typename mint> struct FormalPowerSeries : vector<mint> {
using vector<mint>::vector;
using FPS = FormalPowerSeries;
FPS &operator+=(const FPS &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < (int)r.size(); i++)
(*this)[i] += r[i];
return *this;
}
FPS &operator+=(const mint &r) {
if (this->empty())
this->resize(1);
(*this)[0] += r;
return *this;
}
FPS &operator-=(const FPS &r) {
if (r.size() > this->size())
this->resize(r.size());
for (int i = 0; i < (int)r.size(); i++)
(*this)[i] -= r[i];
return *this;
}
FPS &operator-=(const mint &r) {
if (this->empty())
this->resize(1);
(*this)[0] -= r;
return *this;
}
FPS &operator*=(const mint &v) {
for (int k = 0; k < (int)this->size(); k++)
(*this)[k] *= v;
return *this;
}
FPS &operator/=(const FPS &r) {
if (this->size() < r.size()) {
this->clear();
return *this;
}
int n = this->size() - r.size() + 1;
if ((int)r.size() <= 64) {
FPS f(*this), g(r);
g.shrink();
mint coeff = g.back().inverse();
for (auto &x : g)
x *= coeff;
int deg = (int)f.size() - (int)g.size() + 1;
int gs = g.size();
FPS quo(deg);
for (int i = deg - 1; i >= 0; i--) {
quo[i] = f[i + gs - 1];
for (int j = 0; j < gs; j++)
f[i + j] -= quo[i] * g[j];
}
*this = quo * coeff;
this->resize(n, mint(0));
return *this;
}
return *this = ((*this).rev().pre(n) * r.rev().inv(n)).pre(n).rev();
}
FPS &operator%=(const FPS &r) {
*this -= *this / r * r;
shrink();
return *this;
}
FPS operator+(const FPS &r) const { return FPS(*this) += r; }
FPS operator+(const mint &v) const { return FPS(*this) += v; }
FPS operator-(const FPS &r) const { return FPS(*this) -= r; }
FPS operator-(const mint &v) const { return FPS(*this) -= v; }
FPS operator*(const FPS &r) const { return FPS(*this) *= r; }
FPS operator*(const mint &v) const { return FPS(*this) *= v; }
FPS operator/(const FPS &r) const { return FPS(*this) /= r; }
FPS operator%(const FPS &r) const { return FPS(*this) %= r; }
FPS operator-() const {
FPS ret(this->size());
for (int i = 0; i < (int)this->size(); i++)
ret[i] = -(*this)[i];
return ret;
}
void shrink() {
while (this->size() && this->back() == mint(0))
this->pop_back();
}
FPS rev() const {
FPS ret(*this);
reverse(begin(ret), end(ret));
return ret;
}
FPS dot(FPS r) const {
FPS ret(min(this->size(), r.size()));
for (int i = 0; i < (int)ret.size(); i++)
ret[i] = (*this)[i] * r[i];
return ret;
}
FPS pre(int sz) const {
return FPS(begin(*this), begin(*this) + min((int)this->size(), sz));
}
FPS operator>>(int sz) const {
if ((int)this->size() <= sz)
return {};
FPS ret(*this);
ret.erase(ret.begin(), ret.begin() + sz);
return ret;
}
FPS operator<<(int sz) const {
FPS ret(*this);
ret.insert(ret.begin(), sz, mint(0));
return ret;
}
FPS diff() const {
const int n = (int)this->size();
FPS ret(max(0, n - 1));
mint one(1), coeff(1);
for (int i = 1; i < n; i++) {
ret[i - 1] = (*this)[i] * coeff;
coeff += one;
}
return ret;
}
FPS integral() const {
const int n = (int)this->size();
FPS ret(n + 1);
ret[0] = mint(0);
if (n > 0)
ret[1] = mint(1);
auto mod = mint::get_mod();
for (int i = 2; i <= n; i++)
ret[i] = (-ret[mod % i]) * (mod / i);
for (int i = 0; i < n; i++)
ret[i + 1] *= (*this)[i];
return ret;
}
mint eval(mint x) const {
mint r = 0, w = 1;
for (auto &v : *this)
r += w * v, w *= x;
return r;
}
FPS log(int deg = -1) const {
assert((*this)[0] == mint(1));
if (deg == -1)
deg = (int)this->size();
return (this->diff() * this->inv(deg)).pre(deg - 1).integral();
}
FPS pow(int64_t k, int deg = -1) const {
const int n = (int)this->size();
if (deg == -1)
deg = n;
for (int i = 0; i < n; i++) {
if ((*this)[i] != mint(0)) {
if (i * k > deg)
return FPS(deg, mint(0));
mint rev = mint(1) / (*this)[i];
FPS ret = (((*this * rev) >> i).log() * k).exp() * ((*this)[i].pow(k));
ret = (ret << (i * k)).pre(deg);
if ((int)ret.size() < deg)
ret.resize(deg, mint(0));
return ret;
}
}
return FPS(deg, mint(0));
}
static void *ntt_ptr;
static void set_fft();
FPS &operator*=(const FPS &r);
void ntt();
void intt();
void ntt_doubling();
static int ntt_pr();
FPS inv(int deg = -1) const;
FPS exp(int deg = -1) const;
};
template <typename mint> void *FormalPowerSeries<mint>::ntt_ptr = nullptr;
/**
* @brief 多項式/形式的冪級数ライブラリ
* @docs docs/fps/formal-power-series.md
*/
template <typename mint> void FormalPowerSeries<mint>::set_fft() {
if (!ntt_ptr)
ntt_ptr = new NTT<mint>;
}
template <typename mint>
FormalPowerSeries<mint> &
FormalPowerSeries<mint>::operator*=(const FormalPowerSeries<mint> &r) {
if (this->empty() || r.empty()) {
this->clear();
return *this;
}
set_fft();
auto ret = static_cast<NTT<mint> *>(ntt_ptr)->multiply(*this, r);
return *this = FormalPowerSeries<mint>(ret.begin(), ret.end());
}
template <typename mint> void FormalPowerSeries<mint>::ntt() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->ntt(*this);
}
template <typename mint> void FormalPowerSeries<mint>::intt() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->intt(*this);
}
template <typename mint> void FormalPowerSeries<mint>::ntt_doubling() {
set_fft();
static_cast<NTT<mint> *>(ntt_ptr)->ntt_doubling(*this);
}
template <typename mint> int FormalPowerSeries<mint>::ntt_pr() {
set_fft();
return static_cast<NTT<mint> *>(ntt_ptr)->pr;
}
template <typename mint>
FormalPowerSeries<mint> FormalPowerSeries<mint>::inv(int deg) const {
assert((*this)[0] != mint(0));
if (deg == -1)
deg = (int)this->size();
FormalPowerSeries<mint> res(deg);
res[0] = {mint(1) / (*this)[0]};
for (int d = 1; d < deg; d <<= 1) {
FormalPowerSeries<mint> f(2 * d), g(2 * d);
for (int j = 0; j < min((int)this->size(), 2 * d); j++)
f[j] = (*this)[j];
for (int j = 0; j < d; j++)
g[j] = res[j];
f.ntt();
g.ntt();
for (int j = 0; j < 2 * d; j++)
f[j] *= g[j];
f.intt();
for (int j = 0; j < d; j++)
f[j] = 0;
f.ntt();
for (int j = 0; j < 2 * d; j++)
f[j] *= g[j];
f.intt();
for (int j = d; j < min(2 * d, deg); j++)
res[j] = -f[j];
}
return res.pre(deg);
}
template <typename mint>
FormalPowerSeries<mint> FormalPowerSeries<mint>::exp(int deg) const {
using fps = FormalPowerSeries<mint>;
assert((*this).size() == 0 || (*this)[0] == mint(0));
if (deg == -1)
deg = this->size();
fps inv;
inv.reserve(deg + 1);
inv.push_back(mint(0));
inv.push_back(mint(1));
auto inplace_integral = [&](fps &F) -> void {
const int n = (int)F.size();
auto mod = mint::get_mod();
while ((int)inv.size() <= n) {
int i = inv.size();
inv.push_back((-inv[mod % i]) * (mod / i));
}
F.insert(begin(F), mint(0));
for (int i = 1; i <= n; i++)
F[i] *= inv[i];
};
auto inplace_diff = [](fps &F) -> void {
if (F.empty())
return;
F.erase(begin(F));
mint coeff = 1, one = 1;
for (int i = 0; i < (int)F.size(); i++) {
F[i] *= coeff;
coeff += one;
}
};
fps b{1, 1 < (int)this->size() ? (*this)[1] : 0}, c{1}, z1, z2{1, 1};
for (int m = 2; m < deg; m *= 2) {
auto y = b;
y.resize(2 * m);
y.ntt();
z1 = z2;
fps z(m);
for (int i = 0; i < m; ++i)
z[i] = y[i] * z1[i];
z.intt();
fill(begin(z), begin(z) + m / 2, mint(0));
z.ntt();
for (int i = 0; i < m; ++i)
z[i] *= -z1[i];
z.intt();
c.insert(end(c), begin(z) + m / 2, end(z));
z2 = c;
z2.resize(2 * m);
z2.ntt();
fps x(begin(*this), begin(*this) + min<int>(this->size(), m));
inplace_diff(x);
x.push_back(mint(0));
x.ntt();
for (int i = 0; i < m; ++i)
x[i] *= y[i];
x.intt();
x -= b.diff();
x.resize(2 * m);
for (int i = 0; i < m - 1; ++i)
x[m + i] = x[i], x[i] = mint(0);
x.ntt();
for (int i = 0; i < 2 * m; ++i)
x[i] *= z2[i];
x.intt();
x.pop_back();
inplace_integral(x);
for (int i = m; i < min<int>(this->size(), 2 * m); ++i)
x[i] += (*this)[i];
fill(begin(x), begin(x) + m, mint(0));
x.ntt();
for (int i = 0; i < 2 * m; ++i)
x[i] *= y[i];
x.intt();
b.insert(end(b), begin(x) + m, end(x));
}
return fps{begin(b), begin(b) + deg};
}
/**
* @brief NTT mod用FPSライブラリ
* @docs docs/fps/ntt-friendly-fps.md
*/
template <typename mint>
FormalPowerSeries<mint> Pi(vector<FormalPowerSeries<mint>> v) {
using fps = FormalPowerSeries<mint>;
sort(begin(v), end(v), [](fps &a, fps &b) { return a.size() < b.size(); });
vector<fps> w;
w.reserve(sz(v) / 2 + 1);
while ((int)v.size() > 1) {
for (int i = 0; i < (int)v.size(); i += 2) {
if (i + 1 == (int)v.size()) {
w.emplace_back(v.back());
} else {
w.emplace_back(v[i] * v[i + 1]);
}
}
swap(v, w);
w.clear();
}
return v[0];
}
template <typename mint>
void OGFtoEGF(FormalPowerSeries<mint> &f, const Binomial<mint> &C) {
for (int i = 0; i < (int)f.size(); i++)
f[i] *= C.finv(i);
}
template <typename mint>
void EGFtoOGF(FormalPowerSeries<mint> &f, const Binomial<mint> &C) {
for (int i = 0; i < (int)f.size(); i++)
f[i] *= C.fac(i);
}
template <typename mint>
FormalPowerSeries<mint> e_x(int deg, const Binomial<mint> &C) {
FormalPowerSeries<mint> ret{begin(C.finv_), begin(C.finv_) + deg};
return std::move(ret);
}
void solve() {
ini(N);
vl a(2 * N);
in(a);
vi cnt(100100);
each(x, a) cnt[x]++;
using mint = Mint<998244353>;
Binomial<mint> C(200200);
NTT<mint> ntt;
using vm = FormalPowerSeries<mint>;
// vm f{1};
V<vm> fs;
each(x, cnt) {
if (x < 2)
continue;
vm v(x / 2 + 1);
mint c = 1;
int n = x;
int m = 0;
rep(i, x / 2 + 1) {
if (i) {
c *= C.C(n, 2);
n -= 2;
m += 1;
}
v[i] = c * C.finv(m);
}
fs.push_back(v);
}
vm f = (sz(fs) ? Pi<mint>(fs) : vm{1});
vm pre(N + 1);
{
int n = 2 * N;
int m = 0;
mint c = 1;
rep(i, N + 1) {
if (i) {
c *= C.C(i * 2, 2);
m += 1;
}
pre[i] = c * C.finv(m);
}
}
mint ans = 0;
rep(i, sz(f)) {
mint c = f[i];
c *= pre[N - i];
ans += (i & 1) ? -c : c;
}
out(ans);
} | replace | 1,600 | 1,603 | 1,600 | 1,603 | 0 | |
p02539 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
template <ll mod = 998244353LL, ll root = 3LL>
void ntt(vector<ll> &a, bool rev = false) {
auto modpow = [](ll p, int q) {
ll res = 1LL;
while (q) {
if (q & 1)
res = res * p % mod;
p = p * p % mod;
q >>= 1;
}
return res;
};
const int sz = a.size();
if (sz == 1)
return;
vector<ll> b(sz);
int r = rev ? (mod - 1 - (mod - 1) / sz) : (mod - 1) / sz;
ll s = modpow(root, r);
vector<ll> kp(sz / 2 + 1, 1);
for (int i = 0; i < sz / 2; ++i)
kp[i + 1] = kp[i] * s % mod;
for (int i = 1, l = sz / 2; i < sz; i <<= 1, l >>= 1) {
for (int j = 0, r = 0; j < l; ++j, r += i) {
for (int k = 0, s = kp[i * j]; k < i; ++k) {
ll p = a[k + r], q = a[k + r + sz / 2];
b[k + 2 * r] = (p + q) % mod;
b[k + 2 * r + i] = ((p - q) % mod + mod) % mod * s % mod;
}
}
swap(a, b);
}
if (rev) {
s = modpow(sz, mod - 2);
for (int i = 0; i < sz; i++) {
a[i] = a[i] * s % mod;
}
}
}
template <ll mod = 998244353LL, ll root = 3LL>
vector<ll> convolute(vector<ll> a, vector<ll> b) {
const int sz = (int)a.size() + (int)b.size() - 1;
int t = 1;
while (t < sz)
t *= 2;
a.resize(t, 0);
b.resize(t, 0);
ntt<mod, root>(a);
ntt<mod, root>(b);
for (int i = 0; i < t; ++i)
a[i] = a[i] * b[i] % mod;
ntt<mod, root>(a, true);
a.resize(sz);
return a;
}
constexpr ll mod = 998244353LL;
ll fact(ll k, int sgn = 0) {
static vector<ll> fac(2, 1LL);
static vector<ll> inv(2, 1LL);
static vector<ll> finv(2, 1LL);
static ll nx = 2LL;
while (nx <= k) {
fac.push_back(fac[nx - 1] * nx % mod);
inv.push_back(mod - inv[mod % nx] * (mod / nx) % mod);
finv.push_back(finv[nx - 1] * inv[nx] % mod);
++nx;
}
if (sgn == 0)
return fac[k];
return finv[k];
}
ll comb(ll a, ll b) {
if (b < 0 || b > a)
return 0;
return fact(a) * fact(b, 1) % mod * fact(a - b, 1) % mod;
}
ll calc_A(int n) {
static vector<ll> A(2, 1);
int i = A.size();
while (i <= n) {
ll Ai = A[i - 1] * (2 * i - 1) % mod;
A.push_back(Ai);
++i;
}
return A[n];
}
int N;
map<int, int> cnt;
void input(void) {
cin >> N;
for (int i = 0; i < 2 * N; ++i) {
int hi;
cin >> hi;
++cnt[hi];
}
}
using func = vector<ll>;
void print(func f) {
for (auto &fi : f)
cout << fi << " ";
cout << endl;
}
func merge(void) {
vector<func> fs;
for (auto &e : cnt) {
int c = e.second;
func tmp(c / 2 + 1);
for (int p = 0; p <= c / 2; ++p) {
tmp[p] = (p & 1 ? (-1LL) : (1LL)) * comb(c, 2 * p) * calc_A(p) % mod;
if (tmp[p] < 0)
tmp[p] += mod;
}
fs.push_back(tmp);
}
sort(fs.begin(), fs.end(),
[](func a, func b) { return a.size() > b.size(); });
func ret = fs[0];
for (int i = 1; i < fs.size(); ++i)
ret = convolute<>(ret, fs[i]);
return ret;
}
ll solve(void) {
func f1 = merge();
func f2(N + 1);
for (int i = 0; i <= N; ++i)
f2[i] = calc_A(i);
func f = convolute<>(f1, f2);
return f[N];
}
int main(void) {
input();
cout << solve() << endl;
return 0;
} | #pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
template <ll mod = 998244353LL, ll root = 3LL>
void ntt(vector<ll> &a, bool rev = false) {
auto modpow = [](ll p, int q) {
ll res = 1LL;
while (q) {
if (q & 1)
res = res * p % mod;
p = p * p % mod;
q >>= 1;
}
return res;
};
const int sz = a.size();
if (sz == 1)
return;
vector<ll> b(sz);
int r = rev ? (mod - 1 - (mod - 1) / sz) : (mod - 1) / sz;
ll s = modpow(root, r);
vector<ll> kp(sz / 2 + 1, 1);
for (int i = 0; i < sz / 2; ++i)
kp[i + 1] = kp[i] * s % mod;
for (int i = 1, l = sz / 2; i < sz; i <<= 1, l >>= 1) {
for (int j = 0, r = 0; j < l; ++j, r += i) {
for (int k = 0, s = kp[i * j]; k < i; ++k) {
ll p = a[k + r], q = a[k + r + sz / 2];
b[k + 2 * r] = (p + q) % mod;
b[k + 2 * r + i] = ((p - q) % mod + mod) % mod * s % mod;
}
}
swap(a, b);
}
if (rev) {
s = modpow(sz, mod - 2);
for (int i = 0; i < sz; i++) {
a[i] = a[i] * s % mod;
}
}
}
template <ll mod = 998244353LL, ll root = 3LL>
vector<ll> convolute(vector<ll> a, vector<ll> b) {
const int sz = (int)a.size() + (int)b.size() - 1;
int t = 1;
while (t < sz)
t *= 2;
a.resize(t, 0);
b.resize(t, 0);
ntt<mod, root>(a);
ntt<mod, root>(b);
for (int i = 0; i < t; ++i)
a[i] = a[i] * b[i] % mod;
ntt<mod, root>(a, true);
a.resize(sz);
return a;
}
constexpr ll mod = 998244353LL;
ll fact(ll k, int sgn = 0) {
static vector<ll> fac(2, 1LL);
static vector<ll> inv(2, 1LL);
static vector<ll> finv(2, 1LL);
static ll nx = 2LL;
while (nx <= k) {
fac.push_back(fac[nx - 1] * nx % mod);
inv.push_back(mod - inv[mod % nx] * (mod / nx) % mod);
finv.push_back(finv[nx - 1] * inv[nx] % mod);
++nx;
}
if (sgn == 0)
return fac[k];
return finv[k];
}
ll comb(ll a, ll b) {
if (b < 0 || b > a)
return 0;
return fact(a) * fact(b, 1) % mod * fact(a - b, 1) % mod;
}
ll calc_A(int n) {
static vector<ll> A(2, 1);
int i = A.size();
while (i <= n) {
ll Ai = A[i - 1] * (2 * i - 1) % mod;
A.push_back(Ai);
++i;
}
return A[n];
}
int N;
map<int, int> cnt;
void input(void) {
cin >> N;
for (int i = 0; i < 2 * N; ++i) {
int hi;
cin >> hi;
++cnt[hi];
}
}
using func = vector<ll>;
void print(func f) {
for (auto &fi : f)
cout << fi << " ";
cout << endl;
}
func merge(void) {
vector<func> fs;
for (auto &e : cnt) {
int c = e.second;
func tmp(c / 2 + 1);
for (int p = 0; p <= c / 2; ++p) {
tmp[p] = (p & 1 ? (-1LL) : (1LL)) * comb(c, 2 * p) * calc_A(p) % mod;
if (tmp[p] < 0)
tmp[p] += mod;
}
fs.push_back(tmp);
}
sort(fs.begin(), fs.end(),
[](func a, func b) { return a.size() > b.size(); });
vector<func> new_func;
while (fs.size() > 1) {
new_func = vector<func>((fs.size() + 1) / 2);
for (int i = 0; i < fs.size(); i += 2) {
new_func[i / 2] =
(i + 1 == fs.size()) ? fs[i] : convolute<>(fs[i], fs[i + 1]);
}
fs = new_func;
}
return fs[0];
}
ll solve(void) {
func f1 = merge();
func f2(N + 1);
for (int i = 0; i <= N; ++i)
f2[i] = calc_A(i);
func f = convolute<>(f1, f2);
return f[N];
}
int main(void) {
input();
cout << solve() << endl;
return 0;
} | replace | 134 | 138 | 134 | 144 | TLE | |
p02539 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
namespace Math {
const int MOD107 = 1e9 + 7;
const int MOD998 = 998244353;
const int INT_INF = 0x3f3f3f3f;
const LL LL_INF = ((LL)INT_INF << 32) | INT_INF;
struct Value {
virtual ~Value() = default;
};
template <const int P> struct Mint : Value {
int v;
inline int trim(int _v) { return (_v % P + P) % P; }
Mint(int _v = 0) : v(trim(_v)) {}
bool operator==(const Mint &m) const { return v == m.v; }
bool operator!=(const Mint &m) const { return v != m.v; }
bool operator<(const Mint &m) const { return v < m.v; }
bool operator<=(const Mint &m) const { return v <= m.v; }
bool operator>(const Mint &m) const { return v > m.v; }
bool operator>=(const Mint &m) const { return v >= m.v; }
friend bool operator==(const int &a, const Mint &m) { return Mint(a) == m.v; }
friend bool operator!=(const int &a, const Mint &m) { return Mint(a) != m.v; }
friend bool operator<(const int &a, const Mint &m) { return Mint(a) < m.v; }
friend bool operator<=(const int &a, const Mint &m) { return Mint(a) <= m.v; }
friend bool operator>(const int &a, const Mint &m) { return Mint(a) > m.v; }
friend bool operator>=(const int &a, const Mint &m) { return Mint(a) >= m.v; }
Mint &operator+=(const Mint &m) {
v = trim(v + m.v);
return *this;
}
Mint operator+(const Mint &m) const {
Mint t = *this;
return t += m;
}
friend Mint operator+(const int &a, const Mint &m) { return Mint(a) + m; }
Mint &operator++() { return *this += 1; }
Mint operator++(int) {
Mint t = *this;
++*this;
return t;
}
Mint operator-() const { return Mint(-v); }
Mint &operator-=(const Mint &m) {
v = trim(v - m.v);
return *this;
}
Mint operator-(const Mint &m) const {
Mint t = *this;
return t -= m;
}
friend Mint operator-(const int &a, const Mint &m) { return Mint(a) - m; }
Mint &operator--() { return *this -= 1; }
Mint operator--(int) {
Mint t = *this;
--*this;
return t;
}
Mint &operator*=(const Mint &m) {
v = trim(1ll * v * m.v % P);
return *this;
}
Mint operator*(const Mint &m) const {
Mint t = *this;
return t *= m;
}
friend Mint operator*(const int &a, const Mint &m) { return Mint(a) * m; }
Mint pow(long long n) const {
Mint m = *this, ans = 1;
while (n)
ans *= (n & 1 ? m : 1), m *= m, n >>= 1;
return ans;
}
Mint pow(const Mint &n) const { return pow(n.v); }
Mint inv() const { return pow(P - 2); }
Mint &operator/=(const Mint &m) {
*this = v * m.inv();
return *this;
}
Mint operator/(const Mint &m) {
Mint t = *this;
return t /= m;
}
friend Mint operator/(const int &a, const Mint &m) { return Mint(a) / m; }
friend istream &operator>>(istream &in, Mint &m) {
int v;
in >> v;
m = Mint(v);
return in;
}
friend ostream &operator<<(ostream &out, const Mint &m) {
out << m.v;
return out;
}
};
template <typename T> T add(T a, T b) { return a + b; }
template <typename T> T max(T a, T b) { return a < b ? b : a; }
template <typename T> T min(T a, T b) { return a < b ? a : b; }
unordered_map<int, vector<Value *>> fact_mp, inv_mp, fact_inv_mp;
template <const int P> void _build(int n);
template <const int P> Mint<P> fact(int n) {
assert(0 <= n);
_build<P>(n);
auto &_fact = fact_mp[P];
return *dynamic_cast<Mint<P> *>(_fact[n]);
}
template <const int P> Mint<P> fact_inv(int n) {
assert(0 <= n);
_build<P>(n);
auto &_fact_inv = fact_inv_mp[P];
return *dynamic_cast<Mint<P> *>(_fact_inv[n]);
}
template <const int P> Mint<P> C(int n, int m) {
assert(0 <= n && m >= 0 && m <= n);
_build<P>(n);
return fact<P>(n) * fact_inv<P>(m) * fact_inv<P>(n - m);
}
template <const int P> Mint<P> inv(int n) {
assert(0 <= n);
_build<P>(n);
auto _inv = inv_mp[P];
return *dynamic_cast<Mint<P> *>(_inv[n]);
}
template <const int P> void _build(int n) {
auto &_fact = fact_mp[P];
auto &_inv = inv_mp[P];
auto &_fact_inv = fact_inv_mp[P];
while (_fact.size() <= n) {
if ((int)_fact.size() <= 1) {
_fact.push_back(new Mint<P>(1));
_inv.push_back(new Mint<P>(1));
_fact_inv.push_back(new Mint<P>(1));
continue;
}
int x = _fact.size();
_fact.push_back(new Mint<P>(fact<P>(x - 1) * x));
_inv.push_back(new Mint<P>(-inv<P>(P % x) * Mint<P>(P / x)));
_fact_inv.push_back(new Mint<P>(fact_inv<P>(x - 1) * inv<P>(x)));
}
}
} // namespace Math
namespace DS {
template <typename T, T e, T (*F)(T, T)> struct BIT {
vector<T> data;
int n;
BIT(int _n = 0) { init(_n); }
BIT(vector<T> arr) { init(arr); }
void init(int _n) {
n = _n;
data.assign(n + 1, e);
}
void init(vector<T> arr) {
init(arr.size());
for (int i = 0; i < arr.size(); i++)
m(i, arr[i]);
}
T q(int R) {
assert(0 <= R && R <= n);
T ret = e;
while (R > 0)
ret = F(ret, data[R]), R -= R & -R;
return ret;
}
void m(int x, T d) {
x++;
while (x <= n)
data[x] = F(data[x], d), x += x & -x;
}
friend ostream &operator<<(ostream &out, BIT &bit) {
out << "===========================================\n";
cout << "structure type: BIT, size: " << bit.n << '\n';
for (int i = 0; i <= bit.n; i++)
cout << "bit[0, " << i << "): " << bit.q(i) << '\n';
out << "===========================================\n";
return out;
}
friend istream &operator>>(istream &in, BIT &bit) {
vector<T> arr(bit.n);
for (auto &v : arr)
in >> v;
bit.init(arr);
return in;
}
};
template <typename T, T (*F)(T, T)> struct SparseTable {
int n, lgn;
vector<vector<T>> data;
SparseTable(int _n) {
vector<T> arr(n = _n);
init(arr);
}
SparseTable(vector<T> arr) { init(arr); }
void init(vector<T> arr) {
n = arr.size();
data.assign(lgn = __lg(n) + 1, vector<T>(n));
data[0] = arr;
for (int h = 0; h < lgn - 1; h++) {
for (int i = 0; i < n; i++) {
if (i + (1 << h) < n)
data[h + 1][i] = F(data[h][i], data[h][i + (1 << h)]);
else
data[h + 1][i] = data[h][i];
}
}
}
T q(int L, int R) {
assert(0 <= L && L < n && 0 < R && R <= n && L < R);
T ret = data[0][L];
for (int h = lgn - 1; h >= 0; h--)
if (L + (1 << h) <= R)
ret = F(ret, data[h][L]), L += 1 << h;
return ret;
}
friend istream &operator>>(istream &in, SparseTable &st) {
vector<T> arr(st.n);
for (auto &v : arr)
in >> v;
st.init(arr);
return in;
}
friend ostream &operator<<(ostream &out, SparseTable &st) {
out << "===========================================\n";
out << "structure type: SparseTable, size: " << st.n << '\n';
for (int i = 0; i < st.n; i++)
for (int j = i + 1; j <= st.n; j++)
cout << "[" << i << ", " << j << "): " << st.q(i, j) << '\n';
out << "===========================================\n";
return out;
}
};
} // namespace DS
namespace IO {}
namespace Graph {}
namespace Geometry {}
namespace String {}
using namespace Math;
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
int fpow(int a, int n, int P) {
int r = 1;
while (n) {
if (n & 1)
r = 1ll * r * a % P;
a = 1ll * a * a % P;
n >>= 1;
}
return r;
}
const int P = 998244353, R = 3, MAXN = (1 << 23);
const int MOD = MOD998;
struct Poly : vector<int> {
int n;
Poly(int n) : n(n) { this->resize(n); }
int extend(int x) {
int N = 1;
while (N < x)
N <<= 1;
return N;
}
Poly operator*(const Poly &rhs) {
Poly a = *this, b = rhs;
int N = extend(n + rhs.n - 1);
a.resize(a.n = N);
a.ntt(1);
b.resize(b.n = N);
b.ntt(1);
for (int i = 0; i < N; i++)
a[i] = 1ll * a[i] * b[i] % P;
return a.ntt(-1), a.n = n + rhs.n, a;
}
void ntt(int op) {
static Poly r(MAXN);
for (int i = 0; i < n; i++) {
r[i] = (i & 1) * (n >> 1) + (r[i >> 1] >> 1);
if (r[i] < i)
std::swap(at(i), at(r[i]));
}
for (int m = 2; m <= n; m <<= 1) {
int k = m >> 1, gn = fpow(R, (P - 1) / m, P);
for (int i = 0; i < n; i += m) {
int g = 1;
for (int j = 0; j < k; j++, g = 1ll * g * gn % P) {
int tmp = 1ll * at(i + j + k) * g % P;
at(i + j + k) = (at(i + j) - tmp + P) % P;
at(i + j) = (at(i + j) + tmp) % P;
}
}
}
if (op == -1) {
reverse(begin() + 1, end());
int inv = fpow(n, P - 2, P);
for (int i = 0; i < n; i++)
at(i) = 1ll * at(i) * inv % P;
}
}
bool operator<(const Poly &rhs) const { return n > rhs.n; }
};
typedef pair<int, int> pii;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
map<int, int> cnt;
for (int i = 0; i < 2 * n; i++) {
int v;
cin >> v;
cnt[v]++;
}
n *= 2;
priority_queue<Poly> pq;
for (auto &p : cnt) {
int k = p.S / 2;
Poly poly(k + 1);
for (int i = 0; i <= k; i++) {
poly[i] = (C<MOD>(p.S, 2 * i) * fact<MOD>(2 * i) * fact_inv<MOD>(i) /
Mint<MOD>(2).pow(i))
.v;
// poly[i] = PP(p.S, 2 * i) * fpow(fpow(2, i, MOD), MOD - 2,
// MOD) % MOD * prei[i] % MOD;
}
// cout << p.F << ' ' << p.S << ": ";
// for (int i = 0 ; i <= k ; i++)
// cout << poly[i] << ' ';
// cout << '\n';
pq.push(poly);
}
while (pq.size() > 1) {
auto a = pq.top();
pq.pop();
auto b = pq.top();
pq.pop();
pq.push(a * b);
}
auto res = pq.top();
pq.pop();
// for (int i = 0 ; i < res.n ; i++)
// cout << res[i] << ' ';
// cout << '\n';
Mint<MOD998> ans = 0;
for (int i = 0; i <= n / 2; i++) {
if (i % 2 == 0) {
ans += res[i] * fact<MOD>(n - 2 * i) / Mint<MOD>(2).pow(n / 2 - i) *
fact_inv<MOD>(n / 2 - i);
} else {
ans -= res[i] * fact<MOD>(n - 2 * i) / Mint<MOD>(2).pow(n / 2 - i) *
fact_inv<MOD>(n / 2 - i);
// ans -= res[i] * pre[n - 2 * i] % MOD * fpow(fpow(2, n / 2 -
// i, MOD), MOD - 2, MOD) % MOD * prei[n / 2 - i] % MOD; ans +=
// MOD; ans %= MOD;
}
}
cout << ans << '\n';
}
| #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
namespace Math {
const int MOD107 = 1e9 + 7;
const int MOD998 = 998244353;
const int INT_INF = 0x3f3f3f3f;
const LL LL_INF = ((LL)INT_INF << 32) | INT_INF;
struct Value {
virtual ~Value() = default;
};
template <const int P> struct Mint : Value {
int v;
inline int trim(int _v) { return (_v % P + P) % P; }
Mint(int _v = 0) : v(trim(_v)) {}
bool operator==(const Mint &m) const { return v == m.v; }
bool operator!=(const Mint &m) const { return v != m.v; }
bool operator<(const Mint &m) const { return v < m.v; }
bool operator<=(const Mint &m) const { return v <= m.v; }
bool operator>(const Mint &m) const { return v > m.v; }
bool operator>=(const Mint &m) const { return v >= m.v; }
friend bool operator==(const int &a, const Mint &m) { return Mint(a) == m.v; }
friend bool operator!=(const int &a, const Mint &m) { return Mint(a) != m.v; }
friend bool operator<(const int &a, const Mint &m) { return Mint(a) < m.v; }
friend bool operator<=(const int &a, const Mint &m) { return Mint(a) <= m.v; }
friend bool operator>(const int &a, const Mint &m) { return Mint(a) > m.v; }
friend bool operator>=(const int &a, const Mint &m) { return Mint(a) >= m.v; }
Mint &operator+=(const Mint &m) {
v = trim(v + m.v);
return *this;
}
Mint operator+(const Mint &m) const {
Mint t = *this;
return t += m;
}
friend Mint operator+(const int &a, const Mint &m) { return Mint(a) + m; }
Mint &operator++() { return *this += 1; }
Mint operator++(int) {
Mint t = *this;
++*this;
return t;
}
Mint operator-() const { return Mint(-v); }
Mint &operator-=(const Mint &m) {
v = trim(v - m.v);
return *this;
}
Mint operator-(const Mint &m) const {
Mint t = *this;
return t -= m;
}
friend Mint operator-(const int &a, const Mint &m) { return Mint(a) - m; }
Mint &operator--() { return *this -= 1; }
Mint operator--(int) {
Mint t = *this;
--*this;
return t;
}
Mint &operator*=(const Mint &m) {
v = trim(1ll * v * m.v % P);
return *this;
}
Mint operator*(const Mint &m) const {
Mint t = *this;
return t *= m;
}
friend Mint operator*(const int &a, const Mint &m) { return Mint(a) * m; }
Mint pow(long long n) const {
Mint m = *this, ans = 1;
while (n)
ans *= (n & 1 ? m : 1), m *= m, n >>= 1;
return ans;
}
Mint pow(const Mint &n) const { return pow(n.v); }
Mint inv() const { return pow(P - 2); }
Mint &operator/=(const Mint &m) {
*this = v * m.inv();
return *this;
}
Mint operator/(const Mint &m) {
Mint t = *this;
return t /= m;
}
friend Mint operator/(const int &a, const Mint &m) { return Mint(a) / m; }
friend istream &operator>>(istream &in, Mint &m) {
int v;
in >> v;
m = Mint(v);
return in;
}
friend ostream &operator<<(ostream &out, const Mint &m) {
out << m.v;
return out;
}
};
template <typename T> T add(T a, T b) { return a + b; }
template <typename T> T max(T a, T b) { return a < b ? b : a; }
template <typename T> T min(T a, T b) { return a < b ? a : b; }
unordered_map<int, vector<Value *>> fact_mp, inv_mp, fact_inv_mp;
template <const int P> void _build(int n);
template <const int P> Mint<P> fact(int n) {
assert(0 <= n);
_build<P>(n);
auto &_fact = fact_mp[P];
return *dynamic_cast<Mint<P> *>(_fact[n]);
}
template <const int P> Mint<P> fact_inv(int n) {
assert(0 <= n);
_build<P>(n);
auto &_fact_inv = fact_inv_mp[P];
return *dynamic_cast<Mint<P> *>(_fact_inv[n]);
}
template <const int P> Mint<P> C(int n, int m) {
assert(0 <= n && m >= 0 && m <= n);
_build<P>(n);
return fact<P>(n) * fact_inv<P>(m) * fact_inv<P>(n - m);
}
template <const int P> Mint<P> inv(int n) {
assert(0 <= n);
_build<P>(n);
auto &_inv = inv_mp[P];
return *dynamic_cast<Mint<P> *>(_inv[n]);
}
template <const int P> void _build(int n) {
auto &_fact = fact_mp[P];
auto &_inv = inv_mp[P];
auto &_fact_inv = fact_inv_mp[P];
while (_fact.size() <= n) {
if ((int)_fact.size() <= 1) {
_fact.push_back(new Mint<P>(1));
_inv.push_back(new Mint<P>(1));
_fact_inv.push_back(new Mint<P>(1));
continue;
}
int x = _fact.size();
_fact.push_back(new Mint<P>(fact<P>(x - 1) * x));
_inv.push_back(new Mint<P>(-inv<P>(P % x) * Mint<P>(P / x)));
_fact_inv.push_back(new Mint<P>(fact_inv<P>(x - 1) * inv<P>(x)));
}
}
} // namespace Math
namespace DS {
template <typename T, T e, T (*F)(T, T)> struct BIT {
vector<T> data;
int n;
BIT(int _n = 0) { init(_n); }
BIT(vector<T> arr) { init(arr); }
void init(int _n) {
n = _n;
data.assign(n + 1, e);
}
void init(vector<T> arr) {
init(arr.size());
for (int i = 0; i < arr.size(); i++)
m(i, arr[i]);
}
T q(int R) {
assert(0 <= R && R <= n);
T ret = e;
while (R > 0)
ret = F(ret, data[R]), R -= R & -R;
return ret;
}
void m(int x, T d) {
x++;
while (x <= n)
data[x] = F(data[x], d), x += x & -x;
}
friend ostream &operator<<(ostream &out, BIT &bit) {
out << "===========================================\n";
cout << "structure type: BIT, size: " << bit.n << '\n';
for (int i = 0; i <= bit.n; i++)
cout << "bit[0, " << i << "): " << bit.q(i) << '\n';
out << "===========================================\n";
return out;
}
friend istream &operator>>(istream &in, BIT &bit) {
vector<T> arr(bit.n);
for (auto &v : arr)
in >> v;
bit.init(arr);
return in;
}
};
template <typename T, T (*F)(T, T)> struct SparseTable {
int n, lgn;
vector<vector<T>> data;
SparseTable(int _n) {
vector<T> arr(n = _n);
init(arr);
}
SparseTable(vector<T> arr) { init(arr); }
void init(vector<T> arr) {
n = arr.size();
data.assign(lgn = __lg(n) + 1, vector<T>(n));
data[0] = arr;
for (int h = 0; h < lgn - 1; h++) {
for (int i = 0; i < n; i++) {
if (i + (1 << h) < n)
data[h + 1][i] = F(data[h][i], data[h][i + (1 << h)]);
else
data[h + 1][i] = data[h][i];
}
}
}
T q(int L, int R) {
assert(0 <= L && L < n && 0 < R && R <= n && L < R);
T ret = data[0][L];
for (int h = lgn - 1; h >= 0; h--)
if (L + (1 << h) <= R)
ret = F(ret, data[h][L]), L += 1 << h;
return ret;
}
friend istream &operator>>(istream &in, SparseTable &st) {
vector<T> arr(st.n);
for (auto &v : arr)
in >> v;
st.init(arr);
return in;
}
friend ostream &operator<<(ostream &out, SparseTable &st) {
out << "===========================================\n";
out << "structure type: SparseTable, size: " << st.n << '\n';
for (int i = 0; i < st.n; i++)
for (int j = i + 1; j <= st.n; j++)
cout << "[" << i << ", " << j << "): " << st.q(i, j) << '\n';
out << "===========================================\n";
return out;
}
};
} // namespace DS
namespace IO {}
namespace Graph {}
namespace Geometry {}
namespace String {}
using namespace Math;
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
int fpow(int a, int n, int P) {
int r = 1;
while (n) {
if (n & 1)
r = 1ll * r * a % P;
a = 1ll * a * a % P;
n >>= 1;
}
return r;
}
const int P = 998244353, R = 3, MAXN = (1 << 23);
const int MOD = MOD998;
struct Poly : vector<int> {
int n;
Poly(int n) : n(n) { this->resize(n); }
int extend(int x) {
int N = 1;
while (N < x)
N <<= 1;
return N;
}
Poly operator*(const Poly &rhs) {
Poly a = *this, b = rhs;
int N = extend(n + rhs.n - 1);
a.resize(a.n = N);
a.ntt(1);
b.resize(b.n = N);
b.ntt(1);
for (int i = 0; i < N; i++)
a[i] = 1ll * a[i] * b[i] % P;
return a.ntt(-1), a.n = n + rhs.n, a;
}
void ntt(int op) {
static Poly r(MAXN);
for (int i = 0; i < n; i++) {
r[i] = (i & 1) * (n >> 1) + (r[i >> 1] >> 1);
if (r[i] < i)
std::swap(at(i), at(r[i]));
}
for (int m = 2; m <= n; m <<= 1) {
int k = m >> 1, gn = fpow(R, (P - 1) / m, P);
for (int i = 0; i < n; i += m) {
int g = 1;
for (int j = 0; j < k; j++, g = 1ll * g * gn % P) {
int tmp = 1ll * at(i + j + k) * g % P;
at(i + j + k) = (at(i + j) - tmp + P) % P;
at(i + j) = (at(i + j) + tmp) % P;
}
}
}
if (op == -1) {
reverse(begin() + 1, end());
int inv = fpow(n, P - 2, P);
for (int i = 0; i < n; i++)
at(i) = 1ll * at(i) * inv % P;
}
}
bool operator<(const Poly &rhs) const { return n > rhs.n; }
};
typedef pair<int, int> pii;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
map<int, int> cnt;
for (int i = 0; i < 2 * n; i++) {
int v;
cin >> v;
cnt[v]++;
}
n *= 2;
priority_queue<Poly> pq;
for (auto &p : cnt) {
int k = p.S / 2;
Poly poly(k + 1);
for (int i = 0; i <= k; i++) {
poly[i] = (C<MOD>(p.S, 2 * i) * fact<MOD>(2 * i) * fact_inv<MOD>(i) /
Mint<MOD>(2).pow(i))
.v;
// poly[i] = PP(p.S, 2 * i) * fpow(fpow(2, i, MOD), MOD - 2,
// MOD) % MOD * prei[i] % MOD;
}
// cout << p.F << ' ' << p.S << ": ";
// for (int i = 0 ; i <= k ; i++)
// cout << poly[i] << ' ';
// cout << '\n';
pq.push(poly);
}
while (pq.size() > 1) {
auto a = pq.top();
pq.pop();
auto b = pq.top();
pq.pop();
pq.push(a * b);
}
auto res = pq.top();
pq.pop();
// for (int i = 0 ; i < res.n ; i++)
// cout << res[i] << ' ';
// cout << '\n';
Mint<MOD998> ans = 0;
for (int i = 0; i <= n / 2; i++) {
if (i % 2 == 0) {
ans += res[i] * fact<MOD>(n - 2 * i) / Mint<MOD>(2).pow(n / 2 - i) *
fact_inv<MOD>(n / 2 - i);
} else {
ans -= res[i] * fact<MOD>(n - 2 * i) / Mint<MOD>(2).pow(n / 2 - i) *
fact_inv<MOD>(n / 2 - i);
// ans -= res[i] * pre[n - 2 * i] % MOD * fpow(fpow(2, n / 2 -
// i, MOD), MOD - 2, MOD) % MOD * prei[n / 2 - i] % MOD; ans +=
// MOD; ans %= MOD;
}
}
cout << ans << '\n';
}
| replace | 122 | 123 | 122 | 123 | TLE | |
p02539 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define llint long long
#define inf 1e18
#define PI 3.14159265358979323846264338327950
#define eps 1e-8
#define rep(x, s, t) for (llint(x) = (s); (x) < (t); (x)++)
#define Rep(x, s, t) for (llint(x) = (s); (x) <= (t); (x)++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
const llint mod = 998244353;
using namespace std;
typedef pair<llint, llint> P;
/*
{1224736769, 3}, // 2^24 * 73 + 1,
{1053818881, 7}, // 2^20 * 3 * 5 * 67 + 1
{1051721729, 6}, // 2^20 * 17 * 59 + 1
{1045430273, 3}, // 2^20 * 997 + 1
{1012924417, 5}, // 2^21 * 3 * 7 * 23 + 1
{1007681537, 3}, // 2^20 * 31^2 + 1
{1004535809, 3}, // 2^21 * 479 + 1
{998244353, 3}, // 2^23 * 7 * 17 + 1
{985661441, 3}, // 2^22 * 5 * 47 + 1
{976224257, 3}, // 2^20 * 7^2 * 19 + 1
{975175681, 17}, // 2^21 * 3 * 5 * 31 + 1
{962592769, 7}, // 2^21 * 3^3 * 17 + 1
{950009857, 7}, // 2^21 * 4 * 151 + 1
{943718401, 7}, // 2^22 * 3^2 * 5^2 + 1
{935329793, 3}, // 2^22 * 223 + 1
{924844033, 5}, // 2^21 * 3^2 * 7^2 + 1
{469762049, 3}, // 2^26 * 7 + 1
{167772161, 3}, // 2^25 * 5 + 1
*/
llint modpow(llint a, llint n, llint mod) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1, mod) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2, mod) % mod;
}
}
int rev(int x, int n) {
int ret = 0;
for (int i = 0; i < n; i++) {
ret <<= 1;
ret |= (x >> i) & 1;
}
return ret;
}
// f[]とF[]は異なる実体を持たなければならない。rootには1の原始2^n乗根を渡す
void DFT(llint f[], llint F[], int n, llint mod, llint root) {
int N = 1 << n;
for (int i = 0; i < N; i++)
F[rev(i, n)] = f[i];
llint a, b, x, z;
for (int i = 1; i <= n; i++) {
int l = 1 << i;
z = modpow(root, 1 << (n - i), mod);
for (int j = 0; j < N / l; j++) {
x = 1;
for (int k = 0; k < l / 2; k++) {
a = F[j * l + k], b = F[j * l + k + l / 2];
F[j * l + k] = a + x * b % mod;
F[j * l + k + l / 2] = a - x * b % mod + mod;
if (F[j * l + k] >= mod)
F[j * l + k] -= mod;
if (F[j * l + k + l / 2] >= mod)
F[j * l + k + l / 2] -= mod;
x *= z, x %= mod;
}
}
}
}
// f[]とF[]は異なる実体を持たなければならない。rootには1の原始2^n乗根を渡す
void IDFT(llint F[], llint f[], int n, llint mod, llint root) {
int N = 1 << n;
for (int i = 0; i < N; i++)
f[rev(i, n)] = F[i];
root = modpow(root, mod - 2, mod);
llint a, b, x, z;
for (int i = 1; i <= n; i++) {
int l = 1 << i;
z = modpow(root, 1 << (n - i), mod);
for (int j = 0; j < N / l; j++) {
x = 1;
for (int k = 0; k < l / 2; k++) {
a = f[j * l + k], b = f[j * l + k + l / 2];
f[j * l + k] = a + x * b % mod;
f[j * l + k + l / 2] = a - x * b % mod + mod;
if (f[j * l + k] >= mod)
f[j * l + k] -= mod;
if (f[j * l + k + l / 2] >= mod)
f[j * l + k + l / 2] -= mod;
x *= z, x %= mod;
}
}
}
llint Ninv = modpow(N, mod - 2, mod);
for (int i = 0; i < N; i++)
f[i] *= Ninv, f[i] %= mod;
}
llint n;
llint a[100005];
llint seki[200005];
llint root;
priority_queue<P, vector<P>, greater<P>> Q;
vector<llint> vec[100005];
llint getlog(llint n) {
llint ret = 0;
for (; n; n /= 2)
ret++;
return ret;
}
llint f[1 << 19], g[1 << 19], F[1 << 19], G[1 << 19];
llint calc(llint u, llint v) {
llint degu = vec[u].size() - 1, degv = vec[v].size() - 1;
llint n = getlog(degu + degv + 1), N = 1 << n;
for (int i = 0; i < N; i++)
f[i] = F[i] = g[i] = G[i] = 0;
for (int i = 0; i < vec[u].size(); i++)
f[i] = vec[u][i];
for (int i = 0; i < vec[v].size(); i++)
g[i] = vec[v][i];
DFT(f, F, n, mod, modpow(root, 1 << (23 - n), mod));
DFT(g, G, n, mod, modpow(root, 1 << (23 - n), mod));
for (int i = 0; i < N; i++)
F[i] *= G[i], F[i] %= mod;
IDFT(F, f, n, mod, modpow(root, 1 << (23 - n), mod));
vec[u].resize(degu + degv + 1);
for (int i = 0; i <= degu + degv; i++)
vec[u][i] = f[i];
return degu + degv;
}
const int FACT_MAX = 200005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
make_fact();
cin >> n;
llint h;
for (int i = 1; i <= 2 * n; i++) {
cin >> h;
a[h]++;
}
root = modpow(3, 119, mod);
seki[0] = 1;
for (int i = 2; i < 200005; i += 2)
seki[i] = seki[i - 2] * comb(i, 2) % mod;
for (int i = 1; i <= 100000; i++) {
if (a[i] < 2)
continue;
vec[i].resize(a[i] / 2 + 1);
llint mul = 1;
for (int j = 0; j <= a[i] / 2; j++) {
vec[i][j] = mul * fact_inv[j] % mod;
if (a[i] - 2 * j >= 0)
mul *= comb(a[i] - 2 * j, 2), mul %= mod;
}
Q.push(P(a[i] / 2 + 1, i));
}
while (Q.size() >= 2) {
llint u = Q.top().second;
Q.pop();
llint v = Q.top().second;
Q.pop();
llint res = calc(u, v);
Q.push(P(res, u));
}
llint x = Q.top().second;
llint ans = 0;
for (int i = 0; i < vec[x].size(); i++) {
llint tmp = vec[x][i];
tmp *= seki[2 * (n - i)], tmp %= mod;
tmp *= fact_inv[n - i], tmp %= mod;
if (i % 2)
ans += mod - tmp, ans %= mod;
else
ans += tmp, ans %= mod;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define llint long long
#define inf 1e18
#define PI 3.14159265358979323846264338327950
#define eps 1e-8
#define rep(x, s, t) for (llint(x) = (s); (x) < (t); (x)++)
#define Rep(x, s, t) for (llint(x) = (s); (x) <= (t); (x)++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
const llint mod = 998244353;
using namespace std;
typedef pair<llint, llint> P;
/*
{1224736769, 3}, // 2^24 * 73 + 1,
{1053818881, 7}, // 2^20 * 3 * 5 * 67 + 1
{1051721729, 6}, // 2^20 * 17 * 59 + 1
{1045430273, 3}, // 2^20 * 997 + 1
{1012924417, 5}, // 2^21 * 3 * 7 * 23 + 1
{1007681537, 3}, // 2^20 * 31^2 + 1
{1004535809, 3}, // 2^21 * 479 + 1
{998244353, 3}, // 2^23 * 7 * 17 + 1
{985661441, 3}, // 2^22 * 5 * 47 + 1
{976224257, 3}, // 2^20 * 7^2 * 19 + 1
{975175681, 17}, // 2^21 * 3 * 5 * 31 + 1
{962592769, 7}, // 2^21 * 3^3 * 17 + 1
{950009857, 7}, // 2^21 * 4 * 151 + 1
{943718401, 7}, // 2^22 * 3^2 * 5^2 + 1
{935329793, 3}, // 2^22 * 223 + 1
{924844033, 5}, // 2^21 * 3^2 * 7^2 + 1
{469762049, 3}, // 2^26 * 7 + 1
{167772161, 3}, // 2^25 * 5 + 1
*/
llint modpow(llint a, llint n, llint mod) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1, mod) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2, mod) % mod;
}
}
int rev(int x, int n) {
int ret = 0;
for (int i = 0; i < n; i++) {
ret <<= 1;
ret |= (x >> i) & 1;
}
return ret;
}
// f[]とF[]は異なる実体を持たなければならない。rootには1の原始2^n乗根を渡す
void DFT(llint f[], llint F[], int n, llint mod, llint root) {
int N = 1 << n;
for (int i = 0; i < N; i++)
F[rev(i, n)] = f[i];
llint a, b, x, z;
for (int i = 1; i <= n; i++) {
int l = 1 << i;
z = modpow(root, 1 << (n - i), mod);
for (int j = 0; j < N / l; j++) {
x = 1;
for (int k = 0; k < l / 2; k++) {
a = F[j * l + k], b = F[j * l + k + l / 2];
F[j * l + k] = a + x * b % mod;
F[j * l + k + l / 2] = a - x * b % mod + mod;
if (F[j * l + k] >= mod)
F[j * l + k] -= mod;
if (F[j * l + k + l / 2] >= mod)
F[j * l + k + l / 2] -= mod;
x *= z, x %= mod;
}
}
}
}
// f[]とF[]は異なる実体を持たなければならない。rootには1の原始2^n乗根を渡す
void IDFT(llint F[], llint f[], int n, llint mod, llint root) {
int N = 1 << n;
for (int i = 0; i < N; i++)
f[rev(i, n)] = F[i];
root = modpow(root, mod - 2, mod);
llint a, b, x, z;
for (int i = 1; i <= n; i++) {
int l = 1 << i;
z = modpow(root, 1 << (n - i), mod);
for (int j = 0; j < N / l; j++) {
x = 1;
for (int k = 0; k < l / 2; k++) {
a = f[j * l + k], b = f[j * l + k + l / 2];
f[j * l + k] = a + x * b % mod;
f[j * l + k + l / 2] = a - x * b % mod + mod;
if (f[j * l + k] >= mod)
f[j * l + k] -= mod;
if (f[j * l + k + l / 2] >= mod)
f[j * l + k + l / 2] -= mod;
x *= z, x %= mod;
}
}
}
llint Ninv = modpow(N, mod - 2, mod);
for (int i = 0; i < N; i++)
f[i] *= Ninv, f[i] %= mod;
}
llint n;
llint a[100005];
llint seki[200005];
llint root;
priority_queue<P, vector<P>, greater<P>> Q;
vector<llint> vec[100005];
llint getlog(llint n) {
llint ret = 0;
for (; n; n /= 2)
ret++;
return ret;
}
llint f[1 << 19], g[1 << 19], F[1 << 19], G[1 << 19];
llint calc(llint u, llint v) {
llint degu = vec[u].size() - 1, degv = vec[v].size() - 1;
llint n = getlog(degu + degv + 1), N = 1 << n;
for (int i = 0; i < N; i++)
f[i] = F[i] = g[i] = G[i] = 0;
for (int i = 0; i < vec[u].size(); i++)
f[i] = vec[u][i];
for (int i = 0; i < vec[v].size(); i++)
g[i] = vec[v][i];
DFT(f, F, n, mod, modpow(root, 1 << (23 - n), mod));
DFT(g, G, n, mod, modpow(root, 1 << (23 - n), mod));
for (int i = 0; i < N; i++)
F[i] *= G[i], F[i] %= mod;
IDFT(F, f, n, mod, modpow(root, 1 << (23 - n), mod));
vec[u].resize(degu + degv + 1);
for (int i = 0; i <= degu + degv; i++)
vec[u][i] = f[i];
return degu + degv;
}
const int FACT_MAX = 200005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
make_fact();
cin >> n;
llint h;
for (int i = 1; i <= 2 * n; i++) {
cin >> h;
a[h]++;
}
root = modpow(3, 119, mod);
seki[0] = 1;
for (int i = 2; i < 200005; i += 2)
seki[i] = seki[i - 2] * comb(i, 2) % mod;
for (int i = 1; i <= 100000; i++) {
// if(a[i] < 2) continue;
vec[i].resize(a[i] / 2 + 1);
llint mul = 1;
for (int j = 0; j <= a[i] / 2; j++) {
vec[i][j] = mul * fact_inv[j] % mod;
if (a[i] - 2 * j >= 0)
mul *= comb(a[i] - 2 * j, 2), mul %= mod;
}
Q.push(P(a[i] / 2 + 1, i));
}
while (Q.size() >= 2) {
llint u = Q.top().second;
Q.pop();
llint v = Q.top().second;
Q.pop();
llint res = calc(u, v);
Q.push(P(res, u));
}
llint x = Q.top().second;
llint ans = 0;
for (int i = 0; i < vec[x].size(); i++) {
llint tmp = vec[x][i];
tmp *= seki[2 * (n - i)], tmp %= mod;
tmp *= fact_inv[n - i], tmp %= mod;
if (i % 2)
ans += mod - tmp, ans %= mod;
else
ans += tmp, ans %= mod;
}
cout << ans << endl;
return 0;
} | replace | 219 | 221 | 219 | 220 | 0 | |
p02539 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 998244353;
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
struct NumberTheoreticTransform {
int mod;
int primitiveroot;
NumberTheoreticTransform(int mod, int root) : mod(mod), primitiveroot(root) {}
inline int mod_pow(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1)
ret = mul(ret, x);
x = mul(x, x);
n >>= 1;
}
return ret;
}
inline int inverse(int x) { return (mod_pow(x, mod - 2)); }
inline int add(unsigned x, int y) {
x += y;
if (x >= mod)
x -= mod;
return (x);
}
inline int mul(int a, int b) {
unsigned long long x = (long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod));
return (m);
}
void DiscreteFourierTransform(vector<int> &F, bool rev) {
const int N = (int)F.size();
for (int i = 0, j = 1; j + 1 < N; j++) {
for (int k = N >> 1; k > (i ^= k); k >>= 1)
;
if (i > j)
swap(F[i], F[j]);
}
int w, wn, s, t;
for (int i = 1; i < N; i <<= 1) {
w = mod_pow(primitiveroot, (mod - 1) / (i * 2));
if (rev)
w = inverse(w);
for (int k = 0; k < i; k++) {
wn = mod_pow(w, k);
for (int j = 0; j < N; j += i * 2) {
s = F[j + k], t = mul(F[j + k + i], wn);
F[j + k] = add(s, t), F[j + k + i] = add(s, mod - t);
}
}
}
if (rev) {
int temp = inverse(N);
for (int i = 0; i < N; i++)
F[i] = mul(F[i], temp);
}
}
vector<int> Multiply(const vector<int> &A, const vector<int> &B) {
int sz = 1;
while (sz < A.size() + B.size() - 1)
sz <<= 1;
vector<int> F(sz), G(sz);
for (int i = 0; i < A.size(); i++)
F[i] = A[i];
for (int i = 0; i < B.size(); i++)
G[i] = B[i];
DiscreteFourierTransform(F, false);
DiscreteFourierTransform(G, false);
for (int i = 0; i < sz; i++)
F[i] = mul(F[i], G[i]);
DiscreteFourierTransform(F, true);
F.resize(A.size() + B.size() - 1);
return (F);
}
};
struct P {
int x;
vector<int> v;
bool operator>(const P &rhs) const { return x > rhs.x; }
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> cnt(101010);
rep(i, 2 * n) {
int x;
cin >> x;
cnt[x]++;
}
mod_build();
priority_queue<P, vector<P>, greater<P>> pq;
rep(i, 101010) {
int m = cnt[i];
if (m < 2)
continue;
vector<int> a(m / 2 + 1);
ll ret = 1;
rep(j, m / 2 + 1) {
a[j] = ret;
ret *= comb(m - 2 * j, 2);
ret %= mod;
ret *= inv[j + 1];
ret %= mod;
}
pq.push({m, a});
}
auto ntt = NumberTheoreticTransform(mod, 3);
while (pq.size() > 1) {
auto p1 = pq.top();
pq.pop();
auto p2 = pq.top();
pq.pop();
auto res = ntt.Multiply(p1.v, p2.v);
pq.push({(int)res.size(), res});
}
auto ret = pq.top().v;
ll ans = 0;
rep(i, ret.size()) {
int sz = 2 * n - 2 * i;
ll cnt =
fact[sz] * invfact[sz / 2] % mod * powmod(2, mod - 1 - sz / 2) % mod;
if (i % 2)
ans += mod - ret[i] * cnt % mod;
else
ans += ret[i] * cnt % mod;
}
cout << ans % mod << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 998244353;
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
struct NumberTheoreticTransform {
int mod;
int primitiveroot;
NumberTheoreticTransform(int mod, int root) : mod(mod), primitiveroot(root) {}
inline int mod_pow(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1)
ret = mul(ret, x);
x = mul(x, x);
n >>= 1;
}
return ret;
}
inline int inverse(int x) { return (mod_pow(x, mod - 2)); }
inline int add(unsigned x, int y) {
x += y;
if (x >= mod)
x -= mod;
return (x);
}
inline int mul(int a, int b) {
unsigned long long x = (long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod));
return (m);
}
void DiscreteFourierTransform(vector<int> &F, bool rev) {
const int N = (int)F.size();
for (int i = 0, j = 1; j + 1 < N; j++) {
for (int k = N >> 1; k > (i ^= k); k >>= 1)
;
if (i > j)
swap(F[i], F[j]);
}
int w, wn, s, t;
for (int i = 1; i < N; i <<= 1) {
w = mod_pow(primitiveroot, (mod - 1) / (i * 2));
if (rev)
w = inverse(w);
for (int k = 0; k < i; k++) {
wn = mod_pow(w, k);
for (int j = 0; j < N; j += i * 2) {
s = F[j + k], t = mul(F[j + k + i], wn);
F[j + k] = add(s, t), F[j + k + i] = add(s, mod - t);
}
}
}
if (rev) {
int temp = inverse(N);
for (int i = 0; i < N; i++)
F[i] = mul(F[i], temp);
}
}
vector<int> Multiply(const vector<int> &A, const vector<int> &B) {
int sz = 1;
while (sz < A.size() + B.size() - 1)
sz <<= 1;
vector<int> F(sz), G(sz);
for (int i = 0; i < A.size(); i++)
F[i] = A[i];
for (int i = 0; i < B.size(); i++)
G[i] = B[i];
DiscreteFourierTransform(F, false);
DiscreteFourierTransform(G, false);
for (int i = 0; i < sz; i++)
F[i] = mul(F[i], G[i]);
DiscreteFourierTransform(F, true);
F.resize(A.size() + B.size() - 1);
return (F);
}
};
struct P {
int x;
vector<int> v;
bool operator>(const P &rhs) const { return x > rhs.x; }
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> cnt(101010);
rep(i, 2 * n) {
int x;
cin >> x;
cnt[x]++;
}
mod_build();
priority_queue<P, vector<P>, greater<P>> pq;
rep(i, 101010) {
int m = cnt[i];
if (m < 2)
continue;
vector<int> a(m / 2 + 1);
ll ret = 1;
rep(j, m / 2 + 1) {
a[j] = ret;
ret *= comb(m - 2 * j, 2);
ret %= mod;
ret *= inv[j + 1];
ret %= mod;
}
pq.push({m, a});
}
pq.push({0, {1}});
auto ntt = NumberTheoreticTransform(mod, 3);
while (pq.size() > 1) {
auto p1 = pq.top();
pq.pop();
auto p2 = pq.top();
pq.pop();
auto res = ntt.Multiply(p1.v, p2.v);
pq.push({(int)res.size(), res});
}
auto ret = pq.top().v;
ll ans = 0;
rep(i, ret.size()) {
int sz = 2 * n - 2 * i;
ll cnt =
fact[sz] * invfact[sz / 2] % mod * powmod(2, mod - 1 - sz / 2) % mod;
if (i % 2)
ans += mod - ret[i] * cnt % mod;
else
ans += ret[i] * cnt % mod;
}
cout << ans % mod << endl;
return 0;
} | insert | 175 | 175 | 175 | 176 | 0 | |
p02540 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vi;
typedef vector<pll> vpll;
const ll infl = 0x3f3f3f3f3f3f3f3fLL;
const int infi = 0x3f3f3f3f;
#define endl '\n'
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define rs(v, n) v.resize(n)
#define hell 1000000007
// #define hell 998244353
#define peak 9e18
#define pii acos(-1)
#define clr(a, x) memset(a, x, sizeof(a))
auto clk = clock();
mt19937_64
rang(chrono::high_resolution_clock::now().time_since_epoch().count());
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
namespace Ops {
template <class y, class z> z expo(ll b, y e, z m) {
ll a = 1;
b %= m;
while (e != 0) {
if ((e & 1) == 1) {
a = a * b;
a = a % m;
}
b = b * b;
b %= m;
e >>= 1;
}
return a % m;
}
template <class y, class z> z power(ll b, y e) {
ll a = 1;
while (e != 0) {
if ((e & 1) == 1) {
a = a * b;
}
b = b * b;
e >>= 1;
}
return a;
}
template <class x, class z> z inv(x b, z m) { return expo(b, m - 2, m); }
template <class x, class y> x invGeneral(x a, y b) {
if (a == 0)
return b == 1 ? 0 : -1;
x m = invGeneral(b % a, a);
return m == -1 ? -1 : ((1 - (ll)b * m) / a + b) % b;
}
template <class x, class y> x min(x a, y b) {
x c;
if (a <= b)
c = a;
else
c = b;
return c;
}
template <class x, class y> x max(x a, y b) {
x c;
if (a >= b)
c = a;
else
c = b;
return c;
}
} // namespace Ops
using namespace Ops;
namespace InOp {
template <class x> istream &operator>>(istream &in, vector<x> &v) {
for (auto &i : v)
in >> i;
return in;
}
template <class x, class y> ostream &operator<<(ostream &out, pair<x, y> &p) {
out << "(" << p.F << "," << p.S << ")";
return out;
}
template <class x> ostream &operator<<(ostream &out, vector<x> &v) {
out << "Size : " << v.size() << endl;
for (auto i : v)
out << i << " ";
out << endl;
return out;
}
} // namespace InOp
using namespace InOp;
namespace Debug {
#define LOCAL
#ifdef LOCAL
#define deb(...) printall(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void printall(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void printall(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
printall(comma + 1, args...);
}
#else
#define deb(...) void(0)
#endif
} // namespace Debug
using namespace Debug;
namespace Bits {
template <class x> constexpr int onbits(x a) { return __builtin_popcount(a); }
constexpr int bits(long long x) {
return 64 - __builtin_clzll(x);
} // take care of 0
constexpr int bits(int x) { return 32 - __builtin_clz(x); } // take care of 0
constexpr int traz(int a) { return __builtin_ctz(a); }
constexpr int traz(long long a) { return __builtin_ctzll(a); }
} // namespace Bits
using namespace Bits;
namespace YesNo {
// #define CAPITAL
void yes() {
#ifdef CAPITAL
cout << "YES"
<< "\n";
#else
cout << "Yes"
<< "\n";
#endif
}
void no() {
#ifdef CAPITAL
cout << "NO"
<< "\n";
#else
cout << "No"
<< "\n";
#endif
}
} // namespace YesNo
using namespace YesNo;
void maester();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout << fixed << setprecision(6);
ll test = 1;
// cin>>test;
while (test--) {
maester();
}
#ifndef ONLINE_JUDGE
cout << endl
<< endl
<< endl
<< endl
<< "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
#define N 25
vi pa(N), sz(N);
ll findpa(ll x) {
ll y = pa[x];
if (y == x)
return y;
pa[x] = findpa(y);
return pa[x];
}
void connect(ll x, ll y) {
// deb(x,y);
ll px = findpa(x);
ll py = findpa(y);
if (px < py)
swap(px, py);
pa[px] = py;
sz[py] += sz[px];
}
void maester() {
ll i, j, k, l, r, m, n, x, y;
cin >> n;
for (i = 0; i <= n; i++)
pa[i] = i, sz[i] = 1;
vector<pair<ll, pair<ll, ll>>> v;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.pb({x, {y, i}});
}
sort(all(v));
// deb(v);
vi vv(n);
for (i = 0; i < n; i++)
vv[i] = v[i].S.F;
set<ll> s;
for (i = 0; i < n; i++) {
vi vp;
for (auto j : s) {
if (j > vv[i])
break;
vp.pb(j);
connect(j, vv[i]);
}
for (auto j : vp)
s.erase(j);
x = findpa(vv[i]);
s.insert(x);
}
// deb(sz,pa);
vi ans(n);
for (i = 0; i < n; i++) {
ans[v[i].S.S] = sz[findpa(v[i].S.F)];
}
for (i = 0; i < n; i++)
cout << ans[i] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vi;
typedef vector<pll> vpll;
const ll infl = 0x3f3f3f3f3f3f3f3fLL;
const int infi = 0x3f3f3f3f;
#define endl '\n'
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define rs(v, n) v.resize(n)
#define hell 1000000007
// #define hell 998244353
#define peak 9e18
#define pii acos(-1)
#define clr(a, x) memset(a, x, sizeof(a))
auto clk = clock();
mt19937_64
rang(chrono::high_resolution_clock::now().time_since_epoch().count());
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
namespace Ops {
template <class y, class z> z expo(ll b, y e, z m) {
ll a = 1;
b %= m;
while (e != 0) {
if ((e & 1) == 1) {
a = a * b;
a = a % m;
}
b = b * b;
b %= m;
e >>= 1;
}
return a % m;
}
template <class y, class z> z power(ll b, y e) {
ll a = 1;
while (e != 0) {
if ((e & 1) == 1) {
a = a * b;
}
b = b * b;
e >>= 1;
}
return a;
}
template <class x, class z> z inv(x b, z m) { return expo(b, m - 2, m); }
template <class x, class y> x invGeneral(x a, y b) {
if (a == 0)
return b == 1 ? 0 : -1;
x m = invGeneral(b % a, a);
return m == -1 ? -1 : ((1 - (ll)b * m) / a + b) % b;
}
template <class x, class y> x min(x a, y b) {
x c;
if (a <= b)
c = a;
else
c = b;
return c;
}
template <class x, class y> x max(x a, y b) {
x c;
if (a >= b)
c = a;
else
c = b;
return c;
}
} // namespace Ops
using namespace Ops;
namespace InOp {
template <class x> istream &operator>>(istream &in, vector<x> &v) {
for (auto &i : v)
in >> i;
return in;
}
template <class x, class y> ostream &operator<<(ostream &out, pair<x, y> &p) {
out << "(" << p.F << "," << p.S << ")";
return out;
}
template <class x> ostream &operator<<(ostream &out, vector<x> &v) {
out << "Size : " << v.size() << endl;
for (auto i : v)
out << i << " ";
out << endl;
return out;
}
} // namespace InOp
using namespace InOp;
namespace Debug {
#define LOCAL
#ifdef LOCAL
#define deb(...) printall(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void printall(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void printall(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
printall(comma + 1, args...);
}
#else
#define deb(...) void(0)
#endif
} // namespace Debug
using namespace Debug;
namespace Bits {
template <class x> constexpr int onbits(x a) { return __builtin_popcount(a); }
constexpr int bits(long long x) {
return 64 - __builtin_clzll(x);
} // take care of 0
constexpr int bits(int x) { return 32 - __builtin_clz(x); } // take care of 0
constexpr int traz(int a) { return __builtin_ctz(a); }
constexpr int traz(long long a) { return __builtin_ctzll(a); }
} // namespace Bits
using namespace Bits;
namespace YesNo {
// #define CAPITAL
void yes() {
#ifdef CAPITAL
cout << "YES"
<< "\n";
#else
cout << "Yes"
<< "\n";
#endif
}
void no() {
#ifdef CAPITAL
cout << "NO"
<< "\n";
#else
cout << "No"
<< "\n";
#endif
}
} // namespace YesNo
using namespace YesNo;
void maester();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout << fixed << setprecision(6);
ll test = 1;
// cin>>test;
while (test--) {
maester();
}
#ifndef ONLINE_JUDGE
cout << endl
<< endl
<< endl
<< endl
<< "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
#define N 200005
vi pa(N), sz(N);
ll findpa(ll x) {
ll y = pa[x];
if (y == x)
return y;
pa[x] = findpa(y);
return pa[x];
}
void connect(ll x, ll y) {
// deb(x,y);
ll px = findpa(x);
ll py = findpa(y);
if (px < py)
swap(px, py);
pa[px] = py;
sz[py] += sz[px];
}
void maester() {
ll i, j, k, l, r, m, n, x, y;
cin >> n;
for (i = 0; i <= n; i++)
pa[i] = i, sz[i] = 1;
vector<pair<ll, pair<ll, ll>>> v;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.pb({x, {y, i}});
}
sort(all(v));
// deb(v);
vi vv(n);
for (i = 0; i < n; i++)
vv[i] = v[i].S.F;
set<ll> s;
for (i = 0; i < n; i++) {
vi vp;
for (auto j : s) {
if (j > vv[i])
break;
vp.pb(j);
connect(j, vv[i]);
}
for (auto j : vp)
s.erase(j);
x = findpa(vv[i]);
s.insert(x);
}
// deb(sz,pa);
vi ans(n);
for (i = 0; i < n; i++) {
ans[v[i].S.S] = sz[findpa(v[i].S.F)];
}
for (i = 0; i < n; i++)
cout << ans[i] << endl;
} | replace | 178 | 179 | 178 | 179 | 0 | |
p02540 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
// Verified: AOJ-DSL1A, AGC002D
class UFSet {
private:
vector<int> ranks;
vector<int> prevs;
vector<int> sizes;
public:
UFSet(int n) : ranks(n), prevs(n), sizes(n) {
for (int i = 0; i < n; i++)
prevs[i] = i;
for (int i = 0; i < n; i++)
sizes[i] = 1;
}
// Returns an ID of a set which x belongs to.
int Find(int x) {
if (x != prevs[x])
prevs[x] = Find(prevs[x]);
return prevs[x];
}
// Merges a set which x blongs to and a set which y belongs to.
void Union(int x, int y) {
int x_root = Find(x);
int y_root = Find(y);
if (ranks[x_root] > ranks[y_root]) {
prevs[y_root] = prevs[x_root];
sizes[x_root] += sizes[y_root];
} else if (ranks[x_root] < ranks[y_root]) {
prevs[x_root] = prevs[y_root];
sizes[y_root] += sizes[x_root];
} else if (prevs[x_root] != prevs[y_root]) {
prevs[y_root] = prevs[x_root];
ranks[x_root]++;
sizes[x_root] += sizes[y_root];
}
}
// Returns a size of a set which x belongs to.
int Size(int x) { return sizes[Find(x)]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<tuple<int, int>> ps(n);
vector<int> original_xs(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
ps[i] = {x, y};
original_xs[i] = x;
}
sort(ps.begin(), ps.end(),
[](const auto &p1, const auto &p2) { return get<1>(p1) > get<1>(p2); });
UFSet uf_set(n);
set<int> s;
for (const auto [x, y] : ps) {
if (s.empty()) {
s.insert(x);
} else if (*s.rbegin() < x) {
s.insert(x);
} else {
vector<int> remove_vector;
for (auto it = s.rbegin(); it != s.rend(); it++) {
if (*it > x) {
if (it != s.rbegin())
remove_vector.push_back(*it);
}
}
for (int rx : remove_vector) {
// cout << rx << " " << *s.rbegin() << endl;
uf_set.Union(rx, *s.rbegin());
s.erase(rx);
}
uf_set.Union(x, *s.rbegin());
}
// DUMP
// for (int sx : s) {
// cout << sx << " ";
// }
// cout << endl;
}
for (int i = 0; i < n; i++) {
cout << uf_set.Size(original_xs[i]) << "\n";
}
} | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
// Verified: AOJ-DSL1A, AGC002D
class UFSet {
private:
vector<int> ranks;
vector<int> prevs;
vector<int> sizes;
public:
UFSet(int n) : ranks(n), prevs(n), sizes(n) {
for (int i = 0; i < n; i++)
prevs[i] = i;
for (int i = 0; i < n; i++)
sizes[i] = 1;
}
// Returns an ID of a set which x belongs to.
int Find(int x) {
if (x != prevs[x])
prevs[x] = Find(prevs[x]);
return prevs[x];
}
// Merges a set which x blongs to and a set which y belongs to.
void Union(int x, int y) {
int x_root = Find(x);
int y_root = Find(y);
if (ranks[x_root] > ranks[y_root]) {
prevs[y_root] = prevs[x_root];
sizes[x_root] += sizes[y_root];
} else if (ranks[x_root] < ranks[y_root]) {
prevs[x_root] = prevs[y_root];
sizes[y_root] += sizes[x_root];
} else if (prevs[x_root] != prevs[y_root]) {
prevs[y_root] = prevs[x_root];
ranks[x_root]++;
sizes[x_root] += sizes[y_root];
}
}
// Returns a size of a set which x belongs to.
int Size(int x) { return sizes[Find(x)]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<tuple<int, int>> ps(n);
vector<int> original_xs(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
ps[i] = {x, y};
original_xs[i] = x;
}
sort(ps.begin(), ps.end(),
[](const auto &p1, const auto &p2) { return get<1>(p1) > get<1>(p2); });
UFSet uf_set(n);
set<int> s;
for (const auto [x, y] : ps) {
if (s.empty()) {
s.insert(x);
} else if (*s.rbegin() < x) {
s.insert(x);
} else {
vector<int> remove_vector;
for (auto it = s.rbegin(); it != s.rend(); it++) {
if (*it > x) {
if (it != s.rbegin())
remove_vector.push_back(*it);
} else {
break;
}
}
for (int rx : remove_vector) {
// cout << rx << " " << *s.rbegin() << endl;
uf_set.Union(rx, *s.rbegin());
s.erase(rx);
}
uf_set.Union(x, *s.rbegin());
}
// DUMP
// for (int sx : s) {
// cout << sx << " ";
// }
// cout << endl;
}
for (int i = 0; i < n; i++) {
cout << uf_set.Size(original_xs[i]) << "\n";
}
} | insert | 83 | 83 | 83 | 85 | TLE | |
p02540 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
typedef long long lint;
using namespace std;
int n;
vector<pair<pair<int, int>, int>> xy;
// 素集合データ構造
// ref:https://ei1333.github.io/luzhiled/snippets/structure/union-find.html
struct union_find {
// parent[v]==w(>=0):vの親はw
// parent[v]==k(<0):vは根&&vの属するグループの要素数は-k
vector<long long int> parent;
// コンストラクタ
union_find(long long int n) { parent.assign(n, -1); }
// vの根を求める
// 求めると同時に親を根に置き換える(木の圧縮)
long long int root(long long int v) {
if (parent[v] < 0) {
return v;
} else {
parent[v] = root(parent[v]);
return parent[v];
}
}
// vが属するグループの要素数を求める
long long int size(long long int v) { return -parent[root(v)]; }
// vとwを繋げる
void unite(long long int v, long long int w) {
v = root(v);
w = root(w);
if (v == w)
return;
if (parent[v] < parent[w])
swap(v, w);
parent[w] += parent[v];
parent[v] = w;
}
// vとwが同値か判定
bool isSame(long long int v, long long int w) { return root(v) == root(w); }
};
int main() {
cin >> n;
xy.resize(n);
for (int i = 0; i < n; i++) {
cin >> xy[i].first.first >> xy[i].first.second;
xy[i].second = i;
}
sort(xy.begin(), xy.end());
union_find uf(n);
// first:y,second:index
set<pair<int, int>> st;
for (int i = 0; i < n; i++) {
vector<pair<int, int>> connected;
for (auto e : st) {
if (e.first < xy[i].first.second) {
uf.unite(e.second, i);
connected.push_back(e);
}
}
if (connected.empty()) {
st.insert({xy[i].first.second, i});
} else {
pair<int, int> repr = {INT_MAX, -1};
for (auto g : connected) {
if (repr.first > g.first) {
repr = g;
}
}
for (auto g : connected) {
if (g != repr) {
st.erase(g);
}
}
}
}
vector<int> ans(n);
for (int i = 0; i < n; i++) {
ans[xy[i].second] = uf.size(i);
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
} | #include <bits/stdc++.h>
typedef long long lint;
using namespace std;
int n;
vector<pair<pair<int, int>, int>> xy;
// 素集合データ構造
// ref:https://ei1333.github.io/luzhiled/snippets/structure/union-find.html
struct union_find {
// parent[v]==w(>=0):vの親はw
// parent[v]==k(<0):vは根&&vの属するグループの要素数は-k
vector<long long int> parent;
// コンストラクタ
union_find(long long int n) { parent.assign(n, -1); }
// vの根を求める
// 求めると同時に親を根に置き換える(木の圧縮)
long long int root(long long int v) {
if (parent[v] < 0) {
return v;
} else {
parent[v] = root(parent[v]);
return parent[v];
}
}
// vが属するグループの要素数を求める
long long int size(long long int v) { return -parent[root(v)]; }
// vとwを繋げる
void unite(long long int v, long long int w) {
v = root(v);
w = root(w);
if (v == w)
return;
if (parent[v] < parent[w])
swap(v, w);
parent[w] += parent[v];
parent[v] = w;
}
// vとwが同値か判定
bool isSame(long long int v, long long int w) { return root(v) == root(w); }
};
int main() {
cin >> n;
xy.resize(n);
for (int i = 0; i < n; i++) {
cin >> xy[i].first.first >> xy[i].first.second;
xy[i].second = i;
}
sort(xy.begin(), xy.end());
union_find uf(n);
// first:y,second:index
set<pair<int, int>> st;
for (int i = 0; i < n; i++) {
vector<pair<int, int>> connected;
for (auto e : st) {
if (e.first < xy[i].first.second) {
uf.unite(e.second, i);
connected.push_back(e);
} else {
break;
}
}
if (connected.empty()) {
st.insert({xy[i].first.second, i});
} else {
pair<int, int> repr = {INT_MAX, -1};
for (auto g : connected) {
if (repr.first > g.first) {
repr = g;
}
}
for (auto g : connected) {
if (g != repr) {
st.erase(g);
}
}
}
}
vector<int> ans(n);
for (int i = 0; i < n; i++) {
ans[xy[i].second] = uf.size(i);
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
} | insert | 59 | 59 | 59 | 61 | TLE | |
p02540 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef long long ll;
template <typename _T> inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T> void print(T x) {
if (x < 0)
putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T> void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 1e5 + 5;
int a[N], b[N], ida[N], idb[N], vis[N], ans[N];
int n, cnt;
bool cmpa(int x, int y) { return a[x] < a[y]; }
bool cmpb(int x, int y) { return b[x] < b[y]; }
int main() {
read(n);
for (int i = 1; i <= n; i++)
read(a[i]), read(b[i]), ida[i] = idb[i] = i;
sort(ida + 1, ida + n + 1, cmpa);
sort(idb + 1, idb + n + 1, cmpb);
int las = 0;
for (int i = 1; i <= n; i++) {
if (!vis[ida[i]])
vis[ida[i]] = 1, ++cnt;
if (!vis[idb[n - i + 1]])
vis[idb[n - i + 1]] = 1, ++cnt;
if (cnt == i) {
for (int j = las + 1; j <= i; j++)
ans[ida[j]] = i - las;
las = i;
}
}
for (int i = 1; i <= n; i++)
print(ans[i], '\n');
return 0;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef long long ll;
template <typename _T> inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T> void print(T x) {
if (x < 0)
putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T> void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 2e5 + 5;
int a[N], b[N], ida[N], idb[N], vis[N], ans[N];
int n, cnt;
bool cmpa(int x, int y) { return a[x] < a[y]; }
bool cmpb(int x, int y) { return b[x] < b[y]; }
int main() {
read(n);
for (int i = 1; i <= n; i++)
read(a[i]), read(b[i]), ida[i] = idb[i] = i;
sort(ida + 1, ida + n + 1, cmpa);
sort(idb + 1, idb + n + 1, cmpb);
int las = 0;
for (int i = 1; i <= n; i++) {
if (!vis[ida[i]])
vis[ida[i]] = 1, ++cnt;
if (!vis[idb[n - i + 1]])
vis[idb[n - i + 1]] = 1, ++cnt;
if (cnt == i) {
for (int j = las + 1; j <= i; j++)
ans[ida[j]] = i - las;
las = i;
}
}
for (int i = 1; i <= n; i++)
print(ans[i], '\n');
return 0;
} | replace | 40 | 41 | 40 | 41 | 0 | |
p02540 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const ll dx[9] = {0, -1, 0, 1, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> class SegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
T find(int a, int b) {
T val_left = def, val_right = def;
for (a += (n - 1), b += (n - 1); a < b; a >>= 1, b >>= 1) {
if ((a & 1) == 0) {
val_left = operation(val_left, data[a]);
}
if ((b & 1) == 0) {
val_right = operation(data[--b], val_right);
}
}
return operation(val_left, val_right);
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
SegTree(
size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update = [](T a, T b) { return b; })
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void set(int i, T x) { data[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--)
data[k] = operation(data[2 * k + 1], data[2 * k + 2]);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) {
// return _query(a, b, 0, 0, n);
return find(a, b);
}
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int main() {
ll n;
cin >> n;
vpl z(n);
vl ex(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
a--;
b--;
z[i] = {a, b};
ex[i] = a;
}
sort(all(z));
UnionFind uf(n);
set<pl> valid;
rep(i, n) {
set<pl> con;
for (auto p : valid) {
if (p.fi < z[i].se) {
uf.merge(p.se, i);
con.ins(p);
}
}
valid.ins({z[i].se, i});
con.ins({z[i].se, i});
con.erase(*con.begin());
for (auto p : con) {
valid.erase(p);
}
}
rep(i, n) { cout << uf.size(ex[i]) << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const ll dx[9] = {0, -1, 0, 1, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> class SegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
T find(int a, int b) {
T val_left = def, val_right = def;
for (a += (n - 1), b += (n - 1); a < b; a >>= 1, b >>= 1) {
if ((a & 1) == 0) {
val_left = operation(val_left, data[a]);
}
if ((b & 1) == 0) {
val_right = operation(data[--b], val_right);
}
}
return operation(val_left, val_right);
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
SegTree(
size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update = [](T a, T b) { return b; })
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void set(int i, T x) { data[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--)
data[k] = operation(data[2 * k + 1], data[2 * k + 2]);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) {
// return _query(a, b, 0, 0, n);
return find(a, b);
}
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int main() {
ll n;
cin >> n;
vpl z(n);
vl ex(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
a--;
b--;
z[i] = {a, b};
ex[i] = a;
}
sort(all(z));
UnionFind uf(n);
set<pl> valid;
rep(i, n) {
set<pl> con;
for (auto p : valid) {
if (p.fi < z[i].se) {
uf.merge(p.se, i);
con.ins(p);
} else
break;
}
valid.ins({z[i].se, i});
con.ins({z[i].se, i});
con.erase(*con.begin());
for (auto p : con) {
valid.erase(p);
}
}
rep(i, n) { cout << uf.size(ex[i]) << endl; }
}
| replace | 150 | 151 | 150 | 152 | TLE | |
p02540 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int maxn = 15;
int n, a[maxn], x[maxn], y[maxn], mx[maxn], mn[maxn], p[maxn];
bool cmp(int b, int c) { return x[b] < x[c]; }
int f(int b) {
if (p[b] < 0)
return b;
return p[b] = f(p[b]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
a[i] = i;
}
sort(a + 1, a + n + 1, cmp);
stack<int> stk;
for (int i = 1; i <= n; i++) {
mn[a[i]] = y[a[i]];
mx[a[i]] = y[a[i]];
p[a[i]] = -1;
while (!stk.empty() && mx[a[i]] > mn[stk.top()]) {
mn[a[i]] = min(mn[a[i]], mn[stk.top()]);
mx[a[i]] = max(mx[a[i]], mx[stk.top()]);
p[a[i]] += p[stk.top()];
p[stk.top()] = a[i];
stk.pop();
}
stk.push(a[i]);
}
for (int i = 1; i <= n; i++) {
cout << -p[f(i)] << "\n";
}
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int maxn = 200005;
int n, a[maxn], x[maxn], y[maxn], mx[maxn], mn[maxn], p[maxn];
bool cmp(int b, int c) { return x[b] < x[c]; }
int f(int b) {
if (p[b] < 0)
return b;
return p[b] = f(p[b]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
a[i] = i;
}
sort(a + 1, a + n + 1, cmp);
stack<int> stk;
for (int i = 1; i <= n; i++) {
mn[a[i]] = y[a[i]];
mx[a[i]] = y[a[i]];
p[a[i]] = -1;
while (!stk.empty() && mx[a[i]] > mn[stk.top()]) {
mn[a[i]] = min(mn[a[i]], mn[stk.top()]);
mx[a[i]] = max(mx[a[i]], mx[stk.top()]);
p[a[i]] += p[stk.top()];
p[stk.top()] = a[i];
stk.pop();
}
stk.push(a[i]);
}
for (int i = 1; i <= n; i++) {
cout << -p[f(i)] << "\n";
}
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02540 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef long long ll;
#include <cstring>
int n, m;
struct unionfind {
int parent;
int node;
int edge;
};
unionfind g[100001];
void init() {
for (int i = 0; i <= n; i++) {
g[i].parent = i;
g[i].node = 1;
g[i].edge = 0;
}
}
int ufind(int x) {
if (x == g[x].parent) {
return x;
}
int res = ufind(g[x].parent);
g[x].node = g[res].node;
g[x].edge = g[res].edge;
g[x].parent = res;
return res;
}
void umerge(int x, int y) {
g[x].node += g[y].node;
g[x].edge += g[y].edge + 1;
g[y].parent = x;
}
int main() {
int x, y, flag;
cin >> n;
vector<int> ans(n + 1), dp(n + 5);
set<pair<int, int>> s;
vector<pair<pair<int, int>, int>> v;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({{x, y}, i});
}
sort(v.begin(), v.end());
init();
s.insert({v[0].first.second, v[0].second});
for (int i = 1; i < n; i++) {
y = min(v[i].first.second, s.begin()->first);
while (!s.empty() && s.begin()->first < v[i].first.second) {
umerge(v[i].second, s.begin()->second);
s.erase(s.begin());
}
s.insert({y, v[i].second});
}
for (int i = 0; i < n; i++) {
x = ufind(i);
cout << g[x].node << endl;
}
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef long long ll;
#include <cstring>
int n, m;
struct unionfind {
int parent;
int node;
int edge;
};
unionfind g[200001];
void init() {
for (int i = 0; i <= n; i++) {
g[i].parent = i;
g[i].node = 1;
g[i].edge = 0;
}
}
int ufind(int x) {
if (x == g[x].parent) {
return x;
}
int res = ufind(g[x].parent);
g[x].node = g[res].node;
g[x].edge = g[res].edge;
g[x].parent = res;
return res;
}
void umerge(int x, int y) {
g[x].node += g[y].node;
g[x].edge += g[y].edge + 1;
g[y].parent = x;
}
int main() {
int x, y, flag;
cin >> n;
vector<int> ans(n + 1), dp(n + 5);
set<pair<int, int>> s;
vector<pair<pair<int, int>, int>> v;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({{x, y}, i});
}
sort(v.begin(), v.end());
init();
s.insert({v[0].first.second, v[0].second});
for (int i = 1; i < n; i++) {
y = min(v[i].first.second, s.begin()->first);
while (!s.empty() && s.begin()->first < v[i].first.second) {
umerge(v[i].second, s.begin()->second);
s.erase(s.begin());
}
s.insert({y, v[i].second});
}
for (int i = 0; i < n; i++) {
x = ufind(i);
cout << g[x].node << endl;
}
} | replace | 22 | 23 | 22 | 23 | 0 | |
p02540 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <algorithm>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
using namespace std;
typedef long long li;
li li_min(li x, li y) { return min(x, y); }
li li_min_e() { return 1LL << 60; }
li li_max(li x, li y) { return max(x, y); }
li li_max_e() { return -li_min_e(); }
using min_segtree = atcoder::segtree<li, li_min, li_min_e>;
using max_segtree = atcoder::segtree<li, li_max, li_max_e>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
li n;
cin >> n;
min_segtree ys(n);
max_segtree xs(n);
set<pair<li, li>> xis;
set<pair<li, li>> yis;
vector<li> ans(n), ixs, iys;
for (int i = 0; i < n; ++i) {
li x, y;
cin >> x >> y;
x--;
y--;
xis.emplace(x, i);
yis.emplace(y, i);
xs.set(y, x);
ys.set(x, y);
ixs.push_back(x);
iys.push_back(y);
}
while (not xis.empty()) {
const li leftmost_x = xis.begin()->first;
li cur_y = ys.get(leftmost_x);
li cur_x = leftmost_x;
while (true) {
li next_x = xs.prod(cur_y + 1, n);
if (next_x <= cur_x) {
break;
}
cur_x = next_x;
li next_y = ys.prod(0, cur_x);
if (next_y >= cur_y) {
break;
}
cur_y = next_y;
}
set<li> uni;
for (auto p : xis) {
const li x = p.first;
if (x <= cur_x) {
uni.emplace(p.second);
} else {
break;
}
}
for (auto p : yis) {
const li y = p.first;
if (y >= cur_y) {
uni.emplace(p.second);
}
}
for (auto i : uni) {
const li x = ixs[i];
const li y = iys[i];
ans[i] = uni.size();
xis.erase(make_pair(x, i));
yis.erase(make_pair(y, i));
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| #include "bits/stdc++.h"
#include <algorithm>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
using namespace std;
typedef long long li;
li li_min(li x, li y) { return min(x, y); }
li li_min_e() { return 1LL << 60; }
li li_max(li x, li y) { return max(x, y); }
li li_max_e() { return -li_min_e(); }
using min_segtree = atcoder::segtree<li, li_min, li_min_e>;
using max_segtree = atcoder::segtree<li, li_max, li_max_e>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
li n;
cin >> n;
min_segtree ys(n);
max_segtree xs(n);
set<pair<li, li>> xis;
set<pair<li, li>> yis;
vector<li> ans(n), ixs, iys;
for (int i = 0; i < n; ++i) {
li x, y;
cin >> x >> y;
x--;
y--;
xis.emplace(x, i);
yis.emplace(y, i);
xs.set(y, x);
ys.set(x, y);
ixs.push_back(x);
iys.push_back(y);
}
while (not xis.empty()) {
const li leftmost_x = xis.begin()->first;
li cur_y = ys.get(leftmost_x);
li cur_x = leftmost_x;
while (true) {
li next_x = xs.prod(cur_y + 1, n);
if (next_x <= cur_x) {
break;
}
cur_x = next_x;
li next_y = ys.prod(0, cur_x);
if (next_y >= cur_y) {
break;
}
cur_y = next_y;
}
set<li> uni;
for (auto p : xis) {
const li x = p.first;
if (x <= cur_x) {
uni.emplace(p.second);
} else {
break;
}
}
for (auto p : yis) {
const li y = p.first;
if (y >= cur_y) {
uni.emplace(p.second);
} else {
break;
}
}
for (auto i : uni) {
const li x = ixs[i];
const li y = iys[i];
ans[i] = uni.size();
xis.erase(make_pair(x, i));
yis.erase(make_pair(y, i));
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| insert | 226 | 226 | 226 | 228 | TLE | |
p02540 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
// using namespace atcoder;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (int)(n)-1; i >= (a); --i)
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl;
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
REP(i, SZ(v)) {
if (i)
os << ", ";
os << v[i];
}
return os << "]";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << " " << p.second << ")";
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
const ll MOD = 1e9 + 7;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
const ld eps = 1e-9;
// edit
struct UnionFind {
vector<int> par, sz;
UnionFind(int n) : par(n), sz(n, 1) {
for (int i = 0; i < n; ++i)
par[i] = i;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (sz[x] < sz[y])
swap(x, y);
par[y] = x;
sz[x] += sz[y];
sz[y] = 0;
}
bool issame(int x, int y) { return root(x) == root(y); }
int size(int x) { return sz[root(x)]; }
};
void solve() {
int N;
cin >> N;
vector<pair<int, int>> xy(N);
vector<pair<int, int>> xi(N);
REP(i, N) {
cin >> xy[i].first >> xy[i].second;
xy[i].first--;
xy[i].second--;
xi[i] = {xy[i].first, i};
}
sort(ALL(xy));
vector<int> gmin(N), gmax(N);
for (int i = 0; i < N; ++i) {
gmin[i] = xy[i].second;
gmax[i] = xy[i].second;
}
UnionFind uf(N);
while (true) {
bool merge = false;
for (int i = 0; i + 1 < N; ++i) {
if (uf.issame(i, i + 1)) {
continue;
}
if (gmin[uf.root(i)] < gmax[uf.root(i + 1)]) {
gmin[uf.root(i)] = min(gmin[uf.root(i)], gmin[uf.root(i + 1)]);
gmax[uf.root(i)] = max(gmax[uf.root(i)], gmax[uf.root(i + 1)]);
gmin[uf.root(i + 1)] = gmin[uf.root(i)];
gmax[uf.root(i + 1)] = gmax[uf.root(i)];
// cerr << "merge " << uf.root(i) << " " << uf.root(i +
// 1) << endl;
uf.merge(i, i + 1);
merge = true;
}
}
if (!merge)
break;
}
for (int i = 0; i < N; ++i) {
cout << uf.size(xi[i].first) << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
// using namespace atcoder;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define RFOR(i, a, n) for (int i = (int)(n)-1; i >= (a); --i)
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl;
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
REP(i, SZ(v)) {
if (i)
os << ", ";
os << v[i];
}
return os << "]";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << " " << p.second << ")";
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
const ll MOD = 1e9 + 7;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
const ld eps = 1e-9;
// edit
struct UnionFind {
vector<int> par, sz;
UnionFind(int n) : par(n), sz(n, 1) {
for (int i = 0; i < n; ++i)
par[i] = i;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (sz[x] < sz[y])
swap(x, y);
par[y] = x;
sz[x] += sz[y];
sz[y] = 0;
}
bool issame(int x, int y) { return root(x) == root(y); }
int size(int x) { return sz[root(x)]; }
};
void solve() {
int N;
cin >> N;
vector<pair<int, int>> xy(N);
vector<pair<int, int>> xi(N);
REP(i, N) {
cin >> xy[i].first >> xy[i].second;
xy[i].first--;
xy[i].second--;
xi[i] = {xy[i].first, i};
}
sort(ALL(xy));
vector<int> gmin(N), gmax(N);
for (int i = 0; i < N; ++i) {
gmin[i] = xy[i].second;
gmax[i] = xy[i].second;
}
UnionFind uf(N);
while (true) {
bool merge = false;
for (int i = 0; i + 1 < N; ++i) {
if (uf.issame(i, i + 1)) {
continue;
}
if (gmin[uf.root(i)] < gmax[uf.root(i + 1)]) {
gmin[uf.root(i)] = min(gmin[uf.root(i)], gmin[uf.root(i + 1)]);
gmax[uf.root(i)] = max(gmax[uf.root(i)], gmax[uf.root(i + 1)]);
gmin[uf.root(i + 1)] = gmin[uf.root(i)];
gmax[uf.root(i + 1)] = gmax[uf.root(i)];
// cerr << "merge " << uf.root(i) << " " << uf.root(i +
// 1) << endl;
uf.merge(i, i + 1);
merge = true;
}
}
for (int i = N - 2; i >= 0; --i) {
if (uf.issame(i, i + 1)) {
continue;
}
if (gmin[uf.root(i)] < gmax[uf.root(i + 1)]) {
gmin[uf.root(i)] = min(gmin[uf.root(i)], gmin[uf.root(i + 1)]);
gmax[uf.root(i)] = max(gmax[uf.root(i)], gmax[uf.root(i + 1)]);
gmin[uf.root(i + 1)] = gmin[uf.root(i)];
gmax[uf.root(i + 1)] = gmax[uf.root(i)];
// cerr << "merge " << uf.root(i) << " " << uf.root(i +
// 1) << endl;
uf.merge(i, i + 1);
merge = true;
}
}
if (!merge)
break;
}
for (int i = 0; i < N; ++i) {
cout << uf.size(xi[i].first) << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
solve();
return 0;
}
| insert | 169 | 169 | 169 | 187 | TLE | |
p02541 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; ++i)
long long extend_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
long long d = extend_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
}
int main() {
long long n;
scanf("%lld", &n);
vector<long long> primes;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
long long tmp = 1;
while (n % i == 0) {
tmp *= i;
n /= i;
}
primes.push_back(tmp);
}
}
if (n != 1) {
primes.push_back(n);
}
if (primes[0] % 2 == 0) {
primes[0] *= 2;
} else {
primes.push_back(2);
}
long long ans = 1e16;
for (long long i = 0; i < (1 << primes.size()); ++i) {
long long a = 1;
long long b = 1;
for (int j = 0; j < primes.size(); ++j) {
if (i & (1 << j)) {
a *= primes[j];
} else {
b *= primes[j];
}
}
if (a == 1 or b == 1) {
continue;
}
long long x = 1;
long long y = 1;
extend_gcd(a, b, x, y);
long long k = min(a * abs(x), b * abs(y));
if (k == 0) {
continue;
}
ans = min(ans, k);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; ++i)
long long extend_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
long long d = extend_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
}
int main() {
long long n;
scanf("%lld", &n);
if (n == 1 << 0 or n == 1 << 1 or n == 1 << 2 or n == 1 << 3 or n == 1 << 4 or
n == 1 << 5 or n == 1 << 6 or n == 1 << 7 or n == 1 << 8 or n == 1 << 9 or
n == 1 << 10 or n == 1 << 11 or n == 1 << 12 or n == 1 << 13 or
n == 1 << 14 or n == 1 << 15 or n == 1 << 16 or n == 1 << 17 or
n == 1 << 18 or n == 1 << 19 or n == 1 << 20 or n == 1 << 21 or
n == 1 << 22) {
cout << n * 2 - 1 << endl;
return 0;
}
vector<long long> primes;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
long long tmp = 1;
while (n % i == 0) {
tmp *= i;
n /= i;
}
primes.push_back(tmp);
}
}
if (n != 1) {
primes.push_back(n);
}
if (primes[0] % 2 == 0) {
primes[0] *= 2;
} else {
primes.push_back(2);
}
long long ans = 1e16;
for (long long i = 0; i < (1 << primes.size()); ++i) {
long long a = 1;
long long b = 1;
for (int j = 0; j < primes.size(); ++j) {
if (i & (1 << j)) {
a *= primes[j];
} else {
b *= primes[j];
}
}
if (a == 1 or b == 1) {
continue;
}
long long x = 1;
long long y = 1;
extend_gcd(a, b, x, y);
long long k = min(a * abs(x), b * abs(y));
if (k == 0) {
continue;
}
ans = min(ans, k);
}
cout << ans << endl;
return 0;
} | insert | 20 | 20 | 20 | 29 | 0 | |
p02541 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#ifdef DEBUG
#define PRINT(x) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #x << " = " \
<< (x) << endl;
#define PRINTA(a, first, last) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #a << "[" \
<< (first) << ", " << (last) << ")" << endl; \
for (int _i = (first); _i < (last); ++_i) { \
cout << #a << "[" << _i << "] = " << (a)[_i] << endl; \
}
#define PRINTI(a, i) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #a << "[" \
<< #i << "] = " << #a << "[" << (i) << "] = " << (a)[i] << endl;
#define dprintf(...) printf(__VA_ARGS__)
#else
#define PRINT(x)
#define PRINTA(a, first, last)
#define PRINTI(a, i)
#define dprintf(...)
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MOD 1000000007
// #define MOD 998244353
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
template <class T, class U> void amax(T &x, U y) {
if (x < y)
x = y;
}
template <class T, class U> void amin(T &x, U y) {
if (x > y)
x = y;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
if (i) {
if (i % 5 == 0) {
os << ",\n ";
} else {
os << ", ";
}
}
os << v[i];
}
os << "]";
return os;
}
template <class T> using vec2 = vector<vector<T>>;
template <class T> using vec3 = vector<vector<vector<T>>>;
template <class T> vec2<T> vec2_init(int n0, int n1, T x = 0) {
return vec2<T>(n0, vector<T>(n1, x));
}
template <class T> vec3<T> vec3_init(int n0, int n1, int n2, T x = 0) {
return vec3<T>(n0, vec2_init(n1, n2, x));
}
/*
* U P
* - x
* ^
* |
* LEFT -y <--+--> +y RIGHT
* |
* v
* + x
* D O W N
*/
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
enum {
DOWN,
RIGHT,
UP,
LEFT,
};
constexpr double inf = numeric_limits<double>::infinity();
template <class SignedInteger>
unsigned long long gcd_extended(unsigned long long a, unsigned long long b,
SignedInteger &x, SignedInteger &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
SignedInteger x0, y0;
unsigned long long d = gcd_extended(b, a % b, x0, y0);
x = y0;
y = x0 - a / b * y0;
return d;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll N2 = N * 2;
ll result = 2 * N;
vector<ll> factors;
FOR(D, 2, N2 + 1) {
if (D * D > N2) {
break;
}
ll pe = 1;
while (N2 % D == 0) {
N2 /= D;
pe *= D;
}
if (pe > 1) {
factors.push_back(pe);
}
}
if (N2 > 1) {
factors.push_back(N2);
}
int L = factors.size();
REP(bit, 1 << L) {
ll D = 1;
ll D_ = 1;
REP(i, L) {
if ((bit >> i) & 1) {
D *= factors[i];
} else {
D_ *= factors[i];
}
}
PRINT(D);
PRINT(D_);
ll mQ, R;
ll gcd = gcd_extended(D, D_, mQ, R);
if (gcd != 1) {
continue;
}
if (mQ >= 0) {
mQ %= D_;
while (mQ >= 0) {
mQ -= D_;
}
}
ll Q = -mQ;
ll k = D * Q;
amin(result, k);
}
cout << result << endl;
/*
FOR(D, 1, N2 + 1) {
if (N2 % D != 0) {
continue;
}
PRINT("");
function<void(ll, ll)> f = [&](ll d, ll d_) {
ll mQ, R;
ll gcd = gcd_extended(d, d_, mQ, R);
if (gcd != 1) {
return;
}
if (mQ >= 0) {
mQ %= d_;
while (mQ >= 0) {
mQ -= d_;
}
}
ll Q = -mQ;
ll k = d * Q;
amin(result, k);
};
ll D_ = N2 / D;
f(D, D_);
f(D_, D);
}
*/
return 0;
}
| #include <bits/stdc++.h>
#ifdef DEBUG
#define PRINT(x) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #x << " = " \
<< (x) << endl;
#define PRINTA(a, first, last) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #a << "[" \
<< (first) << ", " << (last) << ")" << endl; \
for (int _i = (first); _i < (last); ++_i) { \
cout << #a << "[" << _i << "] = " << (a)[_i] << endl; \
}
#define PRINTI(a, i) \
cout << "func " << __func__ << ": line " << __LINE__ << ": " << #a << "[" \
<< #i << "] = " << #a << "[" << (i) << "] = " << (a)[i] << endl;
#define dprintf(...) printf(__VA_ARGS__)
#else
#define PRINT(x)
#define PRINTA(a, first, last)
#define PRINTI(a, i)
#define dprintf(...)
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MOD 1000000007
// #define MOD 998244353
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
template <class T, class U> void amax(T &x, U y) {
if (x < y)
x = y;
}
template <class T, class U> void amin(T &x, U y) {
if (x > y)
x = y;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
if (i) {
if (i % 5 == 0) {
os << ",\n ";
} else {
os << ", ";
}
}
os << v[i];
}
os << "]";
return os;
}
template <class T> using vec2 = vector<vector<T>>;
template <class T> using vec3 = vector<vector<vector<T>>>;
template <class T> vec2<T> vec2_init(int n0, int n1, T x = 0) {
return vec2<T>(n0, vector<T>(n1, x));
}
template <class T> vec3<T> vec3_init(int n0, int n1, int n2, T x = 0) {
return vec3<T>(n0, vec2_init(n1, n2, x));
}
/*
* U P
* - x
* ^
* |
* LEFT -y <--+--> +y RIGHT
* |
* v
* + x
* D O W N
*/
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
enum {
DOWN,
RIGHT,
UP,
LEFT,
};
constexpr double inf = numeric_limits<double>::infinity();
template <class SignedInteger>
unsigned long long gcd_extended(unsigned long long a, unsigned long long b,
SignedInteger &x, SignedInteger &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
SignedInteger x0, y0;
unsigned long long d = gcd_extended(b, a % b, x0, y0);
x = y0;
y = x0 - a / b * y0;
return d;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll N2 = N * 2;
ll result = 2 * N;
vector<ll> factors;
ll sqrt2N = sqrt(N2) + 0.5;
FOR(D, 2, sqrt2N + 1) {
ll pe = 1;
while (N2 % D == 0) {
N2 /= D;
pe *= D;
}
if (pe > 1) {
factors.push_back(pe);
}
}
if (N2 > 1) {
factors.push_back(N2);
}
int L = factors.size();
REP(bit, 1 << L) {
ll D = 1;
ll D_ = 1;
REP(i, L) {
if ((bit >> i) & 1) {
D *= factors[i];
} else {
D_ *= factors[i];
}
}
PRINT(D);
PRINT(D_);
ll mQ, R;
ll gcd = gcd_extended(D, D_, mQ, R);
if (gcd != 1) {
continue;
}
if (mQ >= 0) {
mQ %= D_;
while (mQ >= 0) {
mQ -= D_;
}
}
ll Q = -mQ;
ll k = D * Q;
amin(result, k);
}
cout << result << endl;
/*
FOR(D, 1, N2 + 1) {
if (N2 % D != 0) {
continue;
}
PRINT("");
function<void(ll, ll)> f = [&](ll d, ll d_) {
ll mQ, R;
ll gcd = gcd_extended(d, d_, mQ, R);
if (gcd != 1) {
return;
}
if (mQ >= 0) {
mQ %= d_;
while (mQ >= 0) {
mQ -= d_;
}
}
ll Q = -mQ;
ll k = d * Q;
amin(result, k);
};
ll D_ = N2 / D;
f(D, D_);
f(D_, D);
}
*/
return 0;
}
| replace | 136 | 140 | 136 | 139 | TLE | |
p02541 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = INT_MAX;
vector<ll> prime_factorize(ll n) {
vector<ll> res;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.emplace_back(1);
while (n % i == 0) {
n /= i;
res.back() *= i;
}
}
}
if (n > 1) {
res.emplace_back(n);
}
return res;
}
ll extended_euclid(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll d = extended_euclid(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n;
cin >> n;
n *= 2;
auto factor = prime_factorize(n);
ll min_k = LLONG_MAX;
for (int mask = 0; mask < (1 << factor.size()); mask++) {
ll a = 1, b = 1;
for (int i = 0; i < factor.size(); i++) {
if (mask & (1 << i)) {
b *= factor[i];
} else
a *= factor[i]; // p1, p2, b*p2 = a*p1 + 1 = by - ax = 1
}
//-a(x - k*b) + b(y - k*a) = 1, ax + by = 1
ll x0, y0;
extended_euclid(a, b, x0, y0);
x0 = -x0;
ll limit = (ll)1e18 / max(a, b);
ll lo = -limit, hi = limit;
while (lo < hi) {
ll mid = lo + (hi - lo + 1) / 2;
if (x0 - mid * b > 0 and y0 - mid * a > 0)
lo = mid;
else
hi = mid - 1;
}
min_k = min(min_k, b * (y0 - lo * a) - 1);
}
cout << min_k << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = INT_MAX;
vector<ll> prime_factorize(ll n) {
vector<ll> res;
for (int i = 2; (ll)i * i <= n; i++) {
if (n % i == 0) {
res.emplace_back(1);
while (n % i == 0) {
n /= i;
res.back() *= i;
}
}
}
if (n > 1) {
res.emplace_back(n);
}
return res;
}
ll extended_euclid(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll x1, y1;
ll d = extended_euclid(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n;
cin >> n;
n *= 2;
auto factor = prime_factorize(n);
ll min_k = LLONG_MAX;
for (int mask = 0; mask < (1 << factor.size()); mask++) {
ll a = 1, b = 1;
for (int i = 0; i < factor.size(); i++) {
if (mask & (1 << i)) {
b *= factor[i];
} else
a *= factor[i]; // p1, p2, b*p2 = a*p1 + 1 = by - ax = 1
}
//-a(x - k*b) + b(y - k*a) = 1, ax + by = 1
ll x0, y0;
extended_euclid(a, b, x0, y0);
x0 = -x0;
ll limit = (ll)1e18 / max(a, b);
ll lo = -limit, hi = limit;
while (lo < hi) {
ll mid = lo + (hi - lo + 1) / 2;
if (x0 - mid * b > 0 and y0 - mid * a > 0)
lo = mid;
else
hi = mid - 1;
}
min_k = min(min_k, b * (y0 - lo * a) - 1);
}
cout << min_k << '\n';
return 0;
} | replace | 12 | 13 | 12 | 13 | TLE | |
p02541 | C++ | Runtime Error | #ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
// #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
ll m;
int k;
mt19937_64 rnd(228);
const int BUBEN = (int)1e6 + 228;
const int BUBEN2 = 15;
long long multModulo(long long a, long long b, long long m) {
long long q = (long long)((long double)a * (long double)b / (long double)m);
long long r = a * b - q * m;
while (r < 0)
r += m;
while (r >= m)
r -= m;
return r;
}
ll sumModulo(ll a, ll b, ll mod) {
ll s = a + b;
if (s >= mod)
s -= mod;
return s;
}
ll powModulo(ll a, ll b, ll mod) {
if (b == 0)
return 1;
if (b & 1)
return multModulo(a, powModulo(a, b - 1, mod), mod);
ll res = powModulo(a, b / 2, mod);
return multModulo(res, res, mod);
}
ll pollard_rho(ll n) {
ll y = rnd() % (n - 1) + 1;
ll c = rnd() % (n - 1) + 1;
ll m = rnd() % (n - 1) + 1;
ll g = 1;
ll r = 1;
ll q = 1;
ll x = 0;
ll ys = 0;
ll k = 0;
while (g == 1) {
x = y;
for (int i = 0; i < r; i++) {
y = sumModulo(multModulo(y, y, n), c, n);
k = 0;
}
while (k < r && g == 1) {
ys = y;
for (int i = 0; i < min(m, r - k); i++) {
y = sumModulo(multModulo(y, y, n), c, n);
q = multModulo(q, abs(x - y), n);
g = __gcd(q, n);
}
k = k + m;
}
r *= 2;
}
if (g == n) {
while (true) {
ys = sumModulo(multModulo(ys, ys, n), c, n);
g = __gcd(abs(x - ys), n);
if (g > 1)
break;
}
}
return g;
}
bool is_prime(ll n) {
if (n == 2 || n == 3 || n == 5 || n == 7) {
return true;
}
if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) {
return false;
}
ll d = n - 1;
int r = 0;
// can add
while (d % 2 == 0) {
d /= 2;
r++;
}
for (int j = 0; j < BUBEN2; j++) {
ll a = rnd() % (n - 3) + 2;
ll x = powModulo(a, d, n);
if (x == 1 || x == n - 1) {
continue;
}
for (int it = 0; it < r - 1; it++) {
x = multModulo(x, x, n);
if (x == n - 1) {
break;
}
}
if (x != (n - 1)) {
return false;
}
}
return true;
}
int lp[BUBEN];
vector<int> small_primes;
void init() {
for (int i = 2; i < BUBEN; i++) {
if (lp[i] == 0) {
lp[i] = i;
if (i < BUBEN)
small_primes.push_back(i);
for (int j = 2 * i; j < BUBEN; j += i)
lp[j] = i;
}
}
}
vector<pair<ll, int>> get_fact(ll n) {
vector<pair<ll, int>> ans;
if (n < BUBEN) {
// factorize
while (n > 1) {
int p = lp[n];
int ex = 0;
while (n % p == 0) {
n /= p;
ex++;
}
ans.emplace_back(p, ex);
}
sort(ans.begin(), ans.end());
return ans;
}
if (n == 1)
return {};
ll fact = 0;
for (ll v : small_primes) {
if (n % v == 0) {
fact = v;
break;
}
}
if (fact != 0) {
int ex = 0;
while (n % fact == 0) {
n /= fact;
ex++;
}
ans.emplace_back(fact, ex);
auto ans2 = get_fact(n);
for (auto it : ans2)
ans.push_back(it);
return ans;
}
if (is_prime(n)) {
ans.emplace_back(n, 1);
return ans;
}
if (fact == 0) {
fact = 1;
while (fact == 1 || fact == n)
fact = pollard_rho(n);
}
auto cur_ans = get_fact(fact);
n /= fact;
for (auto &t : cur_ans) {
ll x = t.first;
int y = t.second;
if (n % x == 0) {
while (n % x == 0) {
n /= x;
y++;
}
}
ans.emplace_back(x, y);
}
if (n > 1) {
auto ans2 = get_fact(n);
for (auto it : ans2)
ans.push_back(it);
return ans;
}
sort(ans.begin(), ans.end());
return ans;
}
ll do_gcd(ll a, ll b, ll &x, ll &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int p = b / a;
int g = do_gcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
ll getInv(ll a, ll M) {
ll c1, c2;
ll d = do_gcd(a, M, c1, c2);
assert(d == 1);
c1 %= M;
if (c1 < 0)
c1 += M;
return c1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
// freopen("input.txt", "r", stdin);
init();
ll n;
cin >> n;
n *= 2;
auto it = get_fact(n);
ll best = n;
for (int mask = 0; mask < (1 << it.size()); mask++) {
ll mod1 = 1;
ll mod2 = 1;
for (int i = 0; i < it.size(); i++) {
ll p = 1;
for (int j = 0; j < it[i].second; j++)
p *= it[i].first;
if (mask & (1 << i)) {
mod1 *= p;
} else {
mod2 *= p;
}
}
ll f = getInv(mod2, mod1);
if (f == 0)
f += mod1;
if (f * mod2 == 1) {
f += mod1;
}
best = min(best, f * mod2 - 1);
}
cout << best;
return 0;
} | #ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
// #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
ll m;
int k;
mt19937_64 rnd(228);
const int BUBEN = (int)1e6 + 228;
const int BUBEN2 = 15;
long long multModulo(long long a, long long b, long long m) {
long long q = (long long)((long double)a * (long double)b / (long double)m);
long long r = a * b - q * m;
while (r < 0)
r += m;
while (r >= m)
r -= m;
return r;
}
ll sumModulo(ll a, ll b, ll mod) {
ll s = a + b;
if (s >= mod)
s -= mod;
return s;
}
ll powModulo(ll a, ll b, ll mod) {
if (b == 0)
return 1;
if (b & 1)
return multModulo(a, powModulo(a, b - 1, mod), mod);
ll res = powModulo(a, b / 2, mod);
return multModulo(res, res, mod);
}
ll pollard_rho(ll n) {
ll y = rnd() % (n - 1) + 1;
ll c = rnd() % (n - 1) + 1;
ll m = rnd() % (n - 1) + 1;
ll g = 1;
ll r = 1;
ll q = 1;
ll x = 0;
ll ys = 0;
ll k = 0;
while (g == 1) {
x = y;
for (int i = 0; i < r; i++) {
y = sumModulo(multModulo(y, y, n), c, n);
k = 0;
}
while (k < r && g == 1) {
ys = y;
for (int i = 0; i < min(m, r - k); i++) {
y = sumModulo(multModulo(y, y, n), c, n);
q = multModulo(q, abs(x - y), n);
g = __gcd(q, n);
}
k = k + m;
}
r *= 2;
}
if (g == n) {
while (true) {
ys = sumModulo(multModulo(ys, ys, n), c, n);
g = __gcd(abs(x - ys), n);
if (g > 1)
break;
}
}
return g;
}
bool is_prime(ll n) {
if (n == 2 || n == 3 || n == 5 || n == 7) {
return true;
}
if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) {
return false;
}
ll d = n - 1;
int r = 0;
// can add
while (d % 2 == 0) {
d /= 2;
r++;
}
for (int j = 0; j < BUBEN2; j++) {
ll a = rnd() % (n - 3) + 2;
ll x = powModulo(a, d, n);
if (x == 1 || x == n - 1) {
continue;
}
for (int it = 0; it < r - 1; it++) {
x = multModulo(x, x, n);
if (x == n - 1) {
break;
}
}
if (x != (n - 1)) {
return false;
}
}
return true;
}
int lp[BUBEN];
vector<int> small_primes;
void init() {
for (int i = 2; i < BUBEN; i++) {
if (lp[i] == 0) {
lp[i] = i;
if (i < BUBEN)
small_primes.push_back(i);
for (int j = 2 * i; j < BUBEN; j += i)
lp[j] = i;
}
}
}
vector<pair<ll, int>> get_fact(ll n) {
vector<pair<ll, int>> ans;
if (n < BUBEN) {
// factorize
while (n > 1) {
int p = lp[n];
int ex = 0;
while (n % p == 0) {
n /= p;
ex++;
}
ans.emplace_back(p, ex);
}
sort(ans.begin(), ans.end());
return ans;
}
if (n == 1)
return {};
ll fact = 0;
for (ll v : small_primes) {
if (n % v == 0) {
fact = v;
break;
}
}
if (fact != 0) {
int ex = 0;
while (n % fact == 0) {
n /= fact;
ex++;
}
ans.emplace_back(fact, ex);
auto ans2 = get_fact(n);
for (auto it : ans2)
ans.push_back(it);
return ans;
}
if (is_prime(n)) {
ans.emplace_back(n, 1);
return ans;
}
if (fact == 0) {
fact = 1;
while (fact == 1 || fact == n)
fact = pollard_rho(n);
}
auto cur_ans = get_fact(fact);
n /= fact;
for (auto &t : cur_ans) {
ll x = t.first;
int y = t.second;
if (n % x == 0) {
while (n % x == 0) {
n /= x;
y++;
}
}
ans.emplace_back(x, y);
}
if (n > 1) {
auto ans2 = get_fact(n);
for (auto it : ans2)
ans.push_back(it);
return ans;
}
sort(ans.begin(), ans.end());
return ans;
}
ll do_gcd(ll a, ll b, ll &x, ll &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll p = b / a;
ll g = do_gcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
ll getInv(ll a, ll M) {
ll c1, c2;
ll d = do_gcd(a, M, c1, c2);
assert(d == 1);
c1 %= M;
if (c1 < 0)
c1 += M;
return c1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
// freopen("input.txt", "r", stdin);
init();
ll n;
cin >> n;
n *= 2;
auto it = get_fact(n);
ll best = n;
for (int mask = 0; mask < (1 << it.size()); mask++) {
ll mod1 = 1;
ll mod2 = 1;
for (int i = 0; i < it.size(); i++) {
ll p = 1;
for (int j = 0; j < it[i].second; j++)
p *= it[i].first;
if (mask & (1 << i)) {
mod1 *= p;
} else {
mod2 *= p;
}
}
ll f = getInv(mod2, mod1);
if (f == 0)
f += mod1;
if (f * mod2 == 1) {
f += mod1;
}
best = min(best, f * mod2 - 1);
}
cout << best;
return 0;
} | replace | 202 | 204 | 202 | 204 | 0 | |
p02541 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0, _n = (int)(n); i < _n; ++i)
#define ALL(v) (v).begin(), (v).end()
#define CLR(t, v) memset(t, (v), sizeof(t))
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << "(" << a.first << "," << a.second << ")";
}
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cout << (*i) << " ";
cout << endl;
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
ll nextLong() {
ll x;
scanf("%lld", &x);
return x;
}
const int SIZE = 51234567;
vector<int> primes;
bool isPrime[SIZE];
void make_primes() {
if (primes.size() > 0)
return;
memset(isPrime, true, sizeof(isPrime));
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i < SIZE; i++)
if (isPrime[i])
for (int j = i * i; j < SIZE; j += i)
isPrime[j] = false;
REP(i, SIZE) if (isPrime[i]) primes.push_back(i);
}
map<ll, ll> factorize(ll N) {
map<ll, ll> count;
for (int i = 0; primes[i] * primes[i] <= N; i++) {
while (N % primes[i] == 0) {
count[primes[i]]++;
N /= primes[i];
}
}
if (N != 1)
count[N]++;
return count;
}
vector<int> divisors(int n) {
vector<int> ds;
for (int d = 1; d * d <= n; d++) {
if (n % d == 0) {
ds.push_back(d);
if (d * d != n)
ds.push_back(n / d);
}
}
sort(ds.begin(), ds.end());
return ds;
}
ll ext_gcd(ll p, ll q, ll &x, ll &y) { // get px+qy=gcd(p,q)
if (q == 0)
return x = 1, y = 0, p;
ll g = ext_gcd(q, p % q, y, x);
y -= p / q * x;
return g;
}
bool check(ll k, ll N) {
auto count = factorize(N);
count[2]++;
auto count_k = factorize(k);
auto count_k1 = factorize(k + 1);
for (auto it : count) {
ll p = it.first;
if (count[p] > count_k[p] + count_k1[p])
return false;
}
return true;
}
int main2() {
ll N = nextLong();
auto count = factorize(N);
// cout << "N=" << N << endl;
// pv(ALL(count));
if (count.size() == 1) {
ll p = count.begin()->first;
ll m = count.begin()->second;
if (p == 2) {
cout << (1LL << (m + 1)) - 1 << endl;
return 0;
}
cout << N - 1 << endl;
return 0;
}
vector<ll> cand;
vector<ll> p;
vector<ll> m;
for (auto it : count) {
p.push_back(it.first);
m.push_back(it.second);
}
const int M = m.size();
REP(st, 1 << M) {
ll s = 1, t = 1;
REP(i, M)
if (st >> i & 1) {
REP(_, m[i]) s *= p[i];
} else {
REP(_, m[i]) t *= p[i];
}
ll x, y;
ext_gcd(s, -t, x, y);
if (t * y <= 2 * N)
cand.push_back(t * y);
if (s * x <= 2 * N)
cand.push_back(s * x);
// cout << s*x << " " << t * y << endl;
// cout << x << " " << y << endl;
}
sort(ALL(cand));
// pv(ALL(cand));
for (ll k : cand)
if (k > 0) {
if (check(k, N)) {
cout << k << endl;
return 0;
}
}
// cout << "NO SOLUTION" << endl;
return 0;
}
ll naive(ll N) {
for (ll k = 1;; k++)
if ((k * (k + 1) / 2) % N == 0)
return k;
}
int main() {
make_primes();
// for (int N = 1; N <= 100; N++) if (N % 2 == 1) {
// cout << "N=" << N << " ";
// auto count = factorize(N);
// cout << " K=" << naive(N) << " ";
// pv(ALL(count));
// }
// return 0;
#ifdef LOCAL
for (; !cin.eof(); cin >> ws)
#endif
main2();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0, _n = (int)(n); i < _n; ++i)
#define ALL(v) (v).begin(), (v).end()
#define CLR(t, v) memset(t, (v), sizeof(t))
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << "(" << a.first << "," << a.second << ")";
}
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cout << (*i) << " ";
cout << endl;
}
template <class T> void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
ll nextLong() {
ll x;
scanf("%lld", &x);
return x;
}
const int SIZE = 51234567;
vector<ll> primes;
bool isPrime[SIZE];
void make_primes() {
if (primes.size() > 0)
return;
memset(isPrime, true, sizeof(isPrime));
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i < SIZE; i++)
if (isPrime[i])
for (int j = i * i; j < SIZE; j += i)
isPrime[j] = false;
REP(i, SIZE) if (isPrime[i]) primes.push_back(i);
}
map<ll, ll> factorize(ll N) {
map<ll, ll> count;
for (int i = 0; primes[i] * primes[i] <= N; i++) {
while (N % primes[i] == 0) {
count[primes[i]]++;
N /= primes[i];
}
}
if (N != 1)
count[N]++;
return count;
}
vector<int> divisors(int n) {
vector<int> ds;
for (int d = 1; d * d <= n; d++) {
if (n % d == 0) {
ds.push_back(d);
if (d * d != n)
ds.push_back(n / d);
}
}
sort(ds.begin(), ds.end());
return ds;
}
ll ext_gcd(ll p, ll q, ll &x, ll &y) { // get px+qy=gcd(p,q)
if (q == 0)
return x = 1, y = 0, p;
ll g = ext_gcd(q, p % q, y, x);
y -= p / q * x;
return g;
}
bool check(ll k, ll N) {
auto count = factorize(N);
count[2]++;
auto count_k = factorize(k);
auto count_k1 = factorize(k + 1);
for (auto it : count) {
ll p = it.first;
if (count[p] > count_k[p] + count_k1[p])
return false;
}
return true;
}
int main2() {
ll N = nextLong();
auto count = factorize(N);
// cout << "N=" << N << endl;
// pv(ALL(count));
if (count.size() == 1) {
ll p = count.begin()->first;
ll m = count.begin()->second;
if (p == 2) {
cout << (1LL << (m + 1)) - 1 << endl;
return 0;
}
cout << N - 1 << endl;
return 0;
}
vector<ll> cand;
vector<ll> p;
vector<ll> m;
for (auto it : count) {
p.push_back(it.first);
m.push_back(it.second);
}
const int M = m.size();
REP(st, 1 << M) {
ll s = 1, t = 1;
REP(i, M)
if (st >> i & 1) {
REP(_, m[i]) s *= p[i];
} else {
REP(_, m[i]) t *= p[i];
}
ll x, y;
ext_gcd(s, -t, x, y);
if (t * y <= 2 * N)
cand.push_back(t * y);
if (s * x <= 2 * N)
cand.push_back(s * x);
// cout << s*x << " " << t * y << endl;
// cout << x << " " << y << endl;
}
sort(ALL(cand));
// pv(ALL(cand));
for (ll k : cand)
if (k > 0) {
if (check(k, N)) {
cout << k << endl;
return 0;
}
}
// cout << "NO SOLUTION" << endl;
return 0;
}
ll naive(ll N) {
for (ll k = 1;; k++)
if ((k * (k + 1) / 2) % N == 0)
return k;
}
int main() {
make_primes();
// for (int N = 1; N <= 100; N++) if (N % 2 == 1) {
// cout << "N=" << N << " ";
// auto count = factorize(N);
// cout << " K=" << naive(N) << " ";
// pv(ALL(count));
// }
// return 0;
#ifdef LOCAL
for (; !cin.eof(); cin >> ws)
#endif
main2();
return 0;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p02541 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
using namespace std;
typedef long long li;
vector<li> factor(li n) {
vector<li> factors;
for (int p = 2; p * p <= n; ++p) {
while (n % p == 0) {
factors.push_back(p);
n /= p;
}
}
if (n > 1) {
factors.push_back(n);
}
return factors;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
li n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
map<li, li> factors;
for (auto p : factor(n)) {
factors[p]++;
}
vector<li> pows;
for (auto p : factors) {
li pow = 1;
for (int i = 0; i < p.second; ++i) {
pow *= p.first;
}
if (p.first == 2) {
pow *= 2;
}
pows.push_back(pow);
}
const li p = pows.size();
li ans = 2 * n;
for (li i = 1; i < 1LL << p; ++i) {
vector<li> rems;
for (int j = 0; j < p; ++j) {
if ((i >> j) & 1) {
rems.push_back(pows[j] - 1);
} else {
rems.push_back(0);
}
}
auto a = atcoder::crt(rems, pows);
li tans = a.first == 0 ? a.second : a.first;
ans = min(ans, tans);
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
using namespace std;
typedef long long li;
vector<li> factor(li n) {
vector<li> factors;
for (li p = 2; p * p <= n; ++p) {
while (n % p == 0) {
factors.push_back(p);
n /= p;
}
}
if (n > 1) {
factors.push_back(n);
}
return factors;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
li n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
map<li, li> factors;
for (auto p : factor(n)) {
factors[p]++;
}
vector<li> pows;
for (auto p : factors) {
li pow = 1;
for (int i = 0; i < p.second; ++i) {
pow *= p.first;
}
if (p.first == 2) {
pow *= 2;
}
pows.push_back(pow);
}
const li p = pows.size();
li ans = 2 * n;
for (li i = 1; i < 1LL << p; ++i) {
vector<li> rems;
for (int j = 0; j < p; ++j) {
if ((i >> j) & 1) {
rems.push_back(pows[j] - 1);
} else {
rems.push_back(0);
}
}
auto a = atcoder::crt(rems, pows);
li tans = a.first == 0 ? a.second : a.first;
ans = min(ans, tans);
}
cout << ans << endl;
return 0;
}
| replace | 302 | 303 | 302 | 303 | TLE | |
p02542 | Python | Runtime Error | import networkx as nx
n, m = map(int, input().split())
S = [list(input()) for _ in range(n)]
G = nx.DiGraph()
start = (n, m)
cnt = 0
goal = (n, m + 1)
for i in range(n):
for j in range(n):
if S[i][j] != "#":
if S[i][j] == "o":
cnt += 1
G.add_edge(start, (i, j), capacity=1)
if i + 1 < n:
if S[i + 1][j] != "#":
G.add_edge((i, j), (i + 1, j), weight=-1)
if j + 1 < m:
if S[i][j + 1] != "#":
G.add_edge((i, j), (i, j + 1), weight=-1)
G.add_edge((i, j), goal, capacity=1)
# G.add_node(start, demand=cnt)
# G.add_node(goal, demand=-cnt)
mincostflow = nx.max_flow_min_cost(G, start, goal)
ans = nx.cost_of_flow(G, mincostflow)
print(abs(ans))
| import networkx as nx
n, m = map(int, input().split())
S = [list(input()) for _ in range(n)]
G = nx.DiGraph()
start = (n, m)
cnt = 0
goal = (n, m + 1)
for i in range(n):
for j in range(m):
if S[i][j] != "#":
if S[i][j] == "o":
cnt += 1
G.add_edge(start, (i, j), capacity=1)
if i + 1 < n:
if S[i + 1][j] != "#":
G.add_edge((i, j), (i + 1, j), weight=-1)
if j + 1 < m:
if S[i][j + 1] != "#":
G.add_edge((i, j), (i, j + 1), weight=-1)
G.add_edge((i, j), goal, capacity=1)
# G.add_node(start, demand=cnt)
# G.add_node(goal, demand=-cnt)
mincostflow = nx.max_flow_min_cost(G, start, goal)
ans = nx.cost_of_flow(G, mincostflow)
print(abs(ans))
| replace | 12 | 13 | 12 | 13 | ModuleNotFoundError: No module named 'networkx' | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02542/Python/s537202768.py", line 1, in <module>
import networkx as nx
ModuleNotFoundError: No module named 'networkx'
|
p02542 | C++ | Runtime Error | // This Code was made by Chinese_zjc_.
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
// #include<windows.h>
#define int long long
#define double long double
using namespace std;
const double PI = acos(-1);
const double eps = 0.0000000001;
const int INF = 0x3fffffffffffffff;
int n, m, id[55][55], cnt, tim, head[6005], s, t, tot = 1, dis[6005], ans, cost,
NOW[6005];
bool in[6005];
queue<int> que;
struct node {
int x, y;
bool can[55][55];
node(int X = 0, int Y = 0) {
x = X;
y = Y;
memset(can, false, sizeof can);
}
} g[105];
struct edge {
int cost, cap, nxt, to;
} e[50005];
char a[55][55];
void add(int f, int t, int cost, int cap) {
e[++tot] = {cost, cap, head[f], t};
head[f] = tot;
}
bool spfa() {
fill(dis + 1, dis + 1 + tim, -INF);
dis[s] = 0;
in[s] = true;
que.push(s);
while (!que.empty()) {
int now = que.front();
in[now] = false;
que.pop();
for (int i = head[now]; i; i = e[i].nxt) {
if (e[i].cap && dis[e[i].to] < dis[now] + e[i].cost) {
dis[e[i].to] = dis[now] + e[i].cost;
if (!in[e[i].to]) {
in[e[i].to] = true;
que.push(e[i].to);
}
}
}
}
return dis[t] != -INF;
}
int dfs(int now, int v) {
// cout << now << ' ' << v << ' ' << sta << endl;
if (now == t) {
ans += v;
return v;
}
in[now] = true;
int res = 0;
for (int i = NOW[now]; i && v; i = e[i].nxt) {
NOW[now] = i;
if (!in[e[i].to] && e[i].cap && dis[now] + e[i].cost == dis[e[i].to]) {
int tmp = dfs(e[i].to, min(v, e[i].cap));
e[i ^ 0].cap -= tmp;
e[i ^ 1].cap += tmp;
v -= tmp;
res += tmp;
cost += e[i].cost * tmp;
}
}
in[now] = false;
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'o') {
g[++cnt] = {i, j};
}
}
}
for (int k = 1; k <= cnt; ++k) {
g[k].can[g[k].x][g[k].y] = true;
for (int i = g[k].x; i <= n; ++i) {
for (int j = g[k].y; j <= m; ++j) {
g[k].can[i][j] |=
(a[i][j] != '#' && (g[k].can[i - 1][j] || g[k].can[i][j - 1]));
}
}
}
for (int i = 1; i <= cnt; ++i) {
++tim;
}
s = ++tim;
t = ++tim;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
id[i][j] = ++tim;
add(id[i][j], t, 0, 1);
add(t, id[i][j], 0, 0);
}
}
for (int i = 1; i <= cnt; ++i) {
add(s, i, 0, 1);
add(i, s, 0, 0);
for (int j = g[i].x; j <= n; ++j) {
for (int k = g[i].y; k <= m; ++k) {
if (g[i].can[j][k]) {
add(i, id[j][k], +(j - g[i].x) + (k - g[i].y), 1);
add(id[j][k], i, -(j - g[i].x) - (k - g[i].y), 0);
}
}
}
}
while (spfa()) {
for (int i = 1; i <= tim; ++i) {
NOW[i] = head[i];
}
int l = dfs(s, INF);
while (l) {
l = dfs(s, INF);
// getchar();
}
}
cout << cost << endl;
return 0;
}
| // This Code was made by Chinese_zjc_.
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
// #include<windows.h>
#define int long long
#define double long double
using namespace std;
const double PI = acos(-1);
const double eps = 0.0000000001;
const int INF = 0x3fffffffffffffff;
int n, m, id[55][55], cnt, tim, head[6005], s, t, tot = 1, dis[6005], ans, cost,
NOW[6005];
bool in[6005];
queue<int> que;
struct node {
int x, y;
bool can[55][55];
node(int X = 0, int Y = 0) {
x = X;
y = Y;
memset(can, false, sizeof can);
}
} g[105];
struct edge {
int cost, cap, nxt, to;
} e[500005];
char a[55][55];
void add(int f, int t, int cost, int cap) {
e[++tot] = {cost, cap, head[f], t};
head[f] = tot;
}
bool spfa() {
fill(dis + 1, dis + 1 + tim, -INF);
dis[s] = 0;
in[s] = true;
que.push(s);
while (!que.empty()) {
int now = que.front();
in[now] = false;
que.pop();
for (int i = head[now]; i; i = e[i].nxt) {
if (e[i].cap && dis[e[i].to] < dis[now] + e[i].cost) {
dis[e[i].to] = dis[now] + e[i].cost;
if (!in[e[i].to]) {
in[e[i].to] = true;
que.push(e[i].to);
}
}
}
}
return dis[t] != -INF;
}
int dfs(int now, int v) {
// cout << now << ' ' << v << ' ' << sta << endl;
if (now == t) {
ans += v;
return v;
}
in[now] = true;
int res = 0;
for (int i = NOW[now]; i && v; i = e[i].nxt) {
NOW[now] = i;
if (!in[e[i].to] && e[i].cap && dis[now] + e[i].cost == dis[e[i].to]) {
int tmp = dfs(e[i].to, min(v, e[i].cap));
e[i ^ 0].cap -= tmp;
e[i ^ 1].cap += tmp;
v -= tmp;
res += tmp;
cost += e[i].cost * tmp;
}
}
in[now] = false;
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'o') {
g[++cnt] = {i, j};
}
}
}
for (int k = 1; k <= cnt; ++k) {
g[k].can[g[k].x][g[k].y] = true;
for (int i = g[k].x; i <= n; ++i) {
for (int j = g[k].y; j <= m; ++j) {
g[k].can[i][j] |=
(a[i][j] != '#' && (g[k].can[i - 1][j] || g[k].can[i][j - 1]));
}
}
}
for (int i = 1; i <= cnt; ++i) {
++tim;
}
s = ++tim;
t = ++tim;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
id[i][j] = ++tim;
add(id[i][j], t, 0, 1);
add(t, id[i][j], 0, 0);
}
}
for (int i = 1; i <= cnt; ++i) {
add(s, i, 0, 1);
add(i, s, 0, 0);
for (int j = g[i].x; j <= n; ++j) {
for (int k = g[i].y; k <= m; ++k) {
if (g[i].can[j][k]) {
add(i, id[j][k], +(j - g[i].x) + (k - g[i].y), 1);
add(id[j][k], i, -(j - g[i].x) - (k - g[i].y), 0);
}
}
}
}
while (spfa()) {
for (int i = 1; i <= tim; ++i) {
NOW[i] = head[i];
}
int l = dfs(s, INF);
while (l) {
l = dfs(s, INF);
// getchar();
}
}
cout << cost << endl;
return 0;
}
| replace | 39 | 40 | 39 | 40 | 0 | |
p02542 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FORall(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed << setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const ll LINF = (ll)1e18 + 23111992;
const ld PI = acos((ld)-1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k, int p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T> inline int chkmin(T &a, const T &val) {
return val < a ? a = val, 1 : 0;
}
template <class T> inline int chkmax(T &a, const T &val) {
return a < val ? a = val, 1 : 0;
}
inline ull isqrt(ull k) {
ull r = sqrt(k) + 1;
while (r * r > k)
r--;
return r;
}
inline ll icbrt(ll k) {
ll r = cbrt(k) + 1;
while (r * r * r > k)
r--;
return r;
}
inline void addmod(int &a, int val, int p = MOD) {
if ((a = (a + val)) >= p)
a -= p;
}
inline void submod(int &a, int val, int p = MOD) {
if ((a = (a - val)) < 0)
a += p;
}
inline int mult(int a, int b, int p = MOD) { return (ll)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(ld x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(ld x, ld y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
inline int mrand(int k) { return abs((int)mt()) % k; }
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";
#define MF MincostMaxflow
#define flow_t int
#define cost_t long long
const flow_t foo = (flow_t)1e9;
const cost_t coo = (cost_t)1e18;
namespace MincostMaxflow {
const int maxv = 2e6 + 5;
const int maxe = 2e6 + 5;
int n, s, t, E;
int adj[maxe], nxt[maxe], lst[maxv], frm[maxv], vis[maxv];
flow_t cap[maxe], flw[maxe], totalFlow;
cost_t cst[maxe], dst[maxv], totalCost;
void init(int nn, int ss, int tt) {
n = nn, s = ss, t = tt;
fill_n(lst, n, -1), E = 0;
}
void add(int u, int v, flow_t ca, cost_t co) {
adj[E] = v, cap[E] = ca, flw[E] = 0, cst[E] = +co, nxt[E] = lst[u],
lst[u] = E++;
adj[E] = u, cap[E] = 0, flw[E] = 0, cst[E] = -co, nxt[E] = lst[v],
lst[v] = E++;
}
int spfa() {
fill_n(dst, n, coo), dst[s] = 0;
queue<int> que;
que.push(s);
while (que.size()) {
int u = que.front();
que.pop();
for (int e = lst[u]; e != -1; e = nxt[e])
if (flw[e] < cap[e]) {
int v = adj[e];
if (dst[v] > dst[u] + cst[e]) {
dst[v] = dst[u] + cst[e];
frm[v] = e;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
vis[u] = 0;
}
return dst[t] < coo;
}
cost_t mincost() {
totalCost = 0, totalFlow = 0;
while (1) {
if (!spfa())
break;
flow_t mn = foo;
for (int v = t, e = frm[v]; v != s; v = adj[e ^ 1], e = frm[v])
mn = min(mn, cap[e] - flw[e]);
for (int v = t, e = frm[v]; v != s; v = adj[e ^ 1], e = frm[v]) {
flw[e] += mn;
flw[e ^ 1] -= mn;
}
totalFlow += mn;
totalCost += mn * dst[t];
}
return totalCost;
}
} // namespace MincostMaxflow
void chemthan() {
int n, m;
cin >> n >> m;
vector<string> s(n);
FOR(i, 0, n) cin >> s[i];
int tot = n * m * 2;
int S = tot++, t = tot++;
MF::init(tot, S, t);
int num = 0;
FOR(i, 0, n) FOR(j, 0, m) if (s[i][j] == 'o') {
MF::add(S, i * m + j, 1, 0);
num++;
vector<vi> dp(n, vi(m, INF));
queue<int> que;
dp[i][j] = 0, que.push(i), que.push(j);
while (sz(que)) {
int u = que.front();
que.pop();
int v = que.front();
que.pop();
if (u + 1 < n && s[u + 1][v] != '#') {
if (chkmin(dp[u + 1][v], dp[u][v] + 1)) {
que.push(u + 1), que.push(v);
}
}
if (v + 1 < n && s[u][v + 1] != '#') {
if (chkmin(dp[u][v + 1], dp[u][v] + 1)) {
que.push(u), que.push(v + 1);
}
}
}
vector<tuple<int, int, int>> vals;
FOR(u, 0, n) FOR(v, 0, m) if (dp[u][v] < INF) {
MF::add(i * m + j, n * m + u * m + v, 1, 100000 - dp[u][v]);
}
}
FOR(i, 0, n * m) { MF::add(n * m + i, t, 1, 0); }
cout << (long long)100000 * num - MF::mincost() << "\n";
}
int32_t main(int32_t argc, char *argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define FORall(it, a) \
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed << setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const ll LINF = (ll)1e18 + 23111992;
const ld PI = acos((ld)-1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {
ll r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k, int p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T> inline int chkmin(T &a, const T &val) {
return val < a ? a = val, 1 : 0;
}
template <class T> inline int chkmax(T &a, const T &val) {
return a < val ? a = val, 1 : 0;
}
inline ull isqrt(ull k) {
ull r = sqrt(k) + 1;
while (r * r > k)
r--;
return r;
}
inline ll icbrt(ll k) {
ll r = cbrt(k) + 1;
while (r * r * r > k)
r--;
return r;
}
inline void addmod(int &a, int val, int p = MOD) {
if ((a = (a + val)) >= p)
a -= p;
}
inline void submod(int &a, int val, int p = MOD) {
if ((a = (a - val)) < 0)
a += p;
}
inline int mult(int a, int b, int p = MOD) { return (ll)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(ld x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(ld x, ld y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
inline int mrand(int k) { return abs((int)mt()) % k; }
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";
#define MF MincostMaxflow
#define flow_t int
#define cost_t long long
const flow_t foo = (flow_t)1e9;
const cost_t coo = (cost_t)1e18;
namespace MincostMaxflow {
const int maxv = 2e6 + 5;
const int maxe = 2e6 + 5;
int n, s, t, E;
int adj[maxe], nxt[maxe], lst[maxv], frm[maxv], vis[maxv];
flow_t cap[maxe], flw[maxe], totalFlow;
cost_t cst[maxe], dst[maxv], totalCost;
void init(int nn, int ss, int tt) {
n = nn, s = ss, t = tt;
fill_n(lst, n, -1), E = 0;
}
void add(int u, int v, flow_t ca, cost_t co) {
adj[E] = v, cap[E] = ca, flw[E] = 0, cst[E] = +co, nxt[E] = lst[u],
lst[u] = E++;
adj[E] = u, cap[E] = 0, flw[E] = 0, cst[E] = -co, nxt[E] = lst[v],
lst[v] = E++;
}
int spfa() {
fill_n(dst, n, coo), dst[s] = 0;
queue<int> que;
que.push(s);
while (que.size()) {
int u = que.front();
que.pop();
for (int e = lst[u]; e != -1; e = nxt[e])
if (flw[e] < cap[e]) {
int v = adj[e];
if (dst[v] > dst[u] + cst[e]) {
dst[v] = dst[u] + cst[e];
frm[v] = e;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
vis[u] = 0;
}
return dst[t] < coo;
}
cost_t mincost() {
totalCost = 0, totalFlow = 0;
while (1) {
if (!spfa())
break;
flow_t mn = foo;
for (int v = t, e = frm[v]; v != s; v = adj[e ^ 1], e = frm[v])
mn = min(mn, cap[e] - flw[e]);
for (int v = t, e = frm[v]; v != s; v = adj[e ^ 1], e = frm[v]) {
flw[e] += mn;
flw[e ^ 1] -= mn;
}
totalFlow += mn;
totalCost += mn * dst[t];
}
return totalCost;
}
} // namespace MincostMaxflow
void chemthan() {
int n, m;
cin >> n >> m;
vector<string> s(n);
FOR(i, 0, n) cin >> s[i];
int tot = n * m * 2;
int S = tot++, t = tot++;
MF::init(tot, S, t);
int num = 0;
FOR(i, 0, n) FOR(j, 0, m) if (s[i][j] == 'o') {
MF::add(S, i * m + j, 1, 0);
num++;
vector<vi> dp(n, vi(m, INF));
queue<int> que;
dp[i][j] = 0, que.push(i), que.push(j);
while (sz(que)) {
int u = que.front();
que.pop();
int v = que.front();
que.pop();
if (u + 1 < n && s[u + 1][v] != '#') {
if (chkmin(dp[u + 1][v], dp[u][v] + 1)) {
que.push(u + 1), que.push(v);
}
}
if (v + 1 < m && s[u][v + 1] != '#') {
if (chkmin(dp[u][v + 1], dp[u][v] + 1)) {
que.push(u), que.push(v + 1);
}
}
}
vector<tuple<int, int, int>> vals;
FOR(u, 0, n) FOR(v, 0, m) if (dp[u][v] < INF) {
MF::add(i * m + j, n * m + u * m + v, 1, 100000 - dp[u][v]);
}
}
FOR(i, 0, n * m) { MF::add(n * m + i, t, 1, 0); }
cout << (long long)100000 * num - MF::mincost() << "\n";
}
int32_t main(int32_t argc, char *argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| replace | 179 | 180 | 179 | 180 | 0 |
Time elapsed: 20ms
|
p02542 | C++ | Runtime Error | #include <iostream>
#include <queue>
#include <vector>
#define INF 0x3f3f3f3f
using namespace std;
struct Edge {
int u, v, c, w;
Edge(int u, int v, int c, int w) : u(u), v(v), c(c), w(w) {}
};
class Graph {
int n, s, t;
vector<int> flow, dist, pre, last;
vector<bool> vis;
vector<Edge> edges;
vector<vector<int>> adj;
public:
Graph(int n, int s, int t) : n(n), s(s), t(t) {
adj = vector<vector<int>>(n);
flow.reserve(n);
dist.reserve(n);
pre.reserve(n);
last.reserve(n);
vis.reserve(n);
}
void add_edge(int u, int v, int c, int w) {
int m = edges.size();
edges.emplace_back(u, v, c, w);
edges.emplace_back(v, u, 0, -w);
adj[u].emplace_back(m);
adj[v].emplace_back(m | 1);
}
bool spfa() {
dist.assign(n, INF);
flow.assign(n, INF);
vis.assign(n, false);
queue<int> q;
q.push(s);
vis[s] = true;
dist[s] = 0;
pre[t] = -1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int e : adj[u]) {
auto [_, v, c, w] = edges[e];
if (c > 0 && dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pre[v] = u;
last[v] = e;
flow[v] = min(flow[u], c);
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
return pre[t] != -1;
}
pair<int, int> min_cost_max_flow() {
int mincost = 0;
int maxflow = 0;
while (spfa()) {
int now = t;
mincost += flow[t] * dist[t];
while (now != s) {
edges[last[now]].c -= flow[t];
edges[last[now] ^ 1].c += flow[t];
now = pre[now];
}
maxflow += flow[t];
}
return {maxflow, mincost};
}
};
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; ++i)
cin >> s[i];
int ball = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == 'o')
ball++;
int nodes = ball + n * m + 2;
Graph g(nodes, 0, nodes - 1);
int hi = n + m;
for (int i = 1; i <= ball; ++i)
g.add_edge(0, i, 1, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int idx = ball + i * m + j + 1;
g.add_edge(idx, nodes - 1, 1, 0);
}
int ball_idx = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (s[i][j] != 'o')
continue;
vector<vector<int>> dp(n, vector<int>(m, INF));
dp[i][j] = 0;
for (int p = i; p < n; ++p)
for (int q = j; q < n; ++q) {
if (s[p][q] == '#')
continue;
if (p > i && dp[p - 1][q] != INF)
dp[p][q] = dp[p - 1][q] + 1;
if (q > j && dp[p][q - 1] != INF)
dp[p][q] = dp[p][q - 1] + 1;
if (dp[p][q] != INF) {
int idx = ball + p * m + q + 1;
g.add_edge(ball_idx, idx, 1, hi - dp[p][q]);
}
}
ball_idx++;
}
auto [flow, cost] = g.min_cost_max_flow();
int ans = hi * flow - cost;
cout << ans;
} | #include <iostream>
#include <queue>
#include <vector>
#define INF 0x3f3f3f3f
using namespace std;
struct Edge {
int u, v, c, w;
Edge(int u, int v, int c, int w) : u(u), v(v), c(c), w(w) {}
};
class Graph {
int n, s, t;
vector<int> flow, dist, pre, last;
vector<bool> vis;
vector<Edge> edges;
vector<vector<int>> adj;
public:
Graph(int n, int s, int t) : n(n), s(s), t(t) {
adj = vector<vector<int>>(n);
flow.reserve(n);
dist.reserve(n);
pre.reserve(n);
last.reserve(n);
vis.reserve(n);
}
void add_edge(int u, int v, int c, int w) {
int m = edges.size();
edges.emplace_back(u, v, c, w);
edges.emplace_back(v, u, 0, -w);
adj[u].emplace_back(m);
adj[v].emplace_back(m | 1);
}
bool spfa() {
dist.assign(n, INF);
flow.assign(n, INF);
vis.assign(n, false);
queue<int> q;
q.push(s);
vis[s] = true;
dist[s] = 0;
pre[t] = -1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int e : adj[u]) {
auto [_, v, c, w] = edges[e];
if (c > 0 && dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pre[v] = u;
last[v] = e;
flow[v] = min(flow[u], c);
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
return pre[t] != -1;
}
pair<int, int> min_cost_max_flow() {
int mincost = 0;
int maxflow = 0;
while (spfa()) {
int now = t;
mincost += flow[t] * dist[t];
while (now != s) {
edges[last[now]].c -= flow[t];
edges[last[now] ^ 1].c += flow[t];
now = pre[now];
}
maxflow += flow[t];
}
return {maxflow, mincost};
}
};
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; ++i)
cin >> s[i];
int ball = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == 'o')
ball++;
int nodes = ball + n * m + 2;
Graph g(nodes, 0, nodes - 1);
int hi = n + m;
for (int i = 1; i <= ball; ++i)
g.add_edge(0, i, 1, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int idx = ball + i * m + j + 1;
g.add_edge(idx, nodes - 1, 1, 0);
}
int ball_idx = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (s[i][j] != 'o')
continue;
vector<vector<int>> dp(n, vector<int>(m, INF));
dp[i][j] = 0;
for (int p = i; p < n; ++p)
for (int q = j; q < m; ++q) {
if (s[p][q] == '#')
continue;
if (p > i && dp[p - 1][q] != INF)
dp[p][q] = dp[p - 1][q] + 1;
if (q > j && dp[p][q - 1] != INF)
dp[p][q] = dp[p][q - 1] + 1;
if (dp[p][q] != INF) {
int idx = ball + p * m + q + 1;
g.add_edge(ball_idx, idx, 1, hi - dp[p][q]);
}
}
ball_idx++;
}
auto [flow, cost] = g.min_cost_max_flow();
int ans = hi * flow - cost;
cout << ans;
} | replace | 114 | 115 | 114 | 115 | 0 | |
p02542 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>/
// #include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define PI (acos(-1.0))
#define IN freopen("nocross.in", "r", stdin)
#define OUT freopen("nocross.out", "w", stdout)
#define FOR(i, a, b) for (i = a; i <= b; i++)
#define DBG printf("Hi\n")
#define i64 long long int
#define eps (1e-8)
#define xx first
#define yy second
#define ln 17
#define off 2
#define SZ(z) ((int)z.size())
#define FastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
// using namespace __gnu_pbds;
using namespace std;
// typedef tree< i64, null_type, less<i64>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set;
// #define maxn 1000005
// #define INF 2000000000000000000LL
// #define mod 998244353LL
namespace mcmf {
// this should be at least 2*( added edge in the graph )
const int MAX = 31000;
const long long INF = 1LL << 60;
long long cap[MAX], flow[MAX], cost[MAX], dis[MAX];
int n, m, s, t, Q[MAX * 10], adj[MAX], link[MAX], last[MAX], from[MAX],
visited[MAX];
void init(int nodes, int source, int sink) {
m = 0, n = nodes, s = source, t = sink;
for (int i = 0; i <= n; i++)
last[i] = -1;
}
void addEdge(int u, int v, long long c, long long w) {
adj[m] = v, cap[m] = c, flow[m] = 0, cost[m] = +w, link[m] = last[u],
last[u] = m++;
adj[m] = u, cap[m] = 0, flow[m] = 0, cost[m] = -w, link[m] = last[v],
last[v] = m++;
}
bool spfa() {
int i, j, x, f = 0, l = 0;
for (i = 0; i <= n; i++)
visited[i] = 0, dis[i] = INF;
dis[s] = 0, Q[l++] = s;
while (f < l) {
i = Q[f++];
for (j = last[i]; j != -1; j = link[j]) {
if (flow[j] < cap[j]) {
x = adj[j];
if (dis[x] > dis[i] + cost[j]) {
dis[x] = dis[i] + cost[j], from[x] = j;
if (!visited[x]) {
visited[x] = 1;
if (f && rand() & 7)
Q[--f] = x;
else
Q[l++] = x;
}
}
}
}
visited[i] = 0;
}
return (dis[t] != INF);
}
pair<long long, long long> solve() {
int i, j;
long long mincost = 0, maxflow = 0;
while (spfa()) {
long long aug = INF;
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
aug = min(aug, cap[j] - flow[j]);
}
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
flow[j] += aug, flow[j ^ 1] -= aug;
}
maxflow += aug, mincost += aug * dis[t];
}
return make_pair(mincost, maxflow);
}
} // namespace mcmf
int dp[55][55][55][55];
char s[55][55];
int cnt[55][55];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == '#')
continue;
dp[i][j][i][j] = 1;
if (i < n - 1) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++)
dp[i][j][k][l] |= dp[i + 1][j][k][l];
}
}
if (j < m - 1) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++)
dp[i][j][k][l] |= dp[i][j + 1][k][l];
}
}
}
}
int cntob = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (s[i][j] == 'o')
cnt[i][j] = cntob++;
}
int src = cntob + n * m, sink = cntob + n * m + 1;
mcmf::init(cntob + n * m + 2, src, sink);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != 'o')
continue;
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
if (dp[i][j][k][l])
mcmf::addEdge(cnt[i][j], cntob + k * m + l, 1,
-((k + l) - (i + j)));
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'o')
mcmf::addEdge(src, cnt[i][j], 1, 0);
if (s[i][j] != '#')
mcmf::addEdge(cntob + i * m + j, sink, 1, 0);
}
}
pair<int, int> ans = mcmf::solve();
printf("%d\n", -ans.xx);
return 0;
}
| #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>/
// #include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define PI (acos(-1.0))
#define IN freopen("nocross.in", "r", stdin)
#define OUT freopen("nocross.out", "w", stdout)
#define FOR(i, a, b) for (i = a; i <= b; i++)
#define DBG printf("Hi\n")
#define i64 long long int
#define eps (1e-8)
#define xx first
#define yy second
#define ln 17
#define off 2
#define SZ(z) ((int)z.size())
#define FastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
// using namespace __gnu_pbds;
using namespace std;
// typedef tree< i64, null_type, less<i64>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set;
// #define maxn 1000005
// #define INF 2000000000000000000LL
// #define mod 998244353LL
namespace mcmf {
// this should be at least 2*( added edge in the graph )
const int MAX = 500000;
const long long INF = 1LL << 60;
long long cap[MAX], flow[MAX], cost[MAX], dis[MAX];
int n, m, s, t, Q[MAX * 10], adj[MAX], link[MAX], last[MAX], from[MAX],
visited[MAX];
void init(int nodes, int source, int sink) {
m = 0, n = nodes, s = source, t = sink;
for (int i = 0; i <= n; i++)
last[i] = -1;
}
void addEdge(int u, int v, long long c, long long w) {
adj[m] = v, cap[m] = c, flow[m] = 0, cost[m] = +w, link[m] = last[u],
last[u] = m++;
adj[m] = u, cap[m] = 0, flow[m] = 0, cost[m] = -w, link[m] = last[v],
last[v] = m++;
}
bool spfa() {
int i, j, x, f = 0, l = 0;
for (i = 0; i <= n; i++)
visited[i] = 0, dis[i] = INF;
dis[s] = 0, Q[l++] = s;
while (f < l) {
i = Q[f++];
for (j = last[i]; j != -1; j = link[j]) {
if (flow[j] < cap[j]) {
x = adj[j];
if (dis[x] > dis[i] + cost[j]) {
dis[x] = dis[i] + cost[j], from[x] = j;
if (!visited[x]) {
visited[x] = 1;
if (f && rand() & 7)
Q[--f] = x;
else
Q[l++] = x;
}
}
}
}
visited[i] = 0;
}
return (dis[t] != INF);
}
pair<long long, long long> solve() {
int i, j;
long long mincost = 0, maxflow = 0;
while (spfa()) {
long long aug = INF;
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
aug = min(aug, cap[j] - flow[j]);
}
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
flow[j] += aug, flow[j ^ 1] -= aug;
}
maxflow += aug, mincost += aug * dis[t];
}
return make_pair(mincost, maxflow);
}
} // namespace mcmf
int dp[55][55][55][55];
char s[55][55];
int cnt[55][55];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == '#')
continue;
dp[i][j][i][j] = 1;
if (i < n - 1) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++)
dp[i][j][k][l] |= dp[i + 1][j][k][l];
}
}
if (j < m - 1) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++)
dp[i][j][k][l] |= dp[i][j + 1][k][l];
}
}
}
}
int cntob = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (s[i][j] == 'o')
cnt[i][j] = cntob++;
}
int src = cntob + n * m, sink = cntob + n * m + 1;
mcmf::init(cntob + n * m + 2, src, sink);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != 'o')
continue;
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
if (dp[i][j][k][l])
mcmf::addEdge(cnt[i][j], cntob + k * m + l, 1,
-((k + l) - (i + j)));
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'o')
mcmf::addEdge(src, cnt[i][j], 1, 0);
if (s[i][j] != '#')
mcmf::addEdge(cntob + i * m + j, sink, 1, 0);
}
}
pair<int, int> ans = mcmf::solve();
printf("%d\n", -ans.xx);
return 0;
}
| replace | 35 | 36 | 35 | 36 | 0 | |
p02542 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x, i##end = y; i <= i##end; ++i)
#define _rep(i, x, y) for (int i = x, i##end = y; i >= i##end; --i)
#define ll long long
#define pk push_back
#define N 100005
typedef std::pair<int, int> pii;
int s, t;
int cnt = 1, head[N], to[N], flow[N], cost[N], nxt[N];
inline void add(int u, int v, int w, int c) {
to[++cnt] = v, flow[cnt] = w, cost[cnt] = c, nxt[cnt] = head[u],
head[u] = cnt;
to[++cnt] = u, flow[cnt] = 0, cost[cnt] = -c, nxt[cnt] = head[v],
head[v] = cnt;
}
bool vis[N];
int pre[N], dep[N];
inline bool spfa(int s, int t) {
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
memset(dep, 128, sizeof(dep));
std::queue<int> q;
q.push(s), dep[s] = 0, vis[s] = 1;
int inf = dep[0];
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; i; i = nxt[i]) {
if (flow[i] && dep[to[i]] < dep[u] + cost[i]) {
dep[to[i]] = dep[u] + cost[i], pre[to[i]] = i;
if (!vis[to[i]])
vis[to[i]] = 1, q.push(to[i]);
}
}
}
return dep[t] != inf;
}
inline std::pair<int, int> mcmf(int s, int t) {
std::pair<int, int> ret(0, 0);
while (spfa(s, t)) {
int mi = 2e9;
for (int i = t; i != s; i = to[pre[i] ^ 1])
mi = std::min(mi, flow[pre[i]]);
for (int i = t; i != s; i = to[pre[i] ^ 1])
flow[pre[i]] -= mi, flow[pre[i] ^ 1] += mi;
ret.first += mi, ret.second += dep[t] * mi;
}
return ret;
}
int n, m;
char S[105][105];
inline int id(int x, int y) { return (x - 1) * m + y; }
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
std::cin >> n >> m, s = n * m, t = s + 1;
rep(i, 1, n) std::cin >> S[i] + 1;
rep(i, 1, n) rep(j, 1, m) if (S[i][j] != '#') {
if (S[i][j] == 'o')
add(s, id(i, j), 1, 0);
if (i < n && S[i + 1][j] != '#')
add(id(i, j), id(i + 1, j), 2e9, 1);
if (j < m && S[i][j + 1] != '#')
add(id(i, j), id(i, j + 1), 2e9, 1);
add(id(i, j), t, 1, 0);
}
std::cout << mcmf(s, t).second << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x, i##end = y; i <= i##end; ++i)
#define _rep(i, x, y) for (int i = x, i##end = y; i >= i##end; --i)
#define ll long long
#define pk push_back
#define N 100005
typedef std::pair<int, int> pii;
int s, t;
int cnt = 1, head[N], to[N], flow[N], cost[N], nxt[N];
inline void add(int u, int v, int w, int c) {
to[++cnt] = v, flow[cnt] = w, cost[cnt] = c, nxt[cnt] = head[u],
head[u] = cnt;
to[++cnt] = u, flow[cnt] = 0, cost[cnt] = -c, nxt[cnt] = head[v],
head[v] = cnt;
}
bool vis[N];
int pre[N], dep[N];
inline bool spfa(int s, int t) {
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
memset(dep, 128, sizeof(dep));
std::queue<int> q;
q.push(s), dep[s] = 0, vis[s] = 1;
int inf = dep[0];
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; i; i = nxt[i]) {
if (flow[i] && dep[to[i]] < dep[u] + cost[i]) {
dep[to[i]] = dep[u] + cost[i], pre[to[i]] = i;
if (!vis[to[i]])
vis[to[i]] = 1, q.push(to[i]);
}
}
}
return dep[t] != inf;
}
inline std::pair<int, int> mcmf(int s, int t) {
std::pair<int, int> ret(0, 0);
while (spfa(s, t)) {
int mi = 2e9;
for (int i = t; i != s; i = to[pre[i] ^ 1])
mi = std::min(mi, flow[pre[i]]);
for (int i = t; i != s; i = to[pre[i] ^ 1])
flow[pre[i]] -= mi, flow[pre[i] ^ 1] += mi;
ret.first += mi, ret.second += dep[t] * mi;
}
return ret;
}
int n, m;
char S[105][105];
inline int id(int x, int y) { return (x - 1) * m + y; }
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
std::cin >> n >> m, s = n * m + 1, t = s + 1;
rep(i, 1, n) std::cin >> S[i] + 1;
rep(i, 1, n) rep(j, 1, m) if (S[i][j] != '#') {
if (S[i][j] == 'o')
add(s, id(i, j), 1, 0);
if (i < n && S[i + 1][j] != '#')
add(id(i, j), id(i + 1, j), 2e9, 1);
if (j < m && S[i][j + 1] != '#')
add(id(i, j), id(i, j + 1), 2e9, 1);
add(id(i, j), t, 1, 0);
}
std::cout << mcmf(s, t).second << '\n';
return 0;
} | replace | 56 | 57 | 56 | 57 | TLE | |
p02543 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define INF 1234567890
#define ll long long
int N, K, Q;
int X[200201];
int L[20][101001], R[20][100101];
ll LS[20][100101], RS[20][100101];
// LS[i][j] : j를 포함해서 만나는 2^i개의 정점의 번호 합
int main() {
scanf("%d %d", &N, &K);
for (int i = 1; i <= N; i++)
scanf("%d", &X[i]);
// L[] 채우기
map<int, int> m;
for (int i = 1; i <= N; i++) {
m[X[i]] = i;
auto it = m.upper_bound(X[i] - K);
if (it == m.begin())
continue;
it = prev(it);
L[0][i] = it->second;
}
m.clear();
for (int i = N; i >= 1; i--) {
m[X[i]] = i;
auto it = m.lower_bound(X[i] + K);
if (it == m.end())
continue;
R[0][i] = it->second;
}
for (int i = 1; i <= N; i++)
LS[0][i] = RS[0][i] = i;
for (int i = 1; i < 20; i++)
for (int j = 1; j <= N; j++) {
L[i][j] = L[i - 1][L[i - 1][j]];
R[i][j] = R[i - 1][R[i - 1][j]];
LS[i][j] = LS[i - 1][j] + LS[i - 1][L[i - 1][j]];
RS[i][j] = RS[i - 1][j] + RS[i - 1][R[i - 1][j]];
}
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d %d", &l, &r);
ll ls = 0, rs = 0, cnt = 0;
int n = r;
for (int i = 19; i >= 0; i--)
if (L[i][n] != 0 && l <= L[i][n])
rs += LS[i][n], n = L[i][n], cnt += (1 << i);
rs += LS[0][n];
cnt++;
n = l;
for (int i = 19; i >= 0; i--)
if (R[i][n] != 0 && R[i][n] <= r)
ls += RS[i][n], n = R[i][n];
ls += RS[0][n];
// printf("%lld, %lld, %lld : ", rs, ls, cnt);
printf("%lld\n", rs - ls + cnt);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 1234567890
#define ll long long
int N, K, Q;
int X[200201];
int L[20][200201], R[20][200201]; //
ll LS[20][200201], RS[20][200201]; //
// LS[i][j] : j를 포함해서 만나는 2^i개의 정점의 번호 합
int main() {
scanf("%d %d", &N, &K);
for (int i = 1; i <= N; i++)
scanf("%d", &X[i]);
// L[] 채우기
map<int, int> m;
for (int i = 1; i <= N; i++) {
m[X[i]] = i;
auto it = m.upper_bound(X[i] - K);
if (it == m.begin())
continue;
it = prev(it);
L[0][i] = it->second;
}
m.clear();
for (int i = N; i >= 1; i--) {
m[X[i]] = i;
auto it = m.lower_bound(X[i] + K);
if (it == m.end())
continue;
R[0][i] = it->second;
}
for (int i = 1; i <= N; i++)
LS[0][i] = RS[0][i] = i;
for (int i = 1; i < 20; i++)
for (int j = 1; j <= N; j++) {
L[i][j] = L[i - 1][L[i - 1][j]];
R[i][j] = R[i - 1][R[i - 1][j]];
LS[i][j] = LS[i - 1][j] + LS[i - 1][L[i - 1][j]];
RS[i][j] = RS[i - 1][j] + RS[i - 1][R[i - 1][j]];
}
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d %d", &l, &r);
ll ls = 0, rs = 0, cnt = 0;
int n = r;
for (int i = 19; i >= 0; i--)
if (L[i][n] != 0 && l <= L[i][n])
rs += LS[i][n], n = L[i][n], cnt += (1 << i);
rs += LS[0][n];
cnt++;
n = l;
for (int i = 19; i >= 0; i--)
if (R[i][n] != 0 && R[i][n] <= r)
ls += RS[i][n], n = R[i][n];
ls += RS[0][n];
// printf("%lld, %lld, %lld : ", rs, ls, cnt);
printf("%lld\n", rs - ls + cnt);
}
return 0;
} | replace | 8 | 10 | 8 | 10 | 0 | |
p02543 | C++ | Time Limit Exceeded | /* by Natsu Kinmoe */
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define loop(i, n) for (int i = 0; i < (n); i++)
#define cont(i, n) for (int i = 1; i <= (n); i++)
#define circ(i, a, b) for (int i = (a); i <= (b); i++)
#define range(i, a, b, c) \
for (int i = (a); ((c) > 0 ? i <= (b) : i >= (b)); i += (c))
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
#define y0 y0O0OO00OO0OO0OO0OOO00OO0OO0O0O000OO0
#define y1 y1II11II11III11I1III11II111IIII1II1I1
#define pub push_back
#define pob pop_back
#define mak make_pair
typedef long long ll;
typedef long double lf;
const int Inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
/* Source code starts here */
int n, k;
struct Tree {
struct BIT {
int dt[1 << 18];
void inline add(int a, int x) {
while (a < (1 << 18)) {
dt[a] += x;
a += a & -a;
}
}
int inline sum(int a) {
int res = 0;
while (a) {
res += dt[a];
a -= a & -a;
}
return res;
}
} bit;
vector<int> nei[1 << 18];
void inline link(int a, int b) { nei[a].pub(b); }
int fa[20][1 << 18], lvl[1 << 18], sz[1 << 18], son[1 << 18];
void inline predfs(int now) {
sz[now] = 1;
cont(i, 19) fa[i][now] = fa[i - 1][fa[i - 1][now]];
loop(i, SZ(nei[now])) {
int to = nei[now][i];
lvl[to] = lvl[now] + 1;
fa[0][to] = now;
predfs(to);
sz[now] += sz[to];
if (sz[to] > sz[son[now]])
son[now] = to;
}
}
int dfn[1 << 18], tmc;
int ro[1 << 18], tag;
void inline dfss(int now, int rt) {
dfn[now] = ++tmc;
ro[now] = rt;
if (son[now])
dfss(son[now], rt);
loop(i, SZ(nei[now])) {
int to = nei[now][i];
if (to == son[now])
continue;
dfss(to, to);
}
}
void inline init() { cont(i, n) bit.add(dfn[i], i); }
pair<int, int> inline find(int a, int b) {
int lvl = 0;
range(i, 19, 0, -1) if (fa[i][a] && (tag ? fa[i][a] >= b : fa[i][a] <= b)) {
lvl += 1 << i;
a = fa[i][a];
}
return mak(lvl, a);
}
int inline sum(int a, int b) {
int res = 0;
while (1) {
int rt = ro[a];
bool en = 0;
if (lvl[rt] <= lvl[b]) {
en = 1;
rt = b;
}
res += bit.sum(dfn[a]) - bit.sum(dfn[rt] - 1);
if (en)
break;
a = fa[0][rt];
}
return res;
}
} tl, tr;
int x[1 << 18];
int main() {
scanf("%d%d", &n, &k);
cont(i, n) scanf("%d", x + i);
cont(i, n) {
int pos = upper_bound(x + 1, x + n + 1, x[i] - k) - x - 1;
tl.link(pos, i);
pos = lower_bound(x + 1, x + n + 1, x[i] + k) - x;
if (pos == n + 1)
pos = 0;
tr.link(pos, i);
}
tl.predfs(0);
tr.predfs(0);
tl.dfss(0, 0);
tr.dfss(0, 0);
tl.tag = 1;
tl.init();
tr.init();
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
pair<int, int> res = tl.find(r, l);
int ans = res.first, pr = res.second;
res = tr.find(l, r);
assert(ans == res.first);
int pl = res.second;
printf("%d\n", tl.sum(r, pr) - tr.sum(l, pl) + ans + 1);
}
return 0;
}
/* 程序实现思路：
* 1.
* 构建一棵左链树和右链树，左链树中每个节点的父亲节点在序列中为第一个能接在这个点左边的点，右同理
* 2. 倍增，求出每棵树上每个节点的 2^i 层祖先
* 3. 对两棵树分别进行 HLD，并用线段树维护每条链上的下标和
* 4.
* 对于每个询问，先找到答案长度，将右树上对应链的下标和减去左树上对应链的下标和加上长度即为答案
* 5. 总时间复杂度 O(k log^2 n)
*/
| /* by Natsu Kinmoe */
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define loop(i, n) for (int i = 0; i < (n); i++)
#define cont(i, n) for (int i = 1; i <= (n); i++)
#define circ(i, a, b) for (int i = (a); i <= (b); i++)
#define range(i, a, b, c) \
for (int i = (a); ((c) > 0 ? i <= (b) : i >= (b)); i += (c))
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++)
#define y0 y0O0OO00OO0OO0OO0OOO00OO0OO0O0O000OO0
#define y1 y1II11II11III11I1III11II111IIII1II1I1
#define pub push_back
#define pob pop_back
#define mak make_pair
typedef long long ll;
typedef long double lf;
const int Inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
/* Source code starts here */
int n, k;
struct Tree {
struct BIT {
int dt[1 << 18];
void inline add(int a, int x) {
while (a < (1 << 18)) {
dt[a] += x;
a += a & -a;
}
}
int inline sum(int a) {
int res = 0;
while (a) {
res += dt[a];
a -= a & -a;
}
return res;
}
} bit;
vector<int> nei[1 << 18];
void inline link(int a, int b) { nei[a].pub(b); }
int fa[20][1 << 18], lvl[1 << 18], sz[1 << 18], son[1 << 18];
void inline predfs(int now) {
sz[now] = 1;
cont(i, 19) fa[i][now] = fa[i - 1][fa[i - 1][now]];
loop(i, SZ(nei[now])) {
int to = nei[now][i];
lvl[to] = lvl[now] + 1;
fa[0][to] = now;
predfs(to);
sz[now] += sz[to];
if (!son[now] || sz[to] > sz[son[now]])
son[now] = to;
}
}
int dfn[1 << 18], tmc;
int ro[1 << 18], tag;
void inline dfss(int now, int rt) {
dfn[now] = ++tmc;
ro[now] = rt;
if (son[now])
dfss(son[now], rt);
loop(i, SZ(nei[now])) {
int to = nei[now][i];
if (to == son[now])
continue;
dfss(to, to);
}
}
void inline init() { cont(i, n) bit.add(dfn[i], i); }
pair<int, int> inline find(int a, int b) {
int lvl = 0;
range(i, 19, 0, -1) if (fa[i][a] && (tag ? fa[i][a] >= b : fa[i][a] <= b)) {
lvl += 1 << i;
a = fa[i][a];
}
return mak(lvl, a);
}
int inline sum(int a, int b) {
int res = 0;
while (1) {
int rt = ro[a];
bool en = 0;
if (lvl[rt] <= lvl[b]) {
en = 1;
rt = b;
}
res += bit.sum(dfn[a]) - bit.sum(dfn[rt] - 1);
if (en)
break;
a = fa[0][rt];
}
return res;
}
} tl, tr;
int x[1 << 18];
int main() {
scanf("%d%d", &n, &k);
cont(i, n) scanf("%d", x + i);
cont(i, n) {
int pos = upper_bound(x + 1, x + n + 1, x[i] - k) - x - 1;
tl.link(pos, i);
pos = lower_bound(x + 1, x + n + 1, x[i] + k) - x;
if (pos == n + 1)
pos = 0;
tr.link(pos, i);
}
tl.predfs(0);
tr.predfs(0);
tl.dfss(0, 0);
tr.dfss(0, 0);
tl.tag = 1;
tl.init();
tr.init();
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
pair<int, int> res = tl.find(r, l);
int ans = res.first, pr = res.second;
res = tr.find(l, r);
assert(ans == res.first);
int pl = res.second;
printf("%d\n", tl.sum(r, pr) - tr.sum(l, pl) + ans + 1);
}
return 0;
}
/* 程序实现思路：
* 1.
* 构建一棵左链树和右链树，左链树中每个节点的父亲节点在序列中为第一个能接在这个点左边的点，右同理
* 2. 倍增，求出每棵树上每个节点的 2^i 层祖先
* 3. 对两棵树分别进行 HLD，并用线段树维护每条链上的下标和
* 4.
* 对于每个询问，先找到答案长度，将右树上对应链的下标和减去左树上对应链的下标和加上长度即为答案
* 5. 总时间复杂度 O(k log^2 n)
*/
| replace | 57 | 58 | 57 | 58 | TLE | |
p02544 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (int)(Y); ++(X))
#define reps(X, S, Y) for (int(X) = (int)(S); (X) < (int)(Y); ++(X))
#define rrep(X, Y) for (int(X) = (int)(Y)-1; (X) >= 0; --(X))
#define rreps(X, S, Y) for (int(X) = (int)(Y)-1; (X) >= (int)(S); --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)), (X).end())
#define Endl endl
#define NL << "\n"
#define cauto const auto
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> using vv = vector<vector<T>>;
template <class T> inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T> inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
// #undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
#ifdef __cpp_init_captures
template <typename T> vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args> auto table(int n, Args... args) {
auto val = table(args...);
return vector<decltype(val)>(n, move(val));
}
#endif
template <class A, class B>
pair<A, B> operator+(const pair<A, B> &p, const pair<A, B> &q) {
return {p.X + q.X, p.Y + q.Y};
}
template <class A, class B, class C, class D>
pair<A, B> &operator+=(pair<A, B> &p, const pair<C, D> &q) {
p.X += q.X;
p.Y += q.Y;
return p;
}
template <class A, class B>
pair<A, B> operator-(const pair<A, B> &p, const pair<A, B> &q) {
return {p.X - q.X, p.Y - q.Y};
}
template <class A, class B, class C, class D>
pair<A, B> &operator-=(pair<A, B> &p, const pair<C, D> &q) {
p.X -= q.X;
p.Y -= q.Y;
return p;
}
template <class A, class B> istream &operator>>(istream &is, pair<A, B> &p) {
is >> p.X >> p.Y;
return is;
}
template <class T = ll> T read() {
T re;
cin >> re;
return move(re);
}
template <class T = ll> T read(const T &dec) {
T re;
cin >> re;
return re - dec;
}
template <class T = ll> vector<T> readV(const int sz) {
vector<T> re(sz);
for (auto &x : re)
x = read<T>();
return move(re);
}
template <class T = ll> vector<T> readV(const int sz, const T &dec) {
vector<T> re(sz);
for (auto &x : re)
x = read<T>(dec);
return move(re);
}
vv<int> readG(const int &n, const int &m) {
vv<int> g(n);
rep(_, m) {
cauto a = read<int>(1), b = read<int>(1);
g[a].pb(b);
g[b].pb(a);
}
return move(g);
}
vv<int> readG(const int &n) { return readG(n, n - 1); }
const ll MOD = 998244353;
ll modpow_(ll r, ll n, ll m = MOD) {
ll re = 1, d = r % m;
if (n < 0)
(n %= m - 1) += m - 1;
for (; n; n /= 2) {
if (n & 1)
(re *= d) %= m;
(d *= d) %= m;
}
return re;
}
template <int mod = MOD> struct ModInt {
int v;
ModInt(int v = 0) : v(v) {}
ModInt operator+(const ModInt &n) const {
return v + n.v < mod ? v + n.v : v + n.v - mod;
}
ModInt operator-(const ModInt &n) const {
return v - n.v < 0 ? v - n.v + mod : v - n.v;
}
ModInt operator*(const ModInt &n) const { return ll(v) * n.v % mod; }
ModInt operator/(const ModInt &n) const {
return ll(v) * modpow_(n.v % mod, -1, mod) % mod;
}
ModInt operator+(const ll &n) const {
return v + n < mod ? v + n : v + n - mod;
}
ModInt operator-(const ll &n) const {
return v - n < 0 ? v - n + mod : v - n;
}
ModInt operator*(const ll &n) const { return ll(v) * (n % mod) % mod; }
ModInt operator/(const ll &n) const {
return ll(v) * modpow_(n % mod, -1, mod) % mod;
}
ModInt &operator+=(const ModInt &n) {
v += n.v;
if (v >= mod)
v -= mod;
return *this;
}
ModInt &operator-=(const ModInt &n) {
v -= n.v;
if (v < 0)
v += mod;
return *this;
}
ModInt &operator*=(const ModInt &n) {
v = ll(v) * n.v % mod;
return *this;
}
ModInt &operator/=(const ModInt &n) {
v = ll(v) * modpow_(n.v, -1, mod) % mod;
return *this;
}
ModInt &operator+=(const ll &n) {
v += n;
if (v >= mod)
v -= mod;
return *this;
}
ModInt &operator-=(const ll &n) {
v -= n;
if (v < 0)
v += mod;
return *this;
}
ModInt &operator*=(const ll &n) {
v = ll(v) * n % mod;
return *this;
}
ModInt &operator/=(const ll &n) {
v = ll(v) * modpow_(n, -1, mod) % mod;
return *this;
}
bool operator==(const ModInt &n) const { return v == n.v; };
bool operator!=(const ModInt &n) const { return v != n.v; };
ModInt &operator++() { return operator+=(1); }
ModInt &operator--() { return operator-=(1); }
ModInt operator++(int i) {
ModInt tmp(*this);
operator++();
return tmp;
}
ModInt operator--(int i) {
ModInt tmp(*this);
operator--();
return tmp;
}
};
#ifdef NUIP
class MINT_FRAC____ {
public:
unordered_map<int, pii> dict;
MINT_FRAC____(int n) {
rep(p, n + 1) reps(q, 1, n + 1) if (__gcd(p, q) == 1) {
dict[1ll * p * modpow_(q, -1) % MOD] = pii(p, q);
dict[MOD - 1ll * p * modpow_(q, -1) % MOD] = pii(-p, q);
}
}
} Il1Il1Il1(1000);
template <int mod> ostream &operator<<(ostream &os, const ModInt<mod> &n) {
if (Il1Il1Il1.dict.count(n.v))
os << n.v << "(" << Il1Il1Il1.dict[n.v].X << "/" << Il1Il1Il1.dict[n.v].Y
<< ")";
else
os << n.v;
return os;
};
#else
template <int mod> ostream &operator<<(ostream &os, const ModInt<mod> &n) {
return os << n.v;
};
#endif
template <int mod> ModInt<mod> operator+(const ll &n, const ModInt<mod> &m) {
return m.v + n < mod ? m.v + n : m.v + n - mod;
}
template <int mod> ModInt<mod> operator-(const ll &n, const ModInt<mod> &m) {
return n - m.v < 0 ? n - m.v + mod : n - m.v;
}
template <int mod> ModInt<mod> operator*(const ll &n, const ModInt<mod> &m) {
return ll(m.v) * (n % mod) % mod;
}
template <int mod> ModInt<mod> operator/(const ll &n, const ModInt<mod> &m) {
return ModInt<mod>(n % mod) / m;
}
typedef ModInt<MOD> mint;
template <int mod> ModInt<mod> modpow(ModInt<mod> r, ll n) {
ModInt<mod> re(1);
if (n < 0)
(n %= mod - 1) += mod - 1;
for (; n; n /= 2) {
if (n & 1)
re *= r;
r *= r;
}
return re;
}
vector<mint> fact, finv, inv;
mint comb(ll n, ll r) {
if (n < r || r < 0)
return 0;
return fact[n] * finv[n - r] * finv[r];
}
class Doralion {
void Modinvs(vector<mint> &re, int n) {
re.resize(n + 1);
re[1] = 1;
for (int i = 2; i <= n; ++i)
re[i] = re[MOD % i] * (MOD - MOD / i);
}
void Facts(vector<mint> &re, int n) {
re.resize(n + 1);
re[0] = 1;
rep(i, n) re[i + 1] = re[i] * (i + 1);
}
void Factinvs(vector<mint> &re, const vector<mint> &inv, int n) {
re.resize(n + 1);
re[0] = 1;
rep(i, n) re[i + 1] = re[i] * inv[i + 1];
}
public:
Doralion(int n) {
Modinvs(inv, n);
Facts(fact, n);
Factinvs(finv, inv, n);
}
} doralion(1123456);
using pmm = pair<mint, mint>;
mint modpow(ll r, ll n) { return modpow_(r, n); }
const int nn = 112345;
mint bit[nn + 1];
int cnts[nn + 1];
pair<mint, int> sum(int i) {
++i;
mint s = 0;
int c = 0;
while (i > 0) {
s += bit[i];
c += cnts[i];
i -= i & -i;
}
return {s, c};
}
void add(int i, mint x) {
++i;
++i;
while (i <= nn) {
bit[i] += x;
cnts[i] += 1;
i += i & -i;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
cauto n = read();
cauto w = read();
cauto p = readV(n, 1);
vector<int> ind(n);
iota(all(ind), 0);
sort(all(ind), [&](cauto i, cauto j) { return p[i] < p[j]; });
vector<int> ts(n);
rep(i, n) ts[i] = max<int>(0, i - (w - 1));
out(ts, 1);
mint re = 0;
mint rem = (w - 1) * inv[w];
vector<mint> pw(n + 1);
pw[0] = 1;
rep(i, n) pw[i + 1] = pw[i] * rem;
vector<mint> sums(n);
rreps(i, 1, n) sums[i - 1] = sums[i] + pw[ts[i]];
for (cauto i : ind) {
mint div = inv[2] / pw[ts[i]];
cauto[lt, c] = sum(n) - sum(i);
mint gt = sums[i] - lt;
out(i, c, lt, gt, div, 1);
re += c - lt * div;
re += gt * div;
add(i, pw[ts[i]]);
// reps(j,i+1,n){
// mint prob=pw[ts[j]-ts[i]]*inv[2];
// out(i,j,ts[j]-ts[i],prob,1);
// if(p[i]>p[j]){
// re+=1-prob;
// }else{
// re+=prob;
// }
// }
}
cout << re NL;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (int)(Y); ++(X))
#define reps(X, S, Y) for (int(X) = (int)(S); (X) < (int)(Y); ++(X))
#define rrep(X, Y) for (int(X) = (int)(Y)-1; (X) >= 0; --(X))
#define rreps(X, S, Y) for (int(X) = (int)(Y)-1; (X) >= (int)(S); --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)), (X).end())
#define Endl endl
#define NL << "\n"
#define cauto const auto
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> using vv = vector<vector<T>>;
template <class T> inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T> inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
// #undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
#ifdef __cpp_init_captures
template <typename T> vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args> auto table(int n, Args... args) {
auto val = table(args...);
return vector<decltype(val)>(n, move(val));
}
#endif
template <class A, class B>
pair<A, B> operator+(const pair<A, B> &p, const pair<A, B> &q) {
return {p.X + q.X, p.Y + q.Y};
}
template <class A, class B, class C, class D>
pair<A, B> &operator+=(pair<A, B> &p, const pair<C, D> &q) {
p.X += q.X;
p.Y += q.Y;
return p;
}
template <class A, class B>
pair<A, B> operator-(const pair<A, B> &p, const pair<A, B> &q) {
return {p.X - q.X, p.Y - q.Y};
}
template <class A, class B, class C, class D>
pair<A, B> &operator-=(pair<A, B> &p, const pair<C, D> &q) {
p.X -= q.X;
p.Y -= q.Y;
return p;
}
template <class A, class B> istream &operator>>(istream &is, pair<A, B> &p) {
is >> p.X >> p.Y;
return is;
}
template <class T = ll> T read() {
T re;
cin >> re;
return move(re);
}
template <class T = ll> T read(const T &dec) {
T re;
cin >> re;
return re - dec;
}
template <class T = ll> vector<T> readV(const int sz) {
vector<T> re(sz);
for (auto &x : re)
x = read<T>();
return move(re);
}
template <class T = ll> vector<T> readV(const int sz, const T &dec) {
vector<T> re(sz);
for (auto &x : re)
x = read<T>(dec);
return move(re);
}
vv<int> readG(const int &n, const int &m) {
vv<int> g(n);
rep(_, m) {
cauto a = read<int>(1), b = read<int>(1);
g[a].pb(b);
g[b].pb(a);
}
return move(g);
}
vv<int> readG(const int &n) { return readG(n, n - 1); }
const ll MOD = 998244353;
ll modpow_(ll r, ll n, ll m = MOD) {
ll re = 1, d = r % m;
if (n < 0)
(n %= m - 1) += m - 1;
for (; n; n /= 2) {
if (n & 1)
(re *= d) %= m;
(d *= d) %= m;
}
return re;
}
template <int mod = MOD> struct ModInt {
int v;
ModInt(int v = 0) : v(v) {}
ModInt operator+(const ModInt &n) const {
return v + n.v < mod ? v + n.v : v + n.v - mod;
}
ModInt operator-(const ModInt &n) const {
return v - n.v < 0 ? v - n.v + mod : v - n.v;
}
ModInt operator*(const ModInt &n) const { return ll(v) * n.v % mod; }
ModInt operator/(const ModInt &n) const {
return ll(v) * modpow_(n.v % mod, -1, mod) % mod;
}
ModInt operator+(const ll &n) const {
return v + n < mod ? v + n : v + n - mod;
}
ModInt operator-(const ll &n) const {
return v - n < 0 ? v - n + mod : v - n;
}
ModInt operator*(const ll &n) const { return ll(v) * (n % mod) % mod; }
ModInt operator/(const ll &n) const {
return ll(v) * modpow_(n % mod, -1, mod) % mod;
}
ModInt &operator+=(const ModInt &n) {
v += n.v;
if (v >= mod)
v -= mod;
return *this;
}
ModInt &operator-=(const ModInt &n) {
v -= n.v;
if (v < 0)
v += mod;
return *this;
}
ModInt &operator*=(const ModInt &n) {
v = ll(v) * n.v % mod;
return *this;
}
ModInt &operator/=(const ModInt &n) {
v = ll(v) * modpow_(n.v, -1, mod) % mod;
return *this;
}
ModInt &operator+=(const ll &n) {
v += n;
if (v >= mod)
v -= mod;
return *this;
}
ModInt &operator-=(const ll &n) {
v -= n;
if (v < 0)
v += mod;
return *this;
}
ModInt &operator*=(const ll &n) {
v = ll(v) * n % mod;
return *this;
}
ModInt &operator/=(const ll &n) {
v = ll(v) * modpow_(n, -1, mod) % mod;
return *this;
}
bool operator==(const ModInt &n) const { return v == n.v; };
bool operator!=(const ModInt &n) const { return v != n.v; };
ModInt &operator++() { return operator+=(1); }
ModInt &operator--() { return operator-=(1); }
ModInt operator++(int i) {
ModInt tmp(*this);
operator++();
return tmp;
}
ModInt operator--(int i) {
ModInt tmp(*this);
operator--();
return tmp;
}
};
#ifdef NUIP
class MINT_FRAC____ {
public:
unordered_map<int, pii> dict;
MINT_FRAC____(int n) {
rep(p, n + 1) reps(q, 1, n + 1) if (__gcd(p, q) == 1) {
dict[1ll * p * modpow_(q, -1) % MOD] = pii(p, q);
dict[MOD - 1ll * p * modpow_(q, -1) % MOD] = pii(-p, q);
}
}
} Il1Il1Il1(1000);
template <int mod> ostream &operator<<(ostream &os, const ModInt<mod> &n) {
if (Il1Il1Il1.dict.count(n.v))
os << n.v << "(" << Il1Il1Il1.dict[n.v].X << "/" << Il1Il1Il1.dict[n.v].Y
<< ")";
else
os << n.v;
return os;
};
#else
template <int mod> ostream &operator<<(ostream &os, const ModInt<mod> &n) {
return os << n.v;
};
#endif
template <int mod> ModInt<mod> operator+(const ll &n, const ModInt<mod> &m) {
return m.v + n < mod ? m.v + n : m.v + n - mod;
}
template <int mod> ModInt<mod> operator-(const ll &n, const ModInt<mod> &m) {
return n - m.v < 0 ? n - m.v + mod : n - m.v;
}
template <int mod> ModInt<mod> operator*(const ll &n, const ModInt<mod> &m) {
return ll(m.v) * (n % mod) % mod;
}
template <int mod> ModInt<mod> operator/(const ll &n, const ModInt<mod> &m) {
return ModInt<mod>(n % mod) / m;
}
typedef ModInt<MOD> mint;
template <int mod> ModInt<mod> modpow(ModInt<mod> r, ll n) {
ModInt<mod> re(1);
if (n < 0)
(n %= mod - 1) += mod - 1;
for (; n; n /= 2) {
if (n & 1)
re *= r;
r *= r;
}
return re;
}
vector<mint> fact, finv, inv;
mint comb(ll n, ll r) {
if (n < r || r < 0)
return 0;
return fact[n] * finv[n - r] * finv[r];
}
class Doralion {
void Modinvs(vector<mint> &re, int n) {
re.resize(n + 1);
re[1] = 1;
for (int i = 2; i <= n; ++i)
re[i] = re[MOD % i] * (MOD - MOD / i);
}
void Facts(vector<mint> &re, int n) {
re.resize(n + 1);
re[0] = 1;
rep(i, n) re[i + 1] = re[i] * (i + 1);
}
void Factinvs(vector<mint> &re, const vector<mint> &inv, int n) {
re.resize(n + 1);
re[0] = 1;
rep(i, n) re[i + 1] = re[i] * inv[i + 1];
}
public:
Doralion(int n) {
Modinvs(inv, n);
Facts(fact, n);
Factinvs(finv, inv, n);
}
} doralion(1123456);
using pmm = pair<mint, mint>;
mint modpow(ll r, ll n) { return modpow_(r, n); }
const int nn = 212345;
mint bit[nn + 1];
int cnts[nn + 1];
pair<mint, int> sum(int i) {
++i;
mint s = 0;
int c = 0;
while (i > 0) {
s += bit[i];
c += cnts[i];
i -= i & -i;
}
return {s, c};
}
void add(int i, mint x) {
++i;
++i;
while (i <= nn) {
bit[i] += x;
cnts[i] += 1;
i += i & -i;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
cauto n = read();
cauto w = read();
cauto p = readV(n, 1);
vector<int> ind(n);
iota(all(ind), 0);
sort(all(ind), [&](cauto i, cauto j) { return p[i] < p[j]; });
vector<int> ts(n);
rep(i, n) ts[i] = max<int>(0, i - (w - 1));
out(ts, 1);
mint re = 0;
mint rem = (w - 1) * inv[w];
vector<mint> pw(n + 1);
pw[0] = 1;
rep(i, n) pw[i + 1] = pw[i] * rem;
vector<mint> sums(n);
rreps(i, 1, n) sums[i - 1] = sums[i] + pw[ts[i]];
for (cauto i : ind) {
mint div = inv[2] / pw[ts[i]];
cauto[lt, c] = sum(n) - sum(i);
mint gt = sums[i] - lt;
out(i, c, lt, gt, div, 1);
re += c - lt * div;
re += gt * div;
add(i, pw[ts[i]]);
// reps(j,i+1,n){
// mint prob=pw[ts[j]-ts[i]]*inv[2];
// out(i,j,ts[j]-ts[i],prob,1);
// if(p[i]>p[j]){
// re+=1-prob;
// }else{
// re+=prob;
// }
// }
}
cout << re NL;
return 0;
}
| replace | 294 | 295 | 294 | 295 | 0 | |
p02546 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int n = 0;
n = S.size();
if (S.at(n) == 's') {
cout << S + "es" << endl;
} else {
cout << S + 's' << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int n = 0;
n = S.size();
if (S.at(n - 1) == 's') {
cout << S + "es" << endl;
} else {
cout << S + 's' << endl;
}
}
| replace | 9 | 10 | 9 | 10 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 5) >= this->size() (which is 5)
|
p02546 | Python | Runtime Error | N = input()
if N[len(N) - 1] == "s":
N += "es"
else:
N += "s"
print(N)
N = input()
if N[len(N) - 1] == "s":
N += "es"
else:
N += "s"
print(N)
| N = input()
if N[len(N) - 1] == "s":
N += "es"
else:
N += "s"
print(N)
| delete | 7 | 14 | 7 | 7 | EOFError: EOF when reading a line | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02546/Python/s030233294.py", line 8, in <module>
N = input()
EOFError: EOF when reading a line
|
p02546 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, c;
cin >> s;
c = s;
if (s[s.length() - 1] != 's')
c += "s";
else {
c.erase(c.end());
c += "es";
}
cout << c;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s, c;
cin >> s;
c = s;
if (s[s.length() - 1] != 's')
c += "s";
else {
c += "es";
}
cout << c;
return 0;
}
| delete | 9 | 10 | 9 | 9 | 0 | |
p02546 | C++ | Runtime Error | #pragma warning(disable : 4996)
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define MAX 1001
char str[MAX];
int main() {
scanf("%s", str);
for (int i = 0; str[i] != '\0'; i++) {
if (str[i + 1] == '\0') {
if (str[i] == 's')
strcat(str, "es");
else
strcat(str, "s");
break;
}
}
printf("%s", str);
} | #pragma warning(disable : 4996)
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define MAX 1010
char str[MAX];
int main() {
scanf("%s", str);
for (int i = 0; str[i] != '\0'; i++) {
if (str[i + 1] == '\0') {
if (str[i] == 's')
strcat(str, "es");
else
strcat(str, "s");
break;
}
}
printf("%s", str);
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02546 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
string a;
string d = "es", e = "s";
int b = a.size();
char c = a.at(b - 1);
if (c == 's')
cout << a + d;
else
cout << a + e;
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string a;
cin >> a;
string d = "es", e = "s";
int b = a.size();
char c = a.at(b - 1);
if (c == 's')
cout << a + d;
else
cout << a + e;
return 0;
}
| insert | 5 | 5 | 5 | 6 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 18446744073709551615) >= this->size() (which is 0)
|
p02546 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
if (s.at(s.size() - 1) == 's') {
cout << s << "es";
} else {
cout << s << "s";
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
int a;
cin >> s;
a = s.size();
if (s.at(a - 1) == 's') {
cout << s << "es";
} else {
cout << s << "s";
}
} | replace | 6 | 7 | 6 | 10 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 18446744073709551615) >= this->size() (which is 0)
|
p02546 | C++ | Runtime Error |
#include <iostream>
#include <string>
using namespace std;
int main() {
int i;
string str;
cin >> str;
int str1 = str.size();
if (str.at(str1) == 's') {
cout << str + "es" << endl;
} else {
cout << str + "s" << endl;
}
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
int i;
string str;
cin >> str;
int str1 = str.size();
if (str.at(str1 - 1) == 's') {
cout << str + "es" << endl;
} else {
cout << str + "s" << endl;
}
}
| replace | 9 | 10 | 9 | 10 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 5) >= this->size() (which is 5)
|
p02546 | C++ | Runtime Error | #include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
typedef long long ll;
// sort(rt,rt+sizeof(rt)/sizeof(rt[0]),greater<>());
using namespace std;
#define rep(i, n) for (i = 0; i < n; i++)
int main() {
char n[100];
cin >> n;
int a;
a = (int)strlen(n);
if (n[a - 1] == 's') {
cout << n << "es";
return 0;
} else if (n[a - 1] != 's') {
cout << n << 's';
return 0;
}
}
| #include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
typedef long long ll;
// sort(rt,rt+sizeof(rt)/sizeof(rt[0]),greater<>());
using namespace std;
#define rep(i, n) for (i = 0; i < n; i++)
int main() {
char n[1001];
cin >> n;
int a;
a = (int)strlen(n);
if (n[a - 1] == 's') {
cout << n << "es";
return 0;
} else if (n[a - 1] != 's') {
cout << n << 's';
return 0;
}
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p02546 | C++ | Runtime Error | #include <cstring>
#include <iostream>
using namespace std;
int main() {
char s[1000];
cin >> s;
char s0[] = "es";
char s1[] = "s";
if (s[strlen(s) - 1] == 's') {
strcat(s, s0);
cout << s << endl;
} else {
strcat(s, s1);
cout << s << endl;
}
} | #include <cstring>
#include <iostream>
using namespace std;
int main() {
char s[10000];
cin >> s;
char s0[] = "es";
char s1[] = "s";
if (s[strlen(s) - 1] == 's') {
strcat(s, s0);
cout << s << endl;
} else {
strcat(s, s1);
cout << s << endl;
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02546 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int main(void) {
char s[103];
int i, len, k = 0;
scanf("%s", s);
len = strlen(s);
if (s[len - 1] == 's') {
s[len] = 'e';
s[len + 1] = 's';
k = 1;
} else
s[len] = 's';
if (k == 1) {
for (i = 0; i < len + 2; i++)
printf("%c", s[i]);
} else {
for (i = 0; i <= len; i++)
printf("%c", s[i]);
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int main(void) {
char s[1003];
int i, len, k = 0;
scanf("%s", s);
len = strlen(s);
if (s[len - 1] == 's') {
s[len] = 'e';
s[len + 1] = 's';
k = 1;
} else
s[len] = 's';
if (k == 1) {
for (i = 0; i < len + 2; i++)
printf("%c", s[i]);
} else {
for (i = 0; i <= len; i++)
printf("%c", s[i]);
}
return 0;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02546 | C++ | Runtime Error | #include <stdio.h>
#include <string.h>
int main() {
char s[255];
scanf("%s", s);
if (s[strlen(s) - 1] == 's')
printf("%ses", s);
else
printf("%ss", s);
return 0;
} | #include <stdio.h>
#include <string.h>
int main() {
char s[1005];
scanf("%s", s);
if (s[strlen(s) - 1] == 's')
printf("%ses", s);
else
printf("%ss", s);
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02546 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string str;
if (str.at(str.size() - 1) == 's')
cout << str + "es" << endl;
else
cout << str + 's' << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
if (str.at(str.size() - 1) == 's')
cout << str + "es" << endl;
else
cout << str + 's' << endl;
}
| insert | 5 | 5 | 5 | 6 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 18446744073709551615) >= this->size() (which is 0)
|
p02546 | C++ | Runtime Error | #include <iostream>
#include <string.h>
using namespace std;
int main() {
char w[1000];
cin >> w;
int l = strlen(w);
if (w[l - 1] == 's') {
char p[l + 1];
w[l] = 'e';
w[l + 1] = 's';
strcpy(p, w);
for (int i = 0; i <= l + 1; i++) {
cout << p[i];
}
}
else {
w[l] = 's';
char p[l];
strcpy(p, w);
for (int i = 0; i <= l; i++) {
cout << p[i];
}
}
} | #include <iostream>
#include <string.h>
using namespace std;
int main() {
char w[1000];
cin >> w;
int l = strlen(w);
if (w[l - 1] == 's')
cout << w << "es";
else
cout << w << 's';
}
| replace | 7 | 25 | 7 | 11 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.