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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02660 | C++ | Time Limit Exceeded | // #include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
#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(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define SORT(s) sort(s.begin(), s.end())
#define P pair<int, int>
#define mp make_pair
const double INF = 1e+09;
const int MOD = 1e9 + 7;
using namespace std;
template <typename _Ty>
ostream &operator<<(ostream &ostr, const vector<_Ty> &v) {
if (v.empty()) {
ostr << "{ }";
return ostr;
}
ostr << "{" << v.front();
for (auto itr = ++v.begin(); itr != v.end(); itr++) {
ostr << ", " << *itr;
}
ostr << "}";
return ostr;
}
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;
}
int gcd(int a, int b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
vector<int> uniq(vector<int> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
vector<ll> divisor(ll n) {
vector<ll> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
void permu(int n) {
vector<int> perm(n);
REP(i, n) perm[i] = i;
do {
cout << perm << endl;
} while (next_permutation(perm.begin(), perm.end()));
return;
}
vector<pair<ll, int>> prime_div(ll n) {
vector<pair<ll, int>> res;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
int a = 0;
while (n % i == 0) {
n /= i;
a++;
}
pair<ll, int> tmp;
tmp.first = i;
tmp.second = a;
res.push_back(tmp);
}
}
if (n != 1) {
pair<ll, int> now;
now.first = n;
now.second = 1;
res.push_back(now);
}
return res;
}
// printf("%.10f\n" , ans);
int main(void) {
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<pair<ll, int>> res = prime_div(n);
int ans = 0;
for (auto v : res) {
int b = 1;
while (b <= v.second) {
ans++;
v.second -= b;
b++;
}
}
cout << ans << endl;
return 0;
}
| // #include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
#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(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define SORT(s) sort(s.begin(), s.end())
#define P pair<int, int>
#define mp make_pair
const double INF = 1e+09;
const int MOD = 1e9 + 7;
using namespace std;
template <typename _Ty>
ostream &operator<<(ostream &ostr, const vector<_Ty> &v) {
if (v.empty()) {
ostr << "{ }";
return ostr;
}
ostr << "{" << v.front();
for (auto itr = ++v.begin(); itr != v.end(); itr++) {
ostr << ", " << *itr;
}
ostr << "}";
return ostr;
}
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;
}
int gcd(int a, int b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
vector<int> uniq(vector<int> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
vector<ll> divisor(ll n) {
vector<ll> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
void permu(int n) {
vector<int> perm(n);
REP(i, n) perm[i] = i;
do {
cout << perm << endl;
} while (next_permutation(perm.begin(), perm.end()));
return;
}
vector<pair<ll, int>> prime_div(ll n) {
vector<pair<ll, int>> res;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
int a = 0;
while (n % i == 0) {
n /= i;
a++;
}
pair<ll, int> tmp;
tmp.first = i;
tmp.second = a;
res.push_back(tmp);
}
}
if (n != 1) {
pair<ll, int> now;
now.first = n;
now.second = 1;
res.push_back(now);
}
return res;
}
// printf("%.10f\n" , ans);
int main(void) {
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<pair<ll, int>> res = prime_div(n);
int ans = 0;
for (auto v : res) {
int b = 1;
while (b <= v.second) {
ans++;
v.second -= b;
b++;
}
}
cout << ans << endl;
return 0;
}
| replace | 96 | 97 | 96 | 97 | TLE | |
p02660 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
const ll inf = 1LL << 60;
const int pp = 1e6 + 10;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
ll N;
cin >> N;
vector<bool> is_prime(pp + 1, true);
REP(i, pp + 1) {
if (i == 0 || i == 1) {
is_prime[i] = false;
}
if (is_prime[i] == true) {
for (int k = 2 * i; k <= pp; k += i) {
is_prime[k] = false;
}
}
}
vector<int> prime(pp + 1, 0);
int itr = 0;
for (int i = 2; i * i <= N; i++) {
if (is_prime[i]) {
while (N % i == 0) {
N /= i;
prime[itr]++;
}
itr++;
if (N == 1)
break;
}
}
if (N > 1) {
prime[itr]++;
itr++;
}
int ans = 0;
REP(i, itr) {
int k = 1;
while (k * (k + 1) / 2 <= prime[i]) {
k++;
}
k--;
ans += k;
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
const ll inf = 1LL << 60;
const int pp = 1e6 + 10;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
ll N;
cin >> N;
vector<bool> is_prime(pp + 1, true);
REP(i, pp + 1) {
if (i == 0 || i == 1) {
is_prime[i] = false;
}
if (is_prime[i] == true) {
for (int k = 2 * i; k <= pp; k += i) {
is_prime[k] = false;
}
}
}
vector<int> prime(pp + 1, 0);
int itr = 0;
for (ll i = 2; i * i <= N; i++) {
if (is_prime[i]) {
while (N % i == 0) {
N /= i;
prime[itr]++;
}
itr++;
if (N == 1)
break;
}
}
if (N > 1) {
prime[itr]++;
itr++;
}
int ans = 0;
REP(i, itr) {
int k = 1;
while (k * (k + 1) / 2 <= prime[i]) {
k++;
}
k--;
ans += k;
}
cout << ans << endl;
} | replace | 38 | 39 | 38 | 39 | 0 | |
p02661 | 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 fi first
#define se second
#define mp make_pair
#define pii pair<int, int>
#define fr(i, a, b) for (int i = a; i < b; i++)
#define frb(i, a, b) for (int i = a; i > b; i--)
#define sz(s) (int)s.size()
#define all(v) (v).begin(), (v).end()
#define srt(v) sort(all(v))
#define srtGreat(v) sort(all(v), greater<ll>())
#define iset \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define oset \
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long
using namespace std;
using namespace __gnu_pbds;
int prg() {
int n;
cin >> n;
vector<int> a(n), b(n);
fr(i, 0, n) cin >> a[i] >> b[i];
srt(a);
srt(b);
if (n % 2 == 1)
cout << b[n / 2] - a[n / 2] + 1;
else {
cout << b[n / 2] + b[n / 2 - 1] - a[n / 2] - a[n / 2 - 1] + 1;
}
}
void multi() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
prg();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
prg();
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 fi first
#define se second
#define mp make_pair
#define pii pair<int, int>
#define fr(i, a, b) for (int i = a; i < b; i++)
#define frb(i, a, b) for (int i = a; i > b; i--)
#define sz(s) (int)s.size()
#define all(v) (v).begin(), (v).end()
#define srt(v) sort(all(v))
#define srtGreat(v) sort(all(v), greater<ll>())
#define iset \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define oset \
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long
using namespace std;
using namespace __gnu_pbds;
int prg() {
int n;
cin >> n;
vector<int> a(n), b(n);
fr(i, 0, n) cin >> a[i] >> b[i];
srt(a);
srt(b);
if (n % 2 == 1)
cout << b[n / 2] - a[n / 2] + 1;
else {
cout << b[n / 2] + b[n / 2 - 1] - a[n / 2] - a[n / 2 - 1] + 1;
}
return 0;
}
void multi() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
prg();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
prg();
return 0;
} | insert | 36 | 36 | 36 | 37 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
#define f first
#define s second
#define FOR(i, s, e) for (ll i = s; i <= ll(e); ++i)
#define DEC(i, s, e) for (ll i = s; i >= ll(e); --i)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
#define aFOR(i, x) for (auto i : x)
#define mem(x, i) memset(x, i, sizeof x)
#define fast ios_base::sync_with_stdio(false), cin.tie(0)
#define maxn 100001
typedef pair<pi, int> pii;
int N;
int A[maxn], B[maxn];
int main() {
fast;
cin >> N;
vi vect;
FOR(i, 0, N - 1) { cin >> A[i] >> B[i]; }
sort(A, A + N);
sort(B, B + N);
if (N % 2 == 0)
cout << 1 - A[N / 2 - 1] - A[N / 2] + B[N / 2 - 1] + B[N / 2];
else
cout << B[N / 2] - A[N / 2] + 1;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
#define f first
#define s second
#define FOR(i, s, e) for (ll i = s; i <= ll(e); ++i)
#define DEC(i, s, e) for (ll i = s; i >= ll(e); --i)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
#define aFOR(i, x) for (auto i : x)
#define mem(x, i) memset(x, i, sizeof x)
#define fast ios_base::sync_with_stdio(false), cin.tie(0)
#define maxn 200001
typedef pair<pi, int> pii;
int N;
int A[maxn], B[maxn];
int main() {
fast;
cin >> N;
vi vect;
FOR(i, 0, N - 1) { cin >> A[i] >> B[i]; }
sort(A, A + N);
sort(B, B + N);
if (N % 2 == 0)
cout << 1 - A[N / 2 - 1] - A[N / 2] + B[N / 2 - 1] + B[N / 2];
else
cout << B[N / 2] - A[N / 2] + 1;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
typedef long long ll;
typedef long double ld;
const int N = (int)1e5 + 7;
int n;
int a[N];
int b[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
int f = a[n / 2 + 1], s = b[n / 2 + 1];
cout << s - f + 1 << "\n";
} else {
int f = a[n / 2] + a[n / 2 + 1], s = b[n / 2] + b[n / 2 + 1];
cout << s - f + 1 << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
typedef long long ll;
typedef long double ld;
const int N = (int)2e5 + 7;
int n;
int a[N];
int b[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
int f = a[n / 2 + 1], s = b[n / 2 + 1];
cout << s - f + 1 << "\n";
} else {
int f = a[n / 2] + a[n / 2 + 1], s = b[n / 2] + b[n / 2 + 1];
cout << s - f + 1 << "\n";
}
return 0;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
int n, a[N], b[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
reverse(b, b + n);
if (n & 1) {
cout << b[n / 2] - a[n / 2] + 1;
} else {
assert(false);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
int n, a[N], b[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
reverse(b, b + n);
if (n & 1) {
cout << b[n / 2] - a[n / 2] + 1;
} else {
pair<ll, ll> le = {a[n / 2 - 1], b[n / 2]};
pair<ll, ll> re = {a[n / 2], b[n / 2 - 1]};
cout << (le.second + re.second) - (le.first + re.first) + 1;
}
return 0;
} | replace | 18 | 19 | 18 | 21 | -6 | 60a20911-e310-4689-aa97-7ce55aa24a1e.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02661/C++/s947088133.cpp:20: int main(): Assertion `false' failed.
|
p02661 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll M = 1e9 + 7;
const ll INF = 1e9 + 7;
ll n;
ll a[110000], b[110000];
int main() {
cin >> n;
for (ll i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
if (n % 2) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
cout << b[n / 2 - 1] + b[n / 2] - a[n / 2 - 1] - a[n / 2] + 1 << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll M = 1e9 + 7;
const ll INF = 1e9 + 7;
ll n;
ll a[220000], b[220000];
int main() {
cin >> n;
for (ll i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
if (n % 2) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
cout << b[n / 2 - 1] + b[n / 2] - a[n / 2 - 1] - a[n / 2] + 1 << endl;
}
return 0;
} | replace | 22 | 23 | 22 | 23 | 0 | |
p02661 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll a[100005], b[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
cout << (ll)(b[n / 2 + 1] - a[n / 2 + 1] + 1) << endl;
} else {
cout << (ll)(b[n / 2] + b[n / 2 + 1] - a[n / 2] - a[n / 2 + 1] + 1) << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll a[200005], b[200005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
cout << (ll)(b[n / 2 + 1] - a[n / 2 + 1] + 1) << endl;
} else {
cout << (ll)(b[n / 2] + b[n / 2 + 1] - a[n / 2] - a[n / 2 + 1] + 1) << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
long long N;
vector<long long> A;
vector<long long> B;
int main() {
cin >> N;
for (long long i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
A.push_back(a);
B.push_back(b);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
if (N % 2 == 1) {
long long left = A[N / 2];
long long right = B[N / 2];
// cout << "left: " << left << endl;
// cout << "right: " << right << endl;
cout << right - left + 1 << endl;
return 0;
}
long long left1 = A[N / 2 - 1];
long long right1 = B[N / 2 - 1];
long long left2 = A[N / 2];
long long right2 = B[N / 2];
// cout << "left1: " << left1 << endl;
// cout << "right1: " << right1 << endl;
// cout << "left2: " << left2 << endl;
// cout << "right2: " << right2 << endl;
cout << right1 + right2 - left1 - left2 + 1 << endl;
return -1;
} | #include <bits/stdc++.h>
using namespace std;
long long N;
vector<long long> A;
vector<long long> B;
int main() {
cin >> N;
for (long long i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
A.push_back(a);
B.push_back(b);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
if (N % 2 == 1) {
long long left = A[N / 2];
long long right = B[N / 2];
// cout << "left: " << left << endl;
// cout << "right: " << right << endl;
cout << right - left + 1 << endl;
return 0;
}
long long left1 = A[N / 2 - 1];
long long right1 = B[N / 2 - 1];
long long left2 = A[N / 2];
long long right2 = B[N / 2];
// cout << "left1: " << left1 << endl;
// cout << "right1: " << right1 << endl;
// cout << "left2: " << left2 << endl;
// cout << "right2: " << right2 << endl;
cout << right1 + right2 - left1 - left2 + 1 << endl;
return 0;
} | replace | 35 | 36 | 35 | 36 | 255 | |
p02661 | C++ | Runtime Error | #pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define se second
#define fi first
#define N 3005
#define inf 1e9
#define pb push_back
#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;
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return w == 1 ? x : -x;
}
struct node {
int a, b;
bool operator<(node const &x) const {
if (a == x.a)
return b < x.b;
return a < x.a;
}
} x[N];
pair<int, int> p[N];
int n;
inline void sol1(int cnt) {
int one = 0, two = 0, l = 0, r = 0;
rep(i, 1, cnt) {
if (p[i].se > 0) {
one++;
if (one == n / 2 + 1)
l = p[i].fi;
} else {
two++;
if (two == n / 2 + 1)
r = p[i].fi;
}
}
cout << r - l + 1 << '\n';
}
inline void sol2(int cnt) {
int one = 0, two = 0;
int l1 = -1, r1 = -1, l2 = -1, r2 = -1;
rep(i, 1, cnt) {
if (p[i].se > 0) {
one++;
if (one == n / 2)
l1 = p[i].fi;
else if (one == n / 2 + 1)
l2 = p[i].fi;
} else {
two++;
if (two == n / 2)
r1 = p[i].fi;
else if (two == n / 2 + 1)
r2 = p[i].fi;
}
}
cout << r1 - l1 + 1 + r2 - l2 << '\n';
}
signed main() {
n = read();
rep(i, 1, n) x[i].a = read(), x[i].b = read();
sort(x + 1, x + 1 + n);
int cnt = 0;
rep(i, 1, n) {
p[++cnt].fi = x[i].a;
p[cnt].se = i;
p[++cnt].fi = x[i].b;
p[cnt].se = -i;
}
sort(p + 1, p + cnt + 1);
if (n & 1)
sol1(cnt);
else
sol2(cnt);
return 0;
}
| #pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define se second
#define fi first
#define N 1000005
#define inf 1e9
#define pb push_back
#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;
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return w == 1 ? x : -x;
}
struct node {
int a, b;
bool operator<(node const &x) const {
if (a == x.a)
return b < x.b;
return a < x.a;
}
} x[N];
pair<int, int> p[N];
int n;
inline void sol1(int cnt) {
int one = 0, two = 0, l = 0, r = 0;
rep(i, 1, cnt) {
if (p[i].se > 0) {
one++;
if (one == n / 2 + 1)
l = p[i].fi;
} else {
two++;
if (two == n / 2 + 1)
r = p[i].fi;
}
}
cout << r - l + 1 << '\n';
}
inline void sol2(int cnt) {
int one = 0, two = 0;
int l1 = -1, r1 = -1, l2 = -1, r2 = -1;
rep(i, 1, cnt) {
if (p[i].se > 0) {
one++;
if (one == n / 2)
l1 = p[i].fi;
else if (one == n / 2 + 1)
l2 = p[i].fi;
} else {
two++;
if (two == n / 2)
r1 = p[i].fi;
else if (two == n / 2 + 1)
r2 = p[i].fi;
}
}
cout << r1 - l1 + 1 + r2 - l2 << '\n';
}
signed main() {
n = read();
rep(i, 1, n) x[i].a = read(), x[i].b = read();
sort(x + 1, x + 1 + n);
int cnt = 0;
rep(i, 1, n) {
p[++cnt].fi = x[i].a;
p[cnt].se = i;
p[++cnt].fi = x[i].b;
p[cnt].se = -i;
}
sort(p + 1, p + cnt + 1);
if (n & 1)
sol1(cnt);
else
sol2(cnt);
return 0;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a, b;
for (int i = 0; i < n; i++) {
cin >> a.at(i);
cin >> b.at(i);
}
// debug a,b
sort(a.begin(), a.end());
sort(b.begin(), b.end());
ll res;
if (n % 2 == 1)
res = b.at((n) / 2) - a.at((n) / 2) + 1;
else
res = b.at(n / 2 - 1) + b.at(n / 2) - a.at(n / 2 - 1) - a.at(n / 2) + 1;
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
cin >> b.at(i);
}
// debug a,b
sort(a.begin(), a.end());
sort(b.begin(), b.end());
ll res;
if (n % 2 == 1)
res = b.at((n) / 2) - a.at((n) / 2) + 1;
else
res = b.at(n / 2 - 1) + b.at(n / 2) - a.at(n / 2 - 1) - a.at(n / 2) + 1;
cout << res << endl;
return 0;
}
| replace | 10 | 11 | 10 | 11 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 0) >= this->size() (which is 0)
|
p02661 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll l[100005], r[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
sort(l, l + n);
sort(r, r + n);
if (n % 2 == 1) {
cout << abs(r[n / 2] - l[n / 2]) + 1 << '\n';
} else {
ll l1 = l[n / 2];
ll l2 = l[n / 2 - 1];
ll r1 = r[n / 2];
ll r2 = r[n / 2 - 1];
cout << r1 + r2 - l1 - l2 + 1 << '\n';
}
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll l[200005], r[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
sort(l, l + n);
sort(r, r + n);
if (n % 2 == 1) {
cout << abs(r[n / 2] - l[n / 2]) + 1 << '\n';
} else {
ll l1 = l[n / 2];
ll l2 = l[n / 2 - 1];
ll r1 = r[n / 2];
ll r2 = r[n / 2 - 1];
cout << r1 + r2 - l1 - l2 + 1 << '\n';
}
return 0;
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02661 | Python | Runtime Error | N = int(input())
A, B = [], []
for i in range(N):
tm, p = map(int, input().split())
A.append(tm), B.append(p)
A.sort(), B.sort()
a = A[N // 2] * 2 if N % 2 == 1 else A[N // 2] + A[N // 2 + 1]
b = B[N // 2] * 2 if N % 2 == 1 else B[N // 2] + B[N // 2 + 1]
print((b - a) // 2 + 1)
| N = int(input())
A, B = [], []
for i in range(N):
tm, p = map(int, input().split())
A.append(tm), B.append(p)
A.sort(), B.sort()
a = A[N // 2] * 2 if N % 2 == 1 else A[N // 2 - 1] + A[N // 2]
b = B[N // 2] * 2 if N % 2 == 1 else B[N // 2 - 1] + B[N // 2]
print((b - a) // 2 + 1 if N % 2 == 1 else b - a + 1)
| replace | 7 | 10 | 7 | 11 | IndexError: list index out of range | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02661/Python/s174189740.py", line 8, in <module>
a = A[N // 2] * 2 if N % 2 == 1 else A[N // 2] + A[N // 2 + 1]
IndexError: list index out of range
|
p02661 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
using namespace std;
#define MAX_N 100005
int N;
int A[MAX_N], B[MAX_N];
void solve() {
sort(A, A + N);
sort(B, B + N);
printf("%d\n", (N % 2 == 1 ? B[N / 2] - A[N / 2]
: (B[N / 2] + B[(N - 1) / 2] - A[N / 2] -
A[(N - 1) / 2])) +
1);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", A + i, B + i);
}
solve();
}
| #include <algorithm>
#include <cstdio>
using namespace std;
#define MAX_N 200005
int N;
int A[MAX_N], B[MAX_N];
void solve() {
sort(A, A + N);
sort(B, B + N);
printf("%d\n", (N % 2 == 1 ? B[N / 2] - A[N / 2]
: (B[N / 2] + B[(N - 1) / 2] - A[N / 2] -
A[(N - 1) / 2])) +
1);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", A + i, B + i);
}
solve();
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02661 | C++ | Runtime Error | // AtCoder template
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll a, b;
vector<pair<ll, ll>> p1(n), p2(n);
rep(i, n) {
cin >> a >> b;
p1[i] = make_pair(a, b);
p2[i] = make_pair(a, b);
}
sort(p1.begin(), p1.end());
sort(p2.begin(), p2.end(), [](pair<ll, ll> a, pair<ll, ll> b) {
if (a.second == b.second) {
return a.first < a.second;
} else {
return a.second < b.second;
}
});
if (n % 2) {
cout << p2[n / 2].second - p1[n / 2].first + 1 << endl;
} else {
cout << (p2[n / 2].second + p2[n / 2 - 1].second) -
(p1[n / 2].first + p1[n / 2 - 1].first) + 1
<< endl;
}
} | // AtCoder template
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll a, b;
vector<pair<ll, ll>> p1(n), p2(n);
rep(i, n) {
cin >> a >> b;
p1[i] = make_pair(a, b);
p2[i] = make_pair(a, b);
}
sort(p1.begin(), p1.end());
sort(p2.begin(), p2.end(), [](pair<ll, ll> a, pair<ll, ll> b) {
if (a.second == b.second) {
return a.first < b.first;
} else {
return a.second < b.second;
}
});
if (n % 2) {
cout << p2[n / 2].second - p1[n / 2].first + 1 << endl;
} else {
cout << (p2[n / 2].second + p2[n / 2 - 1].second) -
(p1[n / 2].first + p1[n / 2 - 1].first) + 1
<< endl;
}
} | replace | 22 | 23 | 22 | 23 | 0 | |
p02661 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define pll pair<ll, ll>
#define reps(i, f, n) for (int i = (f); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
const int INF = 1111111111;
using namespace std;
const int N = 111111;
int a[N];
int b[N];
int n;
void init() {
cin >> n;
rep(i, n) { cin >> a[i] >> b[i]; }
}
void solve() {
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 0) {
int p1 = n / 2 - 1;
int p2 = n / 2;
int val = (b[p1] + b[p2] - a[p1] - a[p2] + 1);
cout << val << endl;
} else {
int p = n / 2;
cout << b[p] - a[p] + 1 << endl;
}
}
int main() {
init();
solve();
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define pll pair<ll, ll>
#define reps(i, f, n) for (int i = (f); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
const int INF = 1111111111;
using namespace std;
const int N = 1111111;
int a[N];
int b[N];
int n;
void init() {
cin >> n;
rep(i, n) { cin >> a[i] >> b[i]; }
}
void solve() {
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 0) {
int p1 = n / 2 - 1;
int p2 = n / 2;
int val = (b[p1] + b[p2] - a[p1] - a[p2] + 1);
cout << val << endl;
} else {
int p = n / 2;
cout << b[p] - a[p] + 1 << endl;
}
}
int main() {
init();
solve();
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define FORR(i, n) for (ll i = (ll)n - 1LL; i >= 0LL; i--)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) begin(x), end(x)
using namespace std;
using ll = long long;
template <typename T> using V = vector<T>;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
const double PI = acos(-1);
template <typename T> constexpr bool chmax(T &a, const T &b) {
if (a >= b)
return false;
a = b;
return true;
}
template <typename T> constexpr bool chmin(T &a, const T &b) {
if (a <= b)
return false;
a = b;
return true;
}
/*-------------------------------------------*/
int n;
ll a[100009], b[100009];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) cin >> a[i] >> b[i];
sort(a, a + n);
sort(b, b + n);
if (n & 1) {
cout << b[n >> 1] - a[n >> 1] + 1 << endl;
return 0;
}
cout << ((b[n / 2 - 1] + b[n / 2]) - (a[n / 2 - 1] + a[n / 2])) + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define FORR(i, n) for (ll i = (ll)n - 1LL; i >= 0LL; i--)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) begin(x), end(x)
using namespace std;
using ll = long long;
template <typename T> using V = vector<T>;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
const double PI = acos(-1);
template <typename T> constexpr bool chmax(T &a, const T &b) {
if (a >= b)
return false;
a = b;
return true;
}
template <typename T> constexpr bool chmin(T &a, const T &b) {
if (a <= b)
return false;
a = b;
return true;
}
/*-------------------------------------------*/
int n;
ll a[200009], b[200009];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n) cin >> a[i] >> b[i];
sort(a, a + n);
sort(b, b + n);
if (n & 1) {
cout << b[n >> 1] - a[n >> 1] + 1 << endl;
return 0;
}
cout << ((b[n / 2 - 1] + b[n / 2]) - (a[n / 2 - 1] + a[n / 2])) + 1 << endl;
return 0;
} | replace | 28 | 29 | 28 | 29 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, a, b) for (int i = a; i <= b; i++)
#define _Rep(i, a, b) for (int i = a; i >= b; i--)
#define RepG(i, u) for (int i = head[u]; ~i; i = e[i].next)
typedef long long ll;
const int N = 1e5 + 5;
template <typename T> void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = (x << 1) + (x << 3) + c - '0';
x *= f;
}
int n;
int l[N], r[N];
int p, q;
int main() {
read(n);
Rep(i, 1, n) read(l[i]), read(r[i]);
sort(l + 1, l + n + 1);
sort(r + 1, r + n + 1);
if (n % 2 == 0) {
p = l[n >> 1] + l[(n >> 1) + 1], q = r[n >> 1] + r[(n >> 1) + 1];
printf("%d\n", q - p + 1);
} else {
p = l[n + 1 >> 1], q = r[n + 1 >> 1];
printf("%d\n", q - p + 1);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, a, b) for (int i = a; i <= b; i++)
#define _Rep(i, a, b) for (int i = a; i >= b; i--)
#define RepG(i, u) for (int i = head[u]; ~i; i = e[i].next)
typedef long long ll;
const int N = 2e5 + 5;
template <typename T> void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = (x << 1) + (x << 3) + c - '0';
x *= f;
}
int n;
int l[N], r[N];
int p, q;
int main() {
read(n);
Rep(i, 1, n) read(l[i]), read(r[i]);
sort(l + 1, l + n + 1);
sort(r + 1, r + n + 1);
if (n % 2 == 0) {
p = l[n >> 1] + l[(n >> 1) + 1], q = r[n >> 1] + r[(n >> 1) + 1];
printf("%d\n", q - p + 1);
} else {
p = l[n + 1 >> 1], q = r[n + 1 >> 1];
printf("%d\n", q - p + 1);
}
return 0;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int a[100001], b[100001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i] >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
long long ans;
if (n % 2 == 0)
ans = b[n / 2] + b[(n / 2) + 1] - a[n / 2] - a[(n / 2) + 1] + 1;
else
ans = b[(n + 1) / 2] - a[(n + 1) / 2] + 1;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[200001], b[200001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i] >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
long long ans;
if (n % 2 == 0)
ans = b[n / 2] + b[(n / 2) + 1] - a[n / 2] - a[(n / 2) + 1] + 1;
else
ans = b[(n + 1) / 2] - a[(n + 1) / 2] + 1;
cout << ans << endl;
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int nm = 1e5;
int n, a[nm], b[nm];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
sort(a, a + n);
sort(b, b + n);
if (n & 1) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
cout << b[n / 2 - 1] + b[n / 2] - a[n / 2 - 1] - a[n / 2] + 1 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
const int nm = 2e5;
int n, a[nm], b[nm];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i];
sort(a, a + n);
sort(b, b + n);
if (n & 1) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
cout << b[n / 2 - 1] + b[n / 2] - a[n / 2 - 1] - a[n / 2] + 1 << endl;
}
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN = 1e5 + 4;
int n;
int A[MAXN], B[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &A[i], &B[i]);
sort(A + 1, A + n + 1);
sort(B + 1, B + n + 1);
if (n & 1) {
printf("%lld\n", 1LL + B[(n + 1) / 2] - A[(n + 1) / 2]);
} else {
int p = n / 2;
printf("%lld\n", 1LL + B[p + 1] - A[p + 1] + B[p] - A[p]);
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN = 2e5 + 4;
int n;
int A[MAXN], B[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &A[i], &B[i]);
sort(A + 1, A + n + 1);
sort(B + 1, B + n + 1);
if (n & 1) {
printf("%lld\n", 1LL + B[(n + 1) / 2] - A[(n + 1) / 2]);
} else {
int p = n / 2;
printf("%lld\n", 1LL + B[p + 1] - A[p + 1] + B[p] - A[p]);
}
return 0;
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp> //required
// #include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define lb long double
#define pb push_back
#define loop(i, start, n) for (ll i = start; i < n; i++)
#define rloop(i, n, start) for (ll i = n; i >= start; i--)
#define mod 1000000007
#define endl "\n"
#define INF 1e15
#define NEG_INF -1e15
#define pll pair<ll, ll>
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
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
// template <typename T> using ordered_set = tree<T, null_type, less<T>,
// rb_tree_tag, tree_order_statistics_node_update>; using namespace __gnu_pbds;
bool comp(pll a, pll b) { return a.y < b.y; }
int main() {
IOS;
ll n;
cin >> n;
pll a[n + 1];
loop(i, 1, n + 1) cin >> a[i].x >> a[i].y;
if (n % 2 == 1) {
sort(a + 1, a + n + 1);
ll l = a[(n + 1) / 2].x;
sort(a + 1, a + n + 1, comp);
ll r = a[(n + 1) / 2].y;
cout << r - l + 1 << endl;
} else {
assert(0);
sort(a + 1, a + n + 1);
ll l1 = a[n / 2].x, l2 = a[(n / 2) + 1].x;
sort(a + 1, a + n + 1, comp);
ll r1 = a[n / 2].y, r2 = a[(n / 2) + 1].y;
ll ans = (r2 - l2 + 1) + (r1 - l1 + 1) - 1;
cout << ans << endl;
}
} | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp> //required
// #include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define lb long double
#define pb push_back
#define loop(i, start, n) for (ll i = start; i < n; i++)
#define rloop(i, n, start) for (ll i = n; i >= start; i--)
#define mod 1000000007
#define endl "\n"
#define INF 1e15
#define NEG_INF -1e15
#define pll pair<ll, ll>
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
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
// template <typename T> using ordered_set = tree<T, null_type, less<T>,
// rb_tree_tag, tree_order_statistics_node_update>; using namespace __gnu_pbds;
bool comp(pll a, pll b) { return a.y < b.y; }
int main() {
IOS;
ll n;
cin >> n;
pll a[n + 1];
loop(i, 1, n + 1) cin >> a[i].x >> a[i].y;
if (n % 2 == 1) {
sort(a + 1, a + n + 1);
ll l = a[(n + 1) / 2].x;
sort(a + 1, a + n + 1, comp);
ll r = a[(n + 1) / 2].y;
cout << r - l + 1 << endl;
} else {
sort(a + 1, a + n + 1);
ll l1 = a[n / 2].x, l2 = a[(n / 2) + 1].x;
sort(a + 1, a + n + 1, comp);
ll r1 = a[n / 2].y, r2 = a[(n / 2) + 1].y;
ll ans = (r2 - l2 + 1) + (r1 - l1 + 1) - 1;
cout << ans << endl;
}
} | delete | 79 | 80 | 79 | 79 | -6 | 196b38a7-576d-4cdf-85cd-932fb271d3c1.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02661/C++/s208766323.cpp:64: int main(): Assertion `0' failed.
|
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pqgreater(x) x, vector<x>, greater<x>
#define decimal(x) cout << fixed << setprecision(x)
#define dbg(x) cerr << #x << ": " << x << endl;
#define gc getchar //_unlocked
#define pc putchar //_unlocked
const int mod = 998244353; // 1e9+7 or 998244353, remove const if changing mods
const ld eps = 1e-6;
ld sign(ld x) { return (x > 0) - (x < 0); }
ll sign(ll x) { return (x > 0) - (x < 0); }
int sign(int x) { return (x > 0) - (x < 0); }
struct pt {
ld x, y;
pt() {}
pt(ld _x, ld _y) : x(_x), y(_y) {}
bool operator<(pt p) { return tie(x, y) < tie(p.x, p.y); }
bool operator==(pt p) { return tie(x, y) == tie(p.x, p.y); }
pt operator+(pt p) { return {x + p.x, y + p.y}; }
pt operator-(pt p) { return {x - p.x, y - p.y}; }
pt operator*(ld d) { return {x * d, y * d}; }
pt operator/(ld d) { return {x / d, y / d}; }
ld dot(pt p) { return x * p.x + y * p.y; }
ld det(pt p) { return x * p.y - y * p.x; }
ld cross(pt p, pt q) { return (p - *this).det(q - *this); }
ld dist() { return sqrtl(x * x + y * y); }
pt rot90() { return pt(-y, x); }
pt unit() { return *this / dist(); }
ld angle() { return atan2(y, x); }
pt rot(ld an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
void read() { cin >> x >> y; }
void write() { cout << "(" << x << "," << y << ")" << endl; }
};
struct seg {
pt fi, sc;
seg() {}
seg(pt _fi, pt _sc) : fi(_fi), sc(_sc) {}
ld dist(pt C) {
if (fi == sc)
return (C - fi).dist();
ld d = pow((sc - fi).dist(), 2);
ld t = min(d, max((ld)0.0, (C - fi).dot(sc - fi)));
return ((C - fi) * d - (sc - fi) * t).dist() / d;
}
ld len() { return (fi - sc).dist(); }
bool on_seg(pt C) {
return abs(C.cross(fi, sc)) < eps && (fi - C).dot(sc - C) <= eps;
}
vector<pt> intersect(seg rhs) {
ld oa = rhs.fi.cross(rhs.sc, fi);
ld ob = rhs.fi.cross(rhs.sc, sc);
ld oc = fi.cross(sc, rhs.fi);
ld od = fi.cross(sc, rhs.sc);
if (sign(oa) * sign(ob) < 0 && sign(oc) * sign(od) < 0)
return {(fi * ob - sc * oa) / (ob - oa)};
vector<pt> ans;
if (rhs.on_seg(fi))
ans.push_back(fi);
if (rhs.on_seg(sc))
ans.push_back(sc);
if (on_seg(rhs.fi))
ans.push_back(rhs.fi);
if (on_seg(rhs.sc))
ans.push_back(rhs.sc);
return ans;
}
};
struct line {
ld a, b, c; // line a*x+b*y=c
line(pt p1, pt p2) {
assert(!(p1 == p2));
a = p2.y - p1.y;
b = p1.x - p2.x;
c = a * p1.x + b * p1.y;
}
line() {}
line(ld _a, ld _b, ld _c) : a(_a), b(_b), c(_c) {}
ld dist(pt p) { return fabs(a * p.x + b * p.y - c) / sqrtl(a * a + b * b); }
pair<int, pt> intersect(line rhs) {
ld dett = a * rhs.b - b * rhs.a;
if (fabs(dett) <= eps) {
ld det2 = c * rhs.a - a * rhs.c;
if (fabs(det2) <= eps)
return {-1, pt()}; // infinte
return {0, pt()}; // no sol
}
return {1,
pt((c * rhs.b - rhs.c * b) / dett, (a * rhs.c - c * rhs.a) / dett)};
}
};
pt reflect(pt A, line L) {
line perpendicular(-L.b, L.a, -L.b * A.x + L.a * A.y);
pt insect = perpendicular.intersect(L).second;
return insect * (ld)2.0 - A;
}
struct mint {
int val;
mint() { val = 0; }
mint(const ll &v) {
val = (-mod <= v && v < mod) ? v : v % mod;
if (val < 0)
val += mod;
}
friend ostream &operator<<(ostream &os, const mint &a) { return os << a.val; }
friend bool operator==(const mint &a, const mint &b) {
return a.val == b.val;
}
friend bool operator!=(const mint &a, const mint &b) {
return a.val != b.val;
}
friend bool operator<(const mint &a, const mint &b) { return a.val < b.val; }
friend bool operator>(const mint &a, const mint &b) { return a.val > b.val; }
friend bool operator<=(const mint &a, const mint &b) {
return a.val <= b.val;
}
friend bool operator>=(const mint &a, const mint &b) {
return a.val >= b.val;
}
mint operator-() { return mint(-val); }
mint &operator+=(const mint &m) {
if ((val += m.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &m) {
if ((val -= m.val) < mod)
val += mod;
return *this;
}
mint &operator*=(const mint &m) {
val = (val * 1ll * m.val) % mod;
return *this;
}
friend mint pow(mint a, ll p) {
mint ans = 1;
for (; p; p /= 2, a *= a)
if (p % 2 == 1)
ans *= a;
return ans;
}
friend mint inv(const mint &a) {
assert(a.val);
return pow(a, mod - 2);
}
mint &operator/=(const mint &m) { return (*this) *= inv(m); }
friend mint operator+(mint a, const mint &b) { return a += b; }
friend mint operator-(mint a, const mint &b) { return a -= b; }
friend mint operator*(mint a, const mint &b) { return a *= b; }
friend mint operator/(mint a, const mint &b) { return a /= b; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
int solve();
void precomp();
#define multitest 0
#define usecase 0
#define usedecimal 0
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (multitest)
cin >> t;
if (usedecimal)
decimal(10);
precomp();
for (int tc = 1; tc <= t; tc++) {
if (multitest && usecase)
cout << "Case #" << tc << ": ";
solve();
}
}
void precomp() { return; }
int solve() {
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(all(v));
cout << v[n / 2].second - v[(n - 1) / 2].first + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pqgreater(x) x, vector<x>, greater<x>
#define decimal(x) cout << fixed << setprecision(x)
#define dbg(x) cerr << #x << ": " << x << endl;
#define gc getchar //_unlocked
#define pc putchar //_unlocked
const int mod = 998244353; // 1e9+7 or 998244353, remove const if changing mods
const ld eps = 1e-6;
ld sign(ld x) { return (x > 0) - (x < 0); }
ll sign(ll x) { return (x > 0) - (x < 0); }
int sign(int x) { return (x > 0) - (x < 0); }
struct pt {
ld x, y;
pt() {}
pt(ld _x, ld _y) : x(_x), y(_y) {}
bool operator<(pt p) { return tie(x, y) < tie(p.x, p.y); }
bool operator==(pt p) { return tie(x, y) == tie(p.x, p.y); }
pt operator+(pt p) { return {x + p.x, y + p.y}; }
pt operator-(pt p) { return {x - p.x, y - p.y}; }
pt operator*(ld d) { return {x * d, y * d}; }
pt operator/(ld d) { return {x / d, y / d}; }
ld dot(pt p) { return x * p.x + y * p.y; }
ld det(pt p) { return x * p.y - y * p.x; }
ld cross(pt p, pt q) { return (p - *this).det(q - *this); }
ld dist() { return sqrtl(x * x + y * y); }
pt rot90() { return pt(-y, x); }
pt unit() { return *this / dist(); }
ld angle() { return atan2(y, x); }
pt rot(ld an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
void read() { cin >> x >> y; }
void write() { cout << "(" << x << "," << y << ")" << endl; }
};
struct seg {
pt fi, sc;
seg() {}
seg(pt _fi, pt _sc) : fi(_fi), sc(_sc) {}
ld dist(pt C) {
if (fi == sc)
return (C - fi).dist();
ld d = pow((sc - fi).dist(), 2);
ld t = min(d, max((ld)0.0, (C - fi).dot(sc - fi)));
return ((C - fi) * d - (sc - fi) * t).dist() / d;
}
ld len() { return (fi - sc).dist(); }
bool on_seg(pt C) {
return abs(C.cross(fi, sc)) < eps && (fi - C).dot(sc - C) <= eps;
}
vector<pt> intersect(seg rhs) {
ld oa = rhs.fi.cross(rhs.sc, fi);
ld ob = rhs.fi.cross(rhs.sc, sc);
ld oc = fi.cross(sc, rhs.fi);
ld od = fi.cross(sc, rhs.sc);
if (sign(oa) * sign(ob) < 0 && sign(oc) * sign(od) < 0)
return {(fi * ob - sc * oa) / (ob - oa)};
vector<pt> ans;
if (rhs.on_seg(fi))
ans.push_back(fi);
if (rhs.on_seg(sc))
ans.push_back(sc);
if (on_seg(rhs.fi))
ans.push_back(rhs.fi);
if (on_seg(rhs.sc))
ans.push_back(rhs.sc);
return ans;
}
};
struct line {
ld a, b, c; // line a*x+b*y=c
line(pt p1, pt p2) {
assert(!(p1 == p2));
a = p2.y - p1.y;
b = p1.x - p2.x;
c = a * p1.x + b * p1.y;
}
line() {}
line(ld _a, ld _b, ld _c) : a(_a), b(_b), c(_c) {}
ld dist(pt p) { return fabs(a * p.x + b * p.y - c) / sqrtl(a * a + b * b); }
pair<int, pt> intersect(line rhs) {
ld dett = a * rhs.b - b * rhs.a;
if (fabs(dett) <= eps) {
ld det2 = c * rhs.a - a * rhs.c;
if (fabs(det2) <= eps)
return {-1, pt()}; // infinte
return {0, pt()}; // no sol
}
return {1,
pt((c * rhs.b - rhs.c * b) / dett, (a * rhs.c - c * rhs.a) / dett)};
}
};
pt reflect(pt A, line L) {
line perpendicular(-L.b, L.a, -L.b * A.x + L.a * A.y);
pt insect = perpendicular.intersect(L).second;
return insect * (ld)2.0 - A;
}
struct mint {
int val;
mint() { val = 0; }
mint(const ll &v) {
val = (-mod <= v && v < mod) ? v : v % mod;
if (val < 0)
val += mod;
}
friend ostream &operator<<(ostream &os, const mint &a) { return os << a.val; }
friend bool operator==(const mint &a, const mint &b) {
return a.val == b.val;
}
friend bool operator!=(const mint &a, const mint &b) {
return a.val != b.val;
}
friend bool operator<(const mint &a, const mint &b) { return a.val < b.val; }
friend bool operator>(const mint &a, const mint &b) { return a.val > b.val; }
friend bool operator<=(const mint &a, const mint &b) {
return a.val <= b.val;
}
friend bool operator>=(const mint &a, const mint &b) {
return a.val >= b.val;
}
mint operator-() { return mint(-val); }
mint &operator+=(const mint &m) {
if ((val += m.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &m) {
if ((val -= m.val) < mod)
val += mod;
return *this;
}
mint &operator*=(const mint &m) {
val = (val * 1ll * m.val) % mod;
return *this;
}
friend mint pow(mint a, ll p) {
mint ans = 1;
for (; p; p /= 2, a *= a)
if (p % 2 == 1)
ans *= a;
return ans;
}
friend mint inv(const mint &a) {
assert(a.val);
return pow(a, mod - 2);
}
mint &operator/=(const mint &m) { return (*this) *= inv(m); }
friend mint operator+(mint a, const mint &b) { return a += b; }
friend mint operator-(mint a, const mint &b) { return a -= b; }
friend mint operator*(mint a, const mint &b) { return a *= b; }
friend mint operator/(mint a, const mint &b) { return a /= b; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
int solve();
void precomp();
#define multitest 0
#define usecase 0
#define usedecimal 0
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (multitest)
cin >> t;
if (usedecimal)
decimal(10);
precomp();
for (int tc = 1; tc <= t; tc++) {
if (multitest && usecase)
cout << "Case #" << tc << ": ";
solve();
}
}
void precomp() { return; }
int solve() {
int n;
cin >> n;
vector<int> l(n), r(n);
for (int i = 0; i < n; i++)
cin >> l[i] >> r[i];
sort(all(l));
sort(all(r));
if (n & 1)
cout << r[n / 2] - l[n / 2] + 1 << endl;
else
cout << r[n / 2] + r[(n - 1) / 2] - l[n / 2] - l[(n - 1) / 2] + 1 << endl;
return 0;
} | replace | 191 | 197 | 191 | 201 | 0 | |
p02661 | C++ | Runtime Error |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a[100001], b[100001];
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
cout << b[(n + 1) / 2] - a[(n + 1) / 2] + 1 << endl;
} else
cout << b[n / 2] + b[n / 2 + 1] - a[n / 2] - a[n / 2 + 1] + 1 << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int a[200001], b[200001];
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1) {
cout << b[(n + 1) / 2] - a[(n + 1) / 2] + 1 << endl;
} else
cout << b[n / 2] + b[n / 2 + 1] - a[n / 2] - a[n / 2 + 1] + 1 << endl;
return 0;
}
| replace | 16 | 17 | 16 | 17 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
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;
}
signed main() {
int n;
cin >> n;
int a[100010];
int b[100010];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 1) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
int t1 = a[n / 2] + a[n / 2 - 1];
int t2 = b[n / 2] + b[n / 2 - 1];
int ans = t2 - t1;
cout << ans + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
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;
}
signed main() {
int n;
cin >> n;
int a[200010];
int b[200010];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 1) {
cout << b[n / 2] - a[n / 2] + 1 << endl;
} else {
int t1 = a[n / 2] + a[n / 2 - 1];
int t2 = b[n / 2] + b[n / 2 - 1];
int ans = t2 - t1;
cout << ans + 1 << endl;
}
return 0;
}
| replace | 23 | 25 | 23 | 25 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
constexpr int MX = 100005;
int n, a[MX], b[MX], ans;
int main() {
scanf("%d", &n);
rep(i, n) scanf("%d%d", a + i, b + i);
sort(a, a + n);
sort(b, b + n);
if (n % 2)
ans = b[n / 2] - a[n / 2] + 1;
else
ans = b[n / 2 - 1] - a[n / 2 - 1] + b[n / 2] - a[n / 2] + 1;
printf("%d\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
constexpr int MX = 200005;
int n, a[MX], b[MX], ans;
int main() {
scanf("%d", &n);
rep(i, n) scanf("%d%d", a + i, b + i);
sort(a, a + n);
sort(b, b + n);
if (n % 2)
ans = b[n / 2] - a[n / 2] + 1;
else
ans = b[n / 2 - 1] - a[n / 2 - 1] + b[n / 2] - a[n / 2] + 1;
printf("%d\n", ans);
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
long long a[100000];
long long b[100000];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &a[i], &b[i]);
}
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 1) {
printf("%lld", b[n / 2] - a[n / 2] + 1);
} else {
printf("%lld", b[n / 2] + b[n / 2 - 1] - a[n / 2] - a[n / 2 - 1] + 1);
}
} | #include <bits/stdc++.h>
using namespace std;
long long a[200000];
long long b[200000];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &a[i], &b[i]);
}
sort(a, a + n);
sort(b, b + n);
if (n % 2 == 1) {
printf("%lld", b[n / 2] - a[n / 2] + 1);
} else {
printf("%lld", b[n / 2] + b[n / 2 - 1] - a[n / 2] - a[n / 2 - 1] + 1);
}
} | replace | 3 | 5 | 3 | 5 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = int_fast64_t;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60;
constexpr ll MOD = 1e9 + 7;
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;
}
#if loc || local
void dump() { cerr << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
cerr << h << ", ";
dump(forward<Ts>(t)...);
}
#else
void dump() {}
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
for (auto const &vi : v)
os << vi << " ";
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
os << p.first << "," << p.second;
return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
signed main() {
ll n;
cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
sort(begin(a), end(a));
sort(begin(b), end(b));
if (n & 1) {
int m = n / 2;
cout << b[m] - a[m] + 1 << endl;
} else {
return 1;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = int_fast64_t;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60;
constexpr ll MOD = 1e9 + 7;
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;
}
#if loc || local
void dump() { cerr << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
cerr << h << ", ";
dump(forward<Ts>(t)...);
}
#else
void dump() {}
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
for (auto const &vi : v)
os << vi << " ";
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
os << p.first << "," << p.second;
return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
signed main() {
ll n;
cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
sort(begin(a), end(a));
sort(begin(b), end(b));
if (n & 1) {
int m = n / 2;
cout << b[m] - a[m] + 1 << endl;
} else {
int m = n / 2;
double mn = (a[m] + a[m - 1]) / 2.0;
double mx = (b[m] + b[m - 1]) / 2.0;
double ansd = (mx - mn) / 0.5;
ll ans = ansd + 1;
cout << ans << endl;
}
} | replace | 69 | 70 | 69 | 75 | 1 | |
p02661 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <vector>
#define lowbit(x) ((x) & (-(x)))
#define re register
#define ll long long
#define ull unsigned long long
#define rep(i, a, b) for (re int i = a; i <= b; ++i)
#define per(i, a, b) for (re int i = a; i >= b; --i)
template <typename T> inline void read(T &x) {
x = 0;
char s = (char)getchar();
bool f = false;
while (!(s >= '0' && s <= '9')) {
if (s == '-')
f = true;
s = (char)getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 1) + (x << 3) + s - '0';
s = (char)getchar();
}
if (f)
x = (~x) + 1;
}
template <typename T> inline void clear(T *a, int l, int r, int val) {
memset(&a[l], val, sizeof(T) * (r - l + 1));
}
using namespace std;
const int N = 1e5 + 5;
struct node {
int a, b;
inline bool operator<(node const &x) const {
if (a == x.a)
return b < x.b;
return a < x.a;
}
} x[N];
pair<int, int> p[N];
#define fi first
#define se second
int n;
signed main() {
read(n);
rep(i, 1, n) read(x[i].a), read(x[i].b);
sort(x + 1, x + 1 + n);
int cnt = 0;
rep(i, 1, n) {
p[++cnt].fi = x[i].a;
p[cnt].se = i;
p[++cnt].fi = x[i].b;
p[cnt].se = -i;
}
sort(p + 1, p + 1 + cnt);
if (n & 1) {
int one = 0, two = 0;
int l = 0, r = 0;
rep(i, 1, cnt) {
if (p[i].se > 0) {
++one;
if (one == n / 2 + 1)
l = p[i].fi;
} else {
++two;
if (two == n / 2 + 1)
r = p[i].fi;
}
}
printf("%d\n", r - l + 1);
} else {
int one = 0, two = 0;
int l1 = -1, r1 = -1, l2 = -1, r2 = -1;
rep(i, 1, cnt) {
if (p[i].se > 0) {
++one;
if (one == n / 2)
l1 = p[i].fi;
else if (one == n / 2 + 1)
l2 = p[i].fi;
} else {
++two;
if (two == n / 2)
r1 = p[i].fi;
else if (two == n / 2 + 1)
r2 = p[i].fi;
}
}
printf("%d\n", r1 - l1 + 1 + r2 - l2);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <vector>
#define lowbit(x) ((x) & (-(x)))
#define re register
#define ll long long
#define ull unsigned long long
#define rep(i, a, b) for (re int i = a; i <= b; ++i)
#define per(i, a, b) for (re int i = a; i >= b; --i)
template <typename T> inline void read(T &x) {
x = 0;
char s = (char)getchar();
bool f = false;
while (!(s >= '0' && s <= '9')) {
if (s == '-')
f = true;
s = (char)getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 1) + (x << 3) + s - '0';
s = (char)getchar();
}
if (f)
x = (~x) + 1;
}
template <typename T> inline void clear(T *a, int l, int r, int val) {
memset(&a[l], val, sizeof(T) * (r - l + 1));
}
using namespace std;
const int N = 1e6 + 5;
struct node {
int a, b;
inline bool operator<(node const &x) const {
if (a == x.a)
return b < x.b;
return a < x.a;
}
} x[N];
pair<int, int> p[N];
#define fi first
#define se second
int n;
signed main() {
read(n);
rep(i, 1, n) read(x[i].a), read(x[i].b);
sort(x + 1, x + 1 + n);
int cnt = 0;
rep(i, 1, n) {
p[++cnt].fi = x[i].a;
p[cnt].se = i;
p[++cnt].fi = x[i].b;
p[cnt].se = -i;
}
sort(p + 1, p + 1 + cnt);
if (n & 1) {
int one = 0, two = 0;
int l = 0, r = 0;
rep(i, 1, cnt) {
if (p[i].se > 0) {
++one;
if (one == n / 2 + 1)
l = p[i].fi;
} else {
++two;
if (two == n / 2 + 1)
r = p[i].fi;
}
}
printf("%d\n", r - l + 1);
} else {
int one = 0, two = 0;
int l1 = -1, r1 = -1, l2 = -1, r2 = -1;
rep(i, 1, cnt) {
if (p[i].se > 0) {
++one;
if (one == n / 2)
l1 = p[i].fi;
else if (one == n / 2 + 1)
l2 = p[i].fi;
} else {
++two;
if (two == n / 2)
r1 = p[i].fi;
else if (two == n / 2 + 1)
r2 = p[i].fi;
}
}
printf("%d\n", r1 - l1 + 1 + r2 - l2);
}
return 0;
} | replace | 29 | 30 | 29 | 30 | 0 | |
p02661 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
#define INF 10000000000000
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
#define repN_1(i, n) for (ll i = 0; i < (ll)(n - 1); i++)
#define repM(i, n) for (ll i = (ll)(n - 1); i >= 0; i--)
#define repM1(i, n) for (ll i = (ll)(n - 1); i > 0; i--)
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;
}
int main() {
cout << fixed << setprecision(18);
ll n;
cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
ll ans;
if (n % 2 == 1) {
ans = b[(n + 1) / 2 - 1] - a[(n + 1) / 2 - 1] + 1;
} else {
double tmp_a = (a[n / 2 - 1] + a[(n / 2 + 1) - 1]) * 0.5;
double tmp_b = (b[n / 2 - 1] + b[(n / 2 + 1) - 1]) * 0.5;
ans = 0;
for (; tmp_a <= tmp_b; tmp_a += 0.5)
ans++;
}
cout << ans << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
#define INF 10000000000000
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
#define repN_1(i, n) for (ll i = 0; i < (ll)(n - 1); i++)
#define repM(i, n) for (ll i = (ll)(n - 1); i >= 0; i--)
#define repM1(i, n) for (ll i = (ll)(n - 1); i > 0; i--)
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;
}
int main() {
cout << fixed << setprecision(18);
ll n;
cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
ll ans;
if (n % 2 == 1) {
ans = b[(n + 1) / 2 - 1] - a[(n + 1) / 2 - 1] + 1;
} else {
double tmp_a = (a[n / 2 - 1] + a[(n / 2 + 1) - 1]) * 0.5;
double tmp_b = (b[n / 2 - 1] + b[(n / 2 + 1) - 1]) * 0.5;
ll aa = tmp_a * 10 + 0.5;
ll bb = tmp_b * 10 + 0.5;
ans = (bb - aa) / 5 + 1;
}
cout << ans << endl;
return 0;
} | replace | 46 | 49 | 46 | 50 | TLE | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ss second
#define ff first
#define N 100005
#define inf 1000000009
#define ll long long
#define pii pair<int, int>
#define sz(a) int(a.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int n, a[N], b[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a[i], &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1)
printf("%d", b[(n + 1) / 2] - a[(n + 1) / 2] + 1);
else {
int ma = a[n / 2 + 1] + a[n / 2];
int mb = b[n / 2 + 1] + b[n / 2];
printf("%d", mb - ma + 1);
}
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ss second
#define ff first
#define N 200005
#define inf 1000000009
#define ll long long
#define pii pair<int, int>
#define sz(a) int(a.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int n, a[N], b[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a[i], &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
if (n % 2 == 1)
printf("%d", b[(n + 1) / 2] - a[(n + 1) / 2] + 1);
else {
int ma = a[n / 2 + 1] + a[n / 2];
int mb = b[n / 2 + 1] + b[n / 2];
printf("%d", mb - ma + 1);
}
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
ll a[100010], b[100010];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> a[i] >> b[i];
a[i] *= 2;
b[i] *= 2;
}
sort(a, a + n);
sort(b, b + n);
ll medl, medr, ans;
if (n % 2 == 0) {
medl = (a[n / 2 - 1] + a[n / 2]) / 2;
medr = (b[n / 2 - 1] + b[n / 2]) / 2;
ans = medr - medl + 1;
} else {
medl = a[(n - 1) / 2];
medr = b[(n - 1) / 2];
ans = (medr - medl) / 2 + 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
ll a[200010], b[200010];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> a[i] >> b[i];
a[i] *= 2;
b[i] *= 2;
}
sort(a, a + n);
sort(b, b + n);
ll medl, medr, ans;
if (n % 2 == 0) {
medl = (a[n / 2 - 1] + a[n / 2]) / 2;
medr = (b[n / 2 - 1] + b[n / 2]) / 2;
ans = medr - medl + 1;
} else {
medl = a[(n - 1) / 2];
medr = b[(n - 1) / 2];
ans = (medr - medl) / 2 + 1;
}
cout << ans << endl;
return 0;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr char newl = '\n';
ll solve(int n, const vector<ll> &a, const vector<ll> &b, int num) {
ll ng = 0, ok = 1e9 + 1;
while (ok - ng > 1) {
ll mid = (ok + ng) / 2;
int le = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i] < mid)
++le;
else if (mid >= a[i])
++cnt;
}
if (num <= le + cnt) {
ok = mid;
} else {
ng = mid;
}
// cerr << ok << "," << ng << newl;
}
return ok;
}
ll solve2(int n, const vector<ll> &a, const vector<ll> &b, int num) {
ll ok = 0, ng = 1e9 + 1;
while (ng - ok > 1) {
ll mid = (ok + ng) / 2;
int le = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i] < mid)
++le;
else if (mid >= a[i])
++cnt;
}
if (le < num) {
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
void solve3(int n, const vector<ll> &a, const vector<ll> &b) {
map<ll, vector<int>> memo;
for (int i = 0; i < n; i++) {
memo[a[i]].push_back(0);
memo[b[i]].push_back(1);
}
int le = 0, cnt = 0;
ll minv = -1, maxv = -1;
for (auto &p : memo) {
for (int i : p.second) {
if (i == 0) {
++cnt;
} else {
--cnt;
++le;
}
}
if (le <= n / 2 + 1 && n / 2 + 1 <= le + cnt) {
if (minv == -1)
minv = p.first;
maxv = max(maxv, p.first);
}
}
cout << maxv - minv + 1 << newl;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
if (n % 2 == 1) {
cout << solve2(n, a, b, (n + 1) / 2) - solve(n, a, b, (n + 1) / 2) + 1
<< newl;
} else {
assert(false);
ll foo = solve(n, a, b, (n + 1) / 2 + 1);
ll bar = solve(n, a, b, (n + 1) / 2);
ll foo2 = solve2(n, a, b, (n + 1) / 2 + 1);
ll bar2 = solve2(n, a, b, (n + 1) / 2);
cout << (foo2 + bar2) - (foo + bar) + 1 << newl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr char newl = '\n';
ll solve(int n, const vector<ll> &a, const vector<ll> &b, int num) {
ll ng = 0, ok = 1e9 + 1;
while (ok - ng > 1) {
ll mid = (ok + ng) / 2;
int le = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i] < mid)
++le;
else if (mid >= a[i])
++cnt;
}
if (num <= le + cnt) {
ok = mid;
} else {
ng = mid;
}
// cerr << ok << "," << ng << newl;
}
return ok;
}
ll solve2(int n, const vector<ll> &a, const vector<ll> &b, int num) {
ll ok = 0, ng = 1e9 + 1;
while (ng - ok > 1) {
ll mid = (ok + ng) / 2;
int le = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i] < mid)
++le;
else if (mid >= a[i])
++cnt;
}
if (le < num) {
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
void solve3(int n, const vector<ll> &a, const vector<ll> &b) {
map<ll, vector<int>> memo;
for (int i = 0; i < n; i++) {
memo[a[i]].push_back(0);
memo[b[i]].push_back(1);
}
int le = 0, cnt = 0;
ll minv = -1, maxv = -1;
for (auto &p : memo) {
for (int i : p.second) {
if (i == 0) {
++cnt;
} else {
--cnt;
++le;
}
}
if (le <= n / 2 + 1 && n / 2 + 1 <= le + cnt) {
if (minv == -1)
minv = p.first;
maxv = max(maxv, p.first);
}
}
cout << maxv - minv + 1 << newl;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
if (n % 2 == 1) {
cout << solve2(n, a, b, (n + 1) / 2) - solve(n, a, b, (n + 1) / 2) + 1
<< newl;
} else {
ll foo = solve(n, a, b, (n + 1) / 2 + 1);
ll bar = solve(n, a, b, (n + 1) / 2);
ll foo2 = solve2(n, a, b, (n + 1) / 2 + 1);
ll bar2 = solve2(n, a, b, (n + 1) / 2);
cout << (foo2 + bar2) - (foo + bar) + 1 << newl;
}
return 0;
}
| delete | 98 | 99 | 98 | 98 | -6 | 3215041b-504d-42b3-869b-1c3e93111d9b.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02661/C++/s862422443.cpp:93: int main(): Assertion `false' failed.
|
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void read(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-')
f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
#define ll long long
ll le[100005];
ll ri[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> le[i] >> ri[i];
}
sort(le + 1, le + n + 1);
sort(ri + 1, ri + n + 1);
if (n % 2 == 1) {
cout << ri[n / 2 + 1] - le[n / 2 + 1] + 1LL << endl;
} else {
cout << ri[n / 2] + ri[n / 2 + 1] - le[n / 2] - le[n / 2 + 1] + 1LL << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void read(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-')
f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
#define ll long long
ll le[200005];
ll ri[200005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> le[i] >> ri[i];
}
sort(le + 1, le + n + 1);
sort(ri + 1, ri + n + 1);
if (n % 2 == 1) {
cout << ri[n / 2 + 1] - le[n / 2 + 1] + 1LL << endl;
} else {
cout << ri[n / 2] + ri[n / 2 + 1] - le[n / 2] - le[n / 2 + 1] + 1LL << endl;
}
return 0;
} | replace | 19 | 21 | 19 | 21 | 0 | |
p02661 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vec<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
int inf = 2e9 + 1;
if (N % 2 == 1) {
int la = 0, ra = inf;
while (la + 1 < ra) {
int m = (la + ra) / 2;
int c = 0;
for (int i = 0; i < N; i++) {
if (A[i] <= m)
c++;
}
if (c >= (N + 1) / 2)
ra = m;
else
la = m;
}
int lb = 0, rb = inf;
while (lb + 1 < rb) {
int m = (lb + rb) / 2;
int c = 0;
for (int i = 0; i < N; i++) {
if (m <= B[i])
c++;
}
if (c >= (N + 1) / 2)
lb = m;
else
rb = m;
}
cout << lb - ra + 1 << "\n";
} else {
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int a = A[N / 2 - 1] + A[N / 2], b = B[N / 2 - 1] + B[N / 2];
cout << b - a + 1 << "\n";
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vec<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
int inf = 2e9 + 1;
if (N % 2 == 1) {
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int a = A[N / 2], b = B[N / 2];
cout << b - a + 1 << "\n";
} else {
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int a = A[N / 2 - 1] + A[N / 2], b = B[N / 2 - 1] + B[N / 2];
cout << b - a + 1 << "\n";
}
} | replace | 18 | 45 | 18 | 22 | TLE | |
p02661 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll a[100005], b[100005];
int main() {
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
}
sort(a, a + n);
sort(b, b + n);
ll low, hi;
if (n & 1) {
low = a[(n - 1) / 2];
hi = b[(n - 1) / 2];
} else {
low = a[(n - 2) / 2] + a[(n - 2) / 2 + 1];
hi = b[(n - 2) / 2] + b[(n - 2) / 2 + 1];
}
cout << hi - low + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll a[200005], b[200005];
int main() {
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
}
sort(a, a + n);
sort(b, b + n);
ll low, hi;
if (n & 1) {
low = a[(n - 1) / 2];
hi = b[(n - 1) / 2];
} else {
low = a[(n - 2) / 2] + a[(n - 2) / 2 + 1];
hi = b[(n - 2) / 2] + b[(n - 2) / 2 + 1];
}
cout << hi - low + 1 << endl;
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02662 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
// #include"testlib.h"
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
const int N = 1e3 + 9;
ll mem[N][N];
int mod = 998244353;
int n, s;
vi v1;
ll fpow(ll x, ll p) {
if (!p)
return 1;
ll sq = fpow(x, p / 2);
sq *= sq;
sq %= mod;
if (p & 1)
sq *= x;
return sq % mod;
}
ll solve(int idx, int rem) {
if (rem < 0)
return 0;
if (!rem)
return fpow(2, n - (ll)idx);
if (idx == n)
return 0;
ll &ret = mem[idx][rem];
if (ret != -1)
return ret;
ret = 2 * solve(idx + 1, rem) + solve(idx + 1, rem - v1[idx]);
ret %= mod;
return ret;
}
int main() {
// file();
fast();
memset(mem, -1, sizeof mem);
cin >> n >> s;
v1 = vi(n);
for (auto &it : v1)
cin >> it;
ll ans = 0;
for (int i = 0; i < n; i++) {
// watch(solve(i + 1, s - v1[i]));
ans += fpow(2, i) * solve(i + 1, s - v1[i]);
ans %= mod;
}
cout << ans << endl;
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
// #include"testlib.h"
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
const int N = 3e3 + 9;
ll mem[N][N];
int mod = 998244353;
int n, s;
vi v1;
ll fpow(ll x, ll p) {
if (!p)
return 1;
ll sq = fpow(x, p / 2);
sq *= sq;
sq %= mod;
if (p & 1)
sq *= x;
return sq % mod;
}
ll solve(int idx, int rem) {
if (rem < 0)
return 0;
if (!rem)
return fpow(2, n - (ll)idx);
if (idx == n)
return 0;
ll &ret = mem[idx][rem];
if (ret != -1)
return ret;
ret = 2 * solve(idx + 1, rem) + solve(idx + 1, rem - v1[idx]);
ret %= mod;
return ret;
}
int main() {
// file();
fast();
memset(mem, -1, sizeof mem);
cin >> n >> s;
v1 = vi(n);
for (auto &it : v1)
cin >> it;
ll ans = 0;
for (int i = 0; i < n; i++) {
// watch(solve(i + 1, s - v1[i]));
ans += fpow(2, i) * solve(i + 1, s - v1[i]);
ans %= mod;
}
cout << ans << endl;
return 0;
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p02662 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#define REL
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef int64_t i64;
typedef long long LL;
typedef long long ll;
typedef long double LD;
typedef complex<LD> cld;
typedef unsigned int uint;
typedef complex<double> cd;
typedef unsigned long long ULL;
// #define endl "\n"
#define dendl "\n\n"
#define mp make_pair
#define mt make_tuple
#define size(v) (int)v.size()
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
/////////////////////////////////////////////////////////////////////
template <typename T> T sqr(T a) { return a * a; }
template <typename T> int sign(T a) {
if (a == 0)
return 0;
return (a > 0 ? 1 : -1);
}
template <typename T> bool uax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool uin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
mt19937_64 rnd(0);
const int LOG = 64;
const int N = (int)3e2 + 7;
const int MAXN = (int)4e5 + 7;
const int MOD = (int)998244353;
const int INF = (int)2e9 + 7;
const int CONST = 450;
const LL LINF = (i64)1e18;
const LD PI = 3.1415926535897932384626433832795;
const LD EPS = 1;
/////////////////////////////////////////////////////////////////////
int n, s, a[N];
int cnt[N][N];
int bin_pow(int a, int p) {
int res = 1;
while (p) {
if (p & 1)
res = 1LL * res * a % MOD;
a = 1LL * a * a % MOD;
p >>= 1;
}
return res;
}
void solve() {
cin >> n >> s;
for (int i = 1; i <= n; i++)
cin >> a[i];
cnt[0][0] = bin_pow(2, n);
int mul = bin_pow(2, MOD - 2);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= s; j++) {
cnt[i][j] = cnt[i - 1][j];
if (j < a[i])
continue;
cnt[i][j] = (cnt[i][j] + 1LL * cnt[i - 1][j - a[i]] * mul) % MOD;
}
}
cout << cnt[n][s];
}
int main() {
double start = clock();
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cout << fixed << setprecision(20);
cerr << fixed << setprecision(20);
#else
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
rnd.seed(time(0));
#endif
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
#ifdef _DEBUG
cout << endl << "Time is " << (clock() - start) / 1000.0;
#endif
} | #define _CRT_SECURE_NO_WARNINGS
#define REL
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef int64_t i64;
typedef long long LL;
typedef long long ll;
typedef long double LD;
typedef complex<LD> cld;
typedef unsigned int uint;
typedef complex<double> cd;
typedef unsigned long long ULL;
// #define endl "\n"
#define dendl "\n\n"
#define mp make_pair
#define mt make_tuple
#define size(v) (int)v.size()
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
/////////////////////////////////////////////////////////////////////
template <typename T> T sqr(T a) { return a * a; }
template <typename T> int sign(T a) {
if (a == 0)
return 0;
return (a > 0 ? 1 : -1);
}
template <typename T> bool uax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool uin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
mt19937_64 rnd(0);
const int LOG = 64;
const int N = (int)3e3 + 7;
const int MAXN = (int)4e5 + 7;
const int MOD = (int)998244353;
const int INF = (int)2e9 + 7;
const int CONST = 450;
const LL LINF = (i64)1e18;
const LD PI = 3.1415926535897932384626433832795;
const LD EPS = 1;
/////////////////////////////////////////////////////////////////////
int n, s, a[N];
int cnt[N][N];
int bin_pow(int a, int p) {
int res = 1;
while (p) {
if (p & 1)
res = 1LL * res * a % MOD;
a = 1LL * a * a % MOD;
p >>= 1;
}
return res;
}
void solve() {
cin >> n >> s;
for (int i = 1; i <= n; i++)
cin >> a[i];
cnt[0][0] = bin_pow(2, n);
int mul = bin_pow(2, MOD - 2);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= s; j++) {
cnt[i][j] = cnt[i - 1][j];
if (j < a[i])
continue;
cnt[i][j] = (cnt[i][j] + 1LL * cnt[i - 1][j - a[i]] * mul) % MOD;
}
}
cout << cnt[n][s];
}
int main() {
double start = clock();
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cout << fixed << setprecision(20);
cerr << fixed << setprecision(20);
#else
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
rnd.seed(time(0));
#endif
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
#ifdef _DEBUG
cout << endl << "Time is " << (clock() - start) / 1000.0;
#endif
} | replace | 88 | 89 | 88 | 89 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define per(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fst first
#define snd second
template <class T> bool ckmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pii> vii;
const ll mod = 998244353;
ll modpow(ll b, ll e) {
ll ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1)
ans = ans * b % mod;
return ans;
}
ll inv(ll x) { return modpow(x, mod - 2); }
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int n, s;
cin >> n >> s;
vi a(n);
rep(i, 0, n) cin >> a[i];
ll i2 = inv(2);
vi dp(s + 1, 0);
dp[0] = 1;
rep(i, 0, n) {
per(j, 0, 3000) {
if (j + a[i] <= 3000) {
dp[j + a[i]] += dp[j] * i2 % mod;
dp[j + a[i]] %= mod;
}
}
}
ll ans = modpow(2, n) * dp[s] % mod;
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << '\n';
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define per(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fst first
#define snd second
template <class T> bool ckmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <class T> bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pii> vii;
const ll mod = 998244353;
ll modpow(ll b, ll e) {
ll ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1)
ans = ans * b % mod;
return ans;
}
ll inv(ll x) { return modpow(x, mod - 2); }
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int n, s;
cin >> n >> s;
vi a(n);
rep(i, 0, n) cin >> a[i];
ll i2 = inv(2);
vi dp(s + 1, 0);
dp[0] = 1;
rep(i, 0, n) {
per(j, 0, s) {
if (j + a[i] <= s) {
dp[j + a[i]] += dp[j] * i2 % mod;
dp[j + a[i]] %= mod;
}
}
}
ll ans = modpow(2, n) * dp[s] % mod;
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << '\n';
} | replace | 50 | 52 | 50 | 52 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define en "\n"
#define INF (int)9e18
#define HELL 998244353LL
#define int long long
#define double long double
#define uint unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fs first
#define sc second
#define size(a) (int)a.size()
#define deb(x) cerr << #x << " => " << x << en
#define debp(a) \
cerr << #a << " => " \
<< "(" << a.fs << ", " << a.sc << ") " << en;
#define deba(x) \
cerr << #x << en; \
for (auto a : x) \
cerr << a << " "; \
cerr << en;
#define debpa(x) \
cerr << #x << en; \
for (auto a : x) \
cerr << "(" << a.fs << ", " << a.sc << ") "; \
cerr << en;
#define debm(x) \
cerr << #x << en; \
for (auto a : x) { \
for (auto b : a) \
cerr << b << " "; \
cerr << en; \
}
#define getMat(x, n, m, val) vector<vector<int>> x(n, vector<int>(m, val))
#define fastio \
ios_base ::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
#define pout cout << fixed << setprecision(10)
int fastpow(int a, int b, int m = HELL) {
int res = 1;
a %= m;
while (b > 0) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
#define inv(a) fastpow(a, HELL - 2)
#define mul(a, b) ((a % HELL) * (b % HELL)) % HELL
int n, s;
const int maxN = 3e3 + 5;
int arr[maxN];
int dp[maxN][maxN];
int res(int pos, int sum) {
if (sum > s) {
return 0;
}
if (pos == n) {
return sum == s;
}
int ans = dp[pos][sum];
if (ans == -1) {
ans = 0;
int x = res(pos + 1, sum);
if (x)
ans = mul(2, x);
ans = (ans + res(pos + 1, sum + arr[pos])) % HELL;
}
return ans;
}
int32_t main() {
fastio;
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof dp);
cout << res(0, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define en "\n"
#define INF (int)9e18
#define HELL 998244353LL
#define int long long
#define double long double
#define uint unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fs first
#define sc second
#define size(a) (int)a.size()
#define deb(x) cerr << #x << " => " << x << en
#define debp(a) \
cerr << #a << " => " \
<< "(" << a.fs << ", " << a.sc << ") " << en;
#define deba(x) \
cerr << #x << en; \
for (auto a : x) \
cerr << a << " "; \
cerr << en;
#define debpa(x) \
cerr << #x << en; \
for (auto a : x) \
cerr << "(" << a.fs << ", " << a.sc << ") "; \
cerr << en;
#define debm(x) \
cerr << #x << en; \
for (auto a : x) { \
for (auto b : a) \
cerr << b << " "; \
cerr << en; \
}
#define getMat(x, n, m, val) vector<vector<int>> x(n, vector<int>(m, val))
#define fastio \
ios_base ::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
#define pout cout << fixed << setprecision(10)
int fastpow(int a, int b, int m = HELL) {
int res = 1;
a %= m;
while (b > 0) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
#define inv(a) fastpow(a, HELL - 2)
#define mul(a, b) ((a % HELL) * (b % HELL)) % HELL
int n, s;
const int maxN = 3e3 + 5;
int arr[maxN];
int dp[maxN][maxN];
int res(int pos, int sum) {
if (sum > s) {
return 0;
}
if (pos == n) {
return sum == s;
}
int &ans = dp[pos][sum];
if (ans == -1) {
ans = 0;
int x = res(pos + 1, sum);
if (x)
ans = mul(2, x);
ans = (ans + res(pos + 1, sum + arr[pos])) % HELL;
}
return ans;
}
int32_t main() {
fastio;
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof dp);
cout << res(0, 0) << endl;
return 0;
}
| replace | 67 | 68 | 67 | 68 | TLE | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[3123][3123], n, s, v[3123];
// dp[i][j]:sum:2^(n-k)*(i-1番目まで見てk個使って合計がjになる個数)
// dp[i+1][j]=dp[i][j-v[i]]/2+dp[i][j]
// 初期値はdp[0][0]=2^n
const int MOD = 998244353;
int pw(int n, int k) {
assert(k >= 0);
int res = 1;
while (k) {
if (k & 1)
(res *= n) %= MOD;
(n *= n) %= MOD;
k >>= 1;
}
return res;
}
int f(int i, int j) {
if (j < 0)
return 0;
if (!i)
return pw(2, n) * (!j);
if (~dp[i][j])
return dp[i][j];
return (f(i - 1, j - v[i - 1]) * pw(2, MOD - 2) + f(i - 1, j)) % MOD;
}
signed main() {
memset(dp, -1, sizeof(dp));
cin >> n >> s;
for (int i = 0; i < n; i++)
cin >> v[i];
cout << f(n, s) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[3123][3123], n, s, v[3123];
// dp[i][j]:sum:2^(n-k)*(i-1番目まで見てk個使って合計がjになる個数)
// dp[i+1][j]=dp[i][j-v[i]]/2+dp[i][j]
// 初期値はdp[0][0]=2^n
const int MOD = 998244353;
int pw(int n, int k) {
assert(k >= 0);
int res = 1;
while (k) {
if (k & 1)
(res *= n) %= MOD;
(n *= n) %= MOD;
k >>= 1;
}
return res;
}
int f(int i, int j) {
if (j < 0)
return 0;
if (!i)
return pw(2, n) * (!j);
if (~dp[i][j])
return dp[i][j];
return dp[i][j] =
(f(i - 1, j - v[i - 1]) * pw(2, MOD - 2) + f(i - 1, j)) % MOD;
}
signed main() {
memset(dp, -1, sizeof(dp));
cin >> n >> s;
for (int i = 0; i < n; i++)
cin >> v[i];
cout << f(n, s) << endl;
}
| replace | 27 | 28 | 27 | 29 | TLE | |
p02662 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
// #define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SORT_DESC(c) sort((c).rbegin(), (c).rend())
#define REV(c) reverse((c).begin(), (c).end())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * (LL)INF;
const int MOD = 998244353;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL n, s;
cin >> n >> s;
VL a(n);
REP(i, n) { cin >> a[i]; }
VVL dp(n);
REP(i, n) { dp[i].resize(s); }
if (a[0] <= s) {
dp[0][a[0]] = 1;
}
// dp[0][0] = 1;
FOR(i, 1, n) {
REP(j, s + 1) {
dp[i][j] += dp[i - 1][j] * 2;
dp[i][j] %= MOD;
if (j + a[i] <= s) {
if (j == 0) {
dp[i][j + a[i]] += modpow(2, i);
} else {
dp[i][j + a[i]] += dp[i - 1][j];
}
dp[i][j + a[i]] %= MOD;
}
}
}
cout << dp[n - 1][s] % MOD << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
// #define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SORT_DESC(c) sort((c).rbegin(), (c).rend())
#define REV(c) reverse((c).begin(), (c).end())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * (LL)INF;
const int MOD = 998244353;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL n, s;
cin >> n >> s;
VL a(n);
REP(i, n) { cin >> a[i]; }
VVL dp(n);
REP(i, n) { dp[i].resize(s + 1); }
if (a[0] <= s) {
dp[0][a[0]] = 1;
}
// dp[0][0] = 1;
FOR(i, 1, n) {
REP(j, s + 1) {
dp[i][j] += dp[i - 1][j] * 2;
dp[i][j] %= MOD;
if (j + a[i] <= s) {
if (j == 0) {
dp[i][j + a[i]] += modpow(2, i);
} else {
dp[i][j + a[i]] += dp[i - 1][j];
}
dp[i][j + a[i]] %= MOD;
}
}
}
cout << dp[n - 1][s] % MOD << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | replace | 63 | 64 | 63 | 64 | 0 | |
p02662 | C++ | Runtime Error |
// Problem : F - Knapsack for All Subsets
// Contest : AtCoder - AtCoder Beginner Contest 169
// URL : https://atcoder.jp/contests/abc169/tasks/abc169_f
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
using namespace std;
// #include "testlib.h"
#define ff first
#define ss second
#define all(v) v.begin(), v.end()
#define int long long
#define ll long long
#define M 1000000007
#define MM 998244353
#define inputarr(a, n) \
for (int i = 0; i < n; ++i) \
cin >> a[i]
#define GCD(m, n) __gcd(m, n)
#define LCM(m, n) m *(n / GCD(m, n))
#define mii map<ll, ll>
#define msi map<string, ll>
#define rep(a, b) for (ll i = a; i < b; i++)
#define rep0(n) for (ll i = 0; i < n; i++)
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define pb push_back
#define vi vector<ll>
#define vs vector<string>
#define ppb pop_back
#define endl '\n'
#define asdf \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define r0 return 0;
#define FORD(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define inputoutput \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define Set(a, s) (a, s, sizeof(a))
#define FOR repi
#define vii vector<pii>
#define pii pair<int, int>
#define REVERSE(v) reverse(all(v))
#define trav(a, x) for (auto &a : x)
#define display(x) \
trav(a, x) cout << a << " "; \
cout << endl
#define debug cerr << "bhau" << endl
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T, typename U> static inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> static inline void amax(T &x, U y) {
if (x < y)
x = y;
}
ll max(ll a, ll b) { return (a > b) ? a : b; }
int min(int a, int b) { return (a < b) ? a : b; }
int power(int x, unsigned int y, unsigned int m) {
if (y == 0)
return 1;
int p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
int solve() {
int n, s;
cin >> n >> s;
int a[n];
inputarr(a, n);
// int dp[2*s];
vi dp(2 * s + 1, 0);
// memset(dp,0,sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n; i++) {
vi temp(2 * s + 1, 0);
for (int j = 0; j < s; j++) {
if (j == 0) {
temp[a[i]] = power(2, i, MM);
} else
temp[a[i] + j] += dp[j];
temp[a[i] + j] %= MM;
}
for (int j = 1; j <= s; j++) {
dp[j] *= 2;
dp[j] += temp[j];
dp[j] %= MM;
}
// trace(dp[a[i]],temp[a[i]]);
}
cout << dp[s];
return 0;
}
signed main() {
asdf int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
|
// Problem : F - Knapsack for All Subsets
// Contest : AtCoder - AtCoder Beginner Contest 169
// URL : https://atcoder.jp/contests/abc169/tasks/abc169_f
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
using namespace std;
// #include "testlib.h"
#define ff first
#define ss second
#define all(v) v.begin(), v.end()
#define int long long
#define ll long long
#define M 1000000007
#define MM 998244353
#define inputarr(a, n) \
for (int i = 0; i < n; ++i) \
cin >> a[i]
#define GCD(m, n) __gcd(m, n)
#define LCM(m, n) m *(n / GCD(m, n))
#define mii map<ll, ll>
#define msi map<string, ll>
#define rep(a, b) for (ll i = a; i < b; i++)
#define rep0(n) for (ll i = 0; i < n; i++)
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define pb push_back
#define vi vector<ll>
#define vs vector<string>
#define ppb pop_back
#define endl '\n'
#define asdf \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define r0 return 0;
#define FORD(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define inputoutput \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define Set(a, s) (a, s, sizeof(a))
#define FOR repi
#define vii vector<pii>
#define pii pair<int, int>
#define REVERSE(v) reverse(all(v))
#define trav(a, x) for (auto &a : x)
#define display(x) \
trav(a, x) cout << a << " "; \
cout << endl
#define debug cerr << "bhau" << endl
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T, typename U> static inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> static inline void amax(T &x, U y) {
if (x < y)
x = y;
}
ll max(ll a, ll b) { return (a > b) ? a : b; }
int min(int a, int b) { return (a < b) ? a : b; }
int power(int x, unsigned int y, unsigned int m) {
if (y == 0)
return 1;
int p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
int solve() {
int n, s;
cin >> n >> s;
int a[n];
inputarr(a, n);
// int dp[2*s];
vi dp(2 * s + 1, 0);
// memset(dp,0,sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n; i++) {
vi temp(2 * s + 1, 0);
for (int j = 0; j < s; j++) {
if (a[i] + j > s)
break;
if (j == 0) {
temp[a[i]] = power(2, i, MM);
} else
temp[a[i] + j] += dp[j];
temp[a[i] + j] %= MM;
}
for (int j = 1; j <= s; j++) {
dp[j] *= 2;
dp[j] += temp[j];
dp[j] %= MM;
}
// trace(dp[a[i]],temp[a[i]]);
}
cout << dp[s];
return 0;
}
signed main() {
asdf int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
| insert | 96 | 96 | 96 | 98 | 0 | |
p02662 | Python | Time Limit Exceeded | MOD = 998244353
n, s = map(int, input().split())
a = list(map(int, input().split()))
f = [0] * (s + 1)
f[0] = pow(2, n, MOD)
v = pow(2, MOD - 2, MOD)
for i in range(n):
for j in range(s, a[i] - 1, -1):
f[j] += f[j - a[i]] * v
for j in range(s + 1):
f[j] %= MOD
print(f[s])
| MOD = 998244353
n, s = map(int, input().split())
a = list(map(int, input().split()))
f = [0] * (s + 1)
f[0] = pow(2, n, MOD)
v = pow(2, MOD - 2, MOD)
for x in a:
for j in range(s, x - 1, -1):
f[j] += f[j - x] * v
for j in range(s + 1):
f[j] %= MOD
print(f[s])
| replace | 6 | 9 | 6 | 9 | TLE | |
p02662 | Python | Runtime Error | import numpy as np
import sys
input = sys.stdin.readline
def main():
n, s = map(int, input().split())
A = [int(i) for i in input().split()]
MOD = 998244353
dp = np.zeros(s + 1, dtype="int32")
dp[0] = 1
for a in A:
p = (dp * 2) % MOD
p %= MOD
p[a:] += dp[:a]
dp = p % MOD
print(dp[s])
if __name__ == "__main__":
main()
| import numpy as np
import sys
input = sys.stdin.readline
def main():
n, s = map(int, input().split())
A = [int(i) for i in input().split()]
MOD = 998244353
dp = np.zeros(s + 1, dtype="int32")
dp[0] = 1
for a in A:
p = (dp * 2) % MOD
p %= MOD
p[a:] += dp[:-a]
dp = p % MOD
print(dp[s])
if __name__ == "__main__":
main()
| replace | 18 | 19 | 18 | 19 | TLE | |
p02662 | Python | Runtime Error | def resolve():
n, s = map(int, input().split())
a = list(map(int, input().split()))
mod = 998244353
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
for j in range(s - i, -1, -1):
dp[j + i] = dp[j + i] * 2 + dp[j]
dp[j + i] %= mod
for j in range(min(i, s + 2)):
dp[j] *= 2
dp[j] %= mod
print(dp[-1])
if __name__ == "__main__":
resolve()
| def resolve():
n, s = map(int, input().split())
a = list(map(int, input().split()))
mod = 998244353
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
for j in range(s - i, -1, -1):
dp[j + i] = dp[j + i] * 2 + dp[j]
dp[j + i] %= mod
for j in range(min(i, s + 1)):
dp[j] *= 2
dp[j] %= mod
print(dp[-1])
if __name__ == "__main__":
resolve()
| replace | 10 | 11 | 10 | 11 | 0 | |
p02662 | C++ | Runtime Error |
/**
* Coded by : lucky_21
* --------Lokesh Singh
**/
#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;
template <class T>
using oset =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define F first
#define S second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define all(x) x.begin(), x.end()
#define fix fixed << setprecision(10)
#define rep(i, a, b) for (int i = int(a); i <= int(b); i++)
#define repb(i, b, a) for (int i = int(b); i >= int(a); i--)
#define FastIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
typedef double db;
typedef long long ll;
const int N = 3005;
const int mod = 998244353;
int n, s, a[N], p[N], dp[N][N];
ll rec(int i, int x) {
if (x == 0)
return p[n - i + 1];
if (i > n or x < 0)
return 0;
int &cache = dp[i][x];
if (cache != -1)
return cache;
return cache = (rec(i + 1, x - a[i]) + 2 * rec(i + 1, x)) % mod;
}
signed main() {
FastIO;
p[0] = 1;
rep(i, 1, 3e5) p[i] = p[i - 1] * 2 % mod;
cin >> n >> s;
rep(i, 1, n) cin >> a[i];
memset(dp, -1, sizeof dp);
cout << rec(1, s);
return 0;
}
|
/**
* Coded by : lucky_21
* --------Lokesh Singh
**/
#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;
template <class T>
using oset =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define F first
#define S second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define all(x) x.begin(), x.end()
#define fix fixed << setprecision(10)
#define rep(i, a, b) for (int i = int(a); i <= int(b); i++)
#define repb(i, b, a) for (int i = int(b); i >= int(a); i--)
#define FastIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
typedef double db;
typedef long long ll;
const int N = 3005;
const int mod = 998244353;
int n, s, a[N], p[N], dp[N][N];
ll rec(int i, int x) {
if (x == 0)
return p[n - i + 1];
if (i > n or x < 0)
return 0;
int &cache = dp[i][x];
if (cache != -1)
return cache;
return cache = (rec(i + 1, x - a[i]) + 2 * rec(i + 1, x)) % mod;
}
signed main() {
FastIO;
p[0] = 1;
rep(i, 1, 3000) p[i] = p[i - 1] * 2 % mod;
cin >> n >> s;
rep(i, 1, n) cin >> a[i];
memset(dp, -1, sizeof dp);
cout << rec(1, s);
return 0;
}
| replace | 48 | 49 | 48 | 49 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 3e3 + 23;
const int mod = 998244353;
long long dp[N][N];
int a[N];
void solve() {
int n, s;
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
dp[0][0] = 1;
for (int i = 0; i <= s; ++i) {
for (int j = 0; j < n; ++j) {
dp[i][j + 1] = (dp[i][j + 1] + dp[i][j] * 2) % mod;
if (i + a[j] <= N)
dp[i + a[j]][j + 1] = (dp[i + a[j]][j + 1] + dp[i][j]) % mod;
}
}
printf("%lld", dp[s][n]);
}
int main() {
init();
int t = 1; // scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 3e3 + 23;
const int mod = 998244353;
long long dp[N][N];
int a[N];
void solve() {
int n, s;
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
dp[0][0] = 1;
for (int i = 0; i <= s; ++i) {
for (int j = 0; j < n; ++j) {
dp[i][j + 1] = (dp[i][j + 1] + dp[i][j] * 2) % mod;
if (i + a[j] <= s)
dp[i + a[j]][j + 1] = (dp[i + a[j]][j + 1] + dp[i][j]) % mod;
}
}
printf("%lld", dp[s][n]);
}
int main() {
init();
int t = 1; // scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| replace | 31 | 32 | 31 | 32 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class T> void chmin(T &a, const T &b) noexcept {
if (b < a)
a = b;
}
template <class T> void chmax(T &a, const T &b) noexcept {
if (a < b)
a = b;
}
void debug_out() { cout << "\n"; }
template <class T, class... Args>
void debug_out(const T &x, const Args &...args) {
cout << x << " ";
debug_out(args...);
}
#ifdef _DEBUG
#define debug(...) debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// const int mod = 1000000007;
const int mod = 998244353;
struct mint {
ll x;
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; }
bool operator==(const mint rhs) const { return x == rhs.x; }
bool operator!=(const mint rhs) const { return x != rhs.x; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
int n, s;
cin >> n >> s;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<vector<mint>> F(n + 5, vector<mint>(s + 5, 0));
F[0][0] = 2;
F[0][a[0]] = 1;
for (int i = 1; i < n; ++i) {
for (int j = 0; j <= s; ++j) {
F[i][j] += F[i - 1][j] * 2;
if (j + a[i] <= s)
F[i][j + a[i]] += F[i - 1][j];
}
}
cout << F[n - 1][s] << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class T> void chmin(T &a, const T &b) noexcept {
if (b < a)
a = b;
}
template <class T> void chmax(T &a, const T &b) noexcept {
if (a < b)
a = b;
}
void debug_out() { cout << "\n"; }
template <class T, class... Args>
void debug_out(const T &x, const Args &...args) {
cout << x << " ";
debug_out(args...);
}
#ifdef _DEBUG
#define debug(...) debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// const int mod = 1000000007;
const int mod = 998244353;
struct mint {
ll x;
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; }
bool operator==(const mint rhs) const { return x == rhs.x; }
bool operator!=(const mint rhs) const { return x != rhs.x; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
int n, s;
cin >> n >> s;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<vector<mint>> F(n + 5, vector<mint>(s + 5, 0));
F[0][0] = 2;
if (a[0] <= s)
F[0][a[0]] = 1;
for (int i = 1; i < n; ++i) {
for (int j = 0; j <= s; ++j) {
F[i][j] += F[i - 1][j] * 2;
if (j + a[i] <= s)
F[i][j + a[i]] += F[i - 1][j];
}
}
cout << F[n - 1][s] << endl;
return 0;
} | replace | 78 | 79 | 78 | 80 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define REP(i, n) for (int i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 998244353;
const int MAX_N = 3010;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t 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 ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
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 inverse() 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(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
int N, S;
vector<int> A;
int dp[MAX_N][MAX_N][3];
// Ai を見ていて、現在の値は val, i の選定ステートは state のときの
// 合計パターン数
// state:
// 0: T の選定漏れ(Ai は選べない)
// 1: T にはいるけど選ばれなかった
// 2: T にいるし、選ばれた
modint dfs(int i, int val, int state) {
if (i >= N) {
return (val == S) ? 1 : 0;
}
int pres = dp[i][val][state];
if (~pres) {
return modint(pres);
}
modint ret(0);
if (state == 0) {
ret += dfs(i + 1, val, 0);
ret += dfs(i + 1, val, 1);
ret += dfs(i + 1, val, 2);
} else if (state == 1) {
ret += dfs(i + 1, val, 0);
ret += dfs(i + 1, val, 1);
ret += dfs(i + 1, val, 2);
} else {
int next_val = val + A[i];
if (next_val <= S) {
ret += dfs(i + 1, next_val, 0);
ret += dfs(i + 1, next_val, 1);
ret += dfs(i + 1, next_val, 2);
}
}
return ret;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> N >> S;
A.resize(N);
REP(i, N) { cin >> A[i]; }
MINUS(dp);
modint ans(0);
ans += dfs(0, 0, 0);
ans += dfs(0, 0, 1);
ans += dfs(0, 0, 2);
ans /= modint(3);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define REP(i, n) for (int i = 0; i < n; ++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG(fmt, ...)
#endif
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 998244353;
const int MAX_N = 3010;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t 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 ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
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 inverse() 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(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>;
int N, S;
vector<int> A;
int dp[MAX_N][MAX_N][3];
// Ai を見ていて、現在の値は val, i の選定ステートは state のときの
// 合計パターン数
// state:
// 0: T の選定漏れ(Ai は選べない)
// 1: T にはいるけど選ばれなかった
// 2: T にいるし、選ばれた
modint dfs(int i, int val, int state) {
if (i >= N) {
return (val == S) ? 1 : 0;
}
int pres = dp[i][val][state];
if (~pres) {
return modint(pres);
}
modint ret(0);
if (state == 0) {
ret += dfs(i + 1, val, 0);
ret += dfs(i + 1, val, 1);
ret += dfs(i + 1, val, 2);
} else if (state == 1) {
ret += dfs(i + 1, val, 0);
ret += dfs(i + 1, val, 1);
ret += dfs(i + 1, val, 2);
} else {
int next_val = val + A[i];
if (next_val <= S) {
ret += dfs(i + 1, next_val, 0);
ret += dfs(i + 1, next_val, 1);
ret += dfs(i + 1, next_val, 2);
}
}
dp[i][val][state] = ret.x;
return ret;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> N >> S;
A.resize(N);
REP(i, N) { cin >> A[i]; }
MINUS(dp);
modint ans(0);
ans += dfs(0, 0, 0);
ans += dfs(0, 0, 1);
ans += dfs(0, 0, 2);
ans /= modint(3);
cout << ans << endl;
return 0;
}
| insert | 150 | 150 | 150 | 152 | TLE | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#if 1 // 折り畳み用
//------------------------------------------------------------
using ll = long long;
#define int ll
#define FOR(i, s, e) for (ll i = ll(s); i < (ll)e; ++i)
#define RFOR(i, s, e) for (ll i = ll(e) - 1; i >= ll(s); --i)
#define REP(i, n) for (ll i = 0, i##_size = n; i < i##_size; ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
//------------------------------------------------------------
template <class T> struct arr : public vector<T> {
arr() {}
arr(ll n, T v = T()) : vector<T>(n, v) {}
void init(ll n, T v = T()) {
this->clear();
this->resize(n, v);
}
ll sz() const { return (ll)this->size(); }
void pb(T v) { this->push_back(v); }
void sort() { std::sort(this->begin(), this->end()); }
void rsort() { std::sort(this->begin(), this->end(), greater<T>()); }
};
using ints = arr<ll>;
using intss = arr<arr<ll>>;
template <class T> struct que : public queue<T> {
ll sz() const { return (ll)this->size(); }
T popfront() {
T v = this->front();
this->pop();
return v;
}
};
//------------------------------------------------------------
#if defined(TEST)
extern istream &myInputStream;
extern ostream &myOutputStream;
#else
istream &myInputStream = cin;
ostream &myOutputStream = cout;
#endif
struct input_ar {
ll n;
input_ar(ll n_) : n(n_) {}
template <class T> operator arr<T>() {
arr<T> var(n);
REP(i, n) { myInputStream >> var[i]; };
return var;
}
};
struct input {
template <class T> operator T() {
T var;
myInputStream >> var;
return var;
}
input_ar operator()(ll N) { return input_ar(N); }
} input;
template <class T> void output(T var) { myOutputStream << (var) << '\n'; }
//------------------------------------------------------------
template <class T> void chmin(T &a, T b) {
if (b < a) {
a = b;
}
}
template <class T> void chmax(T &a, T b) {
if (b > a) {
a = b;
}
}
struct bfs {
ints froms;
ints steps;
bfs(int N, intss const &adjacency) {
froms.init(N, -1);
steps.init(N, -1);
que<ll> queue;
queue.push(0);
froms[0] = 0;
steps[0] = 0;
while (queue.empty() == false) {
ll p = queue.popfront();
for (ll n : adjacency[p]) {
if (froms[n] != -1) {
continue;
}
froms[n] = p;
steps[n] = steps[p] + 1;
queue.push(n);
}
}
}
};
//------------------------------------------------------------
#if !defined(TEST)
void myMain();
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(16);
myMain();
return 0;
}
#endif
#endif
#define DIV 998244353
int N;
int S;
ints A;
int dp[3001][3001];
int Calc(int index, int sum) {
if (index == N) {
if (sum == S) {
return 1;
} else {
return 0;
}
}
if (dp[index][sum] >= 0) {
return dp[index][sum];
}
int c1 = Calc(index + 1, sum + A[index]);
int c2 = Calc(index + 1, sum);
int c3 = c2;
int r = (c1 + c2 + c3) % DIV;
dp[index][sum] = r;
return r;
}
//------------------------------------------------------------
void myMain() {
N = input;
S = input;
A = input(N);
A.sort();
REP(i, N + 1) {
REP(j, S + 1) { dp[i][j] = -1; }
}
int ans = Calc(0, 0);
output(ans);
}
| #include <bits/stdc++.h>
using namespace std;
#if 1 // 折り畳み用
//------------------------------------------------------------
using ll = long long;
#define int ll
#define FOR(i, s, e) for (ll i = ll(s); i < (ll)e; ++i)
#define RFOR(i, s, e) for (ll i = ll(e) - 1; i >= ll(s); --i)
#define REP(i, n) for (ll i = 0, i##_size = n; i < i##_size; ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
//------------------------------------------------------------
template <class T> struct arr : public vector<T> {
arr() {}
arr(ll n, T v = T()) : vector<T>(n, v) {}
void init(ll n, T v = T()) {
this->clear();
this->resize(n, v);
}
ll sz() const { return (ll)this->size(); }
void pb(T v) { this->push_back(v); }
void sort() { std::sort(this->begin(), this->end()); }
void rsort() { std::sort(this->begin(), this->end(), greater<T>()); }
};
using ints = arr<ll>;
using intss = arr<arr<ll>>;
template <class T> struct que : public queue<T> {
ll sz() const { return (ll)this->size(); }
T popfront() {
T v = this->front();
this->pop();
return v;
}
};
//------------------------------------------------------------
#if defined(TEST)
extern istream &myInputStream;
extern ostream &myOutputStream;
#else
istream &myInputStream = cin;
ostream &myOutputStream = cout;
#endif
struct input_ar {
ll n;
input_ar(ll n_) : n(n_) {}
template <class T> operator arr<T>() {
arr<T> var(n);
REP(i, n) { myInputStream >> var[i]; };
return var;
}
};
struct input {
template <class T> operator T() {
T var;
myInputStream >> var;
return var;
}
input_ar operator()(ll N) { return input_ar(N); }
} input;
template <class T> void output(T var) { myOutputStream << (var) << '\n'; }
//------------------------------------------------------------
template <class T> void chmin(T &a, T b) {
if (b < a) {
a = b;
}
}
template <class T> void chmax(T &a, T b) {
if (b > a) {
a = b;
}
}
struct bfs {
ints froms;
ints steps;
bfs(int N, intss const &adjacency) {
froms.init(N, -1);
steps.init(N, -1);
que<ll> queue;
queue.push(0);
froms[0] = 0;
steps[0] = 0;
while (queue.empty() == false) {
ll p = queue.popfront();
for (ll n : adjacency[p]) {
if (froms[n] != -1) {
continue;
}
froms[n] = p;
steps[n] = steps[p] + 1;
queue.push(n);
}
}
}
};
//------------------------------------------------------------
#if !defined(TEST)
void myMain();
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(16);
myMain();
return 0;
}
#endif
#endif
#define DIV 998244353
int N;
int S;
ints A;
int dp[3001][3001];
int Calc(int index, int sum) {
if (index == N) {
if (sum == S) {
return 1;
} else {
return 0;
}
}
if (sum > S) {
return 0;
}
if (dp[index][sum] >= 0) {
return dp[index][sum];
}
int c1 = Calc(index + 1, sum + A[index]);
int c2 = Calc(index + 1, sum);
int c3 = c2;
int r = (c1 + c2 + c3) % DIV;
dp[index][sum] = r;
return r;
}
//------------------------------------------------------------
void myMain() {
N = input;
S = input;
A = input(N);
A.sort();
REP(i, N + 1) {
REP(j, S + 1) { dp[i][j] = -1; }
}
int ans = Calc(0, 0);
output(ans);
}
| insert | 137 | 137 | 137 | 140 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define DEBUG(...)
#endif
template <class T, class Op = multiplies<T>>
constexpr T power(T a, long long n, Op op = Op(), T e = {1}) {
assert(n >= 0);
while (n) {
if (n & 1)
e = op(e, a);
if (n >>= 1)
a = op(a, a);
}
return e;
}
template <unsigned M> struct modular {
using m = modular;
static constexpr unsigned mod = M;
unsigned v;
modular(long long x = 0) : v((x %= mod) < 0 ? x + mod : x) {}
m operator-() const { return m() -= *this; }
m &operator+=(m b) {
if ((int)(v += b.v - mod) < 0)
v += mod;
return *this;
}
m &operator-=(m b) {
if ((int)(v -= b.v) < 0)
v += mod;
return *this;
}
m &operator*=(m b) {
v = (uint64_t)v * b.v % mod;
return *this;
}
m &operator/=(m b) { return *this *= power(b, mod - 2); }
friend m operator+(m a, m b) { return a += b; }
friend m operator-(m a, m b) { return a -= b; }
friend m operator*(m a, m b) { return a *= b; }
friend m operator/(m a, m b) { return a /= b; }
friend bool operator==(m a, m b) { return a.v == b.v; }
};
using mint = modular<998244353>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
vector<mint> dp(s + 1);
dp[0] = 1;
mint res;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
vector<mint> ndp(n + 1);
for (int j = 0; j <= s; ++j) {
ndp[j] = 2 * dp[j];
}
for (int j = s - a; j >= 0; --j) {
ndp[j + a] += dp[j];
}
swap(dp, ndp);
}
cout << dp[s].v << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define DEBUG(...)
#endif
template <class T, class Op = multiplies<T>>
constexpr T power(T a, long long n, Op op = Op(), T e = {1}) {
assert(n >= 0);
while (n) {
if (n & 1)
e = op(e, a);
if (n >>= 1)
a = op(a, a);
}
return e;
}
template <unsigned M> struct modular {
using m = modular;
static constexpr unsigned mod = M;
unsigned v;
modular(long long x = 0) : v((x %= mod) < 0 ? x + mod : x) {}
m operator-() const { return m() -= *this; }
m &operator+=(m b) {
if ((int)(v += b.v - mod) < 0)
v += mod;
return *this;
}
m &operator-=(m b) {
if ((int)(v -= b.v) < 0)
v += mod;
return *this;
}
m &operator*=(m b) {
v = (uint64_t)v * b.v % mod;
return *this;
}
m &operator/=(m b) { return *this *= power(b, mod - 2); }
friend m operator+(m a, m b) { return a += b; }
friend m operator-(m a, m b) { return a -= b; }
friend m operator*(m a, m b) { return a *= b; }
friend m operator/(m a, m b) { return a /= b; }
friend bool operator==(m a, m b) { return a.v == b.v; }
};
using mint = modular<998244353>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
vector<mint> dp(s + 1);
dp[0] = 1;
mint res;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
vector<mint> ndp(s + 1);
for (int j = 0; j <= s; ++j) {
ndp[j] = 2 * dp[j];
}
for (int j = s - a; j >= 0; --j) {
ndp[j + a] += dp[j];
}
swap(dp, ndp);
}
cout << dp[s].v << '\n';
}
| replace | 62 | 63 | 62 | 63 | 0 | |
p02662 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const ll MOD = 998244353;
ll DP[3000][3000];
// A の部分集合 T、Tの部分集合 U で数える
int main() {
int N, S;
cin >> N >> S;
vector<ll> A(N);
REP(i, N) cin >> A[i];
DP[0][0] = 1;
REP(i, N) REP(j, S + 1) {
// Ai が T に選ばれない場合
DP[i + 1][j] += DP[i][j];
// Ai が T には選ばれているが U には選ばれていない場合
DP[i + 1][j] += DP[i][j];
DP[i + 1][j] %= MOD;
// Ai が選ばれた場合
if (A[i] + j <= S)
DP[i + 1][j + A[i]] += DP[i][j];
DP[i + 1][j] %= MOD;
}
cout << DP[N][S] << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const ll MOD = 998244353;
ll DP[3001][3001];
// A の部分集合 T、Tの部分集合 U で数える
int main() {
int N, S;
cin >> N >> S;
vector<ll> A(N);
REP(i, N) cin >> A[i];
DP[0][0] = 1;
REP(i, N) REP(j, S + 1) {
// Ai が T に選ばれない場合
DP[i + 1][j] += DP[i][j];
// Ai が T には選ばれているが U には選ばれていない場合
DP[i + 1][j] += DP[i][j];
DP[i + 1][j] %= MOD;
// Ai が選ばれた場合
if (A[i] + j <= S)
DP[i + 1][j + A[i]] += DP[i][j];
DP[i + 1][j] %= MOD;
}
cout << DP[N][S] << endl;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 3e3 + 5;
const int INF = 0x7f7f7f7f;
const ll p = 998244353;
#define DEBUG(x) cout << x << '\n'
int n, s, t, f[MAXN];
ll f_pow(ll a, ll b) {
ll res = 1;
for (; b; b >>= 1, a = a * a % p)
if (b & 1)
res = res * a % p;
return res;
}
int main() {
#ifdef Irene
freopen("in.txt", "r", stdin);
#endif // Irene
ios::sync_with_stdio(false);
cin >> n >> s;
f[0] = f_pow(2, n);
ll inv2 = f_pow(2, p - 2);
for (int i = 1; i <= n; i++) {
cin >> t;
for (int j = s - t; ~j; j--)
f[j + t] = (f[j + t] + f[j] * inv2) % p;
}
cout << f[s];
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 3e3 + 5;
const int INF = 0x7f7f7f7f;
const ll p = 998244353;
#define DEBUG(x) cout << x << '\n'
int n, s, t, f[MAXN];
ll f_pow(ll a, ll b) {
ll res = 1;
for (; b; b >>= 1, a = a * a % p)
if (b & 1)
res = res * a % p;
return res;
}
int main() {
#ifdef Irene
freopen("in.txt", "r", stdin);
#endif // Irene
ios::sync_with_stdio(false);
cin >> n >> s;
f[0] = f_pow(2, n);
ll inv2 = f_pow(2, p - 2);
for (int i = 1; i <= n; i++) {
cin >> t;
for (int j = s - t; j >= 0; j--)
f[j + t] = (f[j + t] + f[j] * inv2) % p;
}
cout << f[s];
}
| replace | 27 | 28 | 27 | 28 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 5, M = 998244353, OO = 0x3f3f3f3f;
typedef long long ll;
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0);
const double Pii = 3.14159265359;
ll n, m;
ll mem[N][N];
ll a[N];
ll solve(int idx, int su) {
if (idx == n) {
if (su == m)
return 1;
return 0;
}
if (mem[idx][su] != -1)
return mem[idx][su];
ll op1 = 0, op2 = 0;
if (su + a[idx] <= m)
op1 = solve(idx + 1, su + a[idx]);
op2 = (solve(idx + 1, su) * 2);
return mem[idx][su] = (op1 + (op2 % M)) % M;
}
int main() {
FIO cin >> n >> m;
for (int i = 0; i < n; ++i)
cin >> a[i];
memset(mem, -1, sizeof mem);
ll ans = solve(0, 0);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long N = 3e3 + 5, M = 998244353, OO = 0x3f3f3f3f;
typedef long long ll;
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0);
const double Pii = 3.14159265359;
ll n, m;
ll mem[N][N];
ll a[N];
ll solve(int idx, int su) {
if (idx == n) {
if (su == m)
return 1;
return 0;
}
if (mem[idx][su] != -1)
return mem[idx][su];
ll op1 = 0, op2 = 0;
if (su + a[idx] <= m)
op1 = solve(idx + 1, su + a[idx]);
op2 = (solve(idx + 1, su) * 2);
return mem[idx][su] = (op1 + (op2 % M)) % M;
}
int main() {
FIO cin >> n >> m;
for (int i = 0; i < n; ++i)
cin >> a[i];
memset(mem, -1, sizeof mem);
ll ans = solve(0, 0);
cout << ans << endl;
return 0;
}
| replace | 2 | 3 | 2 | 3 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(s, i, n) for (int i = s; i n; i++)
typedef long long ll;
const int INF = 1e9;
// 1000 mb = 1e9 b = 2.5e8 intergers
const int MOD = 998244353;
ll dp[3000][7000] = {{0}}; // ans up to i and n = i
ll dp2[3000][7000] = {{0}}; // solCnt up to i
ll binPow(ll x, ll k) {
ll ans = 1;
while (k > 0) {
if (k % 2 == 0) {
x = (x * x) % MOD;
k /= 2;
} else {
ans = (ans * x) % MOD;
k--;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, s;
cin >> n >> s;
vector<int> nums(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
for (int i = 0; i < n; i++) {
dp[i][0] = binPow(2, i);
// dp2[i][0] = 1;
for (int j = 0; j <= 3000; j++) {
dp[i + 1][j] += dp[i][j] * 2;
dp[i + 1][j] %= MOD;
dp[i + 1][j + nums[i]] += dp[i][j];
dp[i + 1][j + nums[i]] %= MOD;
// dp2[i+1][j] += dp2[i][j];
// dp2[i+1][j+nums[i]] += dp2[i][j];
}
}
// for (int i = 0; i <= n; i++){
// for (int j = 0; j <= 10; j++){
// cout<<dp[i][j]<<' ';
// }
// cout<<'\n';
// }
cout << dp[n][s] << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(s, i, n) for (int i = s; i n; i++)
typedef long long ll;
const int INF = 1e9;
// 1000 mb = 1e9 b = 2.5e8 intergers
const int MOD = 998244353;
ll dp[3005][7000] = {{0}}; // ans up to i and n = i
ll dp2[3005][7000] = {{0}}; // solCnt up to i
ll binPow(ll x, ll k) {
ll ans = 1;
while (k > 0) {
if (k % 2 == 0) {
x = (x * x) % MOD;
k /= 2;
} else {
ans = (ans * x) % MOD;
k--;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, s;
cin >> n >> s;
vector<int> nums(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
for (int i = 0; i < n; i++) {
dp[i][0] = binPow(2, i);
// dp2[i][0] = 1;
for (int j = 0; j <= 3000; j++) {
dp[i + 1][j] += dp[i][j] * 2;
dp[i + 1][j] %= MOD;
dp[i + 1][j + nums[i]] += dp[i][j];
dp[i + 1][j + nums[i]] %= MOD;
// dp2[i+1][j] += dp2[i][j];
// dp2[i+1][j+nums[i]] += dp2[i][j];
}
}
// for (int i = 0; i <= n; i++){
// for (int j = 0; j <= 10; j++){
// cout<<dp[i][j]<<' ';
// }
// cout<<'\n';
// }
cout << dp[n][s] << '\n';
return 0;
} | replace | 10 | 12 | 10 | 12 | -11 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 998244353;
const int MAX_N = 305;
int N, S;
int A[MAX_N];
ll dp[MAX_N][MAX_N]; // len, sum
ll powmod(ll x, int y) {
ll res = 1;
while (y) {
if (y & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
y >>= 1;
}
return res;
}
void solve() {
dp[0][0] = powmod(2, N);
for (int i = 0; i < N; ++i)
for (int j = 0; j <= S; ++j) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
if (j + A[i] <= S)
(dp[i + 1][j + A[i]] += dp[i][j] * powmod(2, MOD - 2) % MOD) %= MOD;
}
cout << dp[N][S];
}
int main() {
cin >> N >> S;
for (int i = 0; i < N; ++i)
cin >> A[i];
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 998244353;
const int MAX_N = 3005;
int N, S;
int A[MAX_N];
ll dp[MAX_N][MAX_N]; // len, sum
ll powmod(ll x, int y) {
ll res = 1;
while (y) {
if (y & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
y >>= 1;
}
return res;
}
void solve() {
dp[0][0] = powmod(2, N);
for (int i = 0; i < N; ++i)
for (int j = 0; j <= S; ++j) {
(dp[i + 1][j] += dp[i][j]) %= MOD;
if (j + A[i] <= S)
(dp[i + 1][j + A[i]] += dp[i][j] * powmod(2, MOD - 2) % MOD) %= MOD;
}
cout << dp[N][S];
}
int main() {
cin >> N >> S;
for (int i = 0; i < N; ++i)
cin >> A[i];
solve();
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define dl double
#define mp make_pair
#define pb push_back
using namespace std;
//***********************************************************************
// hash struct for unordered_map
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int MAXNUM = 5e3 + 5;
vector<int> vis(MAXNUM);
vector<int> pr;
void sieve() {
pr.push_back(2);
for (ll i = 3; i < MAXNUM; i += 2)
if (!vis[i]) {
pr.push_back(i);
for (ll j = i * i; j < MAXNUM; j += 2 * i)
vis[j] = true;
}
}
//************************************************************************
ll mod = 998244353;
void solve() {
ll n, s;
cin >> n >> s;
vector<ll> v(n);
vector<vector<ll>> dp(n + 5, vector<ll>(s + 5));
ll p = 1;
for (int i = 0; i < n; i++) {
cin >> v[i];
p *= 2;
p %= mod;
dp[i][0] = p;
}
dp[0][v[0]] = 1;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= s; j++) {
dp[i][j] = (2 * dp[i - 1][j]) % mod;
if (j >= v[i]) {
dp[i][j] += dp[i - 1][j - v[i]];
dp[i][j] %= mod;
}
}
}
cout << dp[n - 1][s] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
// cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define dl double
#define mp make_pair
#define pb push_back
using namespace std;
//***********************************************************************
// hash struct for unordered_map
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int MAXNUM = 5e3 + 5;
vector<int> vis(MAXNUM);
vector<int> pr;
void sieve() {
pr.push_back(2);
for (ll i = 3; i < MAXNUM; i += 2)
if (!vis[i]) {
pr.push_back(i);
for (ll j = i * i; j < MAXNUM; j += 2 * i)
vis[j] = true;
}
}
//************************************************************************
ll mod = 998244353;
void solve() {
ll n, s;
cin >> n >> s;
vector<ll> v(n);
vector<vector<ll>> dp(n + 100, vector<ll>(s + 100, 0));
ll p = 1;
for (int i = 0; i < n; i++) {
cin >> v[i];
p *= 2;
p %= mod;
dp[i][0] = p;
}
dp[0][v[0]] = 1;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= s; j++) {
dp[i][j] = (2 * dp[i - 1][j]) % mod;
if (j >= v[i]) {
dp[i][j] += dp[i - 1][j - v[i]];
dp[i][j] %= mod;
}
}
}
cout << dp[n - 1][s] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
// cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
} | replace | 38 | 39 | 38 | 39 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define per(i, n) for (int i = (n)-1; i >= 0; --i)
#define rng(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
const int mod = 998244353;
int main() {
ll n, s;
cin >> n >> s;
vl a(n);
rep(i, n) cin >> a[i];
vl dp(6060);
dp[0] = 1;
rep(i, n) {
vl ndp(6060);
rep(j, 6060) {
(ndp[j] += dp[j] * 2) %= mod;
(ndp[j + a[i]] += dp[j]) %= mod;
}
dp = ndp;
}
cout << dp[s] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define per(i, n) for (int i = (n)-1; i >= 0; --i)
#define rng(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
const int mod = 998244353;
int main() {
ll n, s;
cin >> n >> s;
vl a(n);
rep(i, n) cin >> a[i];
vl dp(6060);
dp[0] = 1;
rep(i, n) {
vl ndp(6060);
rep(j, 3030) {
(ndp[j] += dp[j] * 2) %= mod;
(ndp[j + a[i]] += dp[j]) %= mod;
}
dp = ndp;
}
cout << dp[s] << endl;
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#ifndef ATCODER_INTERNAL_BITOP_HPP
#define ATCODER_INTERNAL_BITOP_HPP 1
#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
#endif // ATCODER_INTERNAL_BITOP_HPP
#ifndef ATCODER_INTERNAL_MATH_HPP
#define ATCODER_INTERNAL_MATH_HPP 1
#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
#endif // ATCODER_INTERNAL_MATH_HPP
#ifndef ATCODER_INTERNAL_QUEUE_HPP
#define ATCODER_INTERNAL_QUEUE_HPP 1
#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
#endif // ATCODER_INTERNAL_QUEUE_HPP
#ifndef ATCODER_INTERNAL_SCC_HPP
#define ATCODER_INTERNAL_SCC_HPP 1
#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
#endif // ATCODER_INTERNAL_SCC_HPP
#ifndef ATCODER_INTERNAL_TYPE_TRAITS_HPP
#define ATCODER_INTERNAL_TYPE_TRAITS_HPP 1
#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
#endif // ATCODER_INTERNAL_TYPE_TRAITS_HPP
#ifndef ATCODER_MODINT_HPP
#define ATCODER_MODINT_HPP 1
#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
#endif // ATCODER_MODINT_HPP
#ifndef ATCODER_CONVOLUTION_HPP
#define ATCODER_CONVOLUTION_HPP 1
#include <algorithm>
#include <array>
#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
#endif // ATCODER_CONVOLUTION_HPP
#ifndef ATCODER_DSU_HPP
#define ATCODER_DSU_HPP 1
#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
#endif // ATCODER_DSU_HPP
#ifndef ATCODER_FENWICKTREE_HPP
#define ATCODER_FENWICKTREE_HPP 1
#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
#endif // ATCODER_FENWICKTREE_HPP
#ifndef ATCODER_LAZYSEGTREE_HPP
#define ATCODER_LAZYSEGTREE_HPP 1
#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
#endif // ATCODER_LAZYSEGTREE_HPP
#ifndef ATCODER_MATH_HPP
#define ATCODER_MATH_HPP 1
#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
#endif // ATCODER_MATH_HPP
#ifndef ATCODER_MAXFLOW_HPP
#define ATCODER_MAXFLOW_HPP 1
#include <algorithm>
#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
#endif // ATCODER_MAXFLOW_HPP
#ifndef ATCODER_MINCOSTFLOW_HPP
#define ATCODER_MINCOSTFLOW_HPP 1
#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
#endif // ATCODER_MINCOSTFLOW_HPP
#ifndef ATCODER_SCC_HPP
#define ATCODER_SCC_HPP 1
#include <algorithm>
#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
#endif // ATCODER_SCC_HPP
#ifndef ATCODER_SEGTREE_HPP
#define ATCODER_SEGTREE_HPP 1
#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
#endif // ATCODER_SEGTREE_HPP
#ifndef ATCODER_STRING_HPP
#define ATCODER_STRING_HPP 1
#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
#endif // ATCODER_STRING_HPP
#ifndef ATCODER_TWOSAT_HPP
#define ATCODER_TWOSAT_HPP 1
#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
#endif // ATCODER_TWOSAT_HPP
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx")
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using namespace atcoder;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define endl '\n'
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
// #define modd 1000000007ll
#define modd 998244353ll
#define flagcount(bit) __builtin_popcount(bit)
#define flag(x) (1ll << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1ll << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) \
(distance(v.begin(), low2way(v, x))) // 配列vでx未満の要素数を返す
#define idx_upper(v, x) \
(distance(v.begin(), high2way(v, x))) // 配列vでx以下の要素数を返す
#define idx_lower2(v, x) \
(v.size() - idx_lower(v, x)) // 配列vでx以上の要素数を返す
#define idx_upper2(v, x) \
(v.size() - idx_upper(v, x)) // 配列vでxより大きい要素の数を返す
#define putout(a) cout << a << '\n'
#define Sum(v) accumulate(all(v), 0ll)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return -1;
}
template <typename T> string make_string(T N) {
string ret;
T now = N;
while (now > 0) {
T x = now % 10;
ret += (char)('0' + x);
now /= 10;
}
reverse(all(ret));
return ret;
}
template <typename T> T gcd(T a, T b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> bool primejudge(T n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++) {
if (n % i == 0) {
return false;
}
i++;
}
return true;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b; // aをbで更新
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b; // aをbで更新
return true;
}
return false;
}
// 場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
// 2次元配列の宣言
// vector<vector<ll>> field(h, vector<ll>(w));
int main() {
cout << fixed << setprecision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, S;
cin >> N >> S;
vector<ll> A(N);
loop(i, N) cin >> A[i];
vector<ll> ans(A[0] + 1);
ans[0] = 1;
ans[A[0]] = 2;
Loop(i, 1, N) {
vector<ll> now(A[i] + 1);
now[0] = 1;
now[A[i]] = 2;
ans = convolution<modd>(ans, now);
}
ll siz = ans.size();
if (siz < S + 1) {
putout(0);
return 0;
}
putout(ans[siz - 1 - S]);
return 0;
}
| #include <bits/stdc++.h>
#ifndef ATCODER_INTERNAL_BITOP_HPP
#define ATCODER_INTERNAL_BITOP_HPP 1
#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
#endif // ATCODER_INTERNAL_BITOP_HPP
#ifndef ATCODER_INTERNAL_MATH_HPP
#define ATCODER_INTERNAL_MATH_HPP 1
#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
#endif // ATCODER_INTERNAL_MATH_HPP
#ifndef ATCODER_INTERNAL_QUEUE_HPP
#define ATCODER_INTERNAL_QUEUE_HPP 1
#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
#endif // ATCODER_INTERNAL_QUEUE_HPP
#ifndef ATCODER_INTERNAL_SCC_HPP
#define ATCODER_INTERNAL_SCC_HPP 1
#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
#endif // ATCODER_INTERNAL_SCC_HPP
#ifndef ATCODER_INTERNAL_TYPE_TRAITS_HPP
#define ATCODER_INTERNAL_TYPE_TRAITS_HPP 1
#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
#endif // ATCODER_INTERNAL_TYPE_TRAITS_HPP
#ifndef ATCODER_MODINT_HPP
#define ATCODER_MODINT_HPP 1
#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
#endif // ATCODER_MODINT_HPP
#ifndef ATCODER_CONVOLUTION_HPP
#define ATCODER_CONVOLUTION_HPP 1
#include <algorithm>
#include <array>
#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
#endif // ATCODER_CONVOLUTION_HPP
#ifndef ATCODER_DSU_HPP
#define ATCODER_DSU_HPP 1
#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
#endif // ATCODER_DSU_HPP
#ifndef ATCODER_FENWICKTREE_HPP
#define ATCODER_FENWICKTREE_HPP 1
#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
#endif // ATCODER_FENWICKTREE_HPP
#ifndef ATCODER_LAZYSEGTREE_HPP
#define ATCODER_LAZYSEGTREE_HPP 1
#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
#endif // ATCODER_LAZYSEGTREE_HPP
#ifndef ATCODER_MATH_HPP
#define ATCODER_MATH_HPP 1
#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
#endif // ATCODER_MATH_HPP
#ifndef ATCODER_MAXFLOW_HPP
#define ATCODER_MAXFLOW_HPP 1
#include <algorithm>
#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
#endif // ATCODER_MAXFLOW_HPP
#ifndef ATCODER_MINCOSTFLOW_HPP
#define ATCODER_MINCOSTFLOW_HPP 1
#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
#endif // ATCODER_MINCOSTFLOW_HPP
#ifndef ATCODER_SCC_HPP
#define ATCODER_SCC_HPP 1
#include <algorithm>
#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
#endif // ATCODER_SCC_HPP
#ifndef ATCODER_SEGTREE_HPP
#define ATCODER_SEGTREE_HPP 1
#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
#endif // ATCODER_SEGTREE_HPP
#ifndef ATCODER_STRING_HPP
#define ATCODER_STRING_HPP 1
#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
#endif // ATCODER_STRING_HPP
#ifndef ATCODER_TWOSAT_HPP
#define ATCODER_TWOSAT_HPP 1
#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
#endif // ATCODER_TWOSAT_HPP
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx")
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using namespace atcoder;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define endl '\n'
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
// #define modd 1000000007ll
#define modd 998244353ll
#define flagcount(bit) __builtin_popcount(bit)
#define flag(x) (1ll << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1ll << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) \
(distance(v.begin(), low2way(v, x))) // 配列vでx未満の要素数を返す
#define idx_upper(v, x) \
(distance(v.begin(), high2way(v, x))) // 配列vでx以下の要素数を返す
#define idx_lower2(v, x) \
(v.size() - idx_lower(v, x)) // 配列vでx以上の要素数を返す
#define idx_upper2(v, x) \
(v.size() - idx_upper(v, x)) // 配列vでxより大きい要素の数を返す
#define putout(a) cout << a << '\n'
#define Sum(v) accumulate(all(v), 0ll)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return -1;
}
template <typename T> string make_string(T N) {
string ret;
T now = N;
while (now > 0) {
T x = now % 10;
ret += (char)('0' + x);
now /= 10;
}
reverse(all(ret));
return ret;
}
template <typename T> T gcd(T a, T b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> bool primejudge(T n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++) {
if (n % i == 0) {
return false;
}
i++;
}
return true;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b; // aをbで更新
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b; // aをbで更新
return true;
}
return false;
}
// 場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
// 2次元配列の宣言
// vector<vector<ll>> field(h, vector<ll>(w));
int main() {
cout << fixed << setprecision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, S;
cin >> N >> S;
vector<ll> A(N);
loop(i, N) cin >> A[i];
vector<ll> ans(A[0] + 1);
ans[0] = 1;
ans[A[0]] = 2;
Loop(i, 1, N) {
vector<ll> now(A[i] + 1);
now[0] = 1;
now[A[i]] = 2;
vector<ll> preans;
ll sizz = ans.size();
if (sizz > S) {
loop(j, S + 1) preans.push_back(ans[sizz - 1 - S + j]);
} else
preans = ans;
ans = convolution<modd>(preans, now);
}
ll siz = ans.size();
if (siz < S + 1) {
putout(0);
return 0;
}
putout(ans[siz - 1 - S]);
return 0;
}
| replace | 2,088 | 2,089 | 2,088 | 2,095 | TLE | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define MAX (ll)(1e3 + 7)
#define INF (ll)(4e18)
#define MOD (ll)(998244353)
using namespace std;
using ll = long long;
using cd = complex<double>;
int dp[MAX][MAX];
int mult(int a, int b) { return (a * 1LL * b) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
int pw(int a, int b) {
int r = 1;
while (b) {
if (b & 1) {
r = mult(r, a);
}
b >>= 1;
a = mult(a, a);
}
return r;
}
int main() {
int n, s;
cin >> n >> s;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
dp[0][0] = pw(2, n);
int div = pw(2, MOD - 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= s; j++) {
dp[i + 1][j] = add(dp[i + 1][j], dp[i][j]);
if (ar[i] + j <= s) {
dp[i + 1][ar[i] + j] = add(dp[i + 1][ar[i] + j], mult(dp[i][j], div));
}
}
}
cout << dp[n][s] << "\n";
}
| #include <bits/stdc++.h>
#define MAX (ll)(3e3 + 7)
#define INF (ll)(4e18)
#define MOD (ll)(998244353)
using namespace std;
using ll = long long;
using cd = complex<double>;
int dp[MAX][MAX];
int mult(int a, int b) { return (a * 1LL * b) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
int pw(int a, int b) {
int r = 1;
while (b) {
if (b & 1) {
r = mult(r, a);
}
b >>= 1;
a = mult(a, a);
}
return r;
}
int main() {
int n, s;
cin >> n >> s;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
dp[0][0] = pw(2, n);
int div = pw(2, MOD - 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= s; j++) {
dp[i + 1][j] = add(dp[i + 1][j], dp[i][j]);
if (ar[i] + j <= s) {
dp[i + 1][ar[i] + j] = add(dp[i + 1][ar[i] + j], mult(dp[i][j], div));
}
}
}
cout << dp[n][s] << "\n";
}
| replace | 1 | 2 | 1 | 2 | 0 | |
p02662 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep_(i, a_, b_, a, b, ...) \
for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define reprev_(i, a_, b_, a, b, ...) \
for (int i = (b - 1), i##_min = (a); i >= i##_min; --i)
#define reprev(i, ...) reprev_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define all(x) (x).begin(), (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> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef long double ld;
constexpr int MOD = 998244353;
// + - * / ^
int mod(int a) {
int res = a % MOD;
if (res < 0) {
return res + MOD;
}
return res;
}
int mul_mod(int a, int b) {
ll res = ((ll)a * (ll)b) % MOD;
return mod((int)res);
}
int pow_mod(int a, int b) {
ll res = 1;
while (b > 0) {
if (b & 1) {
res = res * (ll)a % (ll)MOD;
}
a = mul_mod(a, a);
b >>= 1;
}
return (int)res;
}
int inv_mod(int a) { return pow_mod(a, MOD - 2); }
int div_mod(int a, int b) { return mul_mod(a, inv_mod(b)); }
// ! C
constexpr int FAC_MAX = 3000001;
ll fac[FAC_MAX], finv[FAC_MAX], inv[FAC_MAX];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < FAC_MAX; 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;
}
}
ll com_mod(int a, int b) {
if (a < b)
return 0;
if (a < 0 || b < 0)
return 0;
return fac[a] * (finv[b] * finv[a - b] % MOD) % MOD;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vector<vector<ll>> dp(n + 1, vector<ll>(n + 3001));
dp[0][0] = pow_mod(2, n);
rep(i, n) {
rep(j, s + 1) {
dp[i + 1][j + a[i]] = mod(dp[i + 1][j + a[i]] + div_mod(dp[i][j], 2));
dp[i + 1][j] = mod(dp[i + 1][j] + dp[i][j]);
// dp[i + 1][j] = mod(dp[i + 1][j] + div_mod(dp[i][j], 2));
}
}
ll ans = 0;
// rep (i, 1, n + 1) ans = mod(ans + dp[i][s]);
// cout << ans << "\n";
rep(i, n + 1) {
rep(j, s + 1) eprintf("%d ", dp[i][j]);
eprintf("\n");
}
cout << dp[n][s] << "\n";
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep_(i, a_, b_, a, b, ...) \
for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define reprev_(i, a_, b_, a, b, ...) \
for (int i = (b - 1), i##_min = (a); i >= i##_min; --i)
#define reprev(i, ...) reprev_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define all(x) (x).begin(), (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> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef long double ld;
constexpr int MOD = 998244353;
// + - * / ^
int mod(int a) {
int res = a % MOD;
if (res < 0) {
return res + MOD;
}
return res;
}
int mul_mod(int a, int b) {
ll res = ((ll)a * (ll)b) % MOD;
return mod((int)res);
}
int pow_mod(int a, int b) {
ll res = 1;
while (b > 0) {
if (b & 1) {
res = res * (ll)a % (ll)MOD;
}
a = mul_mod(a, a);
b >>= 1;
}
return (int)res;
}
int inv_mod(int a) { return pow_mod(a, MOD - 2); }
int div_mod(int a, int b) { return mul_mod(a, inv_mod(b)); }
// ! C
constexpr int FAC_MAX = 3000001;
ll fac[FAC_MAX], finv[FAC_MAX], inv[FAC_MAX];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < FAC_MAX; 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;
}
}
ll com_mod(int a, int b) {
if (a < b)
return 0;
if (a < 0 || b < 0)
return 0;
return fac[a] * (finv[b] * finv[a - b] % MOD) % MOD;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, s;
cin >> n >> s;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vector<vector<ll>> dp(n + 1, vector<ll>(s + 3001));
dp[0][0] = pow_mod(2, n);
rep(i, n) {
rep(j, s + 1) {
dp[i + 1][j + a[i]] = mod(dp[i + 1][j + a[i]] + div_mod(dp[i][j], 2));
dp[i + 1][j] = mod(dp[i + 1][j] + dp[i][j]);
// dp[i + 1][j] = mod(dp[i + 1][j] + div_mod(dp[i][j], 2));
}
}
ll ans = 0;
// rep (i, 1, n + 1) ans = mod(ans + dp[i][s]);
// cout << ans << "\n";
rep(i, n + 1) {
rep(j, s + 1) eprintf("%d ", dp[i][j]);
eprintf("\n");
}
cout << dp[n][s] << "\n";
return 0;
} | replace | 114 | 115 | 114 | 115 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORL(i, a, b) for (LL i = (a); i < (b); ++i)
#define REPL(i, n) FORL(i, 0, n)
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(), (a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
// debug func
template <typename T> void vprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vvprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T1, typename T2> void vpprint(vector<pair<T1, T2>> vp) {
REP(i, SIZE(vp)) { cerr << vp[i].first << ", " << vp[i].second << endl; }
}
template <typename T1, typename T2> void mprint(map<T1, T2> m) {
for (auto x : m)
cerr << x.first << ", " << x.second << endl;
}
void yesno(bool flg) { cout << (flg ? "Yes" : "No") << endl; }
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T lcm(T a, T b) { return (a / __gcd(a, b)) * b; }
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
#define MOD 998244353
LL mypow(LL a, LL n) {
if (n == 0)
return 1;
if (n == 1)
return a % MOD;
if (n % 2 == 1)
return (a * mypow(a, n - 1)) % MOD;
LL t = mypow(a, n / 2);
return (t * t) % MOD;
}
#define FACT_SZ 100010
VLL _fact, _inv;
bool _fact_flg = true;
void _fact_init() {
_fact = VLL(FACT_SZ);
_inv = VLL(FACT_SZ);
_fact[0] = 1;
FOR(i, 1, FACT_SZ) _fact[i] = (_fact[i - 1] * i) % MOD;
_inv[FACT_SZ - 1] = mypow(_fact[FACT_SZ - 1], MOD - 2);
for (int i = FACT_SZ - 2; i >= 0; i--) {
_inv[i] = ((i + 1) * _inv[i + 1]) % MOD;
}
}
LL mycomb(LL n, LL k) {
if (_fact_flg) {
_fact_flg = false;
_fact_init();
}
if (n < k)
return 0;
return (((_fact[n] * _inv[k]) % MOD) * _inv[n - k]) % MOD;
}
VLL par, rnk, sz;
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) {
x = root(x);
y = root(y);
return x == y;
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (rnk[x] < rnk[y]) {
par[x] = y;
// sz[y] += sz[x];
} else {
par[y] = x;
// sz[x] += sz[y];
if (rnk[x] == rnk[y])
rnk[x]++;
}
}
#define INF 1e15
int main(void) {
LL n, s;
cin >> n >> s;
VLL a(n);
REP(i, n) cin >> a[i];
VVLL dp(n + 1, VLL(s + 1, 0));
dp[0][0] = 1;
FOR(i, 1, n + 1) {
REP(j, s + 1) {
if (j - a[i - 1] < 0)
dp[i][j] = 2 * dp[i - 1][j];
else
dp[i][j] = dp[i - 1][j - a[i - 1]] + 2 * dp[i - 1][j];
dp[i][j] %= MOD;
}
}
vvprint(dp);
cout << dp[n][s] << endl;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORL(i, a, b) for (LL i = (a); i < (b); ++i)
#define REPL(i, n) FORL(i, 0, n)
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(), (a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
// debug func
template <typename T> void vprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vvprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T1, typename T2> void vpprint(vector<pair<T1, T2>> vp) {
REP(i, SIZE(vp)) { cerr << vp[i].first << ", " << vp[i].second << endl; }
}
template <typename T1, typename T2> void mprint(map<T1, T2> m) {
for (auto x : m)
cerr << x.first << ", " << x.second << endl;
}
void yesno(bool flg) { cout << (flg ? "Yes" : "No") << endl; }
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T lcm(T a, T b) { return (a / __gcd(a, b)) * b; }
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
#define MOD 998244353
LL mypow(LL a, LL n) {
if (n == 0)
return 1;
if (n == 1)
return a % MOD;
if (n % 2 == 1)
return (a * mypow(a, n - 1)) % MOD;
LL t = mypow(a, n / 2);
return (t * t) % MOD;
}
#define FACT_SZ 100010
VLL _fact, _inv;
bool _fact_flg = true;
void _fact_init() {
_fact = VLL(FACT_SZ);
_inv = VLL(FACT_SZ);
_fact[0] = 1;
FOR(i, 1, FACT_SZ) _fact[i] = (_fact[i - 1] * i) % MOD;
_inv[FACT_SZ - 1] = mypow(_fact[FACT_SZ - 1], MOD - 2);
for (int i = FACT_SZ - 2; i >= 0; i--) {
_inv[i] = ((i + 1) * _inv[i + 1]) % MOD;
}
}
LL mycomb(LL n, LL k) {
if (_fact_flg) {
_fact_flg = false;
_fact_init();
}
if (n < k)
return 0;
return (((_fact[n] * _inv[k]) % MOD) * _inv[n - k]) % MOD;
}
VLL par, rnk, sz;
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) {
x = root(x);
y = root(y);
return x == y;
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (rnk[x] < rnk[y]) {
par[x] = y;
// sz[y] += sz[x];
} else {
par[y] = x;
// sz[x] += sz[y];
if (rnk[x] == rnk[y])
rnk[x]++;
}
}
#define INF 1e15
int main(void) {
LL n, s;
cin >> n >> s;
VLL a(n);
REP(i, n) cin >> a[i];
VVLL dp(n + 1, VLL(s + 1, 0));
dp[0][0] = 1;
FOR(i, 1, n + 1) {
REP(j, s + 1) {
if (j - a[i - 1] < 0)
dp[i][j] = 2 * dp[i - 1][j];
else
dp[i][j] = dp[i - 1][j - a[i - 1]] + 2 * dp[i - 1][j];
dp[i][j] %= MOD;
}
}
// vvprint(dp);
cout << dp[n][s] << endl;
} | replace | 199 | 200 | 199 | 200 | TLE | |
p02662 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define mkp make_pair
#define mkt make_tuple
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
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;
}
#define MAX_N 1000010
ll inv[MAX_N + 10], fac[MAX_N + 10], ifac[MAX_N + 10];
void setComb() {
inv[0] = 1;
inv[1] = 1;
fac[1] = 1;
ifac[1] = 1;
fac[0] = 1;
ifac[0] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = (-MOD / i) * inv[MOD % i] % MOD;
fac[i] = fac[i - 1] * i % MOD;
ifac[i] = ifac[i - 1] * inv[i] % MOD;
inv[i] = (inv[i] + MOD) % MOD;
fac[i] = (fac[i] + MOD) % MOD;
ifac[i] = (ifac[i] + MOD) % MOD;
}
return;
}
ll comb(ll n, ll k) {
if (n < k || n < 0 || k < 0)
return 0;
else
return ((fac[n] * ifac[k] % MOD * ifac[n - k] % MOD + MOD) % MOD);
}
ll hcomb(ll n, ll r) { // this size is really ok??
if (n == 0 && r == 0)
return 1;
else if (n < 0 || r < 0)
return 0;
else
return comb(n + r - 1, r);
}
ll mod_pow(ll x, ll n) {
x %= MOD;
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
void add(ll &a, ll b) { a = (a + b) % MOD; }
void mul(ll &a, ll b) {
a %= MOD;
b %= MOD;
a = a * b % MOD;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, S;
cin >> N >> S;
vector<int> A(N);
rep(i, N) cin >> A[i];
vector<vector<ll>> dp(N + 1, vector<ll>(S, 0));
dp[0][0] = 1;
for (int i = 0; i < N; i++)
for (int j = 0; j <= S; j++) {
if (dp[i][j] == 0)
continue;
add(dp[i + 1][j], dp[i][j] * 2 % MOD);
if (j + A[i] <= S)
add(dp[i + 1][j + A[i]], dp[i][j]);
}
cout << dp[N][S] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define mkp make_pair
#define mkt make_tuple
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
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;
}
#define MAX_N 1000010
ll inv[MAX_N + 10], fac[MAX_N + 10], ifac[MAX_N + 10];
void setComb() {
inv[0] = 1;
inv[1] = 1;
fac[1] = 1;
ifac[1] = 1;
fac[0] = 1;
ifac[0] = 1;
for (int i = 2; i < MAX_N; i++) {
inv[i] = (-MOD / i) * inv[MOD % i] % MOD;
fac[i] = fac[i - 1] * i % MOD;
ifac[i] = ifac[i - 1] * inv[i] % MOD;
inv[i] = (inv[i] + MOD) % MOD;
fac[i] = (fac[i] + MOD) % MOD;
ifac[i] = (ifac[i] + MOD) % MOD;
}
return;
}
ll comb(ll n, ll k) {
if (n < k || n < 0 || k < 0)
return 0;
else
return ((fac[n] * ifac[k] % MOD * ifac[n - k] % MOD + MOD) % MOD);
}
ll hcomb(ll n, ll r) { // this size is really ok??
if (n == 0 && r == 0)
return 1;
else if (n < 0 || r < 0)
return 0;
else
return comb(n + r - 1, r);
}
ll mod_pow(ll x, ll n) {
x %= MOD;
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
void add(ll &a, ll b) { a = (a + b) % MOD; }
void mul(ll &a, ll b) {
a %= MOD;
b %= MOD;
a = a * b % MOD;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, S;
cin >> N >> S;
vector<int> A(N);
rep(i, N) cin >> A[i];
vector<vector<ll>> dp(N + 1, vector<ll>(S + 1, 0));
dp[0][0] = 1;
for (int i = 0; i < N; i++)
for (int j = 0; j <= S; j++) {
if (dp[i][j] == 0)
continue;
add(dp[i + 1][j], dp[i][j] * 2 % MOD);
if (j + A[i] <= S)
add(dp[i + 1][j + A[i]], dp[i][j]);
}
cout << dp[N][S] << endl;
return 0;
}
| replace | 92 | 93 | 92 | 93 | 0 | |
p02662 | C++ | Runtime Error | #include <iostream>
using namespace std;
const long long INIT = -1;
const long long MOD = 998244353;
long long dp[3001][3001];
int _array[3005];
long long fact[3005];
long long dfs(int n, int value);
int main() {
int n;
int sum;
cin >> n >> sum;
fact[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> _array[i];
fact[i] = fact[i - 1] * i;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
dp[i][j] = INIT;
}
}
cout << dfs(n, sum) << endl;
return (0);
}
long long dfs(int n, int value) {
if (n == 0) {
if (value == 0) {
return (1);
} else {
return (0);
}
}
if (dp[n][value] != INIT) {
return (dp[n][value]);
}
long long s =
(dfs(n - 1, value) * 2 % MOD + dfs(n - 1, value - _array[n]) % MOD) % MOD;
// cout<<"n:"<<n<<endl;
// cout<<"s:"<<s<<endl<<endl;
return (dp[n][value] = s);
} | #include <iostream>
using namespace std;
const long long INIT = -1;
const long long MOD = 998244353;
long long dp[3001][3001];
int _array[3005];
long long fact[3005];
long long dfs(int n, int value);
int main() {
int n;
int sum;
cin >> n >> sum;
fact[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> _array[i];
fact[i] = fact[i - 1] * i;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= sum; j++) {
dp[i][j] = INIT;
}
}
cout << dfs(n, sum) << endl;
return (0);
}
long long dfs(int n, int value) {
if (n == 0) {
if (value == 0) {
return (1);
} else {
return (0);
}
}
if (dp[n][value] != INIT) {
return (dp[n][value]);
}
long long s = dfs(n - 1, value) * 2 % MOD;
if (value >= _array[n]) {
s = (s + dfs(n - 1, value - _array[n] % MOD)) % MOD;
}
// cout<<"n:"<<n<<endl;
// cout<<"s:"<<s<<endl<<endl;
return (dp[n][value] = s);
} | replace | 40 | 42 | 40 | 44 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 998244353;
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, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// combination MOD prime
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];
}
mint p(int n, int k) { return fact[n] * ifact[n - k]; }
} comb(10000007);
// comb(5, 2) → 10, comb.p(5, 2) → 20
// comb.fact[4] → 24, 2のN乗 → mint(2).pow(N)
const int MAX_A = 20;
mint dp[MAX_A + 1];
int main() {
// ApplePen、ansにその都度足していく
// 左を決める
int N, S;
cin >> N >> S;
vector<int> A(N);
rep(i, N) cin >> A[i];
mint ans = 0;
dp[0] = 1;
for (int i = 0; i < N; i++) {
int a = A[i];
mint prev[MAX_A + 1];
memcpy(
prev, dp,
sizeof(
dp)); // 左端が既に決まっていて、A[i]を集合の要素として選ばないもの
for (int j = 0; j < min(S + 1, MAX_A); j++) {
dp[j] += prev[j]; // 左端が既に決まっていて、A[i]を集合の要素として選ぶ
if (j + a <= min(S + 1, MAX_A)) {
dp[j + a] += prev[j]; // 左端がA[i]でA[i]を足す
}
}
}
cout << dp[S] << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 998244353;
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, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// combination MOD prime
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];
}
mint p(int n, int k) { return fact[n] * ifact[n - k]; }
} comb(10000007);
// comb(5, 2) → 10, comb.p(5, 2) → 20
// comb.fact[4] → 24, 2のN乗 → mint(2).pow(N)
const int MAX_A = 3003;
mint dp[MAX_A + 1];
int main() {
// ApplePen、ansにその都度足していく
// 左を決める
int N, S;
cin >> N >> S;
vector<int> A(N);
rep(i, N) cin >> A[i];
mint ans = 0;
dp[0] = 1;
for (int i = 0; i < N; i++) {
int a = A[i];
mint prev[MAX_A + 1];
memcpy(
prev, dp,
sizeof(
dp)); // 左端が既に決まっていて、A[i]を集合の要素として選ばないもの
for (int j = 0; j < min(S + 1, MAX_A); j++) {
dp[j] += prev[j]; // 左端が既に決まっていて、A[i]を集合の要素として選ぶ
if (j + a <= min(S + 1, MAX_A)) {
dp[j + a] += prev[j]; // 左端がA[i]でA[i]を足す
}
}
}
cout << dp[S] << '\n';
return 0;
} | replace | 75 | 76 | 75 | 76 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02662 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const ll MOD = 998244353;
// あとで S+1 までループを回しているため
ll DP[3000][3001];
// A の部分集合 T、Tの部分集合 U で数える
int main() {
int N, S;
cin >> N >> S;
vector<ll> A(N);
REP(i, N) cin >> A[i];
DP[0][0] = 1;
REP(i, N) REP(j, S + 1) {
// Ai が T に選ばれない場合
DP[i + 1][j] += DP[i][j];
// Ai が T には選ばれているが U には選ばれていない場合
DP[i + 1][j] += DP[i][j];
DP[i + 1][j] %= MOD;
// Ai が選ばれた場合
if (A[i] + j <= S) {
DP[i + 1][j + A[i]] += DP[i][j];
DP[i + 1][j + A[i]] %= MOD;
}
}
cout << DP[N][S] << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const ll MOD = 998244353;
// あとで S+1 までループを回しているため
ll DP[3001][3001];
// A の部分集合 T、Tの部分集合 U で数える
int main() {
int N, S;
cin >> N >> S;
vector<ll> A(N);
REP(i, N) cin >> A[i];
DP[0][0] = 1;
REP(i, N) REP(j, S + 1) {
// Ai が T に選ばれない場合
DP[i + 1][j] += DP[i][j];
// Ai が T には選ばれているが U には選ばれていない場合
DP[i + 1][j] += DP[i][j];
DP[i + 1][j] %= MOD;
// Ai が選ばれた場合
if (A[i] + j <= S) {
DP[i + 1][j + A[i]] += DP[i][j];
DP[i + 1][j + A[i]] %= MOD;
}
}
cout << DP[N][S] << endl;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3010;
const int mod = 998244353;
int n, s;
ll arr[N], dp[N][N];
bool vis[N][N];
ll fun(int pos, int rem) {
if (pos > n) {
if (rem == 0)
return 1;
return 0;
}
ll &ret = dp[pos][rem];
if (vis[pos][rem])
return ret;
ret = 0;
if (rem >= arr[pos]) {
ret = (ret + fun(pos + 1, rem - arr[pos])) % mod;
}
ret = (ret + 2LL * fun(pos + 1, rem)) % mod;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s;
for (int i = 1; i <= n; ++i)
cin >> arr[i];
cout << fun(1, s) << '\n';
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3010;
const int mod = 998244353;
int n, s;
ll arr[N], dp[N][N];
bool vis[N][N];
ll fun(int pos, int rem) {
if (pos > n) {
if (rem == 0)
return 1;
return 0;
}
ll &ret = dp[pos][rem];
if (vis[pos][rem])
return ret;
vis[pos][rem] = true;
ret = 0;
if (rem >= arr[pos]) {
ret = (ret + fun(pos + 1, rem - arr[pos])) % mod;
}
ret = (ret + 2LL * fun(pos + 1, rem)) % mod;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s;
for (int i = 1; i <= n; ++i)
cin >> arr[i];
cout << fun(1, s) << '\n';
} | insert | 19 | 19 | 19 | 20 | TLE | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, s;
ll a[3003], dp[3003];
const ll mod = 998244353;
int main(void) {
scanf("%lld%lld", &n, &s);
for (ll i = 0; i < n; i++)
scanf("%lld", &a[i]);
dp[0] = 1;
for (ll i = 0; i < n; i++) {
for (ll j = s; j >= 0; j--) {
dp[j + a[i]] += dp[j];
dp[j + a[i]] %= mod;
dp[j] *= 2;
dp[j] %= mod;
}
}
printf("%lld", dp[s]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, s;
ll a[3003], dp[6003];
const ll mod = 998244353;
int main(void) {
scanf("%lld%lld", &n, &s);
for (ll i = 0; i < n; i++)
scanf("%lld", &a[i]);
dp[0] = 1;
for (ll i = 0; i < n; i++) {
for (ll j = s; j >= 0; j--) {
dp[j + a[i]] += dp[j];
dp[j + a[i]] %= mod;
dp[j] *= 2;
dp[j] %= mod;
}
}
printf("%lld", dp[s]);
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// __uint128_t
const static ll MOD = 998244353;
long long modpow(long long a, long long n, long long mod = MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
ll N, S;
cin >> N >> S;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<vector<ll>> DP(N + 1, vector<ll>(S + 1, 0));
DP[0][A[0]] = 1;
for (int i = 1; i < N; i++) {
ll a = A[i];
for (int j = 0; j <= S; j++) {
DP[i][j] += DP[i - 1][j] * 2;
DP[i][j] %= MOD;
if (j == a)
DP[i][j] += modpow(2, i);
DP[i][j] %= MOD;
if (j - a >= 0)
DP[i][j] += DP[i - 1][j - a];
DP[i][j] %= MOD;
}
}
cout << DP[N - 1][S] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// __uint128_t
const static ll MOD = 998244353;
long long modpow(long long a, long long n, long long mod = MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
ll N, S;
cin >> N >> S;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<vector<ll>> DP(N + 1, vector<ll>(5000 + 1, 0));
DP[0][A[0]] = 1;
for (int i = 1; i < N; i++) {
ll a = A[i];
for (int j = 0; j <= S; j++) {
DP[i][j] += DP[i - 1][j] * 2;
DP[i][j] %= MOD;
if (j == a)
DP[i][j] += modpow(2, i);
DP[i][j] %= MOD;
if (j - a >= 0)
DP[i][j] += DP[i - 1][j - a];
DP[i][j] %= MOD;
}
}
cout << DP[N - 1][S] << endl;
} | replace | 24 | 25 | 24 | 25 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int lli;
const lli mod = 998244353;
vector<lli> solve(int b, int e, lli s, vector<lli> &a) {
vector<lli> res(s + 1, 0);
if (e - b == 1) {
res[0] = 2;
if (a[b] <= s) {
res[a[b]] = 1;
}
return res;
}
int mid = (b + e) / 2;
auto ret1 = solve(b, mid, s, a);
auto ret2 = solve(mid, e, s, a);
for (int i = 0; i <= s; i++) {
for (int j = 0; j <= i; j++) {
res[i] += (ret1[j] * ret2[i - j]) % mod;
res[i] %= mod;
}
}
/*
cerr << b << "," << e << endl;
for(int i=0; i<=s; i++){
cerr << res[i] << " ";
}
cerr << endl;
*/
return res;
}
int main() {
lli n, s;
cin >> n >> s;
vector<lli> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto ret = solve(0, n, s, a);
cout << ret[s] << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int lli;
const lli mod = 998244353;
vector<lli> solve(int b, int e, lli s, vector<lli> &a) {
vector<lli> res(s + 1, 0);
if (e - b == 1) {
res[0] = 2;
if (a[b] <= s) {
res[a[b]] = 1;
}
return res;
}
int mid = (b + e) / 2;
auto ret1 = solve(b, mid, s, a);
auto ret2 = solve(mid, e, s, a);
for (int i = 0; i <= s; i++) {
for (int j = 0; j <= i; j++) {
res[i] += (ret1[j] * ret2[i - j]) % mod;
res[i] %= mod;
}
}
/*
cerr << b << "," << e << endl;
for(int i=0; i<=s; i++){
cerr << res[i] << " ";
}
cerr << endl;
*/
return res;
}
int main() {
lli n, s;
cin >> n >> s;
vector<lli> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<lli> dp(s + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
vector<lli> ndp(s + 1, 0);
for (int j = 0; j <= s; j++) {
ndp[j] += (2 * dp[j]) % mod;
ndp[j] %= mod;
}
for (int j = 0; j + a[i] <= s; j++) {
ndp[j + a[i]] += dp[j];
ndp[j + a[i]] %= mod;
}
swap(dp, ndp);
}
cout << dp[s] << endl;
return 0;
}
| replace | 44 | 46 | 44 | 59 | TLE | |
p02662 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
const ll mod = 998244353;
int main() {
int n, s;
cin >> n >> s;
vector<vector<ll>> dp(n, vector<ll>(s + 5));
vector<int> a(n);
rep(i, n) cin >> a[i];
dp[0][0] = 2;
dp[0][a[0]] = 1;
rep(i, n - 1) {
rep(j, s + 1) {
dp[i + 1][j] = dp[i][j] * 2 % mod;
if (j >= a[i + 1])
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j - a[i + 1]]) % mod;
}
}
ll ans = dp[n - 1][s];
cout << ans << endl;
return 0;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
const ll mod = 998244353;
int main() {
int n, s;
cin >> n >> s;
vector<vector<ll>> dp(n, vector<ll>(3005));
vector<int> a(n);
rep(i, n) cin >> a[i];
dp[0][0] = 2;
dp[0][a[0]] = 1;
rep(i, n - 1) {
rep(j, s + 1) {
dp[i + 1][j] = dp[i][j] * 2 % mod;
if (j >= a[i + 1])
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j - a[i + 1]]) % mod;
}
}
ll ans = dp[n - 1][s];
cout << ans << endl;
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define f first
#define s second
#define pb push_back
#define eb emplace_back
#define mk make_pair
#define mt make_tuple
#define MOD 998244353
#define fo(i, a, b) for (i = a; i < b; i++)
#define foe(i, a, b) for (i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define vi vector<int>
#define vl vector<long long int>
#define pii pair<int, int>
#define pll pair<long long int, long long int>
#define vpii vector<pair<int, int>>
#define vpll vector<pair<long long int, long long int>>
#define boost \
ios::sync_with_stdio(false); \
cin.tie(0)
using namespace std;
const int inf = 1e9 + 5;
const ll inf64 = 1e18 + 5;
ll add(ll x, ll y) {
ll res = x + y;
return (res >= MOD ? res - MOD : res);
}
ll mul(ll x, ll y) {
ll res = x * y;
return (res >= MOD ? res % MOD : res);
}
ll sub(ll x, ll y) {
ll res = x - y;
return (res < 0 ? res + MOD : res);
}
ll lcm(ll x, ll y) {
ll res = (x * y) / __gcd(x, y);
return res;
}
ll power(ll x, ll y) {
ll res = 1;
x %= MOD;
while (y) {
if (y & 1)
res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
const int MAX = 1e3 + 5;
ll dp[MAX][MAX];
int main() {
boost;
int n, s, i, j;
cin >> n >> s;
int arr[n];
fo(i, 0, n) cin >> arr[i];
ll inv = power(2, MOD - 2);
dp[0][0] = power(2, n);
fo(i, 0, n) {
foe(j, 0, s) {
if (arr[i] > j)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = add(dp[i][j], mul(dp[i][j - arr[i]], inv));
}
}
cout << dp[n][s];
}
| #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define f first
#define s second
#define pb push_back
#define eb emplace_back
#define mk make_pair
#define mt make_tuple
#define MOD 998244353
#define fo(i, a, b) for (i = a; i < b; i++)
#define foe(i, a, b) for (i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define vi vector<int>
#define vl vector<long long int>
#define pii pair<int, int>
#define pll pair<long long int, long long int>
#define vpii vector<pair<int, int>>
#define vpll vector<pair<long long int, long long int>>
#define boost \
ios::sync_with_stdio(false); \
cin.tie(0)
using namespace std;
const int inf = 1e9 + 5;
const ll inf64 = 1e18 + 5;
ll add(ll x, ll y) {
ll res = x + y;
return (res >= MOD ? res - MOD : res);
}
ll mul(ll x, ll y) {
ll res = x * y;
return (res >= MOD ? res % MOD : res);
}
ll sub(ll x, ll y) {
ll res = x - y;
return (res < 0 ? res + MOD : res);
}
ll lcm(ll x, ll y) {
ll res = (x * y) / __gcd(x, y);
return res;
}
ll power(ll x, ll y) {
ll res = 1;
x %= MOD;
while (y) {
if (y & 1)
res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
const int MAX = 3e3 + 5;
ll dp[MAX][MAX];
int main() {
boost;
int n, s, i, j;
cin >> n >> s;
int arr[n];
fo(i, 0, n) cin >> arr[i];
ll inv = power(2, MOD - 2);
dp[0][0] = power(2, n);
fo(i, 0, n) {
foe(j, 0, s) {
if (arr[i] > j)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = add(dp[i][j], mul(dp[i][j - arr[i]], inv));
}
}
cout << dp[n][s];
}
| replace | 54 | 55 | 54 | 55 | 0 | |
p02662 | C++ | Runtime Error | // Copyright © 2020 Diego Garcia Rodriguez del Campo. All rights reserved.
#include <bits/stdc++.h>
#define MAX 3005
#define optimiza_io \
cin.tie(0); \
ios_base::sync_with_stdio(0);
#define what_is(x) cerr << #x << " is " << x << endl;
#define pii pair<ll, ll>
#define fi first
#define se second
using namespace std;
typedef long long ll;
ll a[MAX], N, S, ans;
ll memo[MAX][MAX];
const ll MOD = 998244353;
ll dp(ll x, ll sm) {
if (x > N) {
if (sm != S)
return 0;
return 1;
}
if (memo[x][sm] != -1)
return memo[x][sm];
ll ans = 0;
ans += dp(x + 1, sm + a[x]);
ans += dp(x + 1, sm) * 2;
ans %= MOD;
return memo[x][sm] = ans;
}
int main() {
optimiza_io cin >> N >> S;
for (ll i = 1; i <= N; i++)
cin >> a[i];
memset(memo, -1, sizeof memo);
cout << dp(1, 0) << "\n";
return 0;
}
// CHECAR LIMITES | // Copyright © 2020 Diego Garcia Rodriguez del Campo. All rights reserved.
#include <bits/stdc++.h>
#define MAX 3005
#define optimiza_io \
cin.tie(0); \
ios_base::sync_with_stdio(0);
#define what_is(x) cerr << #x << " is " << x << endl;
#define pii pair<ll, ll>
#define fi first
#define se second
using namespace std;
typedef long long ll;
ll a[MAX], N, S, ans;
ll memo[MAX][MAX];
const ll MOD = 998244353;
ll dp(ll x, ll sm) {
if (x > N) {
if (sm != S)
return 0;
return 1;
}
if (sm > S)
return 0;
if (memo[x][sm] != -1)
return memo[x][sm];
ll ans = 0;
ans += dp(x + 1, sm + a[x]);
ans += dp(x + 1, sm) * 2;
ans %= MOD;
return memo[x][sm] = ans;
}
int main() {
optimiza_io cin >> N >> S;
for (ll i = 1; i <= N; i++)
cin >> a[i];
memset(memo, -1, sizeof memo);
cout << dp(1, 0) << "\n";
return 0;
}
// CHECAR LIMITES | insert | 23 | 23 | 23 | 25 | 0 | |
p02662 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (size_t i = 0; i < (n); i++)
#define nvec(T, v, n) \
vector<T> v(n); \
REP(i, n) { cin >> (v)[i]; }
#define npairs(T1, T2, v, n) \
vector<pair<T1, T2>> v(n); \
REP(i, n) { cin >> v[i].first >> v[i].second; }
#define ntuples(T1, T2, T3, v, n) \
vector<tuple<T1, T2, T3>> v(n); \
REP(i, n) { cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]); }
#define vec2d(T, v, m, n) vector<vector<T>>(v)(m, vector<T>(n))
#define nvec2d(T, v, m, n) \
vec2d(T, v, m, n); \
REP(j, m) { \
REP(i, n) { cin >> (v[j])[i]; } \
}
#define min_index(v) size_t(min_element(all(v)) - (v).begin())
#define max_index(v) size_t(max_element(all(v)) - (v).begin())
#define min_e(v) *min_element(ALL(v))
#define max_e(v) *max_element(ALL(v))
#define count_le(v, a) size_t(upper_bound(ALL(v), a) - (v).begin())
#define count_lt(v, a) size_t(lower_bound(ALL(v), a) - (v).begin())
#define count_ge(v, a) size_t((v).end() - lower_bound(ALL(v), a))
#define count_gt(v, a) size_t((v).end() - upper_bound(ALL(v), a))
#define order(neq_sl) [](const auto s, const auto l) { return neq_sl; }
#define make_lr(v, type, l, r) \
vector<type> l(n + 1), r(n + 1); \
FOR(i, n) { \
l[i + 1] = l[i] + v[i]; \
r[i + 1] = r[i] + v[n - 1 - i]; \
}
#define acm accumulate
#define SUM(v) accumulate(ALL(v), 0l)
#define SORT(v) sort(ALL(v))
#define GCD(v) gcd(ALL(v), 0l)
/*template <typename T>
T gcd(T a, T b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b%a, a);
}
template <typename InputItr, typename T>
T gcd(InputItr first, InputItr last, T init) {
for (; first != last; ++first) init = gcd(init, *first);
return init;
}*/
template <typename T> using vec = vector<T>;
template <typename T> using vvec = vector<vector<T>>;
int main() {
int n, s;
cin >> n >> s;
nvec(long, a, n);
SORT(a);
vvec<long> v(n, vec<long>(s + 1, 0));
v[0][a[0]] = 1;
v[0][0] = 2;
for (int i = 1; i < n; i++) {
for (int l = 0; l <= s; l++) {
v[i][l] += 2 * v[i - 1][l];
if (l - a[i] >= 0) {
v[i][l] += v[i - 1][l - a[i]];
}
v[i][l] %= 998244353;
}
}
cout << v[n - 1][s];
}
/* きょむ〜 */
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (size_t i = 0; i < (n); i++)
#define nvec(T, v, n) \
vector<T> v(n); \
REP(i, n) { cin >> (v)[i]; }
#define npairs(T1, T2, v, n) \
vector<pair<T1, T2>> v(n); \
REP(i, n) { cin >> v[i].first >> v[i].second; }
#define ntuples(T1, T2, T3, v, n) \
vector<tuple<T1, T2, T3>> v(n); \
REP(i, n) { cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]); }
#define vec2d(T, v, m, n) vector<vector<T>>(v)(m, vector<T>(n))
#define nvec2d(T, v, m, n) \
vec2d(T, v, m, n); \
REP(j, m) { \
REP(i, n) { cin >> (v[j])[i]; } \
}
#define min_index(v) size_t(min_element(all(v)) - (v).begin())
#define max_index(v) size_t(max_element(all(v)) - (v).begin())
#define min_e(v) *min_element(ALL(v))
#define max_e(v) *max_element(ALL(v))
#define count_le(v, a) size_t(upper_bound(ALL(v), a) - (v).begin())
#define count_lt(v, a) size_t(lower_bound(ALL(v), a) - (v).begin())
#define count_ge(v, a) size_t((v).end() - lower_bound(ALL(v), a))
#define count_gt(v, a) size_t((v).end() - upper_bound(ALL(v), a))
#define order(neq_sl) [](const auto s, const auto l) { return neq_sl; }
#define make_lr(v, type, l, r) \
vector<type> l(n + 1), r(n + 1); \
FOR(i, n) { \
l[i + 1] = l[i] + v[i]; \
r[i + 1] = r[i] + v[n - 1 - i]; \
}
#define acm accumulate
#define SUM(v) accumulate(ALL(v), 0l)
#define SORT(v) sort(ALL(v))
#define GCD(v) gcd(ALL(v), 0l)
/*template <typename T>
T gcd(T a, T b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b%a, a);
}
template <typename InputItr, typename T>
T gcd(InputItr first, InputItr last, T init) {
for (; first != last; ++first) init = gcd(init, *first);
return init;
}*/
template <typename T> using vec = vector<T>;
template <typename T> using vvec = vector<vector<T>>;
int main() {
int n, s;
cin >> n >> s;
nvec(long, a, n);
SORT(a);
vvec<long> v(n, vec<long>(s + 1, 0));
if (a[0] > s) {
cout << 0;
return 0;
}
v[0][a[0]] = 1;
v[0][0] = 2;
for (int i = 1; i < n; i++) {
for (int l = 0; l <= s; l++) {
v[i][l] += 2 * v[i - 1][l];
if (l - a[i] >= 0) {
v[i][l] += v[i - 1][l - a[i]];
}
v[i][l] %= 998244353;
}
}
cout << v[n - 1][s];
}
/* きょむ〜 */ | insert | 76 | 76 | 76 | 80 | 0 | |
p02662 | C++ | Runtime Error |
#include <algorithm>
#include <chrono>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define forr(i, start, count) for (int i = (start); i < (start) + (count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) \
int i; \
cin >> i
#define readll(i) \
ll i; \
cin >> i
#define readdouble(i) \
double i; \
cin >> i
#define readstring(s) \
string s; \
cin >> s
typedef long long ll;
using namespace std;
ll modd = 998244353;
template <class T> T fastpower(T a, long long n) { // n must be >= 1
if (n % 2 == 0) {
T halfpower = fastpower<T>(a, n / 2);
return (halfpower * halfpower % modd);
} else {
if (n == 1) {
return a;
} else {
T halfpower = fastpower<T>(a, n / 2);
return ((halfpower * halfpower % modd) * a) % modd;
}
}
};
int main() {
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(
0, modd); // rand_gen(rng) gets the rand no
ll infinit = 10000000000000000;
// readint(test_cases);
int test_cases = 1;
forr(t, 1, test_cases) {
readint(n);
readint(s);
vector<ll> d;
forr(i, 0, n) {
readint(kk);
d.push_back(kk);
}
vector<pair<ll, ll>> poss(s + 1, make_pair(0, 0));
poss[0] = make_pair(1, 0);
forr(i, 0, n) {
for (int j = poss.size() - d[i] - 1; j >= 0; --j) {
auto temp1 = poss[j + d[i]];
auto temp2 = poss[j];
temp2.second++;
int new_d = max(temp1.second, temp2.second);
if (temp1.second < new_d) {
temp1.first *= fastpower<ll>(2, new_d - temp1.second);
temp1.first = temp1.first % modd;
temp1.second = new_d;
}
if (temp2.second < new_d) {
temp2.first *= fastpower<ll>(2, new_d - temp2.second);
temp2.first = temp2.first % modd;
temp2.second = new_d;
}
poss[j + d[i]] =
make_pair((temp1.first + temp2.first) % modd, temp1.second);
}
}
ll ret = (fastpower<ll>(2, n - poss[s].second) * poss[s].first) % modd;
cout << ret << endl;
}
return 0;
}
|
#include <algorithm>
#include <chrono>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define forr(i, start, count) for (int i = (start); i < (start) + (count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) \
int i; \
cin >> i
#define readll(i) \
ll i; \
cin >> i
#define readdouble(i) \
double i; \
cin >> i
#define readstring(s) \
string s; \
cin >> s
typedef long long ll;
using namespace std;
ll modd = 998244353;
template <class T> T fastpower(T a, long long n) { // n must be >= 1
if (n % 2 == 0) {
T halfpower = fastpower<T>(a, n / 2);
return (halfpower * halfpower % modd);
} else {
if (n == 1) {
return a;
} else {
T halfpower = fastpower<T>(a, n / 2);
return ((halfpower * halfpower % modd) * a) % modd;
}
}
};
int main() {
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(
0, modd); // rand_gen(rng) gets the rand no
ll infinit = 10000000000000000;
// readint(test_cases);
int test_cases = 1;
forr(t, 1, test_cases) {
readint(n);
readint(s);
vector<ll> d;
forr(i, 0, n) {
readint(kk);
d.push_back(kk);
}
vector<pair<ll, ll>> poss(s + 1, make_pair(0, 0));
poss[0] = make_pair(1, 0);
forr(i, 0, n) {
for (int j = poss.size() - d[i] - 1; j >= 0; --j) {
auto temp1 = poss[j + d[i]];
auto temp2 = poss[j];
temp2.second++;
int new_d = max(temp1.second, temp2.second);
if (temp1.second < new_d) {
temp1.first *= fastpower<ll>(2, new_d - temp1.second);
temp1.first = temp1.first % modd;
temp1.second = new_d;
}
if (temp2.second < new_d) {
temp2.first *= fastpower<ll>(2, new_d - temp2.second);
temp2.first = temp2.first % modd;
temp2.second = new_d;
}
poss[j + d[i]] =
make_pair((temp1.first + temp2.first) % modd, temp1.second);
}
}
if (n > poss[s].second) {
ll ret = (fastpower<ll>(2, n - poss[s].second) * poss[s].first) % modd;
cout << ret << endl;
} else {
cout << poss[s].first << endl;
}
}
return 0;
}
| replace | 97 | 100 | 97 | 103 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
// #define i_7 (long long)(1e9+7)
#define i_7 998'244'353
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
long long po(long a, long b) {
if (b == 0) {
return 1;
}
long long z = po(a, b / 2);
z = mod(z * z);
if (b % 2 != 0) {
z = mod(a * z);
}
return z;
}
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= std::sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
std::swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
// using namespace std;
// using namespace boost::multiprecision;
// using namespace __gnu_pbds;
int main() {
using namespace std;
long long n, s;
cin >> n >> s;
long long a[n];
REP(i, n) cin >> a[i];
vector<vector<long long>> dp(n, vector<long long>(s + 1, 0));
REP(i, n) {
if (i == 0) {
dp[i][0] = 2;
dp[i][a[i]] = 1;
continue;
}
REP(d, s + 1) {
dp[i][d] = mod(dp[i - 1][d] * 2);
if (d - a[i] >= 0) {
dp[i][d] += dp[i - 1][d - a[i]];
dp[i][d] = mod(dp[i][d]);
}
}
}
long long ans = dp[n - 1][s];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
// #define i_7 (long long)(1e9+7)
#define i_7 998'244'353
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
long long po(long a, long b) {
if (b == 0) {
return 1;
}
long long z = po(a, b / 2);
z = mod(z * z);
if (b % 2 != 0) {
z = mod(a * z);
}
return z;
}
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= std::sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
std::swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
// using namespace std;
// using namespace boost::multiprecision;
// using namespace __gnu_pbds;
int main() {
using namespace std;
long long n, s;
cin >> n >> s;
long long a[n];
REP(i, n) cin >> a[i];
vector<vector<long long>> dp(n, vector<long long>(s + 1, 0));
REP(i, n) {
if (i == 0) {
dp[i][0] = 2;
if (a[i] <= s)
dp[i][a[i]] = 1;
continue;
}
REP(d, s + 1) {
dp[i][d] = mod(dp[i - 1][d] * 2);
if (d - a[i] >= 0) {
dp[i][d] += dp[i - 1][d - a[i]];
dp[i][d] = mod(dp[i][d]);
}
}
}
long long ans = dp[n - 1][s];
cout << ans << endl;
return 0;
} | replace | 77 | 78 | 77 | 79 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using llong = long long;
using ldbl = long double;
using lpair = pair<llong, llong>;
#define ALL(x) x.begin(), x.end()
template <typename T>
constexpr T inf =
static_cast<T>(pow(10, static_cast<int>(log10(numeric_limits<T>::max())))) +
7;
constexpr llong mod = 998244353;
llong pow_mod(llong n, llong m) {
if (m == 0)
return 1;
if (m == 1)
return n;
llong ret = pow_mod(n, m / 2);
ret = ret * ret % mod;
if (m & 1) {
ret = ret * n % mod;
}
return ret;
}
int main() {
llong N, S;
vector<llong> A;
cin >> N >> S;
A.resize(N);
for (auto &in : A) {
cin >> in;
}
vector<llong> dp(S + 1);
for (int i = 0; i < N; ++i) {
vector<llong> now(S + 1);
for (int j = S; j >= 0; --j) {
now[j] = dp[j] * 2;
if (j >= A[i]) {
now[j] += dp[j - A[i]];
}
now[j] %= mod;
}
now[A[i]] += pow_mod(2, i);
swap(dp, now);
}
cout << dp[S] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using llong = long long;
using ldbl = long double;
using lpair = pair<llong, llong>;
#define ALL(x) x.begin(), x.end()
template <typename T>
constexpr T inf =
static_cast<T>(pow(10, static_cast<int>(log10(numeric_limits<T>::max())))) +
7;
constexpr llong mod = 998244353;
llong pow_mod(llong n, llong m) {
if (m == 0)
return 1;
if (m == 1)
return n;
llong ret = pow_mod(n, m / 2);
ret = ret * ret % mod;
if (m & 1) {
ret = ret * n % mod;
}
return ret;
}
int main() {
llong N, S;
vector<llong> A;
cin >> N >> S;
A.resize(N);
for (auto &in : A) {
cin >> in;
}
vector<llong> dp(S + 1);
for (int i = 0; i < N; ++i) {
vector<llong> now(S + 1);
for (int j = S; j >= 0; --j) {
now[j] = dp[j] * 2;
if (j >= A[i]) {
now[j] += dp[j - A[i]];
}
now[j] %= mod;
}
if (A[i] <= S) {
now[A[i]] += pow_mod(2, i);
}
swap(dp, now);
}
cout << dp[S] << endl;
return 0;
}
| replace | 49 | 50 | 49 | 52 | 0 | |
p02662 | C++ | Time Limit Exceeded | /*input
3 4
2 2 4
*/
/*
______________
| )
| ) /
|______/
| | \
| | ) \
|_____|_______)
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef long double ld;
#define pb push_back
#define all(c) c.begin(), c.end()
#define allr(c) c.rbegin(), c.rend()
int mod = 1000000007;
const int inf = 1034567891;
const ll LL_INF = 1234567890123456789ll;
#define PI 3.14159265
#define endl '\n'
#define F first
#define S second
#define debug(x) cout << #x << " = " << x << endl;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define out(container) \
for (auto it : container) \
cout << it << " "; \
cout << endl;
template <typename T> T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T> string toString(T a) { return to_string(a); }
template <typename T> void toInt(string s, T &x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod)
x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0)
x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, ll b) {
int x = 1 % mod;
while (b) {
if (b & 1)
x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
const int N = 3005;
int n, s;
vector<int> vec;
int dp[N][N];
int last;
int temp = 0;
int fun(int ind, int cur) {
if (ind == last || cur == s) {
return (cur == s);
}
if (~dp[ind][cur])
return dp[ind][cur];
int ans = 0;
if (cur + vec[ind] <= s) {
ans = add(ans, mul(inv(2), fun(ind + 1, cur + vec[ind])));
}
ans = add(ans, fun(ind + 1, cur));
return dp[ind][cur] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
mod = 998244353;
cin >> n >> s;
int v;
for (int i = 0; i < n; i++) {
cin >> v;
vec.pb(v);
}
last = n;
memset(dp, -1, sizeof(dp));
int ans = fun(0, 0);
ans = mul(ans, powr(2, n));
cout << ans << endl;
return 0;
} | /*input
3 4
2 2 4
*/
/*
______________
| )
| ) /
|______/
| | \
| | ) \
|_____|_______)
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef long double ld;
#define pb push_back
#define all(c) c.begin(), c.end()
#define allr(c) c.rbegin(), c.rend()
int mod = 1000000007;
const int inf = 1034567891;
const ll LL_INF = 1234567890123456789ll;
#define PI 3.14159265
#define endl '\n'
#define F first
#define S second
#define debug(x) cout << #x << " = " << x << endl;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define out(container) \
for (auto it : container) \
cout << it << " "; \
cout << endl;
template <typename T> T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T> string toString(T a) { return to_string(a); }
template <typename T> void toInt(string s, T &x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod)
x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0)
x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, ll b) {
int x = 1 % mod;
while (b) {
if (b & 1)
x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
const int N = 3005;
int n, s;
vector<int> vec;
int dp[N][N];
int last;
int temp = 0;
int fun(int ind, int cur) {
if (ind == last || cur == s) {
return (cur == s);
}
if (~dp[ind][cur])
return dp[ind][cur];
int ans = 0;
if (cur + vec[ind] <= s) {
ans = add(ans, mul(499122177, fun(ind + 1, cur + vec[ind])));
}
ans = add(ans, fun(ind + 1, cur));
return dp[ind][cur] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
mod = 998244353;
cin >> n >> s;
int v;
for (int i = 0; i < n; i++) {
cin >> v;
vec.pb(v);
}
last = n;
memset(dp, -1, sizeof(dp));
int ans = fun(0, 0);
ans = mul(ans, powr(2, n));
cout << ans << endl;
return 0;
} | replace | 134 | 135 | 134 | 135 | TLE | |
p02662 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<vvvl> vvvvl;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vvb> vvvb;
typedef vector<vvvb> vvvvb;
typedef vector<string> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<vvd> vvvd;
typedef vector<long double> vld;
typedef vector<vld> vvld;
typedef unordered_map<ll, ll> uii;
typedef unordered_map<ll, ll> uuii;
typedef unordered_map<ll, ll> uuuii;
typedef pair<ll, ll> PL;
typedef vector<PL> vpl;
typedef vector<vector<PL>> vvpl;
typedef vector<vvpl> vvvpl;
typedef pair<ll, PL> TL;
typedef vector<TL> vtl;
typedef vector<vtl> vvtl;
typedef bitset<64> bs;
const ll LINF = 1e18;
const long double pi = 3.1415926535897932;
const string endstr = "\n";
#define FOR(i, a, b) for (ll i = (a); i < b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FORMAP(it, m) for (auto it = m.begin(); it != m.end(); it++)
#define ff first
#define ss second
#define pb push_back
#define ALL(X) (X).begin(), (X).end()
template <typename T> T gcd(T a, T b) { return (a == 0) ? b : gcd(b % a, a); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
bool p_comp_fs(const PL p1, const PL p2) { return p1.first < p2.first; };
bool p_comp_fg(const PL p1, const PL p2) { return p1.first > p2.first; };
bool p_comp_ss(const PL p1, const PL p2) { return p1.second < p2.second; };
bool p_comp_sg(const PL p1, const PL p2) { return p1.second > p2.second; };
template <typename T> vector<T> uniquen(vector<T> vec /* copy */) {
sort(ALL(vec));
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
inline ll popcnt(ll x) { return __builtin_popcountll((unsigned long long)x); };
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// friend bool operator<(const tpl& lhs, const tpl& rhs){
// return std::tie(lhs.l, lhs.r) < std::tie(rhs.l, rhs.r);
// }
bool bit(ll st, ll b) { return ((st >> b) & 1) == 1; }
const ll mod = 998244353;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t 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 ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inv();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
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(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using mint = ModInt<mod>;
typedef vector<mint> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;
typedef unordered_map<ll, mint> uim;
typedef unordered_map<ll, uim> uuim;
typedef unordered_map<ll, uuim> uuuim;
int main() {
#ifdef __DEBUG_LOCAL__
ifstream file("../../../../../in.txt");
if (file.is_open())
cin.rdbuf(file.rdbuf());
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll N, S;
cin >> N >> S;
vl A(N);
rep(i, N) cin >> A[i];
vvm dp(N + 1, vm(S + 10, 0));
rep(i, N) {
rep(k, S + 1) {
if (k == 0) {
dp[i + 1][k + A[i]] += mint(2).pow(i);
} else if (k + A[i] < S + 1) {
dp[i + 1][k + A[i]] += dp[i][k];
}
dp[i + 1][k] += mint(2) * dp[i][k];
}
}
cout << dp[N][S] << endstr;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <unistd.h>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<vvvl> vvvvl;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vvb> vvvb;
typedef vector<vvvb> vvvvb;
typedef vector<string> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<vvd> vvvd;
typedef vector<long double> vld;
typedef vector<vld> vvld;
typedef unordered_map<ll, ll> uii;
typedef unordered_map<ll, ll> uuii;
typedef unordered_map<ll, ll> uuuii;
typedef pair<ll, ll> PL;
typedef vector<PL> vpl;
typedef vector<vector<PL>> vvpl;
typedef vector<vvpl> vvvpl;
typedef pair<ll, PL> TL;
typedef vector<TL> vtl;
typedef vector<vtl> vvtl;
typedef bitset<64> bs;
const ll LINF = 1e18;
const long double pi = 3.1415926535897932;
const string endstr = "\n";
#define FOR(i, a, b) for (ll i = (a); i < b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FORMAP(it, m) for (auto it = m.begin(); it != m.end(); it++)
#define ff first
#define ss second
#define pb push_back
#define ALL(X) (X).begin(), (X).end()
template <typename T> T gcd(T a, T b) { return (a == 0) ? b : gcd(b % a, a); }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
bool p_comp_fs(const PL p1, const PL p2) { return p1.first < p2.first; };
bool p_comp_fg(const PL p1, const PL p2) { return p1.first > p2.first; };
bool p_comp_ss(const PL p1, const PL p2) { return p1.second < p2.second; };
bool p_comp_sg(const PL p1, const PL p2) { return p1.second > p2.second; };
template <typename T> vector<T> uniquen(vector<T> vec /* copy */) {
sort(ALL(vec));
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
inline ll popcnt(ll x) { return __builtin_popcountll((unsigned long long)x); };
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// friend bool operator<(const tpl& lhs, const tpl& rhs){
// return std::tie(lhs.l, lhs.r) < std::tie(rhs.l, rhs.r);
// }
bool bit(ll st, ll b) { return ((st >> b) & 1) == 1; }
const ll mod = 998244353;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t 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 ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inv();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
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(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using mint = ModInt<mod>;
typedef vector<mint> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;
typedef unordered_map<ll, mint> uim;
typedef unordered_map<ll, uim> uuim;
typedef unordered_map<ll, uuim> uuuim;
int main() {
#ifdef __DEBUG_LOCAL__
ifstream file("../../../../../in.txt");
if (file.is_open())
cin.rdbuf(file.rdbuf());
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll N, S;
cin >> N >> S;
vl A(N);
rep(i, N) cin >> A[i];
vvm dp(N + 1, vm(3000 + 10, 0));
rep(i, N) {
rep(k, S + 1) {
if (k == 0) {
dp[i + 1][k + A[i]] += mint(2).pow(i);
} else if (k + A[i] < S + 1) {
dp[i + 1][k + A[i]] += dp[i][k];
}
dp[i + 1][k] += mint(2) * dp[i][k];
}
}
cout << dp[N][S] << endstr;
return 0;
}
| replace | 188 | 189 | 188 | 189 | 0 | |
p02662 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int mod = 998244353;
const int IMAX = 100000;
constexpr ll modpow(ll A, ll B) {
ll kotae = 1;
while (B > 0) {
if (B & 1)
kotae = kotae * A % mod;
A = A * A % mod;
B >>= 1;
}
return kotae;
}
ll dp[3001];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, S;
cin >> N >> S;
int A[3000];
rep(i, N) cin >> A[i];
sort(A, A + N);
ll k2 = modpow(2, mod - 2);
dp[0] = modpow(2, N);
int s = 0;
rep(i, N) {
s += min(S, s + A[i]);
for (int j = s; j >= A[i]; j--) {
dp[j] = (dp[j] + dp[j - A[i]] * k2) % mod;
}
}
co(dp[S] % mod);
Would you please return 0;
} | #pragma GCC optimize("O3")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int mod = 998244353;
const int IMAX = 100000;
constexpr ll modpow(ll A, ll B) {
ll kotae = 1;
while (B > 0) {
if (B & 1)
kotae = kotae * A % mod;
A = A * A % mod;
B >>= 1;
}
return kotae;
}
ll dp[3001];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, S;
cin >> N >> S;
int A[3000];
rep(i, N) cin >> A[i];
sort(A, A + N);
ll k2 = modpow(2, mod - 2);
dp[0] = modpow(2, N);
int s = 0;
rep(i, N) {
s = min(S, s + A[i]);
for (int j = s; j >= A[i]; j--) {
dp[j] = (dp[j] + dp[j - A[i]] * k2) % mod;
}
}
co(dp[S] % mod);
Would you please return 0;
} | replace | 48 | 49 | 48 | 49 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define fr(i, n) for (int i = 0; i < n; i++)
#define sz(v) (v).begin(), (v).end()
#define prin(a) cout << #a << " = " << a << endl
#define all(v) (v).begin(), (v).end()
typedef long long ll;
const int N = 2e3 + 10;
ll dp[2][N], v[N];
#define cur_dp dp[(i + 1) & 1]
#define ant_dp dp[i & 1]
const ll MOD = 998244353;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, s;
cin >> n >> s;
fr(i, n) cin >> v[i];
dp[0][0] = 1;
fr(i, n) {
for (int j = 0; j <= s; j++) {
cur_dp[j] = 2 * ant_dp[j] % MOD;
if (v[i] <= j)
cur_dp[j] = (ant_dp[j - v[i]] + cur_dp[j]) % MOD;
}
}
cout << dp[n & 1][s] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define fr(i, n) for (int i = 0; i < n; i++)
#define sz(v) (v).begin(), (v).end()
#define prin(a) cout << #a << " = " << a << endl
#define all(v) (v).begin(), (v).end()
typedef long long ll;
const int N = 3e3 + 10;
ll dp[2][N], v[N];
#define cur_dp dp[(i + 1) & 1]
#define ant_dp dp[i & 1]
const ll MOD = 998244353;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, s;
cin >> n >> s;
fr(i, n) cin >> v[i];
dp[0][0] = 1;
fr(i, n) {
for (int j = 0; j <= s; j++) {
cur_dp[j] = 2 * ant_dp[j] % MOD;
if (v[i] <= j)
cur_dp[j] = (ant_dp[j - v[i]] + cur_dp[j]) % MOD;
}
}
cout << dp[n & 1][s] << endl;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long pow(long long x, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n % 2)
ans *= x;
x *= x;
x %= mod;
ans %= mod;
n >>= 1;
}
return ans;
}
long long inv = pow(2, MOD - 2, MOD);
long long dp[3010][3010];
void solve(long long N, long long S, std::vector<long long> A) {
dp[0][0] = pow(2, N, MOD);
if (A[0] <= S) {
dp[0][A[0]] = pow(2, N - 1, MOD);
}
for (int i = 1; i < N; i++) {
for (size_t j = 0; j <= S; j++) {
dp[i][j] += dp[i - 1][j];
if (j - A[i] >= 0) {
dp[i][j] += dp[i - 1][j - A[i]] * inv;
}
dp[i][j] %= MOD;
}
}
cout << dp[N - 1][S] << endl;
}
// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
long long N;
scanf("%lld", &N);
long long S;
scanf("%lld", &S);
std::vector<long long> A(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
solve(N, S, std::move(A));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long pow(long long x, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n % 2)
ans *= x;
x *= x;
x %= mod;
ans %= mod;
n >>= 1;
}
return ans;
}
long long inv = pow(2, MOD - 2, MOD);
long long dp[3010][3010];
void solve(long long N, long long S, std::vector<long long> A) {
dp[0][0] = pow(2, N, MOD);
if (A[0] <= S) {
dp[0][A[0]] = pow(2, N - 1, MOD);
}
for (int i = 1; i < N; i++) {
for (int j = 0; j <= S; j++) {
dp[i][j] += dp[i - 1][j];
if (j - A[i] >= 0) {
dp[i][j] += dp[i - 1][j - A[i]] * inv;
}
dp[i][j] %= MOD;
}
}
cout << dp[N - 1][S] << endl;
}
// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
long long N;
scanf("%lld", &N);
long long S;
scanf("%lld", &S);
std::vector<long long> A(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
solve(N, S, std::move(A));
return 0;
}
| replace | 29 | 30 | 29 | 30 | 0 | |
p02662 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (b); i >= (a); --i)
#define REPP(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (b); i > (a); --i)
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define pf push_front
#define cmin(a, b) \
if ((a) > (b)) \
(a) = (b)
#define cmax(a, b) \
if ((a) < (b)) \
(a) = (b)
#define BIT(x, i) (((x) >> (i)) & 1)
#define MASK(i) (1LL << (i))
#define debug(x) cout << (x) << "\n"
#define endl "\n"
#define ii pair<int, int>
#define ll long long
#define reset(x) memset(x, 0, sizeof(x))
#define mem(a, x) memset(x, (a), sizeof(x))
#define task ""
#define IO freopen(task ".inp", "r", stdin), freopen(task ".out", "w", stdout);
using namespace std;
const int mod = 1007050321;
const int base = 521;
const int MOD = 998244353;
const int inf = 2e9;
const int N = 2e5 + 5;
int n, s;
vector<vector<int>> dp;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> s;
dp.resize(n + 1, vector<int>(n + 1));
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= s; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
for (int j = 0; j <= s; ++j) {
dp[i][j] += 1LL * 2 * dp[i - 1][j] % MOD;
if (j >= x)
dp[i][j] += dp[i - 1][j - x];
dp[i][j] %= MOD;
}
}
cout << dp[n][s];
return 0;
}
| #include <bits/stdc++.h>
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (b); i >= (a); --i)
#define REPP(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (b); i > (a); --i)
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define pf push_front
#define cmin(a, b) \
if ((a) > (b)) \
(a) = (b)
#define cmax(a, b) \
if ((a) < (b)) \
(a) = (b)
#define BIT(x, i) (((x) >> (i)) & 1)
#define MASK(i) (1LL << (i))
#define debug(x) cout << (x) << "\n"
#define endl "\n"
#define ii pair<int, int>
#define ll long long
#define reset(x) memset(x, 0, sizeof(x))
#define mem(a, x) memset(x, (a), sizeof(x))
#define task ""
#define IO freopen(task ".inp", "r", stdin), freopen(task ".out", "w", stdout);
using namespace std;
const int mod = 1007050321;
const int base = 521;
const int MOD = 998244353;
const int inf = 2e9;
const int N = 2e5 + 5;
int n, s;
vector<vector<int>> dp;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> s;
dp.resize(n + 1, vector<int>(s + 1));
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= s; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
for (int j = 0; j <= s; ++j) {
dp[i][j] += 1LL * 2 * dp[i - 1][j] % MOD;
if (j >= x)
dp[i][j] += dp[i - 1][j - x];
dp[i][j] %= MOD;
}
}
cout << dp[n][s];
return 0;
}
| replace | 42 | 43 | 42 | 43 | 0 | |
p02662 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int A[3005];
long long memo[3005][3005];
const long long modConst = 998244353;
long long DP(int N, int S) {
if (S < 0)
return 0;
if (N == 0 && S == 0)
return 1;
if (N == 0)
return 0;
if (memo[N][S] != -1)
return memo[N][S];
long long putToBoth = DP(N - 1, S - A[N]);
long long putToTOnly = DP(N - 1, S);
long long putToNone = DP(N - 1, S);
return (putToBoth + putToTOnly + putToNone) % modConst;
}
int main() {
int N, S;
scanf("%d%d", &N, &S);
for (int i = 1; i <= N; i++)
scanf("%d", &A[i]);
for (int i = 0; i < 3005; i++) {
for (int j = 0; j < 3005; j++)
memo[i][j] = -1;
}
long long ans = DP(N, S);
printf("%lld", ans);
}
| #include <bits/stdc++.h>
using namespace std;
int A[3005];
long long memo[3005][3005];
const long long modConst = 998244353;
long long DP(int N, int S) {
if (S < 0)
return 0;
if (N == 0 && S == 0)
return 1;
if (N == 0)
return 0;
if (memo[N][S] != -1)
return memo[N][S];
long long putToBoth = DP(N - 1, S - A[N]);
long long putToTOnly = DP(N - 1, S);
long long putToNone = DP(N - 1, S);
memo[N][S] = (putToBoth + putToTOnly + putToNone) % modConst;
return memo[N][S];
}
int main() {
int N, S;
scanf("%d%d", &N, &S);
for (int i = 1; i <= N; i++)
scanf("%d", &A[i]);
for (int i = 0; i < 3005; i++) {
for (int j = 0; j < 3005; j++)
memo[i][j] = -1;
}
long long ans = DP(N, S);
printf("%lld", ans);
}
| replace | 25 | 26 | 25 | 27 | TLE | |
p02663 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int H[2], M[2], K;
cin >> H[1] >> M[1] >> H[2] >> M[2] >> K;
cout << 60 * (H[2] - H[1]) + M[2] - M[1] - K << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int H, M, A, B, K;
cin >> H >> M >> A >> B >> K;
cout << 60 * (A - H) + B - M - K << endl;
}
| replace | 4 | 7 | 4 | 7 | -6 | *** stack smashing detected ***: terminated
|
p02663 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int diff = (h2 * 60 + m2) - (h1 * 60 + m1);
// cout<<diff;
if ((diff - k) > 0)
cout << diff - k;
else
cout << 0;
return 1;
} | #include <iostream>
using namespace std;
int main() {
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int diff = (h2 * 60 + m2) - (h1 * 60 + m1);
// cout<<diff;
if ((diff - k) > 0)
cout << diff - k;
else
cout << 0;
return 0;
} | replace | 11 | 12 | 11 | 12 | 1 | |
p02663 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pqgreater(x) x, vector<x>, greater<x>
#define decimal(x) cout << fixed << setprecision(x)
#define dbg(x) cerr << #x << ": " << x << endl;
#define gc getchar //_unlocked
#define pc putchar //_unlocked
const int mod = 998244353; // 1e9+7 or 998244353, remove const if changing mods
const ld eps = 1e-6;
ld sign(ld x) { return (x > 0) - (x < 0); }
ll sign(ll x) { return (x > 0) - (x < 0); }
int sign(int x) { return (x > 0) - (x < 0); }
struct pt {
ld x, y;
pt() {}
pt(ld _x, ld _y) : x(_x), y(_y) {}
bool operator<(pt p) { return tie(x, y) < tie(p.x, p.y); }
bool operator==(pt p) { return tie(x, y) == tie(p.x, p.y); }
pt operator+(pt p) { return {x + p.x, y + p.y}; }
pt operator-(pt p) { return {x - p.x, y - p.y}; }
pt operator*(ld d) { return {x * d, y * d}; }
pt operator/(ld d) { return {x / d, y / d}; }
ld dot(pt p) { return x * p.x + y * p.y; }
ld det(pt p) { return x * p.y - y * p.x; }
ld cross(pt p, pt q) { return (p - *this).det(q - *this); }
ld dist() { return sqrtl(x * x + y * y); }
pt rot90() { return pt(-y, x); }
pt unit() { return *this / dist(); }
ld angle() { return atan2(y, x); }
pt rot(ld an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
void read() { cin >> x >> y; }
void write() { cout << "(" << x << "," << y << ")" << endl; }
};
struct seg {
pt fi, sc;
seg() {}
seg(pt _fi, pt _sc) : fi(_fi), sc(_sc) {}
ld dist(pt C) {
if (fi == sc)
return (C - fi).dist();
ld d = pow((sc - fi).dist(), 2);
ld t = min(d, max((ld)0.0, (C - fi).dot(sc - fi)));
return ((C - fi) * d - (sc - fi) * t).dist() / d;
}
ld len() { return (fi - sc).dist(); }
bool on_seg(pt C) {
return abs(C.cross(fi, sc)) < eps && (fi - C).dot(sc - C) <= eps;
}
vector<pt> intersect(seg rhs) {
ld oa = rhs.fi.cross(rhs.sc, fi);
ld ob = rhs.fi.cross(rhs.sc, sc);
ld oc = fi.cross(sc, rhs.fi);
ld od = fi.cross(sc, rhs.sc);
if (sign(oa) * sign(ob) < 0 && sign(oc) * sign(od) < 0)
return {(fi * ob - sc * oa) / (ob - oa)};
vector<pt> ans;
if (rhs.on_seg(fi))
ans.push_back(fi);
if (rhs.on_seg(sc))
ans.push_back(sc);
if (on_seg(rhs.fi))
ans.push_back(rhs.fi);
if (on_seg(rhs.sc))
ans.push_back(rhs.sc);
return ans;
}
};
struct line {
ld a, b, c; // line a*x+b*y=c
line(pt p1, pt p2) {
assert(!(p1 == p2));
a = p2.y - p1.y;
b = p1.x - p2.x;
c = a * p1.x + b * p1.y;
}
line() {}
line(ld _a, ld _b, ld _c) : a(_a), b(_b), c(_c) {}
ld dist(pt p) { return fabs(a * p.x + b * p.y - c) / sqrtl(a * a + b * b); }
pair<int, pt> intersect(line rhs) {
ld dett = a * rhs.b - b * rhs.a;
if (fabs(dett) <= eps) {
ld det2 = c * rhs.a - a * rhs.c;
if (fabs(det2) <= eps)
return {-1, pt()}; // infinte
return {0, pt()}; // no sol
}
return {1,
pt((c * rhs.b - rhs.c * b) / dett, (a * rhs.c - c * rhs.a) / dett)};
}
};
pt reflect(pt A, line L) {
line perpendicular(-L.b, L.a, -L.b * A.x + L.a * A.y);
pt insect = perpendicular.intersect(L).second;
return insect * (ld)2.0 - A;
}
struct mint {
int val;
mint() { val = 0; }
mint(const ll &v) {
val = (-mod <= v && v < mod) ? v : v % mod;
if (val < 0)
val += mod;
}
friend ostream &operator<<(ostream &os, const mint &a) { return os << a.val; }
friend bool operator==(const mint &a, const mint &b) {
return a.val == b.val;
}
friend bool operator!=(const mint &a, const mint &b) {
return a.val != b.val;
}
friend bool operator<(const mint &a, const mint &b) { return a.val < b.val; }
friend bool operator>(const mint &a, const mint &b) { return a.val > b.val; }
friend bool operator<=(const mint &a, const mint &b) {
return a.val <= b.val;
}
friend bool operator>=(const mint &a, const mint &b) {
return a.val >= b.val;
}
mint operator-() { return mint(-val); }
mint &operator+=(const mint &m) {
if ((val += m.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &m) {
if ((val -= m.val) < mod)
val += mod;
return *this;
}
mint &operator*=(const mint &m) {
val = (val * 1ll * m.val) % mod;
return *this;
}
friend mint pow(mint a, ll p) {
mint ans = 1;
for (; p; p /= 2, a *= a)
if (p % 2 == 1)
ans *= a;
return ans;
}
friend mint inv(const mint &a) {
assert(a.val);
return pow(a, mod - 2);
}
mint &operator/=(const mint &m) { return (*this) *= inv(m); }
friend mint operator+(mint a, const mint &b) { return a += b; }
friend mint operator-(mint a, const mint &b) { return a -= b; }
friend mint operator*(mint a, const mint &b) { return a *= b; }
friend mint operator/(mint a, const mint &b) { return a /= b; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
int solve();
void precomp();
#define multitest 0
#define usecase 0
#define usedecimal 0
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (multitest)
cin >> t;
if (usedecimal)
decimal(10);
precomp();
for (int tc = 1; tc <= t; tc++) {
if (multitest && usecase)
cout << "Case #" << tc << ": ";
solve();
}
}
void precomp() { return; }
int solve() {
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int time;
if (h1 == h2 && m1 <= m2)
time = m2 - m1;
else {
time = 60 - m1;
h1++;
if (h1 > h2)
h2 += 24;
time += (h2 - h1) * 60 + m2;
}
cout << time - k << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pqgreater(x) x, vector<x>, greater<x>
#define decimal(x) cout << fixed << setprecision(x)
#define dbg(x) cerr << #x << ": " << x << endl;
#define gc getchar //_unlocked
#define pc putchar //_unlocked
const int mod = 998244353; // 1e9+7 or 998244353, remove const if changing mods
const ld eps = 1e-6;
ld sign(ld x) { return (x > 0) - (x < 0); }
ll sign(ll x) { return (x > 0) - (x < 0); }
int sign(int x) { return (x > 0) - (x < 0); }
struct pt {
ld x, y;
pt() {}
pt(ld _x, ld _y) : x(_x), y(_y) {}
bool operator<(pt p) { return tie(x, y) < tie(p.x, p.y); }
bool operator==(pt p) { return tie(x, y) == tie(p.x, p.y); }
pt operator+(pt p) { return {x + p.x, y + p.y}; }
pt operator-(pt p) { return {x - p.x, y - p.y}; }
pt operator*(ld d) { return {x * d, y * d}; }
pt operator/(ld d) { return {x / d, y / d}; }
ld dot(pt p) { return x * p.x + y * p.y; }
ld det(pt p) { return x * p.y - y * p.x; }
ld cross(pt p, pt q) { return (p - *this).det(q - *this); }
ld dist() { return sqrtl(x * x + y * y); }
pt rot90() { return pt(-y, x); }
pt unit() { return *this / dist(); }
ld angle() { return atan2(y, x); }
pt rot(ld an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
void read() { cin >> x >> y; }
void write() { cout << "(" << x << "," << y << ")" << endl; }
};
struct seg {
pt fi, sc;
seg() {}
seg(pt _fi, pt _sc) : fi(_fi), sc(_sc) {}
ld dist(pt C) {
if (fi == sc)
return (C - fi).dist();
ld d = pow((sc - fi).dist(), 2);
ld t = min(d, max((ld)0.0, (C - fi).dot(sc - fi)));
return ((C - fi) * d - (sc - fi) * t).dist() / d;
}
ld len() { return (fi - sc).dist(); }
bool on_seg(pt C) {
return abs(C.cross(fi, sc)) < eps && (fi - C).dot(sc - C) <= eps;
}
vector<pt> intersect(seg rhs) {
ld oa = rhs.fi.cross(rhs.sc, fi);
ld ob = rhs.fi.cross(rhs.sc, sc);
ld oc = fi.cross(sc, rhs.fi);
ld od = fi.cross(sc, rhs.sc);
if (sign(oa) * sign(ob) < 0 && sign(oc) * sign(od) < 0)
return {(fi * ob - sc * oa) / (ob - oa)};
vector<pt> ans;
if (rhs.on_seg(fi))
ans.push_back(fi);
if (rhs.on_seg(sc))
ans.push_back(sc);
if (on_seg(rhs.fi))
ans.push_back(rhs.fi);
if (on_seg(rhs.sc))
ans.push_back(rhs.sc);
return ans;
}
};
struct line {
ld a, b, c; // line a*x+b*y=c
line(pt p1, pt p2) {
assert(!(p1 == p2));
a = p2.y - p1.y;
b = p1.x - p2.x;
c = a * p1.x + b * p1.y;
}
line() {}
line(ld _a, ld _b, ld _c) : a(_a), b(_b), c(_c) {}
ld dist(pt p) { return fabs(a * p.x + b * p.y - c) / sqrtl(a * a + b * b); }
pair<int, pt> intersect(line rhs) {
ld dett = a * rhs.b - b * rhs.a;
if (fabs(dett) <= eps) {
ld det2 = c * rhs.a - a * rhs.c;
if (fabs(det2) <= eps)
return {-1, pt()}; // infinte
return {0, pt()}; // no sol
}
return {1,
pt((c * rhs.b - rhs.c * b) / dett, (a * rhs.c - c * rhs.a) / dett)};
}
};
pt reflect(pt A, line L) {
line perpendicular(-L.b, L.a, -L.b * A.x + L.a * A.y);
pt insect = perpendicular.intersect(L).second;
return insect * (ld)2.0 - A;
}
struct mint {
int val;
mint() { val = 0; }
mint(const ll &v) {
val = (-mod <= v && v < mod) ? v : v % mod;
if (val < 0)
val += mod;
}
friend ostream &operator<<(ostream &os, const mint &a) { return os << a.val; }
friend bool operator==(const mint &a, const mint &b) {
return a.val == b.val;
}
friend bool operator!=(const mint &a, const mint &b) {
return a.val != b.val;
}
friend bool operator<(const mint &a, const mint &b) { return a.val < b.val; }
friend bool operator>(const mint &a, const mint &b) { return a.val > b.val; }
friend bool operator<=(const mint &a, const mint &b) {
return a.val <= b.val;
}
friend bool operator>=(const mint &a, const mint &b) {
return a.val >= b.val;
}
mint operator-() { return mint(-val); }
mint &operator+=(const mint &m) {
if ((val += m.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &m) {
if ((val -= m.val) < mod)
val += mod;
return *this;
}
mint &operator*=(const mint &m) {
val = (val * 1ll * m.val) % mod;
return *this;
}
friend mint pow(mint a, ll p) {
mint ans = 1;
for (; p; p /= 2, a *= a)
if (p % 2 == 1)
ans *= a;
return ans;
}
friend mint inv(const mint &a) {
assert(a.val);
return pow(a, mod - 2);
}
mint &operator/=(const mint &m) { return (*this) *= inv(m); }
friend mint operator+(mint a, const mint &b) { return a += b; }
friend mint operator-(mint a, const mint &b) { return a -= b; }
friend mint operator*(mint a, const mint &b) { return a *= b; }
friend mint operator/(mint a, const mint &b) { return a /= b; }
};
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
int solve();
void precomp();
#define multitest 0
#define usecase 0
#define usedecimal 0
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (multitest)
cin >> t;
if (usedecimal)
decimal(10);
precomp();
for (int tc = 1; tc <= t; tc++) {
if (multitest && usecase)
cout << "Case #" << tc << ": ";
solve();
}
}
void precomp() { return; }
int solve() {
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int time;
if (h1 == h2 && m1 <= m2)
time = m2 - m1;
else {
time = 60 - m1;
h1++;
if (h1 > h2)
h2 += 24;
time += (h2 - h1) * 60 + m2;
}
cout << time - k << endl;
return 0;
} | insert | 203 | 203 | 203 | 204 | TLE | |
p02664 | C++ | Runtime Error | #include <stdio.h>
#include <string.h>
int main() {
static char T[100001];
scanf("%s", T);
size_t len = strlen(T);
for (size_t i = 0; i < len; i++) {
if (T[i] == '?') {
T[i] = 'D';
}
}
printf("%s\n", T);
return 0;
}
| #include <stdio.h>
#include <string.h>
int main() {
static char T[200001];
scanf("%s", T);
size_t len = strlen(T);
for (size_t i = 0; i < len; i++) {
if (T[i] == '?') {
T[i] = 'D';
}
}
printf("%s\n", T);
return 0;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p02664 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
for (long long i = 0; i < t.size(); i++) {
if (t.at(i) == '?') {
if (t.at(i - 1) == 'P')
t.at(i) = 'D';
else
t.at(i) = 'P';
}
}
cout << t << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
for (int i = 0; i < t.size(); i++) {
if (t.at(i) == '?')
t.at(i) = 'D';
}
cout << t << endl;
} | replace | 6 | 13 | 6 | 9 | 0 | |
p02664 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
char s[N];
int n;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i)
if (s[i] == '?')
s[i] = 'D';
printf("%s\n", s);
} | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
char s[N];
int n;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i)
if (s[i] == '?')
s[i] = 'D';
printf("%s\n", s);
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02664 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(x) cout << fixed << setprecision(x);
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
int main() {
string S;
cin >> S;
ll N;
rep(i, S.size()) {
if (S.at(i) == '?' && S.at(i - 1) == 'P') {
S.at(i) = 'D';
} else if (S.at(i) == '?' && S.at(i - 1) == 'D') {
S.at(i) = 'D';
} else if (S.at(i) == '?') {
S.at(i) = 'D';
}
}
cout << S << endl;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(x) cout << fixed << setprecision(x);
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
int main() {
string S;
cin >> S;
ll N;
rep(i, S.size()) {
if (S.at(i) == '?') {
S.at(i) = 'D';
}
}
cout << S << endl;
}
| replace | 17 | 22 | 17 | 18 | 0 | |
p02664 | C++ | Runtime Error | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ll long long
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<ll, ll>
#define mii map<pii, ll>
#define all(a) (a).begin(), (a).end()
#define fi first
#define si second
#define sz(x) (ll) x.size()
#define endl '\n'
#define checkbit(n, b) ((n >> b) & 1)
#define mod 1000000007
#define inf 1000000000000000000
#define puts(n) cout << n;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define setbits(x) __builtin_popcount(x)
#define mset(m, v) memset(m, v, sizeof(m))
using namespace std;
string s;
ll n;
ll dp[20005][2];
ll solve(ll i, ll last) {
if (i == n)
return 0;
if (dp[i][last] != -1)
return dp[i][last];
ll ans = 0;
if (i == 0) {
if (s[i] == 'D')
ans = max(ans, solve(i + 1, 0) + 1);
else if (s[i] == 'P')
ans = max(ans, solve(i + 1, 1));
else {
ll v1, v2;
v1 = solve(i + 1, 0) + 1;
v2 = solve(i + 1, 1);
if (v1 > ans) {
ans = v1;
s[i] = 'D';
}
if (v2 > ans) {
ans = v2;
s[i] = 'P';
}
}
} else {
if (s[i] == 'D')
ans = max(ans, solve(i + 1, 0) + 1 + (last == 1));
else if (s[i] == 'P')
ans = max(ans, solve(i + 1, 1));
else {
ll v1, v2;
v1 = solve(i + 1, 0) + 1 + (last == 1);
v2 = solve(i + 1, 1);
if (v1 > ans) {
ans = v1;
s[i] = 'D';
}
if (v2 > ans) {
ans = v2;
s[i] = 'P';
}
}
}
dp[i][last] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
n = s.size();
for (ll i = 0; i < n; i++) {
dp[i][0] = dp[i][1] = -1;
}
ll ans = solve(0, 0);
// cout<<ans<<"\n";
cout << s;
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ll long long
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<ll, ll>
#define mii map<pii, ll>
#define all(a) (a).begin(), (a).end()
#define fi first
#define si second
#define sz(x) (ll) x.size()
#define endl '\n'
#define checkbit(n, b) ((n >> b) & 1)
#define mod 1000000007
#define inf 1000000000000000000
#define puts(n) cout << n;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define setbits(x) __builtin_popcount(x)
#define mset(m, v) memset(m, v, sizeof(m))
using namespace std;
string s;
ll n;
ll dp[200005][2];
ll solve(ll i, ll last) {
if (i == n)
return 0;
if (dp[i][last] != -1)
return dp[i][last];
ll ans = 0;
if (i == 0) {
if (s[i] == 'D')
ans = max(ans, solve(i + 1, 0) + 1);
else if (s[i] == 'P')
ans = max(ans, solve(i + 1, 1));
else {
ll v1, v2;
v1 = solve(i + 1, 0) + 1;
v2 = solve(i + 1, 1);
if (v1 > ans) {
ans = v1;
s[i] = 'D';
}
if (v2 > ans) {
ans = v2;
s[i] = 'P';
}
}
} else {
if (s[i] == 'D')
ans = max(ans, solve(i + 1, 0) + 1 + (last == 1));
else if (s[i] == 'P')
ans = max(ans, solve(i + 1, 1));
else {
ll v1, v2;
v1 = solve(i + 1, 0) + 1 + (last == 1);
v2 = solve(i + 1, 1);
if (v1 > ans) {
ans = v1;
s[i] = 'D';
}
if (v2 > ans) {
ans = v2;
s[i] = 'P';
}
}
}
dp[i][last] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
n = s.size();
for (ll i = 0; i < n; i++) {
dp[i][0] = dp[i][1] = -1;
}
ll ans = solve(0, 0);
// cout<<ans<<"\n";
cout << s;
return 0;
} | replace | 27 | 28 | 27 | 28 | 0 | |
p02664 | C++ | Runtime Error | // #pragma GCC optimize("Ofast")
// #pragma GCC optimize ("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma warning(disable : 4786)
#pragma warning(disable : 4996)
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define MEM(a, b) memset(a, (b), sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(X) ((X) > 0 ? (X) : (-(X)))
#define S(X) ((X) * (X))
#define SZ(V) (int)V.size()
#define FORN(i, n) for (int i = 0; i < n; i++)
#define FORAB(i, a, b) for (int i = a; i <= b; i++)
#define ALL(V) V.begin(), V.end()
#define IN(A, B, C) ((B) <= (A) && (A) <= (C))
#define AIN(A, B, C) assert(IN(A, B, C))
typedef long long int LL;
// typedef __int128 LLL;
typedef long long LLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PLL> VPL;
typedef vector<PII> VP;
typedef vector<double> VD;
typedef vector<vector<int>> VVI;
typedef vector<string> VS;
typedef long double ld;
#define MAXN 1000006
// #define MAXN 1006
const LL MOD = 1000000007;
// const LL MOD = 998244353;
const LL INF = 2000000000000000001LL; // 2e18 + 1
void solve(int ks) {
char S[100005];
scanf("%s", S);
for (int i = 0; S[i]; i++)
if (S[i] == '?')
S[i] = 'D';
printf("%s\n", S);
}
void gen() {}
int main() {
double start_time = clock();
#ifdef LOCAL
freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("out.out", "w", stdout);
#endif
gen();
if (0) {
int T;
scanf("%d", &T);
// AIN(T, 1, 5000);
for (int ks = 1; ks <= T; ks++) {
solve(ks);
if (ks % 1 == 0)
fprintf(stderr, "%d done\n", ks);
}
} else {
solve(0);
}
double end_time = clock();
fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
return 0;
}
| // #pragma GCC optimize("Ofast")
// #pragma GCC optimize ("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma warning(disable : 4786)
#pragma warning(disable : 4996)
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define MEM(a, b) memset(a, (b), sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(X) ((X) > 0 ? (X) : (-(X)))
#define S(X) ((X) * (X))
#define SZ(V) (int)V.size()
#define FORN(i, n) for (int i = 0; i < n; i++)
#define FORAB(i, a, b) for (int i = a; i <= b; i++)
#define ALL(V) V.begin(), V.end()
#define IN(A, B, C) ((B) <= (A) && (A) <= (C))
#define AIN(A, B, C) assert(IN(A, B, C))
typedef long long int LL;
// typedef __int128 LLL;
typedef long long LLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PLL> VPL;
typedef vector<PII> VP;
typedef vector<double> VD;
typedef vector<vector<int>> VVI;
typedef vector<string> VS;
typedef long double ld;
#define MAXN 1000006
// #define MAXN 1006
const LL MOD = 1000000007;
// const LL MOD = 998244353;
const LL INF = 2000000000000000001LL; // 2e18 + 1
void solve(int ks) {
char S[200005];
scanf("%s", S);
for (int i = 0; S[i]; i++)
if (S[i] == '?')
S[i] = 'D';
printf("%s\n", S);
}
void gen() {}
int main() {
double start_time = clock();
#ifdef LOCAL
freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("out.out", "w", stdout);
#endif
gen();
if (0) {
int T;
scanf("%d", &T);
// AIN(T, 1, 5000);
for (int ks = 1; ks <= T; ks++) {
solve(ks);
if (ks % 1 == 0)
fprintf(stderr, "%d done\n", ks);
}
} else {
solve(0);
}
double end_time = clock();
fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
return 0;
}
| replace | 69 | 70 | 69 | 70 | 0 | Time = 0.000173
|
p02664 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
char p[200010];
char a[200010];
int main() {
int i;
scanf("%s", p);
for (i = 0; i < strlen(p); i++) {
if (p[i] == '?')
a[i] = 'D';
else
a[i] = p[i];
}
printf("%s", a);
} | #include <bits/stdc++.h>
using namespace std;
char p[200010];
char a[200010];
int main() {
int i = 0;
char ps;
while (scanf("%c", &ps) != EOF) {
if (ps == '?') {
a[i++] = 'D';
} else
a[i++] = ps;
}
printf("%s", a);
} | replace | 5 | 12 | 5 | 12 | TLE | |
p02664 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string T;
cin >> T;
ll count = 0;
for (ll i = 0; i < (int)T.size(); i++) {
if (i != (int)T.size() - 1 && T.at(i) == '?' && T.at(i + 1) == '?') {
count++;
}
}
for (ll j = 0; j < count + 2; j++) {
for (ll i = 0; i < (int)T.size(); i++) {
if (i == (int)T.size() - 1 && T.at(i) == '?') {
T.at(i) = 'D';
} else if (i != (int)T.size() - 1 && T.at(i) == '?' &&
T.at(i + 1) == 'P') {
T.at(i) = 'D';
} else if (i != (int)T.size() - 1 && T.at(i) == '?' &&
T.at(i + 1) == 'D') {
T.at(i) = 'P';
}
}
}
for (ll i = 0; i < (int)T.size(); i++) {
cout << T.at(i);
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string T;
cin >> T;
ll count = 0;
for (ll i = 0; i < (int)T.size(); i++) {
if (T.at(i) == '?') {
T.at(i) = 'D';
}
}
for (ll i = 0; i < (int)T.size(); i++) {
cout << T.at(i);
}
} | replace | 10 | 27 | 10 | 12 | TLE | |
p02664 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
if (t.at(0) == '?' && t.at(1) == 'P')
t.at(0) = 'D';
else
t.at(0) = 'P';
for (int i = 1; i < t.size() - 1; i++) {
if (t.at(i) == '?') {
if (t.at(i + 1) == 'D' && t.at(i - 1) == 'D')
t.at(i) = 'P';
else
t.at(i) = 'D';
}
}
if (t.at(t.size() - 1) == '?')
t.at(t.size() - 1) = 'D';
cout << t << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
if (t.size() == 1) {
if (t.at(0) == 'P')
t.at(0) = 'P';
else
t.at(0) = 'D';
}
if (t.at(0) == '?' && t.size() > 1) {
if (t.at(1) == 'P')
t.at(0) = 'D';
else
t.at(0) = 'P';
}
for (int i = 1; i < t.size() - 1; i++) {
if (t.at(i) == '?') {
if (t.at(i + 1) == 'D' && t.at(i - 1) == 'D')
t.at(i) = 'P';
else
t.at(i) = 'D';
}
}
if (t.at(t.size() - 1) == '?')
t.at(t.size() - 1) = 'D';
cout << t << endl;
} | replace | 7 | 11 | 7 | 20 | 0 | |
p02664 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
char cc[200010];
int main() {
cin >> cc;
int i, j, k, l;
for (i = 0; i < strlen(cc); i++) {
if (cc[i] == '?') {
cout << "D";
} else
cout << cc[i];
}
} | #include <bits/stdc++.h>
using namespace std;
char cc[200010];
int main() {
scanf("%s", cc);
int i, j, k, l = strlen(cc);
for (i = 0; i < l; i++) {
if (cc[i] == '?') {
cout << "D";
} else
cout << cc[i];
}
} | replace | 4 | 7 | 4 | 7 | TLE | |
p02664 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string t;
cin >> t;
for (int i = 0; i < t.size(); i++) {
if (t.at(i) == '?') {
if (t.at(i + 1) == 'P')
t.at(i) = 'D';
else if (t.at(i + 1) == 'D')
t.at(i) = 'P';
else {
t.at(i) = 'P';
t.at(i + 1) = 'D';
i++;
}
}
}
cout << t << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string t;
cin >> t;
int s = t.size();
for (int i = 0; i < s; i++) {
if (t.at(i) == '?')
t.at(i) = 'D';
}
cout << t << endl;
}
| replace | 7 | 19 | 7 | 11 | 0 | |
p02664 | C++ | Runtime Error | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(), (u).end()
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
typedef pair<int, int> PII;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int MR = 1e5 + 10;
char s[MR];
int main() {
scanf("%s", s);
int n = strlen(s);
REP(i, n)
if (s[i] == '?')
s[i] = 'D';
printf("%s\n", s);
return 0;
}
// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++
// #include <Processthreadsapi.h>
// #include <iostream>
// #include <Synchapi.h>
// #include <windows.h>
// #include <process.h>
//
// DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
// main2(nullptr);
// return 0;
// }
// int main() {
// auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr,
// STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr); WaitForSingleObject(h,
// INFINITE);
// } | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(), (u).end()
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
typedef pair<int, int> PII;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int MR = 2e5 + 10;
char s[MR];
int main() {
scanf("%s", s);
int n = strlen(s);
REP(i, n)
if (s[i] == '?')
s[i] = 'D';
printf("%s\n", s);
return 0;
}
// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++
// #include <Processthreadsapi.h>
// #include <iostream>
// #include <Synchapi.h>
// #include <windows.h>
// #include <process.h>
//
// DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
// main2(nullptr);
// return 0;
// }
// int main() {
// auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr,
// STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr); WaitForSingleObject(h,
// INFINITE);
// } | replace | 47 | 48 | 47 | 48 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.