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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02549 | 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 = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define show(x) cout << #x << " = " << (x) << endl
#define show2(x, y) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << endl
#define show3(x, y, z) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl
#define showv(v) \
rep(i, v.size()) printf("%d%c", v[i], i == v.size() - 1 ? '\n' : ' ')
#define showv2(v) rep(j, v.size()) showv(v[j])
#define showt(t, n) rep(i, n) printf("%d%c", t[i], i == n - 1 ? '\n' : ' ')
#define showt2(t, r, c) rep(j, r) showt(t[j], c)
#define showvp(p) rep(i, p.size()) printf("%d %d\n", p[i].first, p[i].second)
#define printv(v) rep(i, v.size()) printf("%d\n", v[i])
#define printt(t, n) rep(i, n) printf("%d\n", t[i])
#define incl(v, x) (find(all(v), x) != v.end())
#define incls(s, c) (s.find(c) != string::npos)
#define lb(a, x) distance((a).begin(), lower_bound(all(a), (x)))
#define ub(a, x) distance((a).begin(), upper_bound(all(a), (x)))
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define bit(n, k) ((n >> k) & 1) // nのk bit目
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define uni(x) x.erase(unique(all(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vb>;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
using vt = vector<T>;
const double EPS = 1e-9;
// const long double EPS = 1e-14;
const int INF = (1 << 30) - 1;
const ll LINF = (1LL << 62) - 1;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
#define YN \
{ puts("YES"); } \
else { \
puts("NO"); \
}
inline int in() {
int x;
cin >> x;
return x;
}
inline ll lin() {
ll x;
cin >> x;
return x;
}
inline char chin() {
char x;
cin >> x;
return x;
}
inline string stin() {
string x;
cin >> x;
return x;
}
inline double din() {
double x;
cin >> x;
return x;
}
// template<class T = int> inline T in() { T x; cin >> x; return (x);}
template <typename T> inline ll suma(const vector<T> &a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
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;
}
char itoa(int n) { return n + '0'; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const int dy[4] = {0, -1, 0, 1};
const int dx[4] = {1, 0, -1, 0};
const int mod = 998244353;
// mint(a).pow(b) -> a^b
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint operator~() const { return mint(1) / *this; }
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= 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 {
mint res(*this);
return res /= a;
}
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
int main() {
int n, k;
cin >> n >> k;
vi l(k), r(k);
rep(i, k) cin >> l[i] >> r[i];
vector<mint> dp(n + 1);
vector<mint> dpsum(n + 1);
dp[1] = 1;
dpsum[1] = 1;
for (int i = 2; i <= n; ++i) {
rep(j, k) {
// [l[i], r[i]]
int li = i - r[j];
int ri = i - l[j];
// if (ri < 0) continue;
li = max(li, 1);
dp[i] += dpsum[ri] - dpsum[li - 1]; // dp[li]~dp[ri]
}
dpsum[i] = dpsum[i - 1] + dp[i];
}
cout << dp[n] << 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 = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define show(x) cout << #x << " = " << (x) << endl
#define show2(x, y) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << endl
#define show3(x, y, z) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl
#define showv(v) \
rep(i, v.size()) printf("%d%c", v[i], i == v.size() - 1 ? '\n' : ' ')
#define showv2(v) rep(j, v.size()) showv(v[j])
#define showt(t, n) rep(i, n) printf("%d%c", t[i], i == n - 1 ? '\n' : ' ')
#define showt2(t, r, c) rep(j, r) showt(t[j], c)
#define showvp(p) rep(i, p.size()) printf("%d %d\n", p[i].first, p[i].second)
#define printv(v) rep(i, v.size()) printf("%d\n", v[i])
#define printt(t, n) rep(i, n) printf("%d\n", t[i])
#define incl(v, x) (find(all(v), x) != v.end())
#define incls(s, c) (s.find(c) != string::npos)
#define lb(a, x) distance((a).begin(), lower_bound(all(a), (x)))
#define ub(a, x) distance((a).begin(), upper_bound(all(a), (x)))
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define bit(n, k) ((n >> k) & 1) // nのk bit目
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define uni(x) x.erase(unique(all(x)), x.end())
#define SP << " " <<
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vb>;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
using vt = vector<T>;
const double EPS = 1e-9;
// const long double EPS = 1e-14;
const int INF = (1 << 30) - 1;
const ll LINF = (1LL << 62) - 1;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
#define YN \
{ puts("YES"); } \
else { \
puts("NO"); \
}
inline int in() {
int x;
cin >> x;
return x;
}
inline ll lin() {
ll x;
cin >> x;
return x;
}
inline char chin() {
char x;
cin >> x;
return x;
}
inline string stin() {
string x;
cin >> x;
return x;
}
inline double din() {
double x;
cin >> x;
return x;
}
// template<class T = int> inline T in() { T x; cin >> x; return (x);}
template <typename T> inline ll suma(const vector<T> &a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
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;
}
char itoa(int n) { return n + '0'; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const int dy[4] = {0, -1, 0, 1};
const int dx[4] = {1, 0, -1, 0};
const int mod = 998244353;
// mint(a).pow(b) -> a^b
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint operator~() const { return mint(1) / *this; }
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= 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 {
mint res(*this);
return res /= a;
}
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
int main() {
int n, k;
cin >> n >> k;
vi l(k), r(k);
rep(i, k) cin >> l[i] >> r[i];
vector<mint> dp(n + 1);
vector<mint> dpsum(n + 1);
dp[1] = 1;
dpsum[1] = 1;
for (int i = 2; i <= n; ++i) {
rep(j, k) {
// [l[i], r[i]]
int li = i - r[j];
int ri = i - l[j];
if (ri < 0)
continue;
li = max(li, 1);
dp[i] += dpsum[ri] - dpsum[li - 1]; // dp[li]~dp[ri]
}
dpsum[i] = dpsum[i - 1] + dp[i];
}
cout << dp[n] << endl;
return 0;
} | replace | 203 | 204 | 203 | 205 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll mod = 998244353;
int main() {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> sections;
for (int i = 0; i < k; ++i) {
ll l, r;
cin >> l >> r;
sections.push_back({l, r});
}
vector<ll> f(2 * n + 100, 0), a(2 * n + 100, 0);
f[1] = 1;
for (int i = 1; i < 2 * n; ++i) {
for (int j = 0; j < k; ++j) {
ll l = sections[j].first;
ll r = sections[j].second;
a[i + l] += f[i];
a[i + r + 1] += (mod - f[i]);
a[i + l] %= mod;
a[i + r + 1] %= mod;
}
if (i == 1)
f[i + 1] = a[i + 1];
else
f[i + 1] = f[i] + a[i + 1];
f[i + 1] %= mod;
}
cout << f[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll mod = 998244353;
int main() {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> sections;
for (int i = 0; i < k; ++i) {
ll l, r;
cin >> l >> r;
sections.push_back({l, r});
}
vector<ll> f(2 * n + 100, 0), a(2 * n + 100, 0);
f[1] = 1;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < k; ++j) {
ll l = sections[j].first;
ll r = sections[j].second;
a[i + l] += f[i];
a[i + r + 1] += (mod - f[i]);
a[i + l] %= mod;
a[i + r + 1] %= mod;
}
if (i == 1)
f[i + 1] = a[i + 1];
else
f[i + 1] = f[i] + a[i + 1];
f[i + 1] %= mod;
}
cout << f[n] << endl;
} | replace | 16 | 17 | 16 | 17 | 0 | |
p02549 | C++ | Time Limit Exceeded | /*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll conbinationMemo[100][100];
void cmemoInit() {
rep(i, 100) {
rep(j, 100) { conbinationMemo[i][j] = -1; }
}
}
ll nCr(ll n, ll r) {
if (conbinationMemo[n][r] != -1)
return conbinationMemo[n][r];
if (r == 0 || r == n) {
return 1;
} else if (r == 1) {
return n;
}
return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r) {
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--)
ret *= i;
return ret;
}
//-----------------------ここから-----------
ll mod = 998244353;
int main(void) {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> vec;
rep(i, k) {
ll l, r;
cin >> l >> r;
vec.push_back({l, r});
}
sort(all(vec));
ll dp[200100];
dp[0] = 1;
dp[1] = -1;
ll now = 0;
rep(i, n) {
now += dp[i];
while (now < 0)
now += mod;
now %= mod;
rep(j, vec.size()) {
if (i + vec[j].first < n) {
dp[i + vec[j].first] += now;
dp[i + vec[j].first] %= mod;
}
if (i + vec[j].second + 1 < n) {
dp[i + vec[j].second + 1] -= now;
while (dp[i + vec[j].second + 1] < 0)
dp[i + vec[j].second + 1] += mod;
dp[i + vec[j].second + 1] %= mod;
}
}
}
while (now < 0)
now += mod;
cout << now % mod << endl;
}
| /*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int> &f, const pair<int, int> &s) {
return f.second > s.second;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll conbinationMemo[100][100];
void cmemoInit() {
rep(i, 100) {
rep(j, 100) { conbinationMemo[i][j] = -1; }
}
}
ll nCr(ll n, ll r) {
if (conbinationMemo[n][r] != -1)
return conbinationMemo[n][r];
if (r == 0 || r == n) {
return 1;
} else if (r == 1) {
return n;
}
return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r) {
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--)
ret *= i;
return ret;
}
//-----------------------ここから-----------
ll mod = 998244353;
int main(void) {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> vec;
rep(i, k) {
ll l, r;
cin >> l >> r;
vec.push_back({l, r});
}
sort(all(vec));
ll dp[200100] = {0};
dp[0] = 1;
dp[1] = -1;
ll now = 0;
rep(i, n) {
now += dp[i];
while (now < 0)
now += mod;
now %= mod;
rep(j, vec.size()) {
if (i + vec[j].first < n) {
dp[i + vec[j].first] += now;
dp[i + vec[j].first] %= mod;
}
if (i + vec[j].second + 1 < n) {
dp[i + vec[j].second + 1] -= now;
while (dp[i + vec[j].second + 1] < 0)
dp[i + vec[j].second + 1] += mod;
dp[i + vec[j].second + 1] %= mod;
}
}
}
while (now < 0)
now += mod;
cout << now % mod << endl;
}
| replace | 95 | 96 | 95 | 96 | TLE | |
p02549 | C++ | Time Limit Exceeded |
// Problem : D - Leaping Tak
// Contest : AtCoder - AtCoder Beginner Contest 179
// URL : https://atcoder.jp/contests/abc179/tasks/abc179_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// Macros
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define db long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define sz(x) (int)x.size()
#define mod 998244353
#define EPS 1e-9
#define inf 1e10
#define PI acos(-1.0)
#define int long long
#define N 100005
// Solution
int n, k;
vii p;
class SegTree {
int tl, tr, sum;
SegTree *left, *right;
public:
SegTree(int l, int r) {
sum = 0;
tl = l;
tr = r;
left = nullptr;
right = nullptr;
}
void makeChildren() {
int tm = (tl + tr) / 2;
left = new SegTree(tl, tm);
right = new SegTree(tm + 1, tr);
}
void update(int pos, int val) {
sum += val;
if (tl == tr)
return;
if (left == nullptr)
makeChildren();
if (pos <= left->tr)
left->update(pos, val);
else
right->update(pos, val);
}
int get(int l, int r) {
if (l > tr || r < tl)
return 0;
if (tl >= l && tr <= r)
return sum;
if (left == nullptr)
return 0;
return left->get(l, r) + right->get(l, r);
}
};
void solve() {
cin >> n >> k;
p.resize(n);
for (auto &[a, b] : p) {
cin >> a >> b;
}
SegTree *st = new SegTree(1, n);
vector<int> dp(n + 1);
dp[1] = 1;
st->update(1, 1);
for (int i = 2; i <= n; i++) {
for (auto [a, b] : p) {
int l = max(1ll, i - b);
int r = max(0ll, i - a);
dp[i] += st->get(l, r);
dp[i] %= mod;
}
st->update(i, dp[i]);
}
cout << dp[n];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
int tests;
tests = 1;
// cin>>tests;
for (int test = 1; test <= tests; test++) {
// cout<<"Case #"<<test<<": ";
solve();
}
return 0;
} |
// Problem : D - Leaping Tak
// Contest : AtCoder - AtCoder Beginner Contest 179
// URL : https://atcoder.jp/contests/abc179/tasks/abc179_d
// Memory Limit : 1024 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// Macros
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define db long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define sz(x) (int)x.size()
#define mod 998244353
#define EPS 1e-9
#define inf 1e10
#define PI acos(-1.0)
#define int long long
#define N 100005
// Solution
int n, k;
vii p;
class SegTree {
int tl, tr, sum;
SegTree *left, *right;
public:
SegTree(int l, int r) {
sum = 0;
tl = l;
tr = r;
left = nullptr;
right = nullptr;
}
void makeChildren() {
int tm = (tl + tr) / 2;
left = new SegTree(tl, tm);
right = new SegTree(tm + 1, tr);
}
void update(int pos, int val) {
sum += val;
if (tl == tr)
return;
if (left == nullptr)
makeChildren();
if (pos <= left->tr)
left->update(pos, val);
else
right->update(pos, val);
}
int get(int l, int r) {
if (l > tr || r < tl)
return 0;
if (tl >= l && tr <= r)
return sum;
if (left == nullptr)
return 0;
return left->get(l, r) + right->get(l, r);
}
};
void solve() {
cin >> n >> k;
p.resize(k);
for (auto &[a, b] : p) {
cin >> a >> b;
}
SegTree *st = new SegTree(1, n);
vector<int> dp(n + 1);
dp[1] = 1;
st->update(1, 1);
for (int i = 2; i <= n; i++) {
for (auto [a, b] : p) {
int l = max(1ll, i - b);
int r = max(0ll, i - a);
dp[i] += st->get(l, r);
dp[i] %= mod;
}
st->update(i, dp[i]);
}
cout << dp[n];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
int tests;
tests = 1;
// cin>>tests;
for (int test = 1; test <= tests; test++) {
// cout<<"Case #"<<test<<": ";
solve();
}
return 0;
} | replace | 88 | 89 | 88 | 89 | TLE | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define f(i, a, b) for (ll i = a; i < (ll)b; i++)
#define af(i, a, b) for (ll i = a; i >= b; i--)
#define rep(i, a, b, k) for (ll i = a; i < b; i += k)
#define arep(i, a, b, k) for (ll i = a; i >= b; i -= k)
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define sz(a) (ll) a.size()
#define all(a) a.begin(), a.end()
#define sor(a) sort(a.begin(), a.end())
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define inter \
ios::sync_with_stdio(false); \
cin.tie(0)
// policy-based
using namespace std;
typedef long long ll; // int or long long
typedef long double ld;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
const ll MAX = 2e5 + 1;
const ll inf = 1e9;
const ll mod = 998244353;
ll tree[MAX * 2];
ll l[20], r[20], n, k;
void update(ll l, ll r, ll v) {
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
(tree[l++] += v) %= mod;
if (r & 1)
(tree[--r] += v) %= mod;
}
}
ll query(ll x) {
ll ans = 0;
x += n;
while (x)
(ans += tree[x]) %= mod, x >>= 1;
return ans;
}
int main() {
fastio;
cin >> n >> k;
f(i, 0, k) cin >> l[i] >> r[i];
update(0, 1, 1);
f(i, 0, n) {
ll aux = query(i);
f(j, 0, k) update(i + l[j], i + r[j] + 1, aux);
}
cout << query(n - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
#define f(i, a, b) for (ll i = a; i < (ll)b; i++)
#define af(i, a, b) for (ll i = a; i >= b; i--)
#define rep(i, a, b, k) for (ll i = a; i < b; i += k)
#define arep(i, a, b, k) for (ll i = a; i >= b; i -= k)
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define sz(a) (ll) a.size()
#define all(a) a.begin(), a.end()
#define sor(a) sort(a.begin(), a.end())
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define inter \
ios::sync_with_stdio(false); \
cin.tie(0)
// policy-based
using namespace std;
typedef long long ll; // int or long long
typedef long double ld;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
const ll MAX = 2e6 + 1;
const ll inf = 1e9;
const ll mod = 998244353;
ll tree[MAX * 2];
ll l[20], r[20], n, k;
void update(ll l, ll r, ll v) {
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
(tree[l++] += v) %= mod;
if (r & 1)
(tree[--r] += v) %= mod;
}
}
ll query(ll x) {
ll ans = 0;
x += n;
while (x)
(ans += tree[x]) %= mod, x >>= 1;
return ans;
}
int main() {
fastio;
cin >> n >> k;
f(i, 0, k) cin >> l[i] >> r[i];
update(0, 1, 1);
f(i, 0, n) {
ll aux = query(i);
f(j, 0, k) update(i + l[j], i + r[j] + 1, aux);
}
cout << query(n - 1) << endl;
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define RST(i, n) memset(i, n, sizeof i)
#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define X first
#define Y second
#define eb emplace_back
#ifdef cold66
#define debug(...) \
do { \
fprintf(stderr, "LINE %d: (%s) = ", __LINE__, #__VA_ARGS__); \
_do(__VA_ARGS__); \
} while (0)
template <typename T> void _do(T &&_x) { cerr << _x << endl; }
template <typename T, typename... S> void _do(T &&_x, S &&..._t) {
cerr << _x << ", ";
_do(_t...);
}
template <typename _a, typename _b>
ostream &operator<<(ostream &_s, const pair<_a, _b> &_p) {
return _s << "(" << _p.X << "," << _p.Y << ")";
}
template <typename It> ostream &_OUTC(ostream &_s, It _ita, It _itb) {
_s << "{";
for (It _it = _ita; _it != _itb; _it++) {
_s << (_it == _ita ? "" : ",") << *_it;
}
_s << "}";
return _s;
}
template <typename _a> ostream &operator<<(ostream &_s, vector<_a> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _a> ostream &operator<<(ostream &_s, set<_a> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _a, typename _b>
ostream &operator<<(ostream &_s, map<_a, _b> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _t> void pary(_t _a, _t _b) {
_OUTC(cerr, _a, _b);
cerr << endl;
}
#define IOS()
#else
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#endif // cold66
//}
template <class T> inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T> inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
const ll MAXn = 1e5 + 5, MAXlg = __lg(MAXn) + 2;
const ll MOD = 998244353;
const ll INF = 0x3f3f3f3f;
ll dp[MAXn], sum[MAXn];
ii d[MAXn];
ll add(ll x, ll y) {
ll ret = x + y;
if (ret >= MOD)
ret -= MOD;
return ret;
}
ll sub(ll a, ll b) {
ll ret = a - b;
if (ret < 0)
ret += MOD;
return ret;
}
int main() {
IOS();
ll n, k;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
cin >> d[i].X >> d[i].Y;
}
sort(d, d + k);
dp[1] = 1;
sum[1] = 1;
for (int i = 2; i <= n; ++i)
sum[i] = 1;
for (ll i = 2; i <= n; ++i) {
for (ll j = 0; j < k; ++j) {
debug(i);
ll r = i - d[j].X, l = max(0LL, i - d[j].Y - 1);
if (r < 0)
break;
debug(l, r);
dp[i] = add(dp[i], sub(sum[r], sum[l]));
}
sum[i] = add(sum[i - 1], dp[i]);
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define RST(i, n) memset(i, n, sizeof i)
#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define X first
#define Y second
#define eb emplace_back
#ifdef cold66
#define debug(...) \
do { \
fprintf(stderr, "LINE %d: (%s) = ", __LINE__, #__VA_ARGS__); \
_do(__VA_ARGS__); \
} while (0)
template <typename T> void _do(T &&_x) { cerr << _x << endl; }
template <typename T, typename... S> void _do(T &&_x, S &&..._t) {
cerr << _x << ", ";
_do(_t...);
}
template <typename _a, typename _b>
ostream &operator<<(ostream &_s, const pair<_a, _b> &_p) {
return _s << "(" << _p.X << "," << _p.Y << ")";
}
template <typename It> ostream &_OUTC(ostream &_s, It _ita, It _itb) {
_s << "{";
for (It _it = _ita; _it != _itb; _it++) {
_s << (_it == _ita ? "" : ",") << *_it;
}
_s << "}";
return _s;
}
template <typename _a> ostream &operator<<(ostream &_s, vector<_a> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _a> ostream &operator<<(ostream &_s, set<_a> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _a, typename _b>
ostream &operator<<(ostream &_s, map<_a, _b> &_c) {
return _OUTC(_s, ALL(_c));
}
template <typename _t> void pary(_t _a, _t _b) {
_OUTC(cerr, _a, _b);
cerr << endl;
}
#define IOS()
#else
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() \
ios_base::sync_with_stdio(0); \
cin.tie(0);
#endif // cold66
//}
template <class T> inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T> inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
const ll MAXn = 2e5 + 5, MAXlg = __lg(MAXn) + 2;
const ll MOD = 998244353;
const ll INF = 0x3f3f3f3f;
ll dp[MAXn], sum[MAXn];
ii d[MAXn];
ll add(ll x, ll y) {
ll ret = x + y;
if (ret >= MOD)
ret -= MOD;
return ret;
}
ll sub(ll a, ll b) {
ll ret = a - b;
if (ret < 0)
ret += MOD;
return ret;
}
int main() {
IOS();
ll n, k;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
cin >> d[i].X >> d[i].Y;
}
sort(d, d + k);
dp[1] = 1;
sum[1] = 1;
for (int i = 2; i <= n; ++i)
sum[i] = 1;
for (ll i = 2; i <= n; ++i) {
for (ll j = 0; j < k; ++j) {
debug(i);
ll r = i - d[j].X, l = max(0LL, i - d[j].Y - 1);
if (r < 0)
break;
debug(l, r);
dp[i] = add(dp[i], sub(sum[r], sum[l]));
}
sum[i] = add(sum[i - 1], dp[i]);
}
cout << dp[n] << endl;
}
| replace | 68 | 69 | 68 | 69 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, k, n) for (int i = k; i < (int)(n); i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define rrepd(i, k, n) for (int i = n - 1; i >= (int)(k); i--)
#define all(x) (x).begin(), (x).end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PB push_back // 挿入
#define MP make_pair // pairのコンストラクタ
// V,Pは大文字i,l,bは小文字
using ll = long long;
using Vi = vector<int>;
using VVi = vector<Vi>;
using Vl = vector<ll>;
using VVl = vector<Vl>;
using Vb = vector<bool>;
using VVb = vector<Vb>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
const ll inf = 1000000000000; // 10の12乗
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;
}
};
int main() {
ll n, k;
cin >> n >> k;
vector<mint> v(n + 100001, 0), vv(n + 100001, 0);
v[0] = 1;
Vi vl(k), vr(k);
rep(i, k) cin >> vl[i] >> vr[i];
rep(i, n) {
if (i != 0)
v[i] = v[i - 1].x + vv[i].x;
rep(j, k) {
int x = vl[j];
int y = vr[j] + 1;
vv[i + x] += v[i];
vv[i + y] -= v[i];
}
}
cout << vv[n - 1].x << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, k, n) for (int i = k; i < (int)(n); i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define rrepd(i, k, n) for (int i = n - 1; i >= (int)(k); i--)
#define all(x) (x).begin(), (x).end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define PB push_back // 挿入
#define MP make_pair // pairのコンストラクタ
// V,Pは大文字i,l,bは小文字
using ll = long long;
using Vi = vector<int>;
using VVi = vector<Vi>;
using Vl = vector<ll>;
using VVl = vector<Vl>;
using Vb = vector<bool>;
using VVb = vector<Vb>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
const ll inf = 1000000000000; // 10の12乗
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;
}
};
int main() {
ll n, k;
cin >> n >> k;
vector<mint> v(n + 1000002, 0), vv(n + 1000002, 0);
v[0] = 1;
Vi vl(k), vr(k);
rep(i, k) cin >> vl[i] >> vr[i];
rep(i, n) {
if (i != 0)
v[i] = v[i - 1].x + vv[i].x;
rep(j, k) {
int x = vl[j];
int y = vr[j] + 1;
vv[i + x] += v[i];
vv[i + y] -= v[i];
}
}
cout << vv[n - 1].x << endl;
} | replace | 61 | 62 | 61 | 62 | 0 | |
p02549 | C++ | Runtime Error | /*
* if you are interested in the reference code here,
* see https://github.com/georeth/OJLIBS for more information
*
* Solution Author : Georeth Chow <georeth2010@gmail.com>
*/
#include <algorithm>
#include <cassert> // assert
#include <cfloat> // DBL_MIN DBL_MAX
#include <cinttypes> // PRId64 SCNd64
#include <climits> // INT_MIN LLONG_MIN
#include <cmath>
#include <cstdint> // int64_t
#include <cstdio>
#include <cstdlib> // malloc
#include <cstring> // memset
#include <ctime> // clock
#include <deque>
#include <iostream> // be careful.
#include <limits> // numeric_limits
#include <map>
#include <set>
#include <sstream>
#include <tuple> // pair, tuple
#include <vector>
using namespace std; // use as solution header. name polution is fine.
#ifdef LOCAL_JUDGE
#define pr_debug(...) fprintf(stderr, __VA_ARGS__)
#define pr_line() fprintf(stderr, "%s: %d\n", __FILE__, __LINE__)
#else
#define pr_debug(...)
#define pr_line()
#endif
template <typename T> bool chmax(T &m, const T &v) {
if (v > m)
return m = v, true;
return false;
}
template <typename T> bool chmin(T &m, const T &v) {
if (v < m)
return m = v, true;
return false;
}
template <typename T> bool chinc(T &v1, T &v2) {
if (v1 > v2)
return swap(v1, v2), true;
return false;
}
template <typename T> bool chdec(T &v1, T &v2) {
if (v1 < v2)
return swap(v1, v2), true;
return false;
}
#define ALL(x) begin(x), end(x)
#define FOR0(i, n) for (int i = 0, i##end = n; i < i##end; i++)
#define FOR1(i, n) for (int i = 1, i##end = n; i <= i##end; i++)
#define FOR(i, a, b) for (int i = a, i##end = b; i <= i##end; i++)
#define FOD0(i, n) for (int i = (n)-1; ~i; i--)
#define FOD1(i, n) for (int i = n; i; i--)
#define FOD(i, a, b) for (int i = a, i##end = b; i >= i##end; i--)
#define FORE(i, x) for (__typeof(x.end()) i = x.begin(); i != x.end(); ++i)
typedef int64_t ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vii;
typedef vector<vector<int>> vvi;
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#include <iostream>
namespace fio {
static const char eof = '\xff';
#define LL long long
#define I inline
#define OP operator
#define RT return *this;
#define ALL_INT(mcr) \
mcr(int) mcr(long) mcr(LL) mcr(unsigned) mcr(unsigned long) mcr(unsigned LL)
#define ALL_FLT(mcr) mcr(float) mcr(double) mcr(long double)
#define S2D \
x = 0; \
int c = P(); \
while ((c < '0' || c > '9') && c != '-') \
c = P(); \
bool h = false; \
if (c == '-') \
h = true, c = P()
#define R2D \
for (; c >= '0' && c <= '9'; c = P()) \
x = x * 10 + c - '0'
#define R2F \
if (c == '.') { \
double u = 0.1; \
for (c = P(); c >= '0' && c <= '9'; c = P(), u *= 0.1) \
x += u * (c - '0'); \
}
#define RD_INT(Int) \
I Fr &OP, (Int & x) { \
S2D; \
R2D; \
if (h) \
x = -x; \
RT \
}
#define RD_FLT(Flt) \
I Fr &OP, (Flt & x) { \
S2D; \
R2D; \
R2F; \
if (h) \
x = -x; \
RT \
}
struct Cg {
I char OP()() {
char c = (char)getchar();
if (c == eof)
valid = false;
return c;
};
bool valid = true;
};
struct Cp {
I void OP()(int x) { putchar(x); }
};
struct Ce {
I void OP()(int x) { putc(x, stderr); }
};
I bool IS(char x) { return x == ' ' || x == '\r' || x == '\n' || x == '\t'; }
template <class T> struct Fr {
T P;
ALL_INT(RD_INT) ALL_FLT(RD_FLT) I Fr &OP, (char &x) {
for (x = P(); IS(x);)
x = P();
RT
}
I Fr &OP, (char *s) {
for (*s = P(); IS(*s) && P.valid;)
*s = P();
for (; !IS(*s) && P.valid;)
*++s = P();
*s = 0;
RT
}
I Fr &OP, (string & s) {
s.clear();
char c = P();
for (; IS(c) && P.valid;)
c = P();
for (; !IS(c) && P.valid;)
s.push_back(c), c = P();
RT
}
I OP bool() { return P.valid; }
};
#define W4D \
if (x) { \
if (x < 0) \
P('-'), x = -x; \
int p = 0; \
while (x) \
B[p++] = x % 10 + '0', x /= 10; \
while (p--) \
P(B[p]); \
} else \
P('0')
#define WR_INT(Int) \
I Fw &OP, (Int x) { \
W4D; \
RT \
}
#define WR_FLT(Flt) \
I Fw &OP()(Flt g, int d) { \
if (d) { \
double t = 0.5; \
for (int i = d; i--;) \
t *= 0.1; \
if (g < 0) \
P('-'), g = -g; \
g += t; \
*this, (LL)(g); \
P('.'); \
g -= floor(g); \
while (d--) { \
g *= 10; \
int i = (int)floor(g); \
P(i + '0'); \
g -= i; \
} \
} else \
*this, (g > 0 ? (LL)(g + 0.5) : (LL)(g - 0.5)); \
RT \
}
template <class T> struct Fw {
T P;
char B[32];
ALL_INT(WR_INT) ALL_FLT(WR_FLT) I Fw &OP, (char x) {
P(x);
RT
}
typedef char_traits<char> CT;
typedef basic_ostream<char, CT> &OS;
typedef basic_istream<char, CT> &IS;
I Fw &OP, (OS & (*func)(OS)) {
if (func == static_cast<OS &(*)(OS)>(endl<char, CT>))
P('\n');
RT
}
I Fw &OP, (IS & (*func)(IS)) {
if (func == static_cast<IS &(*)(IS)>(ws<char, CT>))
P(' ');
RT
}
I Fw &OP, (const char *s) {
for (; *s; ++s)
P(*s);
RT
}
I Fw &OP, (const string &s) {
(*this), s.c_str();
RT
}
template <class C> I Fw &all(const C &v, char sep = ' ', char nl = '\n') {
auto it = v.begin();
for (int i = 0; i < (int)v.size(); ++i, ++it) {
if (i && sep)
P(sep);
(*this), *it;
}
if (nl)
P(nl);
RT
}
template <class U> I Fw &print(U x) {
(*this), x;
P('\n');
RT
}
template <class U, class... Us> I Fw &print(U x, Us... args) {
(*this), x;
P(' ');
print(args...);
RT
}
};
#undef LL
#undef I
#undef OP
#undef RT
#undef ALL_INT
#undef ALL_FLT
#undef S2D
#undef R2D
#undef R2F
#undef RD_INT
#undef RD_FLT
#undef W4D
#undef WR_INT
#undef WR_FLT
} // namespace fio
fio::Fr<fio::Cg> fin;
fio::Fw<fio::Cp> fout;
fio::Fw<fio::Ce> ferr;
#include <cstdint>
#include <utility>
static inline unsigned all_ones(unsigned x) {
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return x;
}
static inline int floor_log2(unsigned x) {
int ans = 0;
while (x >>= 1)
++ans;
return ans;
}
static inline bool is_pow2(unsigned x) { return !(x & (x - 1)); }
static inline unsigned next_pow2(unsigned x) { return all_ones(x) + 1; }
static inline unsigned ceil_pow2(unsigned x) {
if (is_pow2(x))
return x;
return next_pow2(x);
}
static inline int msb32(unsigned int x) {
x = all_ones(x);
return x & ~(x >> 1);
}
static inline int lsb32(unsigned int x) { return x & -x; }
#include <limits>
#include <type_traits>
#ifndef OJLIBS_USE_INT128
#define OJLIBS_USE_INT128 1
#endif
template <typename Int> Int gcd(Int a, Int b) {
while (a != 0) {
b %= a;
if (b == 0)
return a;
a %= b;
}
return b;
}
template <typename Int, typename RInt = Int> Int lcm(Int a, Int b) {
return a / gcd(a, b) * static_cast<RInt>(b);
}
template <typename Int, typename XInt>
Int extended_gcd(Int a, Int b, XInt &x, XInt &y) {
static_assert(std::numeric_limits<XInt>::is_signed, "x, y must be signed");
if (b == 0) {
x = 1;
y = 0;
return a;
}
/**
* r = a - b * q
* b * k1 + r * k2 = g
* => a * k2 + b * (k1 - q * k2)
* x = k2
* y = k1 - q * k2 = k1 - q * x
*/
Int g = extended_gcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
template <typename Int> Int mul_mod(Int a, Int b, Int m) {
typedef int64_t TInt;
static_assert(2 * std::numeric_limits<Int>::digits <=
std::numeric_limits<TInt>::digits,
"multiplication will overflow!");
TInt p = a;
p = (p * b) % m;
return (Int)p;
}
#if defined(__SIZEOF_INT128__) && OJLIBS_USE_INT128
template <> int64_t mul_mod<int64_t>(int64_t a, int64_t b, int64_t m) {
__int128_t p = __int128_t(a) * b;
return (int64_t)(p % m);
}
#else
template <> int64_t mul_mod<int64_t>(int64_t a, int64_t b, int64_t m) {
int64_t r = 0;
for (int i = 63; i >= 0; --i) {
r = (r + r) % m;
if ((b >> i) & 1)
r = (r + a) % m;
}
return r;
}
#endif
template <typename Int, typename PInt> Int pow_mod(Int a, PInt p, Int m) {
Int r;
a %= m;
for (r = 1; p; p >>= 1) {
if (p & 1)
r = mul_mod(r, a, m);
a = mul_mod(a, a, m);
}
return r;
}
template <typename Int, typename XInt = typename std::make_signed<Int>::type>
Int inv_mod(Int a, Int m) {
XInt x, y;
extended_gcd(a, m, x, y);
if (x < 0)
return x + m;
return x;
}
template <typename Int> Int addx_mod(Int u, Int v, Int m) {
Int r = u + v;
if (r >= m)
r -= m;
return r;
}
template <typename Int> Int subx_mod(Int u, Int v, Int m) {
Int r = u - v;
if (r < 0)
r += m;
return r;
}
template <typename Int> Int div_mod(Int u, Int v, Int m) {
Int g = gcd(v, m);
assert(u % g == 0);
Int mm = m / g;
return mul_mod(u / g, inv_mod(v / g, mm), mm);
}
template <typename Int> Int div_pos_r(Int a, Int b, Int &r) {
Int q = a / b;
r = a % b;
if (r < 0) {
if (b < 0)
q += 1, r -= b;
else
q -= 1, r += b;
}
return q;
}
template <typename Int> Int coprime_div(Int a, Int b) {
while (b != 1) {
while (a % b == 0)
a /= b;
b = gcd(a, b);
}
return a;
}
#define INV_MOD(x) inv_mod((x), MOD)
#define MUL_MOD(x, y) mul_mod((x), (y), MOD)
#define DIV_MOD(x, y) div_mod((x), (y), MOD)
#define MULM_MOD(x, y) (x) = mul_mod((x), (y), MOD)
#define DIVM_MOD(x, y) (x) = div_mod((x), (y), MOD)
#define POW_MOD(x, y) pow_mod((x), (y), MOD)
#define ADDX_MOD(x, y) addx_mod((x), (y), MOD)
#define ADDM_MOD(x, y) (x) = addx_mod((x), (y), MOD)
#define SUBX_MOD(x, y) subx_mod((x), (y), MOD)
#define SUBM_MOD(x, y) (x) = subx_mod((x), (y), MOD)
template <typename T> struct binary_plus {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return t1 + t2; }
T negate(const T &t) { return -t; }
};
template <typename T, T MOD> struct modular_plus {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return (t1 + t2) % MOD; }
T negate(const T &t) { return (MOD - t) % MOD; }
};
template <typename T, T MOD, typename TT = int64_t> struct modular_times {
T identity() const { return 1; }
T operator()(const T &t1, const T &t2) const { return mul_mod(t1, t2, MOD); }
T negate(const T &t) { return inv_mod(t, MOD); }
};
template <typename T> struct binary_xor {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return t1 ^ t2; }
T negate(const T &t) { return t; }
};
template <typename T> struct binary_max {
T identity() const { return std::numeric_limits<T>::min(); }
T operator()(const T &t1, const T &t2) const { return std::max(t1, t2); }
};
template <typename T> struct binary_min {
T identity() const { return std::numeric_limits<T>::max(); }
T operator()(const T &t1, const T &t2) const { return std::min(t1, t2); }
};
#define COMMON_CODE \
Op op; \
std::vector<T> vec; \
int size; /* size of last layer */ \
int offset; \
segtree(int n) { \
size = n; \
offset = ceil_pow2(n); \
vec.resize(size + offset + 1, \
op.identity()); /* ensure every leaf has sibling */ \
} \
T &operator[](int i) { return vec[offset + i]; }
template <typename T, typename Op = binary_plus<T>, bool flavour_one = true>
struct segtree;
template <typename T, typename Op> struct segtree<T, Op, true> {
COMMON_CODE
void rebuild() {
for (int i = (offset + size - 1) / 2; i > 0; --i)
vec[i] = op(vec[i + i], vec[i + i + 1]);
}
void increase_element(int p, const T &n) {
for (p += offset; p; p >>= 1)
vec[p] = op(n, vec[p]);
}
void update_element(int p, const T &n) {
p += offset;
vec[p] = n;
while (p >>= 1)
vec[p] = op(vec[p + p], vec[p + p + 1]);
}
T query_range(int s, int t) { return query_include(s, t - 1); }
T query_include(int s, int t) {
if (s > t)
return op.identity();
s += offset;
t += offset;
T left_acc = vec[s];
if (s == t)
return left_acc;
T right_acc = vec[t];
for (; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1)
left_acc = op(left_acc, vec[s ^ 1]);
if (t & 1)
right_acc = op(vec[t ^ 1], right_acc);
}
return op(left_acc, right_acc);
}
};
template <typename T, typename Op> struct segtree<T, Op, false> {
COMMON_CODE
T query_element(int p) {
T ret = op.identity();
for (p += offset; p; p >>= 1)
ret = op(vec[p], ret);
return ret;
}
void increase_range(int s, int t, const T &inc) {
return increase_include(s, t - 1, inc);
}
void increase_include(int s, int t, const T &inc) {
if (s > t)
return;
s += offset;
t += offset;
vec[s] = op(inc, vec[s]);
if (s == t)
return;
vec[t] = op(inc, vec[t]);
for (; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1)
vec[s ^ 1] = op(inc, vec[s ^ 1]);
if (t & 1)
vec[t ^ 1] = op(inc, vec[t ^ 1]);
}
return;
}
void flatten() {
for (int i = 1; i < offset; ++i) {
if (i + i < offset + size) {
vec[i + i] = op(vec[i], vec[i + i]);
vec[i + i + 1] =
op(vec[i], vec[i + i + 1]); // dummy sibling doesn't matter
} else
break;
vec[i] = op.identity();
}
}
};
#undef COMMON_CODE
template <int32_t MOD> struct mod_int {
mod_int() : v(0) {}
mod_int(int32_t in) : v(in) { fixup(); }
void fixup() {
if (v < 0 || v >= MOD) {
v = v % MOD;
if (v < 0)
v += MOD;
}
}
explicit operator int() const { return v; }
#define MINT_OP_GEN(op_str, op_eq_str, op_arith, op_eq_arith) \
mod_int &operator op_eq_str(const mod_int &that) { \
op_eq_arith(v, that.v); \
return *this; \
} \
mod_int operator op_str(const mod_int &that) const { \
return {op_arith(v, that.v)}; \
}
MINT_OP_GEN(+, +=, ADDX_MOD, ADDM_MOD)
MINT_OP_GEN(-, -=, SUBX_MOD, SUBM_MOD)
MINT_OP_GEN(*, *=, MUL_MOD, MULM_MOD)
MINT_OP_GEN(/, /=, DIV_MOD, DIVM_MOD)
#undef MINT_OP_GEN
int32_t v;
};
/* ===== SOLUTION START ===== */
constexpr int MOD = 998244353;
constexpr int maxn = 100005;
int dp[maxn];
int main() {
int N, K;
fin, N, K;
vector<pii> intv;
FOR0(i, K) {
int L, R;
fin, L, R;
intv.push_back({L, R});
}
typedef mod_int<MOD> INT;
segtree<INT> segtree(maxn);
segtree.increase_element(1, 1);
FOR(i, 2, N) {
INT sum = 0;
for (pii lr : intv) {
int L = i - lr.second;
int R = i - lr.first;
if (R < 1)
continue;
chmax(L, 1);
sum += segtree.query_include(L, R);
}
segtree.increase_element(i, sum);
}
fout, segtree.query_include(N, N).v, '\n';
return 0;
}
| /*
* if you are interested in the reference code here,
* see https://github.com/georeth/OJLIBS for more information
*
* Solution Author : Georeth Chow <georeth2010@gmail.com>
*/
#include <algorithm>
#include <cassert> // assert
#include <cfloat> // DBL_MIN DBL_MAX
#include <cinttypes> // PRId64 SCNd64
#include <climits> // INT_MIN LLONG_MIN
#include <cmath>
#include <cstdint> // int64_t
#include <cstdio>
#include <cstdlib> // malloc
#include <cstring> // memset
#include <ctime> // clock
#include <deque>
#include <iostream> // be careful.
#include <limits> // numeric_limits
#include <map>
#include <set>
#include <sstream>
#include <tuple> // pair, tuple
#include <vector>
using namespace std; // use as solution header. name polution is fine.
#ifdef LOCAL_JUDGE
#define pr_debug(...) fprintf(stderr, __VA_ARGS__)
#define pr_line() fprintf(stderr, "%s: %d\n", __FILE__, __LINE__)
#else
#define pr_debug(...)
#define pr_line()
#endif
template <typename T> bool chmax(T &m, const T &v) {
if (v > m)
return m = v, true;
return false;
}
template <typename T> bool chmin(T &m, const T &v) {
if (v < m)
return m = v, true;
return false;
}
template <typename T> bool chinc(T &v1, T &v2) {
if (v1 > v2)
return swap(v1, v2), true;
return false;
}
template <typename T> bool chdec(T &v1, T &v2) {
if (v1 < v2)
return swap(v1, v2), true;
return false;
}
#define ALL(x) begin(x), end(x)
#define FOR0(i, n) for (int i = 0, i##end = n; i < i##end; i++)
#define FOR1(i, n) for (int i = 1, i##end = n; i <= i##end; i++)
#define FOR(i, a, b) for (int i = a, i##end = b; i <= i##end; i++)
#define FOD0(i, n) for (int i = (n)-1; ~i; i--)
#define FOD1(i, n) for (int i = n; i; i--)
#define FOD(i, a, b) for (int i = a, i##end = b; i >= i##end; i--)
#define FORE(i, x) for (__typeof(x.end()) i = x.begin(); i != x.end(); ++i)
typedef int64_t ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vii;
typedef vector<vector<int>> vvi;
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#include <iostream>
namespace fio {
static const char eof = '\xff';
#define LL long long
#define I inline
#define OP operator
#define RT return *this;
#define ALL_INT(mcr) \
mcr(int) mcr(long) mcr(LL) mcr(unsigned) mcr(unsigned long) mcr(unsigned LL)
#define ALL_FLT(mcr) mcr(float) mcr(double) mcr(long double)
#define S2D \
x = 0; \
int c = P(); \
while ((c < '0' || c > '9') && c != '-') \
c = P(); \
bool h = false; \
if (c == '-') \
h = true, c = P()
#define R2D \
for (; c >= '0' && c <= '9'; c = P()) \
x = x * 10 + c - '0'
#define R2F \
if (c == '.') { \
double u = 0.1; \
for (c = P(); c >= '0' && c <= '9'; c = P(), u *= 0.1) \
x += u * (c - '0'); \
}
#define RD_INT(Int) \
I Fr &OP, (Int & x) { \
S2D; \
R2D; \
if (h) \
x = -x; \
RT \
}
#define RD_FLT(Flt) \
I Fr &OP, (Flt & x) { \
S2D; \
R2D; \
R2F; \
if (h) \
x = -x; \
RT \
}
struct Cg {
I char OP()() {
char c = (char)getchar();
if (c == eof)
valid = false;
return c;
};
bool valid = true;
};
struct Cp {
I void OP()(int x) { putchar(x); }
};
struct Ce {
I void OP()(int x) { putc(x, stderr); }
};
I bool IS(char x) { return x == ' ' || x == '\r' || x == '\n' || x == '\t'; }
template <class T> struct Fr {
T P;
ALL_INT(RD_INT) ALL_FLT(RD_FLT) I Fr &OP, (char &x) {
for (x = P(); IS(x);)
x = P();
RT
}
I Fr &OP, (char *s) {
for (*s = P(); IS(*s) && P.valid;)
*s = P();
for (; !IS(*s) && P.valid;)
*++s = P();
*s = 0;
RT
}
I Fr &OP, (string & s) {
s.clear();
char c = P();
for (; IS(c) && P.valid;)
c = P();
for (; !IS(c) && P.valid;)
s.push_back(c), c = P();
RT
}
I OP bool() { return P.valid; }
};
#define W4D \
if (x) { \
if (x < 0) \
P('-'), x = -x; \
int p = 0; \
while (x) \
B[p++] = x % 10 + '0', x /= 10; \
while (p--) \
P(B[p]); \
} else \
P('0')
#define WR_INT(Int) \
I Fw &OP, (Int x) { \
W4D; \
RT \
}
#define WR_FLT(Flt) \
I Fw &OP()(Flt g, int d) { \
if (d) { \
double t = 0.5; \
for (int i = d; i--;) \
t *= 0.1; \
if (g < 0) \
P('-'), g = -g; \
g += t; \
*this, (LL)(g); \
P('.'); \
g -= floor(g); \
while (d--) { \
g *= 10; \
int i = (int)floor(g); \
P(i + '0'); \
g -= i; \
} \
} else \
*this, (g > 0 ? (LL)(g + 0.5) : (LL)(g - 0.5)); \
RT \
}
template <class T> struct Fw {
T P;
char B[32];
ALL_INT(WR_INT) ALL_FLT(WR_FLT) I Fw &OP, (char x) {
P(x);
RT
}
typedef char_traits<char> CT;
typedef basic_ostream<char, CT> &OS;
typedef basic_istream<char, CT> &IS;
I Fw &OP, (OS & (*func)(OS)) {
if (func == static_cast<OS &(*)(OS)>(endl<char, CT>))
P('\n');
RT
}
I Fw &OP, (IS & (*func)(IS)) {
if (func == static_cast<IS &(*)(IS)>(ws<char, CT>))
P(' ');
RT
}
I Fw &OP, (const char *s) {
for (; *s; ++s)
P(*s);
RT
}
I Fw &OP, (const string &s) {
(*this), s.c_str();
RT
}
template <class C> I Fw &all(const C &v, char sep = ' ', char nl = '\n') {
auto it = v.begin();
for (int i = 0; i < (int)v.size(); ++i, ++it) {
if (i && sep)
P(sep);
(*this), *it;
}
if (nl)
P(nl);
RT
}
template <class U> I Fw &print(U x) {
(*this), x;
P('\n');
RT
}
template <class U, class... Us> I Fw &print(U x, Us... args) {
(*this), x;
P(' ');
print(args...);
RT
}
};
#undef LL
#undef I
#undef OP
#undef RT
#undef ALL_INT
#undef ALL_FLT
#undef S2D
#undef R2D
#undef R2F
#undef RD_INT
#undef RD_FLT
#undef W4D
#undef WR_INT
#undef WR_FLT
} // namespace fio
fio::Fr<fio::Cg> fin;
fio::Fw<fio::Cp> fout;
fio::Fw<fio::Ce> ferr;
#include <cstdint>
#include <utility>
static inline unsigned all_ones(unsigned x) {
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return x;
}
static inline int floor_log2(unsigned x) {
int ans = 0;
while (x >>= 1)
++ans;
return ans;
}
static inline bool is_pow2(unsigned x) { return !(x & (x - 1)); }
static inline unsigned next_pow2(unsigned x) { return all_ones(x) + 1; }
static inline unsigned ceil_pow2(unsigned x) {
if (is_pow2(x))
return x;
return next_pow2(x);
}
static inline int msb32(unsigned int x) {
x = all_ones(x);
return x & ~(x >> 1);
}
static inline int lsb32(unsigned int x) { return x & -x; }
#include <limits>
#include <type_traits>
#ifndef OJLIBS_USE_INT128
#define OJLIBS_USE_INT128 1
#endif
template <typename Int> Int gcd(Int a, Int b) {
while (a != 0) {
b %= a;
if (b == 0)
return a;
a %= b;
}
return b;
}
template <typename Int, typename RInt = Int> Int lcm(Int a, Int b) {
return a / gcd(a, b) * static_cast<RInt>(b);
}
template <typename Int, typename XInt>
Int extended_gcd(Int a, Int b, XInt &x, XInt &y) {
static_assert(std::numeric_limits<XInt>::is_signed, "x, y must be signed");
if (b == 0) {
x = 1;
y = 0;
return a;
}
/**
* r = a - b * q
* b * k1 + r * k2 = g
* => a * k2 + b * (k1 - q * k2)
* x = k2
* y = k1 - q * k2 = k1 - q * x
*/
Int g = extended_gcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
template <typename Int> Int mul_mod(Int a, Int b, Int m) {
typedef int64_t TInt;
static_assert(2 * std::numeric_limits<Int>::digits <=
std::numeric_limits<TInt>::digits,
"multiplication will overflow!");
TInt p = a;
p = (p * b) % m;
return (Int)p;
}
#if defined(__SIZEOF_INT128__) && OJLIBS_USE_INT128
template <> int64_t mul_mod<int64_t>(int64_t a, int64_t b, int64_t m) {
__int128_t p = __int128_t(a) * b;
return (int64_t)(p % m);
}
#else
template <> int64_t mul_mod<int64_t>(int64_t a, int64_t b, int64_t m) {
int64_t r = 0;
for (int i = 63; i >= 0; --i) {
r = (r + r) % m;
if ((b >> i) & 1)
r = (r + a) % m;
}
return r;
}
#endif
template <typename Int, typename PInt> Int pow_mod(Int a, PInt p, Int m) {
Int r;
a %= m;
for (r = 1; p; p >>= 1) {
if (p & 1)
r = mul_mod(r, a, m);
a = mul_mod(a, a, m);
}
return r;
}
template <typename Int, typename XInt = typename std::make_signed<Int>::type>
Int inv_mod(Int a, Int m) {
XInt x, y;
extended_gcd(a, m, x, y);
if (x < 0)
return x + m;
return x;
}
template <typename Int> Int addx_mod(Int u, Int v, Int m) {
Int r = u + v;
if (r >= m)
r -= m;
return r;
}
template <typename Int> Int subx_mod(Int u, Int v, Int m) {
Int r = u - v;
if (r < 0)
r += m;
return r;
}
template <typename Int> Int div_mod(Int u, Int v, Int m) {
Int g = gcd(v, m);
assert(u % g == 0);
Int mm = m / g;
return mul_mod(u / g, inv_mod(v / g, mm), mm);
}
template <typename Int> Int div_pos_r(Int a, Int b, Int &r) {
Int q = a / b;
r = a % b;
if (r < 0) {
if (b < 0)
q += 1, r -= b;
else
q -= 1, r += b;
}
return q;
}
template <typename Int> Int coprime_div(Int a, Int b) {
while (b != 1) {
while (a % b == 0)
a /= b;
b = gcd(a, b);
}
return a;
}
#define INV_MOD(x) inv_mod((x), MOD)
#define MUL_MOD(x, y) mul_mod((x), (y), MOD)
#define DIV_MOD(x, y) div_mod((x), (y), MOD)
#define MULM_MOD(x, y) (x) = mul_mod((x), (y), MOD)
#define DIVM_MOD(x, y) (x) = div_mod((x), (y), MOD)
#define POW_MOD(x, y) pow_mod((x), (y), MOD)
#define ADDX_MOD(x, y) addx_mod((x), (y), MOD)
#define ADDM_MOD(x, y) (x) = addx_mod((x), (y), MOD)
#define SUBX_MOD(x, y) subx_mod((x), (y), MOD)
#define SUBM_MOD(x, y) (x) = subx_mod((x), (y), MOD)
template <typename T> struct binary_plus {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return t1 + t2; }
T negate(const T &t) { return -t; }
};
template <typename T, T MOD> struct modular_plus {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return (t1 + t2) % MOD; }
T negate(const T &t) { return (MOD - t) % MOD; }
};
template <typename T, T MOD, typename TT = int64_t> struct modular_times {
T identity() const { return 1; }
T operator()(const T &t1, const T &t2) const { return mul_mod(t1, t2, MOD); }
T negate(const T &t) { return inv_mod(t, MOD); }
};
template <typename T> struct binary_xor {
T identity() const { return T(); }
T operator()(const T &t1, const T &t2) const { return t1 ^ t2; }
T negate(const T &t) { return t; }
};
template <typename T> struct binary_max {
T identity() const { return std::numeric_limits<T>::min(); }
T operator()(const T &t1, const T &t2) const { return std::max(t1, t2); }
};
template <typename T> struct binary_min {
T identity() const { return std::numeric_limits<T>::max(); }
T operator()(const T &t1, const T &t2) const { return std::min(t1, t2); }
};
#define COMMON_CODE \
Op op; \
std::vector<T> vec; \
int size; /* size of last layer */ \
int offset; \
segtree(int n) { \
size = n; \
offset = ceil_pow2(n); \
vec.resize(size + offset + 1, \
op.identity()); /* ensure every leaf has sibling */ \
} \
T &operator[](int i) { return vec[offset + i]; }
template <typename T, typename Op = binary_plus<T>, bool flavour_one = true>
struct segtree;
template <typename T, typename Op> struct segtree<T, Op, true> {
COMMON_CODE
void rebuild() {
for (int i = (offset + size - 1) / 2; i > 0; --i)
vec[i] = op(vec[i + i], vec[i + i + 1]);
}
void increase_element(int p, const T &n) {
for (p += offset; p; p >>= 1)
vec[p] = op(n, vec[p]);
}
void update_element(int p, const T &n) {
p += offset;
vec[p] = n;
while (p >>= 1)
vec[p] = op(vec[p + p], vec[p + p + 1]);
}
T query_range(int s, int t) { return query_include(s, t - 1); }
T query_include(int s, int t) {
if (s > t)
return op.identity();
s += offset;
t += offset;
T left_acc = vec[s];
if (s == t)
return left_acc;
T right_acc = vec[t];
for (; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1)
left_acc = op(left_acc, vec[s ^ 1]);
if (t & 1)
right_acc = op(vec[t ^ 1], right_acc);
}
return op(left_acc, right_acc);
}
};
template <typename T, typename Op> struct segtree<T, Op, false> {
COMMON_CODE
T query_element(int p) {
T ret = op.identity();
for (p += offset; p; p >>= 1)
ret = op(vec[p], ret);
return ret;
}
void increase_range(int s, int t, const T &inc) {
return increase_include(s, t - 1, inc);
}
void increase_include(int s, int t, const T &inc) {
if (s > t)
return;
s += offset;
t += offset;
vec[s] = op(inc, vec[s]);
if (s == t)
return;
vec[t] = op(inc, vec[t]);
for (; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1)
vec[s ^ 1] = op(inc, vec[s ^ 1]);
if (t & 1)
vec[t ^ 1] = op(inc, vec[t ^ 1]);
}
return;
}
void flatten() {
for (int i = 1; i < offset; ++i) {
if (i + i < offset + size) {
vec[i + i] = op(vec[i], vec[i + i]);
vec[i + i + 1] =
op(vec[i], vec[i + i + 1]); // dummy sibling doesn't matter
} else
break;
vec[i] = op.identity();
}
}
};
#undef COMMON_CODE
template <int32_t MOD> struct mod_int {
mod_int() : v(0) {}
mod_int(int32_t in) : v(in) { fixup(); }
void fixup() {
if (v < 0 || v >= MOD) {
v = v % MOD;
if (v < 0)
v += MOD;
}
}
explicit operator int() const { return v; }
#define MINT_OP_GEN(op_str, op_eq_str, op_arith, op_eq_arith) \
mod_int &operator op_eq_str(const mod_int &that) { \
op_eq_arith(v, that.v); \
return *this; \
} \
mod_int operator op_str(const mod_int &that) const { \
return {op_arith(v, that.v)}; \
}
MINT_OP_GEN(+, +=, ADDX_MOD, ADDM_MOD)
MINT_OP_GEN(-, -=, SUBX_MOD, SUBM_MOD)
MINT_OP_GEN(*, *=, MUL_MOD, MULM_MOD)
MINT_OP_GEN(/, /=, DIV_MOD, DIVM_MOD)
#undef MINT_OP_GEN
int32_t v;
};
/* ===== SOLUTION START ===== */
constexpr int MOD = 998244353;
constexpr int maxn = 200005;
int dp[maxn];
int main() {
int N, K;
fin, N, K;
vector<pii> intv;
FOR0(i, K) {
int L, R;
fin, L, R;
intv.push_back({L, R});
}
typedef mod_int<MOD> INT;
segtree<INT> segtree(maxn);
segtree.increase_element(1, 1);
FOR(i, 2, N) {
INT sum = 0;
for (pii lr : intv) {
int L = i - lr.second;
int R = i - lr.first;
if (R < 1)
continue;
chmax(L, 1);
sum += segtree.query_include(L, R);
}
segtree.increase_element(i, sum);
}
fout, segtree.query_include(N, N).v, '\n';
return 0;
}
| replace | 563 | 564 | 563 | 564 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ll long long
#define MOD 998244353
using namespace std;
;
int main() {
int N, K;
cin >> N >> K;
vector<int> L(K), R(K);
rep(i, 0, K) cin >> L[i] >> R[i];
vector<ll> dp(N + 1, 0);
dp[0] = 1;
dp[1] = -1;
rep(i, 0, N) {
dp[i] = ((dp[i] % MOD) + MOD) % MOD;
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
rep(j, 0, K) {
dp[i + L[j]] += dp[i];
dp[i + R[j] + 1] -= dp[i];
}
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ll long long
#define MOD 998244353
using namespace std;
;
int main() {
int N, K;
cin >> N >> K;
vector<int> L(K), R(K);
rep(i, 0, K) cin >> L[i] >> R[i];
vector<ll> dp(N + 1, 0);
dp[0] = 1;
dp[1] = -1;
rep(i, 0, N) {
dp[i] = ((dp[i] % MOD) + MOD) % MOD;
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
rep(j, 0, K) {
if (i + L[j] < N)
dp[i + L[j]] += dp[i];
if (i + R[j] + 1 < N)
dp[i + R[j] + 1] -= dp[i];
}
}
cout << dp[N - 1] << endl;
} | replace | 19 | 21 | 19 | 23 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
#define _GLIBCXX_DEBUG
ll mod = 998244353;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> l(k), r(k);
rep(i, k) cin >> l[i] >> r[i];
vector<ll> dp(200010);
vector<ll> dpsum(20010);
dp[1] = 1;
dpsum[1] = 1;
for (int i = 2; i <= n; i++) {
rep(j, k) {
int li = i - r[j];
int ri = i - l[j];
if (ri < 0)
continue;
li = max(li, 1);
dp[i] += dpsum[ri] - dpsum[li - 1];
dp[i] += mod;
dp[i] %= mod;
}
dpsum[i] += dpsum[i - 1] + dp[i];
dpsum[i] %= mod;
// cout << dp[i] << " " << dpsum[i] << endl;
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
#define _GLIBCXX_DEBUG
ll mod = 998244353;
int main() {
ll n, k;
cin >> n >> k;
vector<ll> l(k), r(k);
rep(i, k) cin >> l[i] >> r[i];
vector<ll> dp(n + 1);
vector<ll> dpsum(n + 1);
dp[1] = 1;
dpsum[1] = 1;
for (int i = 2; i <= n; i++) {
rep(j, k) {
int li = i - r[j];
int ri = i - l[j];
if (ri < 0)
continue;
li = max(li, 1);
dp[i] += dpsum[ri] - dpsum[li - 1];
dp[i] += mod;
dp[i] %= mod;
}
dpsum[i] += dpsum[i - 1] + dp[i];
dpsum[i] %= mod;
// cout << dp[i] << " " << dpsum[i] << endl;
}
cout << dp[n] << endl;
}
| replace | 13 | 15 | 13 | 15 | 0 | |
p02549 | C++ | Runtime Error | // بساملہ ہیر رحمن نیر رحیم
//---------------------------//
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <bitset>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #define PBDS tree<long long int,null_type,less<long long int>,
// rb_tree_tag,tree_order_statistics_node_update> using namespace __gnu_pbds;
#define arrsize 100001
#define dpsize 1001
#define vpp vector<PP>
#define vll vector<ll>
#define vcc vector<char>
#define endl "\n"
#define vbb vector<bool>
#define w(t) while (t--)
#define PP pair<ll, ll>
#define test(x) \
ll t; \
cin >> t; \
w(t) x()
#define __lb lower_bound
#define __ub upper_bound
#define szs(x) x.length()
#define szv(x) x.size()
#define INF 1999999996000000010
#define ll long long int
#define takeINP(arr, n) \
for (long long int i = 0; i < n; i++) \
cin >> arr[i];
#define f(i, s, e) for (long long int i = s; i < e; i++)
#define cf(i, s, e) for (long long int i = s; i <= e; i++)
#define rf(i, e, s) for (long long int i = e - 1; i >= s; i--)
#define mem(arr) memset(arr, 0, sizeof(arr));
#define MOD 998244353
#define rsz(x, n) x.resize(n)
#define rsr(x, n) x.reserve(n)
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define print(arr, s, e) \
f(i, s, e) cout << arr[i] << " "; \
cout << endl;
#define all(v) v.begin(), v.end()
#define ff first
#define ss second
#define vll vector<ll>
#define triplet pair<ll, pair<ll, ll>>
#define MITR(a, b) map<a, b>::reverse_iterator
using namespace std;
using namespace chrono;
///---------------Functions---------------------///
ll advceil(ll num, ll den) {
return (num % den == 0 ? num / den : num / den + 1);
}
ll lstbt(ll val) {
ll msk = val & (val - 1);
return log2(val ^ msk);
}
ll modexpo(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = (res % MOD * a % MOD) % MOD;
a = (a % MOD * a % MOD);
b /= 2;
}
return res;
}
ll expo(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = (res * a);
a = (a * a);
b /= 2;
}
return res;
}
ll gcd(ll a, ll b) { return a == 0 ? b : gcd(b % a, a); }
vll CALCfactor(ll n) {
vll factor(n + 2, 0);
for (ll i = 4; i <= n; i += 2)
factor[i] = 2;
for (ll j = 3; j <= n; j += 2) {
if (factor[j])
continue;
for (ll i = 2 * j; i <= n; i += j)
factor[i] = j;
}
return factor;
}
vll CALCprimeNUM(ll n) {
vll factor = CALCfactor(n);
vll primeNUM;
primeNUM.reserve(n + 2);
cf(i, 2, n) if (!factor[i]) primeNUM.pb(i);
return primeNUM;
}
vll CALCprimeFACTOR(ll n) {
vll factor = CALCfactor(n);
vll ans;
while (factor[n] != 0) {
ans.pb(factor[n]);
n /= factor[n];
}
ans.pb(n);
return ans;
}
vll unique(vll x) {
sort(all(x));
set<ll> s;
vll ans;
ans.reserve(szv(x));
for (auto elem : x)
s.insert(elem);
for (auto elem : s)
ans.pb(elem);
return ans;
}
vll ZALGO(string s, string pat) {
ll lens = szs(pat);
pat += char(36);
pat += s;
s = pat;
vll pref(szs(s) + 1, 0);
pref[0] = szs(s);
ll spt = -1;
ll ept = -1;
ll processCnt = 0;
for (ll i = 1; i < szs(s); i++) {
bool isdone = false;
if (i <= ept and i >= spt) {
if (pref[i - spt] + i <= ept)
pref[i] = pref[i - spt], isdone = true;
processCnt++;
}
if (!isdone) {
ll ptr = i;
ll lo = 0;
while (s[lo] == s[ptr])
ptr++, lo++, processCnt++;
if (ept < ptr - 1) {
spt = i;
ept = ptr - 1;
}
pref[i] = lo;
}
}
vll ans;
ans.reserve(szs(s) - lens);
for (ll i = lens + 1; i < szs(s); i++)
ans.pb(pref[i]);
return ans;
}
void spclSort(vector<pair<pair<ll, ll>, ll>> &v) {
ll n = szv(v);
{
vll cnt(n);
for (auto elem : v) {
cnt[elem.ff.ss]++;
}
vector<pair<pair<ll, ll>, ll>> a_new(n);
vll pos(szv(cnt));
pos[0] = 0;
for (ll i = 1; i < szv(cnt); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.ff.ss]] = elem;
pos[elem.ff.ss]++;
}
v = a_new;
}
{
vll cnt(n, 0);
for (auto elem : v) {
cnt[elem.ff.ff]++;
}
vector<pair<pair<ll, ll>, ll>> a_new(n);
vll pos(szv(cnt));
pos[0] = 0;
for (ll i = 1; i < szv(cnt); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.ff.ff]] = elem;
pos[elem.ff.ff]++;
}
v = a_new;
}
}
pair<vector<vll>, vector<vll>> getOrdering(string s) {
s += char(36);
vector<vll> dp;
dp.reserve(log2(szs(s)) + 3);
vector<vll> dp2;
dp2.reserve(log2(szs(s)) + 3);
vll ordering(szs(s)), eqClass(szs(s));
{
vector<pair<char, ll>> temp(szs(s));
f(i, 0, szs(s)) temp[i] = {s[i], i};
sort(all(temp));
f(i, 0, szv(temp)) ordering[temp[i].ss] = i;
eqClass[temp[0].ss] = 0;
f(i, 1, szv(temp)) {
if (temp[i].ff != temp[i - 1].ff)
eqClass[temp[i].ss] = eqClass[temp[i - 1].ss] + 1;
else
eqClass[temp[i].ss] = eqClass[temp[i - 1].ss];
}
dp.pb(ordering);
dp2.pb(eqClass);
}
ll k = 1;
while ((1 << (k - 1)) < szs(s)) {
vector<pair<pair<ll, ll>, ll>> arr(szs(s));
for (ll i = 0; i < szs(s); i++) {
arr[i] = {{eqClass[i], eqClass[(i + (1 << (k - 1))) % szs(s)]}, i};
}
spclSort(arr);
f(i, 0, szs(s)) ordering[arr[i].ss] = i;
eqClass[arr[0].ss] = 0;
f(i, 1, szv(s)) {
if (arr[i].ff != arr[i - 1].ff)
eqClass[arr[i].ss] = eqClass[arr[i - 1].ss] + 1;
else
eqClass[arr[i].ss] = eqClass[arr[i - 1].ss];
}
dp.pb(ordering);
dp2.pb(eqClass);
k++;
}
return {dp, dp2};
}
vll sortOrdering(vector<vll> dp) {
vll arr = dp[szv(dp) - 1];
vll ans(szv(arr));
ll cnt = 0;
for (auto elem : arr) {
ans[elem] = cnt;
cnt++;
}
return ans;
}
vll getLps(string pat) {
ll i = 1;
ll j = 0;
vll lps(szs(pat), 0);
lps[0] = 0;
while (i < szs(pat)) {
if (pat[i] == pat[j])
lps[i] = j + 1, i++, j++;
else if (j == 0)
lps[i] = 0, i++;
else
j = lps[j - 1];
}
return lps;
}
///---------x------------x----------x-----------///
ll BIT[arrsize] = {};
ll n;
void update(ll idx, ll val) {
for (ll i = idx; i <= n; i += (i & (-i)))
BIT[i] += val, BIT[i] %= MOD;
}
ll query(ll idx) {
ll sum = 0;
for (ll i = idx; i > 0; i -= (i & (-i)))
sum += BIT[i], sum %= MOD;
return sum;
}
ll get(ll l, ll r) {
if (l > r or l < 1 or r > n)
return 0;
return (query(r) - query(l - 1) + MOD) % MOD;
}
void solve() {
ll k;
cin >> n >> k;
vpp arr(k);
f(i, 0, k) cin >> arr[i].ff >> arr[i].ss;
update(1, 1);
cf(i, 2, n) {
ll cnt = 0;
f(j, 0, k) {
ll lo = i - arr[j].ff;
ll hi = i - arr[j].ss;
if (lo < 1)
continue;
if (hi < 1)
hi = i - min(arr[j].ss, i - 1);
cnt += (get(hi, lo));
cnt %= MOD;
}
update(i, cnt);
// cout<<"#"<<i<<" "<<cnt<<endl;
}
cout << get(n, n) << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
// test(solve);
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
#ifndef ONLINE_JUDGE
cerr << "Time: " << duration.count() / 1000.0 << endl;
cout << duration.count() / 1000.0 << endl;
#endif
} | // بساملہ ہیر رحمن نیر رحیم
//---------------------------//
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <bitset>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #define PBDS tree<long long int,null_type,less<long long int>,
// rb_tree_tag,tree_order_statistics_node_update> using namespace __gnu_pbds;
#define arrsize 2000001
#define dpsize 1001
#define vpp vector<PP>
#define vll vector<ll>
#define vcc vector<char>
#define endl "\n"
#define vbb vector<bool>
#define w(t) while (t--)
#define PP pair<ll, ll>
#define test(x) \
ll t; \
cin >> t; \
w(t) x()
#define __lb lower_bound
#define __ub upper_bound
#define szs(x) x.length()
#define szv(x) x.size()
#define INF 1999999996000000010
#define ll long long int
#define takeINP(arr, n) \
for (long long int i = 0; i < n; i++) \
cin >> arr[i];
#define f(i, s, e) for (long long int i = s; i < e; i++)
#define cf(i, s, e) for (long long int i = s; i <= e; i++)
#define rf(i, e, s) for (long long int i = e - 1; i >= s; i--)
#define mem(arr) memset(arr, 0, sizeof(arr));
#define MOD 998244353
#define rsz(x, n) x.resize(n)
#define rsr(x, n) x.reserve(n)
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define print(arr, s, e) \
f(i, s, e) cout << arr[i] << " "; \
cout << endl;
#define all(v) v.begin(), v.end()
#define ff first
#define ss second
#define vll vector<ll>
#define triplet pair<ll, pair<ll, ll>>
#define MITR(a, b) map<a, b>::reverse_iterator
using namespace std;
using namespace chrono;
///---------------Functions---------------------///
ll advceil(ll num, ll den) {
return (num % den == 0 ? num / den : num / den + 1);
}
ll lstbt(ll val) {
ll msk = val & (val - 1);
return log2(val ^ msk);
}
ll modexpo(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = (res % MOD * a % MOD) % MOD;
a = (a % MOD * a % MOD);
b /= 2;
}
return res;
}
ll expo(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = (res * a);
a = (a * a);
b /= 2;
}
return res;
}
ll gcd(ll a, ll b) { return a == 0 ? b : gcd(b % a, a); }
vll CALCfactor(ll n) {
vll factor(n + 2, 0);
for (ll i = 4; i <= n; i += 2)
factor[i] = 2;
for (ll j = 3; j <= n; j += 2) {
if (factor[j])
continue;
for (ll i = 2 * j; i <= n; i += j)
factor[i] = j;
}
return factor;
}
vll CALCprimeNUM(ll n) {
vll factor = CALCfactor(n);
vll primeNUM;
primeNUM.reserve(n + 2);
cf(i, 2, n) if (!factor[i]) primeNUM.pb(i);
return primeNUM;
}
vll CALCprimeFACTOR(ll n) {
vll factor = CALCfactor(n);
vll ans;
while (factor[n] != 0) {
ans.pb(factor[n]);
n /= factor[n];
}
ans.pb(n);
return ans;
}
vll unique(vll x) {
sort(all(x));
set<ll> s;
vll ans;
ans.reserve(szv(x));
for (auto elem : x)
s.insert(elem);
for (auto elem : s)
ans.pb(elem);
return ans;
}
vll ZALGO(string s, string pat) {
ll lens = szs(pat);
pat += char(36);
pat += s;
s = pat;
vll pref(szs(s) + 1, 0);
pref[0] = szs(s);
ll spt = -1;
ll ept = -1;
ll processCnt = 0;
for (ll i = 1; i < szs(s); i++) {
bool isdone = false;
if (i <= ept and i >= spt) {
if (pref[i - spt] + i <= ept)
pref[i] = pref[i - spt], isdone = true;
processCnt++;
}
if (!isdone) {
ll ptr = i;
ll lo = 0;
while (s[lo] == s[ptr])
ptr++, lo++, processCnt++;
if (ept < ptr - 1) {
spt = i;
ept = ptr - 1;
}
pref[i] = lo;
}
}
vll ans;
ans.reserve(szs(s) - lens);
for (ll i = lens + 1; i < szs(s); i++)
ans.pb(pref[i]);
return ans;
}
void spclSort(vector<pair<pair<ll, ll>, ll>> &v) {
ll n = szv(v);
{
vll cnt(n);
for (auto elem : v) {
cnt[elem.ff.ss]++;
}
vector<pair<pair<ll, ll>, ll>> a_new(n);
vll pos(szv(cnt));
pos[0] = 0;
for (ll i = 1; i < szv(cnt); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.ff.ss]] = elem;
pos[elem.ff.ss]++;
}
v = a_new;
}
{
vll cnt(n, 0);
for (auto elem : v) {
cnt[elem.ff.ff]++;
}
vector<pair<pair<ll, ll>, ll>> a_new(n);
vll pos(szv(cnt));
pos[0] = 0;
for (ll i = 1; i < szv(cnt); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.ff.ff]] = elem;
pos[elem.ff.ff]++;
}
v = a_new;
}
}
pair<vector<vll>, vector<vll>> getOrdering(string s) {
s += char(36);
vector<vll> dp;
dp.reserve(log2(szs(s)) + 3);
vector<vll> dp2;
dp2.reserve(log2(szs(s)) + 3);
vll ordering(szs(s)), eqClass(szs(s));
{
vector<pair<char, ll>> temp(szs(s));
f(i, 0, szs(s)) temp[i] = {s[i], i};
sort(all(temp));
f(i, 0, szv(temp)) ordering[temp[i].ss] = i;
eqClass[temp[0].ss] = 0;
f(i, 1, szv(temp)) {
if (temp[i].ff != temp[i - 1].ff)
eqClass[temp[i].ss] = eqClass[temp[i - 1].ss] + 1;
else
eqClass[temp[i].ss] = eqClass[temp[i - 1].ss];
}
dp.pb(ordering);
dp2.pb(eqClass);
}
ll k = 1;
while ((1 << (k - 1)) < szs(s)) {
vector<pair<pair<ll, ll>, ll>> arr(szs(s));
for (ll i = 0; i < szs(s); i++) {
arr[i] = {{eqClass[i], eqClass[(i + (1 << (k - 1))) % szs(s)]}, i};
}
spclSort(arr);
f(i, 0, szs(s)) ordering[arr[i].ss] = i;
eqClass[arr[0].ss] = 0;
f(i, 1, szv(s)) {
if (arr[i].ff != arr[i - 1].ff)
eqClass[arr[i].ss] = eqClass[arr[i - 1].ss] + 1;
else
eqClass[arr[i].ss] = eqClass[arr[i - 1].ss];
}
dp.pb(ordering);
dp2.pb(eqClass);
k++;
}
return {dp, dp2};
}
vll sortOrdering(vector<vll> dp) {
vll arr = dp[szv(dp) - 1];
vll ans(szv(arr));
ll cnt = 0;
for (auto elem : arr) {
ans[elem] = cnt;
cnt++;
}
return ans;
}
vll getLps(string pat) {
ll i = 1;
ll j = 0;
vll lps(szs(pat), 0);
lps[0] = 0;
while (i < szs(pat)) {
if (pat[i] == pat[j])
lps[i] = j + 1, i++, j++;
else if (j == 0)
lps[i] = 0, i++;
else
j = lps[j - 1];
}
return lps;
}
///---------x------------x----------x-----------///
ll BIT[arrsize] = {};
ll n;
void update(ll idx, ll val) {
for (ll i = idx; i <= n; i += (i & (-i)))
BIT[i] += val, BIT[i] %= MOD;
}
ll query(ll idx) {
ll sum = 0;
for (ll i = idx; i > 0; i -= (i & (-i)))
sum += BIT[i], sum %= MOD;
return sum;
}
ll get(ll l, ll r) {
if (l > r or l < 1 or r > n)
return 0;
return (query(r) - query(l - 1) + MOD) % MOD;
}
void solve() {
ll k;
cin >> n >> k;
vpp arr(k);
f(i, 0, k) cin >> arr[i].ff >> arr[i].ss;
update(1, 1);
cf(i, 2, n) {
ll cnt = 0;
f(j, 0, k) {
ll lo = i - arr[j].ff;
ll hi = i - arr[j].ss;
if (lo < 1)
continue;
if (hi < 1)
hi = i - min(arr[j].ss, i - 1);
cnt += (get(hi, lo));
cnt %= MOD;
}
update(i, cnt);
// cout<<"#"<<i<<" "<<cnt<<endl;
}
cout << get(n, n) << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
// test(solve);
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
#ifndef ONLINE_JUDGE
cerr << "Time: " << duration.count() / 1000.0 << endl;
cout << duration.count() / 1000.0 << endl;
#endif
} | replace | 26 | 27 | 26 | 27 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02549 | C++ | Time Limit Exceeded | #include <cstring>
#include <iostream>
#include <stdio.h>
#define int long long
using namespace std;
const int N = 5e5, M = 15, MOD = 998244353;
int a[N];
int f[N];
int x[M], y[M];
int n, m;
int qzh[N];
inline int modbez(int a, int b) {
register int res = a % b;
if (res < 0)
return res + b;
else
return res;
}
void DP() {
f[n] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
f[i] = modbez(f[i] + qzh[i + x[j]] - qzh[i + y[j] + 1], MOD);
}
qzh[i] = modbez(qzh[i + 1] + f[i], MOD);
}
cout << f[1] % MOD << endl;
}
void common_DP() {
f[n] = 1;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++)
for (int k = x[j]; k <= y[j]; k++) {
if (i + k <= n) {
f[i] = (f[i] + f[i + k]) % MOD;
}
}
cout << f[1] << endl;
}
signed main() {
memset(f, 0, sizeof(f));
memset(a, 0, sizeof(a));
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
}
if (n > 1e4)
common_DP();
else
DP();
}
| #include <cstring>
#include <iostream>
#include <stdio.h>
#define int long long
using namespace std;
const int N = 5e5, M = 15, MOD = 998244353;
int a[N];
int f[N];
int x[M], y[M];
int n, m;
int qzh[N];
inline int modbez(int a, int b) {
register int res = a % b;
if (res < 0)
return res + b;
else
return res;
}
void DP() {
f[n] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
f[i] = modbez(f[i] + qzh[i + x[j]] - qzh[i + y[j] + 1], MOD);
}
qzh[i] = modbez(qzh[i + 1] + f[i], MOD);
}
cout << f[1] % MOD << endl;
}
void common_DP() {
f[n] = 1;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++)
for (int k = x[j]; k <= y[j]; k++) {
if (i + k <= n) {
f[i] = (f[i] + f[i + k]) % MOD;
}
}
cout << f[1] << endl;
}
signed main() {
memset(f, 0, sizeof(f));
memset(a, 0, sizeof(a));
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
}
if (n < 1e4)
common_DP();
else
DP();
}
| replace | 46 | 47 | 46 | 47 | TLE | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long int
#define N int(1e5 + 10)
#define mod 998244353
using namespace std;
ll dp[N], pre[N];
int l[N], r[N], n, k;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cin >> n >> k;
for (int i = 1; i <= k; i++)
cin >> l[i] >> r[i];
pre[0] = dp[0] = 0ll;
pre[1] = dp[1] = 1ll;
for (int i = 2; i <= n; i++) {
dp[i] = 0ll;
for (int j = 1, u, v; j <= k; j++) {
if (l[j] >= i)
continue;
u = l[j];
v = min(i - 1, r[j]);
dp[i] = ((dp[i] + pre[i - u]) % mod - pre[i - v - 1]) % mod;
if (dp[i] < 0ll)
dp[i] += mod;
}
pre[i] = (pre[i - 1] + dp[i]) % mod;
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define N int(2e5 + 10)
#define mod 998244353
using namespace std;
ll dp[N], pre[N];
int l[N], r[N], n, k;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cin >> n >> k;
for (int i = 1; i <= k; i++)
cin >> l[i] >> r[i];
pre[0] = dp[0] = 0ll;
pre[1] = dp[1] = 1ll;
for (int i = 2; i <= n; i++) {
dp[i] = 0ll;
for (int j = 1, u, v; j <= k; j++) {
if (l[j] >= i)
continue;
u = l[j];
v = min(i - 1, r[j]);
dp[i] = ((dp[i] + pre[i - u]) % mod - pre[i - v - 1]) % mod;
if (dp[i] < 0ll)
dp[i] += mod;
}
pre[i] = (pre[i - 1] + dp[i]) % mod;
}
cout << dp[n] << endl;
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define d(x) cerr << #x ":" << x << endl;
#define dd(x, y) cerr << "(" #x "," #y "):(" << x << "," << y << ")" << endl
#define rep(i, n) for (int i = (int)(0); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define dump(v) \
cerr << #v ":[ "; \
for (auto macro_vi : v) { \
cerr << macro_vi << " "; \
} \
cerr << "]" << endl;
#define ddump(v) \
cerr << #v ":" << endl; \
for (auto macro_row : v) { \
cerr << "["; \
for (auto macro__vi : macro_row) { \
cerr << macro__vi << " "; \
} \
cerr << "]" << endl; \
}
using lint = long long;
const int INF = 1e9;
const lint LINF = 1e18;
const double EPS = 1e-10;
const int mod = 998244353;
struct mint {
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(long long 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 {
mint res(*this);
return res /= a;
}
};
int main() {
lint N, K;
cin >> N >> K;
vector<lint> L(K), R(K);
rep(i, K) { cin >> L[i] >> R[i]; }
vector<mint> cnt(N + 3, 0);
cnt[1] = 1;
for (int i = 1; i < N + 1; i++) {
for (int k = 0; k < K; k++) {
int left = i + L[k], right = min(N + 1, i + R[k]);
cnt[left] += cnt[i];
cnt[right + 1] -= cnt[i];
}
cnt[i + 2] += cnt[i + 1];
}
cout << cnt[N].x << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define d(x) cerr << #x ":" << x << endl;
#define dd(x, y) cerr << "(" #x "," #y "):(" << x << "," << y << ")" << endl
#define rep(i, n) for (int i = (int)(0); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define dump(v) \
cerr << #v ":[ "; \
for (auto macro_vi : v) { \
cerr << macro_vi << " "; \
} \
cerr << "]" << endl;
#define ddump(v) \
cerr << #v ":" << endl; \
for (auto macro_row : v) { \
cerr << "["; \
for (auto macro__vi : macro_row) { \
cerr << macro__vi << " "; \
} \
cerr << "]" << endl; \
}
using lint = long long;
const int INF = 1e9;
const lint LINF = 1e18;
const double EPS = 1e-10;
const int mod = 998244353;
struct mint {
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(long long 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 {
mint res(*this);
return res /= a;
}
};
int main() {
lint N, K;
cin >> N >> K;
vector<lint> L(K), R(K);
rep(i, K) { cin >> L[i] >> R[i]; }
vector<mint> cnt(N + 3, 0);
cnt[1] = 1;
for (int i = 1; i < N + 1; i++) {
for (int k = 0; k < K; k++) {
int left = i + L[k], right = min(N + 1, i + R[k]);
if (N < left) {
continue;
}
cnt[left] += cnt[i];
cnt[right + 1] -= cnt[i];
}
cnt[i + 2] += cnt[i + 1];
}
cout << cnt[N].x << endl;
return 0;
} | insert | 89 | 89 | 89 | 92 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-12;
static const double PI = acos(-1.0);
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl
#else
#define dbg(x) true
#endif
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
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, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint dp[200005];
void solve(long long N, long long K, std::vector<long long> L,
std::vector<long long> R) {
REP(i, K) {
dp[L[i]] += 1;
dp[R[i] + 1] -= 1;
}
mint cur = 0;
FOR(j, 1, N) {
cur += dp[j];
REP(i, K) {
dp[L[i] + j] += cur;
dp[R[i] + 1 + j] -= cur;
}
}
cout << cur << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
std::vector<long long> L(K);
std::vector<long long> R(K);
for (int i = 0; i < K; i++) {
scanf("%lld", &L[i]);
scanf("%lld", &R[i]);
}
solve(N, K, std::move(L), std::move(R));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-12;
static const double PI = acos(-1.0);
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl
#else
#define dbg(x) true
#endif
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
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, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint dp[200005];
void solve(long long N, long long K, std::vector<long long> L,
std::vector<long long> R) {
REP(i, K) {
dp[L[i]] += 1;
dp[R[i] + 1] -= 1;
}
mint cur = 0;
FOR(j, 1, N) {
cur += dp[j];
REP(i, K) {
if (L[i] + j < 200005)
dp[L[i] + j] += cur;
if (R[i] + 1 + j < 200005)
dp[R[i] + 1 + j] -= cur;
}
}
cout << cur << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
std::vector<long long> L(K);
std::vector<long long> R(K);
for (int i = 0; i < K; i++) {
scanf("%lld", &L[i]);
scanf("%lld", &R[i]);
}
solve(N, K, std::move(L), std::move(R));
return 0;
}
| replace | 77 | 79 | 77 | 81 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (ll i = from; i < (to); ++i)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using ld = long double;
using vin = vector<int>;
using vvin = vector<vin>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vst = vector<string>;
using P = pair<ll, ll>;
const int inf = 998244353;
const ll INF = 9e18;
const long double PI = acos(-1.0);
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[220000];
int main() {
cout << fixed << setprecision(20);
ll n, k;
cin >> n >> k;
vll l(k), r(k);
rep(i, 0, k) cin >> l[i] >> r[i];
// dp,imos
dp[1] = 1;
dp[2] = -1;
rep(i, 1, n + 1) {
dp[i] = (dp[i] + dp[i - 1]) % inf;
rep(j, 0, k) {
dp[i + l[j]] = (dp[i + l[j]] + dp[i]) % inf;
dp[i + r[j] + 1] = (dp[i + r[j] + 1] - dp[i]) % inf;
}
}
if (dp[n] < 0)
dp[n] += inf;
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (ll i = from; i < (to); ++i)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using ld = long double;
using vin = vector<int>;
using vvin = vector<vin>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vst = vector<string>;
using P = pair<ll, ll>;
const int inf = 998244353;
const ll INF = 9e18;
const long double PI = acos(-1.0);
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[220000];
int main() {
cout << fixed << setprecision(20);
ll n, k;
cin >> n >> k;
vll l(k), r(k);
rep(i, 0, k) cin >> l[i] >> r[i];
// dp,imos
dp[1] = 1;
dp[2] = -1;
rep(i, 1, n + 1) {
dp[i] = (dp[i] + dp[i - 1]) % inf;
rep(j, 0, k) {
if (i + l[j] < n + 2)
dp[i + l[j]] = (dp[i + l[j]] + dp[i]) % inf;
if (i + r[j] + 1 < n + 2)
dp[i + r[j] + 1] = (dp[i + r[j] + 1] - dp[i]) % inf;
}
}
if (dp[n] < 0)
dp[n] += inf;
cout << dp[n] << endl;
} | replace | 62 | 64 | 62 | 66 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n - 1); i >= 0; i--)
#define all(x) x.begin(), x.end()
#define br cout << "\n";
using namespace std;
const long long INF = 1e10;
const long long MOD = 1e9 + 7;
using Graph = vector<vector<ll>>;
using pll = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll ceilll(ll a, ll b) { return (a + b - 1) / b; } // if(a%b == 0) (a/b) + 1
ll get_digit(ll a) {
ll digit = 0;
while (a != 0) {
a /= 10;
digit++;
}
return digit;
} // a != 0
template <typename T> void vecdbg(vector<T> &v) {
rep(i, v.size()) { cout << v[i] << " "; }
br;
}
template <typename T> void vecvecdbg(vector<vector<T>> &v) {
rep(i, v.size()) {
rep(j, v[i].size()) { cout << v[i][j] << " "; }
br;
}
}
// 0 false, 1 true
// string number to int : -48
// a to A : -32
// ceil(a) 1.2->2.0
// c++17 g++ -std=c++17 a.cpp
// global vector -> 0 initialization
// https://atcoder.jp/contests/abc172/submissions/14765570
// 20200724
template <long long mod> struct ModInt {
long long x;
ModInt() : x(0) {}
ModInt(long long x) : x(x >= 0 ? x % mod : (mod - -x % 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 = (long long)x * p.x % mod;
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt &operator^=(long long p) {
ModInt res = 1;
for (; p; p >>= 1) {
if (p & 1)
res *= *this;
*this *= *this;
}
return *this = res;
}
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; }
ModInt operator^(long long 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; }
explicit operator long long() const { return x; }
ModInt &operator=(const long long p) {
x = p;
return *this;
}
ModInt inverse() const {
long long a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
friend std::ostream &operator<<(std::ostream &stream, const ModInt<mod> &p) {
return stream << p.x;
}
friend std::istream &operator>>(std::istream &stream, ModInt<mod> &a) {
long long x;
stream >> x;
a = ModInt<mod>(x);
return stream;
}
};
template <long long mod> struct MComb {
using mint = ModInt<mod>;
std::vector<mint> fact;
std::vector<mint> inv;
MComb(long long n) { // O(n + log(mod))
fact = std::vector<mint>(n + 1, 1);
for (long long i = 1; i <= n; i++)
fact[i] = fact[i - 1] * mint(i);
inv.resize(n + 1);
inv[n] = fact[n] ^ (mod - 2);
for (long long i = n; i--;)
inv[i] = inv[i + 1] * mint(i + 1);
}
mint ncr(long long n, long r) { return fact[n] * inv[r] * inv[n - r]; }
mint npr(long n, long r) { return fact[n] * inv[n - r]; }
mint nhr(long n, long r) {
assert(n + r - 1 < (long long)fact.size());
return ncr(n + r - 1, r);
}
};
template <long long mod> struct MPow {
using mint = ModInt<mod>;
mint modpow(mint a, long long n) {
mint res = 1;
while (n > 0) {
if (n & 1) {
res = res * a;
}
a = a * a;
n >>= 1;
}
return res;
}
};
typedef ModInt<998244353> mint;
MComb<998244353> com(510000);
MPow<998244353> mpow;
mint dp[200010];
mint dp_sum[200010];
int main() {
std::cout << std::fixed << std::setprecision(15);
ll n, k;
cin >> n >> k;
vector<ll> vec;
vector<pair<ll, ll>> pv;
rep(i, k) {
ll l, r;
cin >> l >> r;
pv.emplace_back(l, r);
/*
for(ll j = l; j <= r; j++){
vec.push_back(j);
}
*/
}
sort(all(pv));
rep(i, pv.size()) {
for (ll j = pv[i].first; j <= pv[i].second; j++) {
vec.push_back(j);
}
}
// sort(all(vec));
/*
rep(i, vec.size()){
cout << vec[i] << " ";
}
br;
*/
dp[1] = 1;
dp_sum[1] = 1;
for (ll i = 1; i < n + 1; i++) {
for (ll j = 0; j < pv.size(); j++) {
if (i - pv[j].first < 0)
continue;
if (i - pv[i].second < 1) {
dp[i] += (dp_sum[i - pv[j].first] - dp_sum[0]);
} else {
dp[i] += (dp_sum[i - pv[j].first] - dp_sum[i - pv[j].second - 1]);
}
}
/*
for(ll j = 0; j < vec.size(); j++){
if(i - vec[j] < 0){
//cout << i << " " << j << " c" << endl;
break;
}
dp[i] += dp[i-vec[j]];
}
*/
dp_sum[i] = dp_sum[i - 1] + dp[i];
}
/*
rep(i, n+1){
cout << dp[i] << " ";
}
br;
rep(i, n+1){
cout << dp_sum[i] << " ";
}
br;
*/
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n - 1); i >= 0; i--)
#define all(x) x.begin(), x.end()
#define br cout << "\n";
using namespace std;
const long long INF = 1e10;
const long long MOD = 1e9 + 7;
using Graph = vector<vector<ll>>;
using pll = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll ceilll(ll a, ll b) { return (a + b - 1) / b; } // if(a%b == 0) (a/b) + 1
ll get_digit(ll a) {
ll digit = 0;
while (a != 0) {
a /= 10;
digit++;
}
return digit;
} // a != 0
template <typename T> void vecdbg(vector<T> &v) {
rep(i, v.size()) { cout << v[i] << " "; }
br;
}
template <typename T> void vecvecdbg(vector<vector<T>> &v) {
rep(i, v.size()) {
rep(j, v[i].size()) { cout << v[i][j] << " "; }
br;
}
}
// 0 false, 1 true
// string number to int : -48
// a to A : -32
// ceil(a) 1.2->2.0
// c++17 g++ -std=c++17 a.cpp
// global vector -> 0 initialization
// https://atcoder.jp/contests/abc172/submissions/14765570
// 20200724
template <long long mod> struct ModInt {
long long x;
ModInt() : x(0) {}
ModInt(long long x) : x(x >= 0 ? x % mod : (mod - -x % 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 = (long long)x * p.x % mod;
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt &operator^=(long long p) {
ModInt res = 1;
for (; p; p >>= 1) {
if (p & 1)
res *= *this;
*this *= *this;
}
return *this = res;
}
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; }
ModInt operator^(long long 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; }
explicit operator long long() const { return x; }
ModInt &operator=(const long long p) {
x = p;
return *this;
}
ModInt inverse() const {
long long a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
friend std::ostream &operator<<(std::ostream &stream, const ModInt<mod> &p) {
return stream << p.x;
}
friend std::istream &operator>>(std::istream &stream, ModInt<mod> &a) {
long long x;
stream >> x;
a = ModInt<mod>(x);
return stream;
}
};
template <long long mod> struct MComb {
using mint = ModInt<mod>;
std::vector<mint> fact;
std::vector<mint> inv;
MComb(long long n) { // O(n + log(mod))
fact = std::vector<mint>(n + 1, 1);
for (long long i = 1; i <= n; i++)
fact[i] = fact[i - 1] * mint(i);
inv.resize(n + 1);
inv[n] = fact[n] ^ (mod - 2);
for (long long i = n; i--;)
inv[i] = inv[i + 1] * mint(i + 1);
}
mint ncr(long long n, long r) { return fact[n] * inv[r] * inv[n - r]; }
mint npr(long n, long r) { return fact[n] * inv[n - r]; }
mint nhr(long n, long r) {
assert(n + r - 1 < (long long)fact.size());
return ncr(n + r - 1, r);
}
};
template <long long mod> struct MPow {
using mint = ModInt<mod>;
mint modpow(mint a, long long n) {
mint res = 1;
while (n > 0) {
if (n & 1) {
res = res * a;
}
a = a * a;
n >>= 1;
}
return res;
}
};
typedef ModInt<998244353> mint;
MComb<998244353> com(510000);
MPow<998244353> mpow;
mint dp[200010];
mint dp_sum[200010];
int main() {
std::cout << std::fixed << std::setprecision(15);
ll n, k;
cin >> n >> k;
vector<ll> vec;
vector<pair<ll, ll>> pv;
rep(i, k) {
ll l, r;
cin >> l >> r;
pv.emplace_back(l, r);
/*
for(ll j = l; j <= r; j++){
vec.push_back(j);
}
*/
}
sort(all(pv));
rep(i, pv.size()) {
for (ll j = pv[i].first; j <= pv[i].second; j++) {
vec.push_back(j);
}
}
// sort(all(vec));
/*
rep(i, vec.size()){
cout << vec[i] << " ";
}
br;
*/
dp[1] = 1;
dp_sum[1] = 1;
for (ll i = 1; i < n + 1; i++) {
for (ll j = 0; j < pv.size(); j++) {
if (i - pv[j].first < 0)
continue;
if (i - pv[j].second < 1) {
dp[i] += (dp_sum[i - pv[j].first] - dp_sum[0]);
} else {
dp[i] += (dp_sum[i - pv[j].first] - dp_sum[i - pv[j].second - 1]);
}
}
/*
for(ll j = 0; j < vec.size(); j++){
if(i - vec[j] < 0){
//cout << i << " " << j << " c" << endl;
break;
}
dp[i] += dp[i-vec[j]];
}
*/
dp_sum[i] = dp_sum[i - 1] + dp[i];
}
/*
rep(i, n+1){
cout << dp[i] << " ";
}
br;
rep(i, n+1){
cout << dp_sum[i] << " ";
}
br;
*/
cout << dp[n] << endl;
} | replace | 204 | 205 | 204 | 205 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int mod = 998244353;
vector<pair<int, int>> steps;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
steps.push_back({x, y});
}
sort(steps.begin(), steps.end());
vector<int> dp(n);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
int l = i - steps[j].second;
int r = i - steps[j].first;
if (r >= 0) {
dp[i] = (dp[i] + dp[r]) % mod;
}
if (l > 0) {
dp[i] = (dp[i] - dp[l - 1] + mod) % mod;
}
}
if (i != n - 1) {
dp[i] = (dp[i] + dp[i - 1]) % mod;
}
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int mod = 998244353;
vector<pair<int, int>> steps;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
steps.push_back({x, y});
}
sort(steps.begin(), steps.end());
vector<int> dp(n);
dp[0] = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < k; j++) {
int l = i - steps[j].second;
int r = i - steps[j].first;
if (r >= 0) {
dp[i] = (dp[i] + dp[r]) % mod;
}
if (l > 0) {
dp[i] = (dp[i] - dp[l - 1] + mod) % mod;
}
}
if (i != n - 1) {
dp[i] = (dp[i] + dp[i - 1]) % mod;
}
}
cout << dp[n - 1];
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
// g++ -std=c++11
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define DIV 998244353
long long dp[200005];
int main() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> LR(K);
rep(i, K) { cin >> LR[i].first >> LR[i].second; }
ll cur = 1;
dp[0] = -1;
ll ans = -1;
rep(i, N) {
rep(j, K) {
ll l = LR[j].first;
ll r = LR[j].second;
dp[i + l - 1] += cur;
dp[i + l - 1] %= DIV;
dp[i + r] -= cur;
dp[i + r] += DIV;
dp[i + r] %= DIV;
}
if (i == N - 1) {
ans = cur;
}
cur += dp[i];
cur %= DIV;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
// g++ -std=c++11
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define DIV 998244353
long long dp[200005];
int main() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> LR(K);
rep(i, K) { cin >> LR[i].first >> LR[i].second; }
ll cur = 1;
dp[0] = -1;
ll ans = -1;
rep(i, N) {
rep(j, K) {
ll l = LR[j].first;
ll r = LR[j].second;
if (i + l - 1 <= N) {
dp[i + l - 1] += cur;
dp[i + l - 1] %= DIV;
}
if (i + r <= N) {
dp[i + r] -= cur;
dp[i + r] += DIV;
dp[i + r] %= DIV;
}
}
if (i == N - 1) {
ans = cur;
}
cur += dp[i];
cur %= DIV;
}
cout << ans << endl;
}
| replace | 26 | 31 | 26 | 35 | 0 | |
p02549 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define ll long long
#define pb push_back
#define pp pair<long long, long long>
#define ppp pair<long long, pair<long long, long long>>
#define f first
#define s second
#define pd pair<double, long long>
ll barr[200100], M = 998244353;
void solveTestCase() {
ll n, i, j, k, l;
cin >> n >> k;
vector<pp> arr(k + 1);
for (i = 1; i <= k; i++)
cin >> arr[i].f >> arr[i].s;
barr[1] = 1;
barr[2] = -1;
for (i = 1; i <= n; i++) {
barr[i] += barr[i - 1];
barr[i] %= M;
if (!barr[i])
continue;
for (j = 1; j <= k; j++) {
barr[i + arr[j].f] += barr[i];
barr[i + arr[j].f] %= M;
barr[i + arr[j].s + 1] += (M - barr[i]);
barr[i + arr[j].s + 1] %= M;
}
}
cout << barr[n] << '\n';
}
int main() {
ll t, n, i, j, k, l, m;
ios_base::sync_with_stdio(0);
cin.tie(0);
ll p;
t = 1;
// cin>>t;
for (ll T = 1; T <= t; T++) {
solveTestCase();
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define ll long long
#define pb push_back
#define pp pair<long long, long long>
#define ppp pair<long long, pair<long long, long long>>
#define f first
#define s second
#define pd pair<double, long long>
ll barr[200100], M = 998244353;
void solveTestCase() {
ll n, i, j, k, l;
cin >> n >> k;
vector<pp> arr(k + 1);
for (i = 1; i <= k; i++)
cin >> arr[i].f >> arr[i].s;
barr[1] = 1;
barr[2] = -1;
for (i = 1; i <= n; i++) {
barr[i] += barr[i - 1];
barr[i] %= M;
if (!barr[i])
continue;
for (j = 1; j <= k; j++) {
if (i + arr[j].f <= n) {
barr[i + arr[j].f] += barr[i];
barr[i + arr[j].f] %= M;
}
if (i + arr[j].s + 1 <= n) {
barr[i + arr[j].s + 1] += (M - barr[i]);
barr[i + arr[j].s + 1] %= M;
}
}
}
cout << barr[n] << '\n';
}
int main() {
ll t, n, i, j, k, l, m;
ios_base::sync_with_stdio(0);
cin.tie(0);
ll p;
t = 1;
// cin>>t;
for (ll T = 1; T <= t; T++) {
solveTestCase();
}
return 0;
} | replace | 34 | 38 | 34 | 42 | 0 | |
p02549 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// end
template <unsigned mod = 998244353> struct fp {
int v;
static unsigned get_mod() { return mod; }
int inv() const {
int tmp, a = v, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
if (x < 0) {
x += mod;
}
return x;
}
fp() : v(0) {}
fp(ll x) : v(x >= 0 ? x % mod : mod + (x % mod)) {}
fp operator-() const { return fp(-v); }
fp pow(ll t) {
fp res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
fp &operator+=(const fp &x) {
if ((v += x.v) >= (int)mod)
v -= mod;
return *this;
}
fp &operator-=(const fp &x) {
if ((v += mod - x.v) >= (int)mod)
v -= mod;
return *this;
}
fp &operator*=(const fp &x) {
v = ll(v) * x.v % mod;
return *this;
}
fp &operator/=(const fp &x) {
v = ll(v) * x.inv() % mod;
return *this;
}
fp operator+(const fp &x) const { return fp(*this) += x; }
fp operator-(const fp &x) const { return fp(*this) -= x; }
fp operator*(const fp &x) const { return fp(*this) *= x; }
fp operator/(const fp &x) const { return fp(*this) /= x; }
bool operator==(const fp &x) const { return v == x.v; }
bool operator!=(const fp &x) const { return v != x.v; }
};
using Fp = fp<>;
template <typename M, typename N = M> struct LazySegmentTree {
using F = function<M(M, M)>;
using G = function<M(M, N)>;
using H = function<N(N, N)>;
int sz, height;
vector<M> data;
vector<N> lazy;
const F f;
const G g;
const H h;
const M m1;
const N n1;
LazySegmentTree(int n, const F f, const G g, const H h, const M &m1,
const N n1)
: f(f), g(g), h(h), m1(m1), n1(n1) {
sz = 1, height = 0;
while (sz < n)
sz <<= 1, height++;
data.assign(2 * sz, m1);
lazy.assign(2 * sz, n1);
}
void build(vector<M> v) {
rep(i, 0, v.size()) data[i + sz] = v[i];
for (int k = sz - 1; k > 0; k--)
data[k] = f(data[2 * k], data[2 * k + 1]);
}
M ref(int k) { return lazy[k] == n1 ? data[k] : g(data[k], lazy[k]); }
void recalc(int k) {
while (k >>= 1)
data[k] = f(ref(2 * k), ref(2 * k + 1));
}
void thrust(int k) {
for (int i = height; i > 0; i--)
eval(k >> i);
}
void eval(int k) {
if (lazy[k] != n1) {
lazy[2 * k] = h(lazy[2 * k], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = ref(k);
lazy[k] = n1;
}
}
void set(int a, M x) {
thrust(a += sz);
data[a] = x;
recalc(a);
}
void update(int a, int b, N x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lazy[l] = h(lazy[l], x), ++l;
if (r & 1)
--r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
M query(int a, int b) {
thrust(a += sz);
thrust(b += sz - 1);
M L = m1, R = m1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
L = f(L, ref(l++));
if (r & 1)
R = f(ref(--r), R);
}
return f(L, R);
}
};
int main() {
int n, k;
cin >> n >> k;
vector<int> lb(k), rb(k);
rep(i, 0, k) {
cin >> lb[i] >> rb[i];
rb[i]++;
}
auto f = [&](Fp a, Fp b) { return a + b; };
auto g = [&](Fp a, Fp b) { return a + b; };
auto h = [&](Fp a, Fp b) { return a + b; };
LazySegmentTree<Fp, Fp> seg(n + 10, f, g, h, 0, 0);
seg.update(0, 1, 1);
rep(i, 0, n) {
Fp x = seg.query(i, i + 1);
rep(j, 0, k) { seg.update(i + lb[j], i + rb[j], x); }
}
Fp res = seg.query(n - 1, n);
cout << res.v << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// end
template <unsigned mod = 998244353> struct fp {
int v;
static unsigned get_mod() { return mod; }
int inv() const {
int tmp, a = v, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
if (x < 0) {
x += mod;
}
return x;
}
fp() : v(0) {}
fp(ll x) : v(x >= 0 ? x % mod : mod + (x % mod)) {}
fp operator-() const { return fp(-v); }
fp pow(ll t) {
fp res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
fp &operator+=(const fp &x) {
if ((v += x.v) >= (int)mod)
v -= mod;
return *this;
}
fp &operator-=(const fp &x) {
if ((v += mod - x.v) >= (int)mod)
v -= mod;
return *this;
}
fp &operator*=(const fp &x) {
v = ll(v) * x.v % mod;
return *this;
}
fp &operator/=(const fp &x) {
v = ll(v) * x.inv() % mod;
return *this;
}
fp operator+(const fp &x) const { return fp(*this) += x; }
fp operator-(const fp &x) const { return fp(*this) -= x; }
fp operator*(const fp &x) const { return fp(*this) *= x; }
fp operator/(const fp &x) const { return fp(*this) /= x; }
bool operator==(const fp &x) const { return v == x.v; }
bool operator!=(const fp &x) const { return v != x.v; }
};
using Fp = fp<>;
template <typename M, typename N = M> struct LazySegmentTree {
using F = function<M(M, M)>;
using G = function<M(M, N)>;
using H = function<N(N, N)>;
int sz, height;
vector<M> data;
vector<N> lazy;
const F f;
const G g;
const H h;
const M m1;
const N n1;
LazySegmentTree(int n, const F f, const G g, const H h, const M &m1,
const N n1)
: f(f), g(g), h(h), m1(m1), n1(n1) {
sz = 1, height = 0;
while (sz < n)
sz <<= 1, height++;
data.assign(2 * sz, m1);
lazy.assign(2 * sz, n1);
}
void build(vector<M> v) {
rep(i, 0, v.size()) data[i + sz] = v[i];
for (int k = sz - 1; k > 0; k--)
data[k] = f(data[2 * k], data[2 * k + 1]);
}
M ref(int k) { return lazy[k] == n1 ? data[k] : g(data[k], lazy[k]); }
void recalc(int k) {
while (k >>= 1)
data[k] = f(ref(2 * k), ref(2 * k + 1));
}
void thrust(int k) {
for (int i = height; i > 0; i--)
eval(k >> i);
}
void eval(int k) {
if (lazy[k] != n1) {
lazy[2 * k] = h(lazy[2 * k], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = ref(k);
lazy[k] = n1;
}
}
void set(int a, M x) {
thrust(a += sz);
data[a] = x;
recalc(a);
}
void update(int a, int b, N x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lazy[l] = h(lazy[l], x), ++l;
if (r & 1)
--r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
M query(int a, int b) {
thrust(a += sz);
thrust(b += sz - 1);
M L = m1, R = m1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
L = f(L, ref(l++));
if (r & 1)
R = f(ref(--r), R);
}
return f(L, R);
}
};
int main() {
int n, k;
cin >> n >> k;
vector<int> lb(k), rb(k);
rep(i, 0, k) {
cin >> lb[i] >> rb[i];
rb[i]++;
}
auto f = [&](Fp a, Fp b) { return a + b; };
auto g = [&](Fp a, Fp b) { return a + b; };
auto h = [&](Fp a, Fp b) { return a + b; };
LazySegmentTree<Fp, Fp> seg(n + 10, f, g, h, 0, 0);
seg.update(0, 1, 1);
rep(i, 0, n) {
Fp x = seg.query(i, i + 1);
rep(j, 0, k) {
int L = min(i + lb[j], n), R = min(i + rb[j], n);
seg.update(L, R, x);
}
}
Fp res = seg.query(n - 1, n);
cout << res.v << endl;
return 0;
} | replace | 168 | 169 | 168 | 172 | 0 | |
p02549 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define F first
#define S second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define repi(n) for (int i = 0; i < (n); i++)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(p) p.begin(), p.end()
#define pop_count(p) __builtin_popcountll(p)
#define len(s, e) ((e) - (s) + 1)
#define mid(s, e) ((s) + ((e) - (s)) / 2)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const int mod = 998244353;
const int oo = 1e9;
const ll OO = 1e18;
#ifdef ONLINE_JUDGE
#define endl '\n'
#endif
template <typename A, typename B>
std::istream &operator>>(std::istream &in, pair<A, B> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T> std::istream &operator>>(std::istream &in, vector<T> &a) {
for (auto &v : a)
in >> v;
return in;
}
template <typename T, size_t N>
std::istream &operator>>(std::istream &in, array<T, N> &a) {
for (size_t i = 0; i < N; i++)
in >> a[i];
return in;
}
template <typename A, typename B>
std::ostream &operator<<(std::ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
std::ostream &operator<<(std::ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
std::ostream &operator<<(std::ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, const list<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
#ifdef ANEEE_LOCAL
template <typename T>
std::ostream &operator<<(std::ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
#else
template <typename T>
std::ostream &operator<<(std::ostream &out, const vector<T> &a) {
for (const auto &v : a)
out << v << ' ';
return out;
}
#endif
#ifdef ANEEE_LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 7
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << "[" << name << ": " << arg1 << "]" << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr << "[";
cerr.write(names, comma - names) << ": " << arg1 << "] ";
__f(comma + 2, args...);
}
template <typename Arg1> void print(Arg1 &&arg1) { cout << arg1 << endl; }
template <typename Arg1, typename... Args>
void print(Arg1 &&arg1, Args &&...args) {
cout << arg1 << ' ';
print(args...);
}
template <typename Arg1> void read(Arg1 &&arg1) { cin >> arg1; }
template <typename Arg1, typename... Args>
void read(Arg1 &&arg1, Args &&...args) {
cin >> arg1;
read(args...);
}
int nextInt() {
int x;
read(x);
return x;
}
ll nextLong() {
ll x;
read(x);
return x;
}
class Timer {
string _name;
clock_t _start;
public:
Timer(string name = "Runtime") {
_name = "[" + name + ": ", _start = clock();
}
~Timer() {
cerr << _name << double(clock() - _start) / CLOCKS_PER_SEC << "]\n";
}
};
#ifdef ONLINE_JUDGE
#undef CASE_INFO
#endif
template <class val_t> struct segment_tree {
int n;
vector<val_t> T;
template <typename X> void init(int sz, const vector<X> a) {
n = sz;
T.resize(2 * n);
for (int i = 0; i < n; ++i) {
T[n + i] = a[i];
}
for (int i = n - 1; i > 0; --i) {
T[i] = T[i << 1] + T[i << 1 | 1];
if (T[i] >= mod)
T[i] -= mod;
}
}
val_t query(int i) {
val_t ret = 0;
for (i += n; i > 0; i >>= 1) {
ret += T[i];
if (ret >= mod)
ret -= mod;
}
return ret;
}
void update(int l, int r, val_t val) {
for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
T[l] += val, T[l] -= (T[l] >= mod ? mod : 0), ++l;
if (r & 1)
--r, T[r] += val, T[r] -= (T[r] >= mod ? mod : 0);
}
}
};
void solve() {
int n, k;
read(n, k);
vector<pair<int, int>> a(n);
read(a);
segment_tree<long long> st;
st.init(n, vector<int>(n));
st.update(0, 0, 1);
for (int i = 0; i + 1 < n; ++i) {
long long ways = st.query(i);
trace(i, ways);
for (const auto &ra : a) {
st.update(i + ra.F, min(i + ra.S, n - 1), ways);
}
}
print(st.query(n - 1));
}
signed main() {
Timer ti;
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
#ifdef TEST_CASES
cin >> T;
#endif
for (int tt = 1; tt <= T; tt++) {
#ifdef CASE_INFO
cout << "Case #" << tt << ": ";
#endif
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define repi(n) for (int i = 0; i < (n); i++)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(p) p.begin(), p.end()
#define pop_count(p) __builtin_popcountll(p)
#define len(s, e) ((e) - (s) + 1)
#define mid(s, e) ((s) + ((e) - (s)) / 2)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const int mod = 998244353;
const int oo = 1e9;
const ll OO = 1e18;
#ifdef ONLINE_JUDGE
#define endl '\n'
#endif
template <typename A, typename B>
std::istream &operator>>(std::istream &in, pair<A, B> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T> std::istream &operator>>(std::istream &in, vector<T> &a) {
for (auto &v : a)
in >> v;
return in;
}
template <typename T, size_t N>
std::istream &operator>>(std::istream &in, array<T, N> &a) {
for (size_t i = 0; i < N; i++)
in >> a[i];
return in;
}
template <typename A, typename B>
std::ostream &operator<<(std::ostream &out, const pair<A, B> &a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &out, const array<T, N> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
template <typename T, class Cmp>
std::ostream &operator<<(std::ostream &out, const set<T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "}";
return out;
}
template <typename U, typename T, class Cmp>
std::ostream &operator<<(std::ostream &out, const map<U, T, Cmp> &a) {
out << "{";
bool first = true;
for (auto &p : a) {
out << (first ? "" : ", ");
out << p.first << ":" << p.second;
first = 0;
}
out << "}";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, const list<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
#ifdef ANEEE_LOCAL
template <typename T>
std::ostream &operator<<(std::ostream &out, const vector<T> &a) {
out << "[";
bool first = true;
for (auto &v : a) {
out << (first ? "" : ", ");
out << v;
first = 0;
}
out << "]";
return out;
}
#else
template <typename T>
std::ostream &operator<<(std::ostream &out, const vector<T> &a) {
for (const auto &v : a)
out << v << ' ';
return out;
}
#endif
#ifdef ANEEE_LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 7
#endif
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << "[" << name << ": " << arg1 << "]" << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr << "[";
cerr.write(names, comma - names) << ": " << arg1 << "] ";
__f(comma + 2, args...);
}
template <typename Arg1> void print(Arg1 &&arg1) { cout << arg1 << endl; }
template <typename Arg1, typename... Args>
void print(Arg1 &&arg1, Args &&...args) {
cout << arg1 << ' ';
print(args...);
}
template <typename Arg1> void read(Arg1 &&arg1) { cin >> arg1; }
template <typename Arg1, typename... Args>
void read(Arg1 &&arg1, Args &&...args) {
cin >> arg1;
read(args...);
}
int nextInt() {
int x;
read(x);
return x;
}
ll nextLong() {
ll x;
read(x);
return x;
}
class Timer {
string _name;
clock_t _start;
public:
Timer(string name = "Runtime") {
_name = "[" + name + ": ", _start = clock();
}
~Timer() {
cerr << _name << double(clock() - _start) / CLOCKS_PER_SEC << "]\n";
}
};
#ifdef ONLINE_JUDGE
#undef CASE_INFO
#endif
template <class val_t> struct segment_tree {
int n;
vector<val_t> T;
template <typename X> void init(int sz, const vector<X> a) {
n = sz;
T.resize(2 * n);
for (int i = 0; i < n; ++i) {
T[n + i] = a[i];
}
for (int i = n - 1; i > 0; --i) {
T[i] = T[i << 1] + T[i << 1 | 1];
if (T[i] >= mod)
T[i] -= mod;
}
}
val_t query(int i) {
val_t ret = 0;
for (i += n; i > 0; i >>= 1) {
ret += T[i];
if (ret >= mod)
ret -= mod;
}
return ret;
}
void update(int l, int r, val_t val) {
for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
T[l] += val, T[l] -= (T[l] >= mod ? mod : 0), ++l;
if (r & 1)
--r, T[r] += val, T[r] -= (T[r] >= mod ? mod : 0);
}
}
};
void solve() {
int n, k;
read(n, k);
vector<pair<int, int>> a(k);
read(a);
segment_tree<long long> st;
st.init(n, vector<int>(n));
st.update(0, 0, 1);
for (int i = 0; i + 1 < n; ++i) {
long long ways = st.query(i);
trace(i, ways);
for (const auto &ra : a) {
st.update(i + ra.F, min(i + ra.S, n - 1), ways);
}
}
print(st.query(n - 1));
}
signed main() {
Timer ti;
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
#ifdef TEST_CASES
cin >> T;
#endif
for (int tt = 1; tt <= T; tt++) {
#ifdef CASE_INFO
cout << "Case #" << tt << ": ";
#endif
solve();
}
return 0;
}
| replace | 213 | 214 | 213 | 214 | TLE | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vpi = vector<Pi>;
using vpl = vector<Pl>;
#define debug(arr) cout << #arr << " = " << arr << '\n'
#define debug2(a, b) \
cout << "[" << #a << "," << #b << "] = " \
<< "[" << a << "," << b << "]" << '\n'
template <class T> ostream &operator<<(ostream &out, const vector<T> &arr) {
cout << "{";
for (int i = 0; i < arr.size(); i++)
cout << (!i ? "" : ", ") << arr[i];
cout << "}";
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &arr) {
cout << "{\n";
for (auto &vec : arr)
cout << " " << vec << ",\n";
cout << "}";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
cout << "{" << p.first << "," << p.second << "}" << '\n';
return out;
}
template <class T> istream &operator>>(istream &in, vector<T> &arr) {
for (auto &i : arr)
cin >> i;
return in;
}
/////////////////////////////////////////////////////////////////////////
#define MOD 998244353
template <int mod> struct Modint {
long long x; // typedef long long ll;
Modint(long long x = 0) : x((x % mod + mod) % mod) {}
Modint &operator+=(const Modint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
Modint &operator-=(const Modint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
Modint &operator*=(const Modint a) {
(x *= a.x) %= mod;
return *this;
}
Modint operator+(const Modint a) const {
Modint res(*this);
return res += a;
}
Modint operator-(const Modint a) const {
Modint res(*this);
return res -= a;
}
Modint operator*(const Modint a) const {
Modint res(*this);
return res *= a;
}
Modint pow(ll t) const {
if (!t)
return 1;
Modint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
Modint inv() const { return pow(mod - 2); }
Modint &operator/=(const Modint a) { return (*this) *= a.inv(); }
};
using mint = Modint<MOD>;
template <class T> class RangeSumQuery {
private:
vector<T> dat;
int n;
T INF;
public:
RangeSumQuery(int n_) {
INF = 0;
n = 1;
while (n < n_)
n *= 2;
dat.assign(2 * n - 1, INF);
}
void update(int k, T a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2];
}
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return dat[k];
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return vl + vr;
}
}
T query(int a, int b) { return query(a, b, 0, 0, n); }
};
mint dp[100010];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
// cout << fixed << setprecision(20);
int n, k;
cin >> n >> k;
RangeSumQuery<mint> ST(n + 1);
vector<Pi> range(k);
REP(i, k) { cin >> range[i].first >> range[i].second; }
sort(all(range));
dp[0] = 1;
ST.update(0, 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
int l = i - range[j].second;
int r = i - range[j].first + 1;
if (r < 0)
continue;
dp[i] += ST.query(max(0, l), r);
ST.update(i, dp[i]);
}
}
cout << dp[n - 1].x << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vpi = vector<Pi>;
using vpl = vector<Pl>;
#define debug(arr) cout << #arr << " = " << arr << '\n'
#define debug2(a, b) \
cout << "[" << #a << "," << #b << "] = " \
<< "[" << a << "," << b << "]" << '\n'
template <class T> ostream &operator<<(ostream &out, const vector<T> &arr) {
cout << "{";
for (int i = 0; i < arr.size(); i++)
cout << (!i ? "" : ", ") << arr[i];
cout << "}";
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &arr) {
cout << "{\n";
for (auto &vec : arr)
cout << " " << vec << ",\n";
cout << "}";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
cout << "{" << p.first << "," << p.second << "}" << '\n';
return out;
}
template <class T> istream &operator>>(istream &in, vector<T> &arr) {
for (auto &i : arr)
cin >> i;
return in;
}
/////////////////////////////////////////////////////////////////////////
#define MOD 998244353
template <int mod> struct Modint {
long long x; // typedef long long ll;
Modint(long long x = 0) : x((x % mod + mod) % mod) {}
Modint &operator+=(const Modint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
Modint &operator-=(const Modint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
Modint &operator*=(const Modint a) {
(x *= a.x) %= mod;
return *this;
}
Modint operator+(const Modint a) const {
Modint res(*this);
return res += a;
}
Modint operator-(const Modint a) const {
Modint res(*this);
return res -= a;
}
Modint operator*(const Modint a) const {
Modint res(*this);
return res *= a;
}
Modint pow(ll t) const {
if (!t)
return 1;
Modint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
Modint inv() const { return pow(mod - 2); }
Modint &operator/=(const Modint a) { return (*this) *= a.inv(); }
};
using mint = Modint<MOD>;
template <class T> class RangeSumQuery {
private:
vector<T> dat;
int n;
T INF;
public:
RangeSumQuery(int n_) {
INF = 0;
n = 1;
while (n < n_)
n *= 2;
dat.assign(2 * n - 1, INF);
}
void update(int k, T a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2];
}
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return dat[k];
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return vl + vr;
}
}
T query(int a, int b) { return query(a, b, 0, 0, n); }
};
mint dp[200010];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
// cout << fixed << setprecision(20);
int n, k;
cin >> n >> k;
RangeSumQuery<mint> ST(n + 1);
vector<Pi> range(k);
REP(i, k) { cin >> range[i].first >> range[i].second; }
sort(all(range));
dp[0] = 1;
ST.update(0, 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
int l = i - range[j].second;
int r = i - range[j].first + 1;
if (r < 0)
continue;
dp[i] += ST.query(max(0, l), r);
ST.update(i, dp[i]);
}
}
cout << dp[n - 1].x << '\n';
return 0;
}
| replace | 145 | 146 | 145 | 146 | 0 | |
p02549 | C++ | Runtime Error | /*
Dont BLUNDER
*/
// #pragma GCC optimize("O3")
// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("Ofast")
// #pragma GCC optimization ("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
*/
// #define d long double
#define int long long
#define pii pair<int, int>
#define pb push_back
#define endl '\n'
#define pi acos(-1)
#define init(x, a) memset(x, a, sizeof(x))
#define all(c) c.begin(), c.end()
int const mod1 = 998244353;
int const mod = 1000000007;
#define bitcount(x) __builtin_popcountll(x)
#define l first
#define r second
const int inf = LLONG_MAX;
int toint(const string &s) {
stringstream ss;
ss << s;
int x;
ss >> x;
return x;
}
string tostring(int number) {
stringstream ss;
ss << number;
return ss.str();
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define haha \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
// * Using PBDS *
/*typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
os; */
struct cmp {
bool operator()(pii a, pii b) { return (a.l < b.l); }
};
int modexp(int x, int n) {
if (n == 0) {
return 1;
} else if (n & 1) {
return (modexp((x * x) % mod, n / 2) % mod * x % mod) % mod;
} else {
return (modexp((x * x) % mod, n / 2) % mod);
}
}
int modinv(int n) { return modexp(n, mod - 2); }
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int segm_tree[400001];
int a[200001];
void recalculate(int node) {
// calculate the solution for the current segment,
// considering the sons are correctly solved
segm_tree[node] = (segm_tree[2 * node] + segm_tree[2 * node + 1]) % mod1;
}
void build(int node, int left,
int right) { //"node" is the index in the array, while "left"
// and "right" are the ends of the current segment
if (left == right) {
segm_tree[node] = a[left]; // we are in a leaf node
} else {
int middle = (left + right) / 2;
build(2 * node, left, middle);
build(2 * node + 1, middle + 1, right);
recalculate(node);
}
}
void update(int node, int left, int right, int x, int y) {
if (left == right) { // we are in the xth leaf
segm_tree[node] = y;
} else {
int middle = (left + right) / 2;
if (x <= middle) { // we need to update the left son
update(2 * node, left, middle, x, y);
} else {
update(2 * node + 1, middle + 1, right, x, y);
}
// after updating said son, recalculate the current segment
recalculate(node);
}
}
int query(int node, int left, int right, int x, int y) {
if (y < left or right < x) {
// range represented by a node is completely outside the given range
return 0;
}
if (x <= left && right <= y) {
// the segment of "node" is completely included in the query
return segm_tree[node];
} else {
// int answer = -10000;
int middle = (left + right) / 2;
int p1 = query(2 * node, left, middle, x, y);
int p2 = query(2 * node + 1, middle + 1, right, x, y);
// we would not have entered this function if (x, y) and (left, right) had
// nothing in common, so there is no risk of answer returning -Infinity
// here, as either the left or the right son would update it
return (p1 + p2) % mod1;
}
}
signed main() {
haha
#ifndef ONLINE_JUDGE
freopen("inp.txt", "r", stdin);
freopen("out1.txt", "w", stdout);
#endif
vector<pii> v;
int n, k;
cin >> n >> k;
int ans = 0;
init(a, 0);
a[1] = 1;
build(1, 1, n);
for (int i = 0; i < k; i++) {
int x;
int y;
cin >> x >> y;
v.pb({x, y});
}
for (int i = 2; i <= n; i++) {
int temp = 0;
for (auto x : v) {
int l = x.first;
int r = x.second;
if (i - l >= 1) {
int qr = i - l;
int ql = max(1ll, i - r);
temp += query(1, 1, n, ql, qr);
temp %= mod1;
}
}
a[i] = temp;
update(1, 1, n, i, temp);
}
cout << a[n];
}
| /*
Dont BLUNDER
*/
// #pragma GCC optimize("O3")
// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("Ofast")
// #pragma GCC optimization ("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
*/
// #define d long double
#define int long long
#define pii pair<int, int>
#define pb push_back
#define endl '\n'
#define pi acos(-1)
#define init(x, a) memset(x, a, sizeof(x))
#define all(c) c.begin(), c.end()
int const mod1 = 998244353;
int const mod = 1000000007;
#define bitcount(x) __builtin_popcountll(x)
#define l first
#define r second
const int inf = LLONG_MAX;
int toint(const string &s) {
stringstream ss;
ss << s;
int x;
ss >> x;
return x;
}
string tostring(int number) {
stringstream ss;
ss << number;
return ss.str();
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define haha \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
// * Using PBDS *
/*typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
os; */
struct cmp {
bool operator()(pii a, pii b) { return (a.l < b.l); }
};
int modexp(int x, int n) {
if (n == 0) {
return 1;
} else if (n & 1) {
return (modexp((x * x) % mod, n / 2) % mod * x % mod) % mod;
} else {
return (modexp((x * x) % mod, n / 2) % mod);
}
}
int modinv(int n) { return modexp(n, mod - 2); }
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int segm_tree[600001];
int a[200001];
void recalculate(int node) {
// calculate the solution for the current segment,
// considering the sons are correctly solved
segm_tree[node] = (segm_tree[2 * node] + segm_tree[2 * node + 1]) % mod1;
}
void build(int node, int left,
int right) { //"node" is the index in the array, while "left"
// and "right" are the ends of the current segment
if (left == right) {
segm_tree[node] = a[left]; // we are in a leaf node
} else {
int middle = (left + right) / 2;
build(2 * node, left, middle);
build(2 * node + 1, middle + 1, right);
recalculate(node);
}
}
void update(int node, int left, int right, int x, int y) {
if (left == right) { // we are in the xth leaf
segm_tree[node] = y;
} else {
int middle = (left + right) / 2;
if (x <= middle) { // we need to update the left son
update(2 * node, left, middle, x, y);
} else {
update(2 * node + 1, middle + 1, right, x, y);
}
// after updating said son, recalculate the current segment
recalculate(node);
}
}
int query(int node, int left, int right, int x, int y) {
if (y < left or right < x) {
// range represented by a node is completely outside the given range
return 0;
}
if (x <= left && right <= y) {
// the segment of "node" is completely included in the query
return segm_tree[node];
} else {
// int answer = -10000;
int middle = (left + right) / 2;
int p1 = query(2 * node, left, middle, x, y);
int p2 = query(2 * node + 1, middle + 1, right, x, y);
// we would not have entered this function if (x, y) and (left, right) had
// nothing in common, so there is no risk of answer returning -Infinity
// here, as either the left or the right son would update it
return (p1 + p2) % mod1;
}
}
signed main() {
haha
#ifndef ONLINE_JUDGE
freopen("inp.txt", "r", stdin);
freopen("out1.txt", "w", stdout);
#endif
vector<pii> v;
int n, k;
cin >> n >> k;
int ans = 0;
init(a, 0);
a[1] = 1;
build(1, 1, n);
for (int i = 0; i < k; i++) {
int x;
int y;
cin >> x >> y;
v.pb({x, y});
}
for (int i = 2; i <= n; i++) {
int temp = 0;
for (auto x : v) {
int l = x.first;
int r = x.second;
if (i - l >= 1) {
int qr = i - l;
int ql = max(1ll, i - r);
temp += query(1, 1, n, ql, qr);
temp %= mod1;
}
}
a[i] = temp;
update(1, 1, n, i, temp);
}
cout << a[n];
}
| replace | 106 | 107 | 106 | 107 | -11 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, j, mod = 998244353;
cin >> n >> k;
vector<pair<long, long>> d(k);
for (j = 0; j < k; j++) {
cin >> d[j].first >> d[j].second;
}
vector<long long> ans(n + 1 + 100000, 0), cur(n + 1 + 100000, 0);
long long l, r, res;
res = 1;
for (i = 1; i < n; i++) {
for (j = 0; j < k; j++) {
l = d[j].first;
r = d[j].second + 1;
cur[i + l] += res;
cur[i + r] -= res;
}
ans[i + 1] = (ans[i] + cur[i + 1]) % mod;
res = (ans[i] + cur[i + 1]) % mod;
}
ans[n] %= mod;
if (ans[n] < 0) {
ans[n] += mod;
}
cout << ans[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, j, mod = 998244353;
cin >> n >> k;
vector<pair<long, long>> d(k);
for (j = 0; j < k; j++) {
cin >> d[j].first >> d[j].second;
}
vector<long long> ans(n + 1 + 100000, 0), cur(n + 1 + 100000, 0);
long long l, r, res;
res = 1;
for (i = 1; i < n; i++) {
for (j = 0; j < k; j++) {
l = d[j].first;
r = d[j].second + 1;
if (i + l > n) {
l = n + 1 - i;
}
if (i + r > n) {
r = n + 1 - i;
}
cur[i + l] += res;
cur[i + r] -= res;
}
ans[i + 1] = (ans[i] + cur[i + 1]) % mod;
res = (ans[i] + cur[i + 1]) % mod;
}
ans[n] %= mod;
if (ans[n] < 0) {
ans[n] += mod;
}
cout << ans[n] << endl;
return 0;
} | insert | 20 | 20 | 20 | 26 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#pragma region atcoder
// #include <atcoder/all>
// using namespace atcoder;
#pragma endregion
#pragma region macros
using ll = long long;
using vi = vector<int>;
using vs = vector<string>;
using vl = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#pragma endregion
#pragma region debug for var, v, vv
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
cout << endl;
int cnt = 0;
for (const auto &v : vv) {
cout << cnt << "th : ";
view(v);
cnt++;
}
cout << endl;
}
#pragma endregion
const ll mod = 998244353;
const int inf = 1001001001;
const ll INF = 1001001001001001001;
const int MAX = 2000005;
// using mint = modint998244353;
// These are for segment tree
/*int op(int a, int b){return max(a, b);}
int e(){return -1;}
bool f(int v){ return v < target;}
*/
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
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;
}
ll modpow(ll a, ll p) {
ll ret = 1;
while (p) {
if (p & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
p >>= 1;
}
return ret;
}
/*--------------------------------------------------------------------------------------------------------------------------------*/
ll dp[200005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> l(k), r(k);
for (int i = 0; i < k; i++) {
cin >> l[i] >> r[i];
}
dp[1] = 1;
for (int i = 1; i <= n; i++) {
if (i > 2) {
dp[i] += dp[i - 1];
dp[i] %= mod;
}
for (int j = 0; j < k; j++) {
dp[i + l[j]] += dp[i];
dp[i + l[j]] %= mod;
dp[i + r[j] + 1] += (mod - dp[i]) % mod;
}
}
cout << dp[n] % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
#pragma region atcoder
// #include <atcoder/all>
// using namespace atcoder;
#pragma endregion
#pragma region macros
using ll = long long;
using vi = vector<int>;
using vs = vector<string>;
using vl = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#pragma endregion
#pragma region debug for var, v, vv
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
cout << endl;
int cnt = 0;
for (const auto &v : vv) {
cout << cnt << "th : ";
view(v);
cnt++;
}
cout << endl;
}
#pragma endregion
const ll mod = 998244353;
const int inf = 1001001001;
const ll INF = 1001001001001001001;
const int MAX = 2000005;
// using mint = modint998244353;
// These are for segment tree
/*int op(int a, int b){return max(a, b);}
int e(){return -1;}
bool f(int v){ return v < target;}
*/
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
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;
}
ll modpow(ll a, ll p) {
ll ret = 1;
while (p) {
if (p & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
p >>= 1;
}
return ret;
}
/*--------------------------------------------------------------------------------------------------------------------------------*/
ll dp[200005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> l(k), r(k);
for (int i = 0; i < k; i++) {
cin >> l[i] >> r[i];
}
dp[1] = 1;
for (int i = 1; i <= n; i++) {
if (i > 2) {
dp[i] += dp[i - 1];
dp[i] %= mod;
}
for (int j = 0; j < k; j++) {
if (i + l[j] <= 200004) {
dp[i + l[j]] += dp[i];
dp[i + l[j]] %= mod;
}
if (i + r[j] <= 200004)
dp[i + r[j] + 1] += (mod - dp[i]) % mod;
}
}
cout << dp[n] % mod << endl;
} | replace | 105 | 108 | 105 | 111 | 0 | |
p02549 | C++ | Runtime Error | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set 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;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("YES")
#define p_no() p("NO")
#define possible() p("Possible")
#define impossible() p("Impossible")
ll SUM(VI &V) { return accumulate(ALL(V), 0LL); }
ll MIN(VI &V) { return *min_element(ALL(V)); }
ll MAX(VI &V) { return *max_element(ALL(V)); }
void print_vector(VI &V) {
ll n = V.size();
rep(i, n) {
if (i)
cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// long double
using ld = long double;
#define EPS (1e-14)
#define equals(a, b) (fabs((a) - (b)) < EPS)
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 998244353;
const ll inf = 1e18;
const double PI = acos(-1);
// snuke's mint
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
// const int mod = 1000000007;
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= 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 {
mint res(*this);
return res /= a;
}
};
// #include <atcoder/dsu>
// using namespace atcoder; // 忘れがち
// ei1333's BIT
// struct BIT {
// vector<mint> data;
// BIT(){}
// BIT(ll sz) {
// resize(sz);
// }
// void resize(ll sz){
// data.assign(++sz, 0);
// }
// mint sum(ll k) {
// mint ret = 0;
// for(++k; k > 0; k -= k & -k) ret += data[k];
// return (ret);
// }
// void add(ll k, ll x) {
// for(++k; k < data.size(); k += k & -k) data[k] += x;
// }
// };
// // 区間更新・区間和
// struct Range{
// BIT P, Q;
// Range(ll sz){
// P.resize(sz+1);
// Q.resize(sz+1);
// }
// // 範囲加算 [a, b) にwを加える
// void update(ll a, ll b, ll w){
// P.add(a, -w*a);
// P.add(b, w*b);
// Q.add(a, w);
// Q.add(b, -w);
// }
// // [0, c)
// mint simple_sum(ll c){
// return P.sum(c) + Q.sum(c) * c;
// }
// // [a, b)
// mint sum(ll a, ll b){
// return simple_sum(b) - simple_sum(a);
// }
// };
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// input
ll N, K;
cin >> N >> K;
VI L(K);
VI R(K);
rep(i, K) { cin >> L[i] >> R[i]; }
vector<mint> dp(200200);
vector<mint> Acc(200200);
dp[0] = 1;
rep(i, 200100) {
// rep(i,10){
if (i > 0)
Acc[i] += Acc[i - 1];
dp[i] += Acc[i];
// debug(i, Acc)
// debug(i, dp[i].x);
// debug(i, Acc[i].x);
// iから配る
rep(j, K) {
ll l = L[j];
ll r = R[j];
Acc[i + l] += dp[i];
Acc[i + r + 1] -= dp[i];
}
}
p(dp[N - 1].x);
return 0;
} | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set 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;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("YES")
#define p_no() p("NO")
#define possible() p("Possible")
#define impossible() p("Impossible")
ll SUM(VI &V) { return accumulate(ALL(V), 0LL); }
ll MIN(VI &V) { return *min_element(ALL(V)); }
ll MAX(VI &V) { return *max_element(ALL(V)); }
void print_vector(VI &V) {
ll n = V.size();
rep(i, n) {
if (i)
cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// long double
using ld = long double;
#define EPS (1e-14)
#define equals(a, b) (fabs((a) - (b)) < EPS)
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 998244353;
const ll inf = 1e18;
const double PI = acos(-1);
// snuke's mint
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
// const int mod = 1000000007;
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= 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 {
mint res(*this);
return res /= a;
}
};
// #include <atcoder/dsu>
// using namespace atcoder; // 忘れがち
// ei1333's BIT
// struct BIT {
// vector<mint> data;
// BIT(){}
// BIT(ll sz) {
// resize(sz);
// }
// void resize(ll sz){
// data.assign(++sz, 0);
// }
// mint sum(ll k) {
// mint ret = 0;
// for(++k; k > 0; k -= k & -k) ret += data[k];
// return (ret);
// }
// void add(ll k, ll x) {
// for(++k; k < data.size(); k += k & -k) data[k] += x;
// }
// };
// // 区間更新・区間和
// struct Range{
// BIT P, Q;
// Range(ll sz){
// P.resize(sz+1);
// Q.resize(sz+1);
// }
// // 範囲加算 [a, b) にwを加える
// void update(ll a, ll b, ll w){
// P.add(a, -w*a);
// P.add(b, w*b);
// Q.add(a, w);
// Q.add(b, -w);
// }
// // [0, c)
// mint simple_sum(ll c){
// return P.sum(c) + Q.sum(c) * c;
// }
// // [a, b)
// mint sum(ll a, ll b){
// return simple_sum(b) - simple_sum(a);
// }
// };
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// input
ll N, K;
cin >> N >> K;
VI L(K);
VI R(K);
rep(i, K) { cin >> L[i] >> R[i]; }
vector<mint> dp(200200);
vector<mint> Acc(200200);
dp[0] = 1;
rep(i, 200100) {
// rep(i,10){
if (i > 0)
Acc[i] += Acc[i - 1];
dp[i] += Acc[i];
// debug(i, Acc)
// debug(i, dp[i].x);
// debug(i, Acc[i].x);
// iから配る
rep(j, K) {
ll l = L[j];
ll r = R[j];
if (i + l < 200200) {
Acc[i + l] += dp[i];
}
if (i + r + 1 < 200200) {
Acc[i + r + 1] -= dp[i];
}
}
}
p(dp[N - 1].x);
return 0;
} | replace | 302 | 304 | 302 | 308 | 0 | |
p02549 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dx9[9] = {0, 1, 0, -1, 1, -1, 1, 0, -1};
int dy9[9] = {0, 1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
typedef pair<ll, ll> PLL;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
// << fixed << setprecision
// --------------------------------------
int n, k;
const int mod = 998244353;
#include <cassert>
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint dp[20005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
vector<PLL> vp;
REP(i, k) {
ll l, r;
cin >> l >> r;
vp.push_back(P(l, r));
}
dp[0] = 1;
dp[1] = -1;
mint sum = 0;
REP(i, n) {
sum += dp[i];
dp[i] = sum;
REP(j, k) {
ll l = vp[j].first, r = vp[j].second;
if (i + l <= n)
dp[i + l] += dp[i];
if (i + r + 1 <= n)
dp[i + r + 1] -= dp[i];
}
}
cout << dp[n - 1] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dx9[9] = {0, 1, 0, -1, 1, -1, 1, 0, -1};
int dy9[9] = {0, 1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
typedef pair<ll, ll> PLL;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
// << fixed << setprecision
// --------------------------------------
int n, k;
const int mod = 998244353;
#include <cassert>
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint dp[200005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
vector<PLL> vp;
REP(i, k) {
ll l, r;
cin >> l >> r;
vp.push_back(P(l, r));
}
dp[0] = 1;
dp[1] = -1;
mint sum = 0;
REP(i, n) {
sum += dp[i];
dp[i] = sum;
REP(j, k) {
ll l = vp[j].first, r = vp[j].second;
if (i + l <= n)
dp[i + l] += dp[i];
if (i + r + 1 <= n)
dp[i + r + 1] -= dp[i];
}
}
cout << dp[n - 1] << endl;
}
| replace | 79 | 80 | 79 | 80 | 0 | |
p02549 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
using ll = long long;
const ll MOD = 998244353;
const int INF = 1001001001;
// const ll INF = 1000000000000000000LL;
int main() {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> pr(k);
rep(i, k) {
ll a, b;
cin >> a >> b;
pr[i].first = a;
pr[i].second = b;
}
sort(pr.begin(), pr.end());
vector<ll> dp(n);
vector<ll> dp_sum(n + 1);
dp[0] = 1;
dp_sum[0] = 0;
dp_sum[1] = 1;
for (int i = 1; i < n; i++) {
rep(j, k) {
ll cur_l = pr[j].first;
ll cur_r = pr[j].second;
if (i - cur_l < 0)
break;
if (i - cur_r >= 0) {
// あとで
dp[i] += dp_sum[i - cur_l + 1] - dp_sum[i - cur_r];
dp[i] %= MOD;
} else {
for (int k = cur_l; k <= cur_r; k++) {
if (i - k >= 0) {
dp[i] += dp[i - k];
dp[i] %= MOD;
} else
break;
}
}
}
dp_sum[i + 1] = dp[i] + dp_sum[i];
dp_sum[i + 1] %= MOD;
}
if (dp[n - 1] < 0)
dp[n - 1] += MOD;
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
using ll = long long;
const ll MOD = 998244353;
const int INF = 1001001001;
// const ll INF = 1000000000000000000LL;
int main() {
ll n, k;
cin >> n >> k;
vector<pair<ll, ll>> pr(k);
rep(i, k) {
ll a, b;
cin >> a >> b;
pr[i].first = a;
pr[i].second = b;
}
sort(pr.begin(), pr.end());
vector<ll> dp(n);
vector<ll> dp_sum(n + 1);
dp[0] = 1;
dp_sum[0] = 0;
dp_sum[1] = 1;
for (int i = 1; i < n; i++) {
rep(j, k) {
ll cur_l = pr[j].first;
ll cur_r = pr[j].second;
if (i - cur_l < 0)
break;
if (i - cur_r < 0)
cur_r = i;
// if(i-cur_r>=0){
// あとで
dp[i] += dp_sum[i - cur_l + 1] - dp_sum[i - cur_r];
dp[i] %= MOD;
// }
// else{
// for(int k=cur_l;k<=cur_r;k++){
// if(i-k>=0){
// dp[i] += dp[i-k];
// dp[i]%=MOD;
// }
// else
// break;
// }
// }
}
dp_sum[i + 1] = dp[i] + dp_sum[i];
dp_sum[i + 1] %= MOD;
}
if (dp[n - 1] < 0)
dp[n - 1] += MOD;
cout << dp[n - 1] << endl;
return 0;
} | replace | 31 | 44 | 31 | 48 | TLE | |
p02549 | C++ | Runtime Error | // #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include <ext/rope>
// using namespace __gnu_pbds;
// using namespace __gnu_cxx;
// template <typename T>
// using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,
// tree_order_statistics_node_update>; #define Find order_of_key #define at
// find_by_order
#define x first
#define y second
#define ll long long
#define lll __int128
#define ull unsigned long long
#define ulll unsigned __int128
#define pii pair<int, int>
#define pb push_back
#define eb emplace_back
#define gu getchar_unlocked()
#define pu putchar_unlocked()
#define all(x) x.begin(), x.end()
#define endl '\n'
const int mod = 998244353;
const static int mx = 200010;
ll BIT[mx];
void update(ll pos, ll val) {
for (; pos <= mx; pos += pos & (-pos))
BIT[pos] += val;
}
ll query(ll pos) {
ll sum = 0;
for (; pos > 0; pos -= pos & (-pos))
sum += BIT[pos];
return sum;
}
int k;
int L[15], R[15];
int n;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> L[i] >> R[i];
}
update(n, 1);
for (int i = n - 1; i >= 1; i--) {
int d = n - i;
ll ans = 0;
for (int j = 0; j < k; j++) {
int l = i + L[j];
int r = min(i + R[j], n);
ans += query(r);
if (l != 1)
ans -= query(l - 1);
ans %= mod;
}
if (ans < 0)
ans += mod;
update(i, ans);
}
cout << query(1) << endl;
return 0;
} | // #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include <ext/rope>
// using namespace __gnu_pbds;
// using namespace __gnu_cxx;
// template <typename T>
// using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,
// tree_order_statistics_node_update>; #define Find order_of_key #define at
// find_by_order
#define x first
#define y second
#define ll long long
#define lll __int128
#define ull unsigned long long
#define ulll unsigned __int128
#define pii pair<int, int>
#define pb push_back
#define eb emplace_back
#define gu getchar_unlocked()
#define pu putchar_unlocked()
#define all(x) x.begin(), x.end()
#define endl '\n'
const int mod = 998244353;
const static int mx = 200010;
ll BIT[mx];
void update(ll pos, ll val) {
for (; pos <= mx; pos += pos & (-pos))
BIT[pos] += val;
}
ll query(ll pos) {
ll sum = 0;
for (; pos > 0; pos -= pos & (-pos))
sum += BIT[pos];
return sum;
}
int k;
int L[15], R[15];
int n;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> L[i] >> R[i];
}
update(n, 1);
for (int i = n - 1; i >= 1; i--) {
int d = n - i;
ll ans = 0;
for (int j = 0; j < k; j++) {
int l = i + L[j];
int r = min(i + R[j], n);
if (l <= r) {
ans += query(r);
if (l != 1)
ans -= query(l - 1);
}
ans %= mod;
}
if (ans < 0)
ans += mod;
update(i, ans);
}
cout << query(1) << endl;
return 0;
} | replace | 64 | 67 | 64 | 69 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ntest 0
#define l first
#define r second
using namespace std;
const int mod = 998244353;
int n, k;
pair<int, int> seg[11];
long long dp[100005], f[100005];
void solve() {
cin >> n >> k;
for (int i = 1; i <= k; ++i)
cin >> seg[i].l >> seg[i].r;
dp[1] = 1;
f[1] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
int s = max(0, i - seg[j].l);
int e = max(1, i - seg[j].r);
dp[i] = (dp[i] + (f[s] - f[e - 1] + mod) % mod) % mod;
}
f[i] = (f[i - 1] + dp[i]) % mod;
}
cout << dp[n];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
if (ntest) {
int t;
cin >> t;
while (t--)
solve();
} else {
solve();
}
}
| #include <bits/stdc++.h>
#define ntest 0
#define l first
#define r second
using namespace std;
const int mod = 998244353;
int n, k;
pair<int, int> seg[11];
long long dp[200005], f[200005];
void solve() {
cin >> n >> k;
for (int i = 1; i <= k; ++i)
cin >> seg[i].l >> seg[i].r;
dp[1] = 1;
f[1] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
int s = max(0, i - seg[j].l);
int e = max(1, i - seg[j].r);
dp[i] = (dp[i] + (f[s] - f[e - 1] + mod) % mod) % mod;
}
f[i] = (f[i - 1] + dp[i]) % mod;
}
cout << dp[n];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
if (ntest) {
int t;
cin >> t;
while (t--)
solve();
} else {
solve();
}
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define sws \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define teto(a, b) (((a) + (b)-1) / (b))
#define all(x) x.begin(), x.end()
#define forn(i, n) for (int i = 0; i < (int)n; i++)
#define forne(i, a, b) for (int i = a; i <= b; i++)
#define dbg(msg, var) cerr << msg << " " << var << endl;
using namespace std;
const int MAX = 100010;
const ll MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ld EPS = 1e-7;
const int LOG = ceil(log2(MAX));
// End Template //
namespace seg {
ll seg[2 * MAX], lazy[2 * MAX];
int n;
ll junta(ll a, ll b) { return (a + b) % MOD; }
// soma x na posicao p de tamanho tam
void poe(int p, ll x, int tam, bool prop = 1) {
seg[p] += x * tam;
seg[p] %= MOD;
if (prop and p < n)
lazy[p] += x;
}
// atualiza todos os pais da folha p
void sobe(int p) {
for (int tam = 2; p /= 2; tam *= 2) {
seg[p] = junta(seg[2 * p], seg[2 * p + 1]);
poe(p, lazy[p], tam, 0);
}
}
// propaga o caminho da raiz ate a folha p
void prop(int p) {
int tam = 1 << (LOG - 1);
for (int s = LOG; s; s--, tam /= 2) {
int i = p >> s;
if (lazy[i]) {
poe(2 * i, lazy[i], tam);
poe(2 * i + 1, lazy[i], tam);
lazy[i] = 0;
}
}
}
void build(int n2) {
n = n2;
for (int i = n - 1; i; i--)
seg[i] = junta(seg[2 * i], seg[2 * i + 1]);
for (int i = 0; i < 2 * n; i++)
lazy[i] = 0;
}
ll query(int a, int b) {
ll ret = 0;
for (prop(a += n), prop(b += n); a <= b; ++a /= 2, --b /= 2) {
if (a % 2 == 1)
ret = junta(ret, seg[a]);
if (b % 2 == 0)
ret = junta(ret, seg[b]);
}
return ret;
}
void update(int a, int b, int x) {
int a2 = a += n, b2 = b += n, tam = 1;
for (; a <= b; ++a /= 2, --b /= 2, tam *= 2) {
if (a % 2 == 1)
poe(a, x, tam);
if (b % 2 == 0)
poe(b, x, tam);
}
sobe(a2), sobe(b2);
}
}; // namespace seg
int main() {
sws;
int n, k, l, r;
cin >> n >> k;
vii S;
seg::build(n + 10);
seg::update(1, 1, 1);
for (int i = 0; i < k; i++) {
cin >> l >> r;
S.pb({l, r});
}
for (int i = 1; i <= n; i++) {
ll val = seg::query(i, i);
// cout << "i, val = " << i << " " << val << endl;
for (auto s : S)
seg::update(min(i + s.ff, n + 1), min(i + s.ss, n + 1), val);
}
cout << seg::query(n, n) << endl;
return 0;
} | #include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define pii pair<int, int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define sws \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define teto(a, b) (((a) + (b)-1) / (b))
#define all(x) x.begin(), x.end()
#define forn(i, n) for (int i = 0; i < (int)n; i++)
#define forne(i, a, b) for (int i = a; i <= b; i++)
#define dbg(msg, var) cerr << msg << " " << var << endl;
using namespace std;
const int MAX = 200010;
const ll MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ld EPS = 1e-7;
const int LOG = ceil(log2(MAX));
// End Template //
namespace seg {
ll seg[2 * MAX], lazy[2 * MAX];
int n;
ll junta(ll a, ll b) { return (a + b) % MOD; }
// soma x na posicao p de tamanho tam
void poe(int p, ll x, int tam, bool prop = 1) {
seg[p] += x * tam;
seg[p] %= MOD;
if (prop and p < n)
lazy[p] += x;
}
// atualiza todos os pais da folha p
void sobe(int p) {
for (int tam = 2; p /= 2; tam *= 2) {
seg[p] = junta(seg[2 * p], seg[2 * p + 1]);
poe(p, lazy[p], tam, 0);
}
}
// propaga o caminho da raiz ate a folha p
void prop(int p) {
int tam = 1 << (LOG - 1);
for (int s = LOG; s; s--, tam /= 2) {
int i = p >> s;
if (lazy[i]) {
poe(2 * i, lazy[i], tam);
poe(2 * i + 1, lazy[i], tam);
lazy[i] = 0;
}
}
}
void build(int n2) {
n = n2;
for (int i = n - 1; i; i--)
seg[i] = junta(seg[2 * i], seg[2 * i + 1]);
for (int i = 0; i < 2 * n; i++)
lazy[i] = 0;
}
ll query(int a, int b) {
ll ret = 0;
for (prop(a += n), prop(b += n); a <= b; ++a /= 2, --b /= 2) {
if (a % 2 == 1)
ret = junta(ret, seg[a]);
if (b % 2 == 0)
ret = junta(ret, seg[b]);
}
return ret;
}
void update(int a, int b, int x) {
int a2 = a += n, b2 = b += n, tam = 1;
for (; a <= b; ++a /= 2, --b /= 2, tam *= 2) {
if (a % 2 == 1)
poe(a, x, tam);
if (b % 2 == 0)
poe(b, x, tam);
}
sobe(a2), sobe(b2);
}
}; // namespace seg
int main() {
sws;
int n, k, l, r;
cin >> n >> k;
vii S;
seg::build(n + 10);
seg::update(1, 1, 1);
for (int i = 0; i < k; i++) {
cin >> l >> r;
S.pb({l, r});
}
for (int i = 1; i <= n; i++) {
ll val = seg::query(i, i);
// cout << "i, val = " << i << " " << val << endl;
for (auto s : S)
seg::update(min(i + s.ff, n + 1), min(i + s.ss, n + 1), val);
}
cout << seg::query(n, n) << endl;
return 0;
} | replace | 24 | 25 | 24 | 25 | 0 | |
p02549 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
const ll MOD = 998244353;
int main() {
int N, K, L[10], R[10];
cin >> N >> K;
REP(i, K) {
cin >> L[i] >> R[i];
R[i]++;
}
ll dp[200001] = {};
dp[0] = 1;
FOR(i, 1, N) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
REP(j, K) {
dp[i + L[j]] += dp[i];
dp[i + L[j]] %= MOD;
dp[i + R[j]] -= dp[i];
}
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
const ll MOD = 998244353;
int main() {
int N, K, L[10], R[10];
cin >> N >> K;
REP(i, K) {
cin >> L[i] >> R[i];
R[i]++;
}
ll dp[200001] = {};
dp[0] = 1;
FOR(i, 1, N) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
REP(j, K) {
if (i + L[j] <= N) {
dp[i + L[j]] += dp[i];
dp[i + L[j]] %= MOD;
}
if (i + R[j] <= N) {
dp[i + R[j]] -= dp[i] - MOD;
dp[i + R[j]] %= MOD;
}
}
}
cout << dp[N] << endl;
return 0;
} | replace | 33 | 36 | 33 | 41 | 0 | |
p02549 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int mod = 998244353;
const int N = 1e5 + 10;
int a[N];
int f[N];
struct node {
int s[2];
} T[N];
bool cmp(node t1, node t2) { return t1.s[0] < t2.s[0]; }
int main() {
f[1] = 1;
f[2] = -1;
a[1] = 1;
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i)
cin >> T[i].s[0] >> T[i].s[1];
// for(int i=1;i<=k;++i){
// cout<<T[i].s[0]<<' '<<T[i].s[1]<<endl;
// }
sort(T + 1, T + k + 1, cmp);
for (int i = 1; i <= n; ++i) {
if (i > 2)
f[i] = (f[i - 1] + a[i]) % mod;
else if (i == 2)
f[i] = a[i];
// else if(i==2)f[2]=f[i-1]+f[i];
for (int j = 1; j <= k; ++j) {
if (i + T[j].s[0] <= n)
(a[i + T[j].s[0]] += f[i]) %= mod;
if (i + T[j].s[1] + 1 <= n)
(((a[i + T[j].s[1] + 1] -= f[i]) %= mod) += mod) %= mod;
}
}
// for(int i=1;i<=n;++i){
// cout<<f[i]<<' ';
// }
// cout<<endl;
cout << f[n] << endl;
// int sum=0;
// for(int i=1;i<=n;i++)sum+=f[i];
// cout<<sum<<endl;
} | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int mod = 998244353;
const int N = 2e5 + 10;
int a[N];
int f[N];
struct node {
int s[2];
} T[N];
bool cmp(node t1, node t2) { return t1.s[0] < t2.s[0]; }
int main() {
f[1] = 1;
f[2] = -1;
a[1] = 1;
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i)
cin >> T[i].s[0] >> T[i].s[1];
// for(int i=1;i<=k;++i){
// cout<<T[i].s[0]<<' '<<T[i].s[1]<<endl;
// }
sort(T + 1, T + k + 1, cmp);
for (int i = 1; i <= n; ++i) {
if (i > 2)
f[i] = (f[i - 1] + a[i]) % mod;
else if (i == 2)
f[i] = a[i];
// else if(i==2)f[2]=f[i-1]+f[i];
for (int j = 1; j <= k; ++j) {
if (i + T[j].s[0] <= n)
(a[i + T[j].s[0]] += f[i]) %= mod;
if (i + T[j].s[1] + 1 <= n)
(((a[i + T[j].s[1] + 1] -= f[i]) %= mod) += mod) %= mod;
}
}
// for(int i=1;i<=n;++i){
// cout<<f[i]<<' ';
// }
// cout<<endl;
cout << f[n] << endl;
// int sum=0;
// for(int i=1;i<=n;i++)sum+=f[i];
// cout<<sum<<endl;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pii pair<int, int>
ll dp[(ll)(2e5 + 2)];
ll MOD = 998244353;
int main() {
memset(dp, 0, sizeof dp);
int n, k;
cin >> n >> k;
vector<pii> v(k);
for (int i = 0; i < k; i++) {
cin >> v[i].first >> v[i].second;
}
// int ans=0;
dp[0] = 1;
vector<ll> pref(n + 1);
ll pref_sum = 0;
for (int i = 0; i < n; i++) {
dp[i] += pref_sum;
for (int j = 0; j < k; j++) {
int L = v[j].first;
int R = v[j].second;
if (i + L < n)
pref[i + L] += dp[i];
// pref[i+L] = pref[i+L]%MOD;
if (pref[i + L] > MOD)
pref[i + L] -= MOD;
if (i + R + 1 < n) {
pref[i + R + 1] -= dp[i];
if (pref[i + R + 1] < 0)
pref[i + R + 1] += MOD;
}
}
pref_sum += pref[i + 1];
if (pref_sum > MOD)
pref_sum -= MOD;
if (pref_sum < 0)
pref_sum += MOD;
}
cout << dp[n - 1] % MOD << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pii pair<int, int>
ll dp[(ll)(2e5 + 2)];
ll MOD = 998244353;
int main() {
memset(dp, 0, sizeof dp);
int n, k;
cin >> n >> k;
vector<pii> v(k);
for (int i = 0; i < k; i++) {
cin >> v[i].first >> v[i].second;
}
// int ans=0;
dp[0] = 1;
vector<ll> pref(n + 1);
ll pref_sum = 0;
for (int i = 0; i < n; i++) {
dp[i] += pref_sum;
for (int j = 0; j < k; j++) {
int L = v[j].first;
int R = v[j].second;
if (i + L < n)
pref[i + L] += dp[i];
// pref[i+L] = pref[i+L]%MOD;
if (i + L < n && pref[i + L] > MOD)
pref[i + L] -= MOD;
if (i + R + 1 < n) {
pref[i + R + 1] -= dp[i];
if (pref[i + R + 1] < 0)
pref[i + R + 1] += MOD;
}
}
pref_sum += pref[i + 1];
if (pref_sum > MOD)
pref_sum -= MOD;
if (pref_sum < 0)
pref_sum += MOD;
}
cout << dp[n - 1] % MOD << endl;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p02549 | C++ | Runtime Error | #include <bits/stdc++.h>
/*
CE
#include<algorithm>
#include<bitset>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<deque>
#include<iostream>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<vector>
*/
using namespace std;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define mem(a, b) memset(a, b, sizeof(a))
#define ios \
std::ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout.tie(0);
// ios can not be used with scanf,printf. IF ios MUST cin,cout.
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> PII;
const ll mod = 998244353;
const int INF = 0x3f3f3f3f;
ll ksm(ll a, ll b) {
ll res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const int N = 1e5 + 10;
int n, k;
ll sum[N], dp[N];
int L[N], R[N];
ll get(int l, int r) {
if (l <= 1)
l = 1;
return ((sum[r] - sum[l - 1]) % mod + mod) % mod;
}
int main() {
scanf("%d%d", &n, &k);
rep(i, 1, k) { scanf("%d%d", &L[i], &R[i]); }
dp[1] = sum[1] = 1;
rep(i, 1, n) {
rep(j, 1, k) { dp[i] = (dp[i] + get(i - R[j], i - L[j])) % mod; }
sum[i] = sum[i - 1] + dp[i];
}
printf("%lld\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
/*
CE
#include<algorithm>
#include<bitset>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<deque>
#include<iostream>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<vector>
*/
using namespace std;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define mem(a, b) memset(a, b, sizeof(a))
#define ios \
std::ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout.tie(0);
// ios can not be used with scanf,printf. IF ios MUST cin,cout.
typedef long long ll;
typedef vector<int> VI;
typedef pair<int, int> PII;
const ll mod = 998244353;
const int INF = 0x3f3f3f3f;
ll ksm(ll a, ll b) {
ll res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const int N = 2e5 + 10;
int n, k;
ll sum[N], dp[N];
int L[N], R[N];
ll get(int l, int r) {
if (l <= 1)
l = 1;
return ((sum[r] - sum[l - 1]) % mod + mod) % mod;
}
int main() {
scanf("%d%d", &n, &k);
rep(i, 1, k) { scanf("%d%d", &L[i], &R[i]); }
dp[1] = sum[1] = 1;
rep(i, 1, n) {
rep(j, 1, k) { dp[i] = (dp[i] + get(i - R[j], i - L[j])) % mod; }
sum[i] = sum[i - 1] + dp[i];
}
printf("%lld\n", dp[n]);
return 0;
}
| replace | 52 | 53 | 52 | 53 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define fore(i, l, r) for (int i = int(l); i < int(r); i++)
#define pb push_back
#define all(x) x.begin(), x.end()
#define sz(a) int((a).size())
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> pii;
const int mod = 1e9 + 7;
template <class T, class U> inline void add_self(T &a, U b) {
a += b;
if (a >= mod)
a -= mod;
if (a < 0)
a += mod;
}
template <class T, class U> inline void min_self(T &x, U y) {
if (y < x)
x = y;
}
template <class T, class U> inline void max_self(T &x, U y) {
if (y > x)
x = y;
}
#define _deb(x) cout << x;
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
_deb(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#define deb(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
template <class T, class U> void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m)
cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U> void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T> void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line)
cout << "{ ";
for (auto x : vp)
debp(x, sep_line);
if (!sep_line)
cout << "}\n";
cout << endl;
}
template <typename T> void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < sz(v); i++)
cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v)
cout << setw(w) << el << " ";
cout << endl;
}
template <typename T> void print_vv(const T &vv) {
if (sz(vv) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < sz(*vv.begin()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v)
cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, X, M;
while (cin >> n >> X >> M) {
--n;
vl dp(M);
dp[0] = X;
fore(i, 1, M) { dp[i] = (dp[i - 1] * dp[i - 1]) % M; }
// print(dp);
if (n < M) {
ll sum = 0;
forn(i, n + 1) sum += dp[i];
cout << sum << "\n";
continue;
}
set<ll> seen;
int stval = -1;
for (auto x : dp) {
if (!seen.count(x)) {
seen.insert(x);
} else {
stval = x;
break;
}
}
int st = 0, ed = 0;
while (dp[st] != stval)
++st;
ed = st;
while (dp[ed + 1] != dp[st])
++ed;
ll sum = 0;
forn(i, st) sum += dp[i];
n -= (st - 1);
int clen = (ed - st + 1);
ll cycsum = 0;
for (int i = st; i <= ed; ++i)
cycsum += dp[i];
sum += (cycsum) * (n / clen);
int rem = n % clen;
forn(i, rem) sum += dp[st + i];
cout << sum << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define fore(i, l, r) for (int i = int(l); i < int(r); i++)
#define pb push_back
#define all(x) x.begin(), x.end()
#define sz(a) int((a).size())
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> pii;
const int mod = 1e9 + 7;
template <class T, class U> inline void add_self(T &a, U b) {
a += b;
if (a >= mod)
a -= mod;
if (a < 0)
a += mod;
}
template <class T, class U> inline void min_self(T &x, U y) {
if (y < x)
x = y;
}
template <class T, class U> inline void max_self(T &x, U y) {
if (y > x)
x = y;
}
#define _deb(x) cout << x;
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
_deb(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#define deb(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
template <class T, class U> void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m)
cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U> void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T> void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line)
cout << "{ ";
for (auto x : vp)
debp(x, sep_line);
if (!sep_line)
cout << "}\n";
cout << endl;
}
template <typename T> void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < sz(v); i++)
cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v)
cout << setw(w) << el << " ";
cout << endl;
}
template <typename T> void print_vv(const T &vv) {
if (sz(vv) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < sz(*vv.begin()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v)
cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, X, M;
while (cin >> n >> X >> M) {
--n;
vl dp(M);
dp[0] = X;
fore(i, 1, M) { dp[i] = (dp[i - 1] * dp[i - 1]) % M; }
// print(dp);
if (n < M) {
ll sum = 0;
forn(i, n + 1) sum += dp[i];
cout << sum << "\n";
continue;
}
set<ll> seen;
int stval = -1;
for (auto x : dp) {
if (!seen.count(x)) {
seen.insert(x);
} else {
stval = x;
break;
}
}
int st = 0, ed = 0;
if (stval != -1) {
while (dp[st] != stval)
++st;
ed = st;
while (dp[ed + 1] != dp[st])
++ed;
} else
st = M, ed = M;
ll sum = 0;
forn(i, st) sum += dp[i];
n -= (st - 1);
int clen = (ed - st + 1);
ll cycsum = 0;
for (int i = st; i <= ed; ++i)
cycsum += dp[i];
sum += (cycsum) * (n / clen);
int rem = n % clen;
forn(i, rem) sum += dp[st + i];
cout << sum << "\n";
}
return 0;
} | replace | 130 | 135 | 130 | 138 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> check(m + 1, false);
vector<ll> a;
ll rs;
check[x] = true;
a.push_back(x);
while (1) {
ll f = (x * x) % m;
if (check[f] == true) {
rep(i, a.size()) {
if (a[i] == f)
rs = i;
}
break;
} else {
check[f] = true;
}
x = f;
a.push_back(x);
}
ll roop = a.size() - rs;
ll ans = 0;
vector<ll> asum(a.size());
rep(i, a.size() + 1) {
if (i == 0)
asum[i] = a[i];
else
asum[i] = asum[i - 1] + a[i];
}
if (n < rs) {
ans = asum[n];
} else {
ans = asum[rs] - a[rs];
n = n - rs;
ans += (n / roop) * (asum[asum.size() - 1] - (asum[rs] - a[rs])) +
((asum[n % roop + rs] - a[n % roop + rs]) - (asum[rs] - a[rs]));
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> check(m + 1, false);
vector<ll> a;
ll rs;
check[x] = true;
a.push_back(x);
while (1) {
ll f = (x * x) % m;
if (check[f] == true) {
rep(i, a.size()) {
if (a[i] == f)
rs = i;
}
break;
} else {
check[f] = true;
}
x = f;
a.push_back(x);
}
ll roop = a.size() - rs;
ll ans = 0;
vector<ll> asum(a.size());
rep(i, a.size()) {
if (i == 0)
asum[i] = a[i];
else
asum[i] = asum[i - 1] + a[i];
}
if (n < rs) {
ans = asum[n];
} else {
ans = asum[rs] - a[rs];
n = n - rs;
ans += (n / roop) * (asum[asum.size() - 1] - (asum[rs] - a[rs])) +
((asum[n % roop + rs] - a[n % roop + rs]) - (asum[rs] - a[rs]));
}
cout << ans << endl;
return 0;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e18 + 7;
int mod = 998244353;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N, X, M;
cin >> N >> X >> M;
vector<int> used(100005);
int old = X, j = 1;
used[X] = true;
while (true) {
old = old * old % M;
if (used[old]) {
break;
}
used[old] = true;
j++;
}
int sum = X;
int now = X;
old = X;
for (int i = 2; i <= min(N, j); i++) {
sum += old * old % M;
old = old * old % M;
now = old;
}
vector<int> s(100005);
int cnt = 1;
while (true) {
old = old * old % M;
s[cnt] = s[cnt - 1] + old;
if (old == now) {
break;
}
cnt++;
}
cout << sum + (N - min(N, j)) / cnt * s[cnt] + s[(N - min(N, j)) % cnt]
<< endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e18 + 7;
int mod = 998244353;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N, X, M;
cin >> N >> X >> M;
vector<int> used(100005);
int old = X, j = 1;
used[X] = true;
while (true) {
old = old * old % M;
if (used[old]) {
break;
}
used[old] = true;
j++;
}
int sum = X;
int now = X;
old = X;
for (int i = 2; i <= min(N, j); i++) {
sum += old * old % M;
old = old * old % M;
now = old;
}
if (N <= j) {
cout << sum << endl;
return 0;
}
vector<int> s(100005);
int cnt = 1;
while (true) {
old = old * old % M;
s[cnt] = s[cnt - 1] + old;
if (old == now) {
break;
}
cnt++;
}
cout << sum + (N - min(N, j)) / cnt * s[cnt] + s[(N - min(N, j)) % cnt]
<< endl;
}
| insert | 30 | 30 | 30 | 34 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define MP make_pair
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define DB(x) cerr << #x << " = " << x << endl
#define DB2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define DEBUG \
int x12345; \
cin >> x12345;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
const long long MOD = 1e9 + 7;
///////////////////////////////////////////////
// for template
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/// ⸜( ⌓̈ )⸝ ///
int main() {
ll N, X, M;
cin >> N >> X >> M;
vector<ll> index(M + 2);
vector<ll> XX(M + 2);
REP(i, M + 2) { index[i] = -1; }
ll Xs = X;
ll nsum = 0;
ll lstart, lend;
lstart = -1;
lend = -1;
REP(i, min(M, N)) {
if (i)
Xs = (Xs * Xs) % M;
nsum += Xs;
XX[i] = Xs;
// DB2(i,XX[i]);
// DB2(i,nsum);
if (index[Xs] != -1) {
lstart = index[Xs];
lend = i - 1;
break;
}
index[Xs] = i;
}
// DB2(lstart,lend);
ll ans = 0;
if (lstart != -1) {
ll loopsize = lend - lstart + 1;
ll loopcount = (N - lstart) / loopsize;
ll rest = (N - lstart) % loopsize;
REP(i, lstart) { ans += XX[i]; }
REP(i, rest) { ans += XX[lstart + i]; }
ll loopsum = 0;
FORq(i, lstart, lend) { loopsum += XX[i]; }
ans += loopsum * loopcount;
} else {
REP(i, N) { ans += XX[i]; }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define MP make_pair
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define DB(x) cerr << #x << " = " << x << endl
#define DB2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define DEBUG \
int x12345; \
cin >> x12345;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
const long long MOD = 1e9 + 7;
///////////////////////////////////////////////
// for template
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/// ⸜( ⌓̈ )⸝ ///
int main() {
ll N, X, M;
cin >> N >> X >> M;
vector<ll> index(M + 2);
vector<ll> XX(M + 2);
REP(i, M + 2) { index[i] = -1; }
ll Xs = X;
ll nsum = 0;
ll lstart, lend;
lstart = -1;
lend = -1;
REP(i, 100000) {
if (i)
Xs = (Xs * Xs) % M;
nsum += Xs;
XX[i] = Xs;
// DB2(i,XX[i]);
// DB2(i,nsum);
if (index[Xs] != -1) {
lstart = index[Xs];
lend = i - 1;
break;
}
index[Xs] = i;
}
// DB2(lstart,lend);
ll ans = 0;
if (lstart != -1) {
ll loopsize = lend - lstart + 1;
ll loopcount = (N - lstart) / loopsize;
ll rest = (N - lstart) % loopsize;
REP(i, lstart) { ans += XX[i]; }
REP(i, rest) { ans += XX[lstart + i]; }
ll loopsum = 0;
FORq(i, lstart, lend) { loopsum += XX[i]; }
ans += loopsum * loopcount;
} else {
REP(i, N) { ans += XX[i]; }
}
cout << ans << endl;
} | replace | 59 | 60 | 59 | 60 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define int long long
#define mod 1000000007
#define pb push_back
#define S second
#define F first
#define INF 1e18
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define deb(x) cerr << "\n" << #x << "=" << x << "\n";
#define deb2(x, y) \
cerr << "\n" << #x << "=" << x << "\n" << #y << "=" << y << "\n";
#define w(x) \
int x; \
cin >> x; \
while (x--)
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, m;
cin >> n >> x >> m;
int ans = 0;
vector<int> prev;
map<int, bool> seen;
int cur = 1, start = -1;
while (cur <= n) {
if (seen.find(x) != seen.end()) {
break;
}
ans = (ans + x);
prev.pb(x);
seen[x] = 1;
x = (x % m * x % m) % m;
cur++;
}
if (cur >= n) {
cout << ans;
return 0;
}
int val = 0, ok = -1;
for (int i = 0; i < prev.size(); ++i) {
if (prev[i] == x && ok == -1)
ok = i;
if (ok != -1)
val = val + prev[i];
}
int len = prev.size() - ok;
while (len + cur <= n) {
ans = (ans + val);
cur += len;
}
for (; cur <= n; cur++) {
ans = (ans + prev[ok]);
ok++;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define int long long
#define mod 1000000007
#define pb push_back
#define S second
#define F first
#define INF 1e18
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define deb(x) cerr << "\n" << #x << "=" << x << "\n";
#define deb2(x, y) \
cerr << "\n" << #x << "=" << x << "\n" << #y << "=" << y << "\n";
#define w(x) \
int x; \
cin >> x; \
while (x--)
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, m;
cin >> n >> x >> m;
int ans = 0;
vector<int> prev;
map<int, bool> seen;
int cur = 1, start = -1;
while (cur <= n) {
if (seen.find(x) != seen.end()) {
break;
}
ans = (ans + x);
prev.pb(x);
seen[x] = 1;
x = (x % m * x % m) % m;
cur++;
}
if (cur >= n) {
cout << ans;
return 0;
}
int val = 0, ok = -1;
for (int i = 0; i < prev.size(); ++i) {
if (prev[i] == x && ok == -1)
ok = i;
if (ok != -1)
val = val + prev[i];
}
int len = prev.size() - ok;
// while(len + cur <= n) {
// ans = (ans + val);
// cur += len;
// }
int maxm = (n - cur) / len;
cur += maxm * len;
ans += val * maxm;
for (; cur <= n; cur++) {
ans = (ans + prev[ok]);
ok++;
}
cout << ans;
}
| replace | 62 | 66 | 62 | 70 | TLE | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 1; i <= n; ++i)
#define all(x) begin(x), end(x - I.)
#define show(obj) \
{ \
for (auto x : obj) \
cout << x << ' '; \
cout << endl; \
}
#define line "----------"
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const int inf = 1001001000;
const ll INF = 1LL << 60;
const int MOD = (int)1e9 + 7;
int main() {
ll N, X, M;
cin >> N >> X >> M;
vector<ll> f;
set<ll> al;
f.push_back(X);
al.insert(X);
bool is_zero = false;
ll last = 0;
while (true) {
ll nxt = (f[f.size() - 1] * f[f.size() - 1]) % M;
if (nxt == 0)
is_zero = true;
if (al.count(nxt) == 1) {
last = nxt;
break;
}
f.push_back(nxt);
al.insert(nxt);
}
if (is_zero) {
ll ans = 0;
for (ll i = 0; i < min(N, (ll)f.size()); ++i)
ans += f[i];
cout << ans << endl;
return 0;
}
ll ans = 0;
bool out_head = false;
ll loop_len = 0;
ll loop_sum = 0;
ll rest = N;
vector<ll> loop;
for (int i = 0; i < min(N, (ll)f.size()); ++i) {
if (f[i] == last)
out_head = true;
if (!out_head) {
ans += f[i];
--rest;
} else {
++loop_len;
loop_sum += f[i];
loop.push_back(f[i]);
}
}
ans += rest / loop_len * loop_sum;
rest %= loop_len;
rep(i, rest) ans += loop[i];
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 1; i <= n; ++i)
#define all(x) begin(x), end(x - I.)
#define show(obj) \
{ \
for (auto x : obj) \
cout << x << ' '; \
cout << endl; \
}
#define line "----------"
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const int inf = 1001001000;
const ll INF = 1LL << 60;
const int MOD = (int)1e9 + 7;
int main() {
ll N, X, M;
cin >> N >> X >> M;
if (N == 1) {
cout << X << endl;
return 0;
}
vector<ll> f;
set<ll> al;
f.push_back(X);
al.insert(X);
bool is_zero = false;
ll last = 0;
while (true) {
ll nxt = (f[f.size() - 1] * f[f.size() - 1]) % M;
if (nxt == 0)
is_zero = true;
if (al.count(nxt) == 1) {
last = nxt;
break;
}
f.push_back(nxt);
al.insert(nxt);
}
if (is_zero) {
ll ans = 0;
for (ll i = 0; i < min(N, (ll)f.size()); ++i)
ans += f[i];
cout << ans << endl;
return 0;
}
ll ans = 0;
bool out_head = false;
ll loop_len = 0;
ll loop_sum = 0;
ll rest = N;
vector<ll> loop;
for (int i = 0; i < min(N, (ll)f.size()); ++i) {
if (f[i] == last)
out_head = true;
if (!out_head) {
ans += f[i];
--rest;
} else {
++loop_len;
loop_sum += f[i];
loop.push_back(f[i]);
}
}
ans += rest / loop_len * loop_sum;
rest %= loop_len;
rep(i, rest) ans += loop[i];
cout << ans << endl;
return 0;
} | insert | 35 | 35 | 35 | 39 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
// constexpr int mod = 1000000007;
constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, X, M;
cin >> N >> X >> M;
vector<vector<int>> graph(M), rev(M);
for (int i = 1; i < M; ++i) {
ll v = (ll)i * i % M;
graph[i].emplace_back(v);
rev[v].emplace_back(i);
}
vector<int> vs;
vector<bool> used(M, false);
auto dfs = [&](auto &&self, int from) -> void {
used[from] = true;
for (int to : graph[from]) {
if (!used[to])
self(self, to);
}
vs.emplace_back(from);
};
for (int v = 0; v < M; ++v) {
if (!used[v])
dfs(dfs, v);
}
reverse(vs.begin(), vs.end());
vector<int> scc_id(M, -1);
int K = 0;
auto rdfs = [&](auto &&self, int from) -> void {
scc_id[from] = K;
for (int to : rev[from]) {
if (scc_id[to] == -1)
self(self, to);
}
};
for (int v : vs) {
if (scc_id[v] == -1) {
rdfs(rdfs, v);
++K;
}
}
vector<vector<int>> scc_set(K);
for (int i = 0; i < M; ++i) {
scc_set[scc_id[i]].emplace_back(i);
}
ll ans = X;
--N;
X = graph[X][0];
while (N > 0) {
if (X == 0)
break;
if (scc_set[scc_id[X]].size() == 1) {
if (X == graph[X][0]) {
ans += X * N;
N = 0;
} else {
ans += X;
X = graph[X][0];
--N;
}
} else {
int loop = scc_set[scc_id[X]].size();
ll total = 0;
for (int v : scc_set[scc_id[X]]) {
total += v;
}
ans += total * (N / loop);
N %= loop;
while (N-- > 0) {
if (X == 0) {
N = 0;
break;
}
ans += X;
X = graph[X][0];
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr int INF = 1001001001;
// constexpr int mod = 1000000007;
constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, X, M;
cin >> N >> X >> M;
vector<vector<int>> graph(M), rev(M);
for (int i = 0; i < M; ++i) {
ll v = (ll)i * i % M;
graph[i].emplace_back(v);
rev[v].emplace_back(i);
}
vector<int> vs;
vector<bool> used(M, false);
auto dfs = [&](auto &&self, int from) -> void {
used[from] = true;
for (int to : graph[from]) {
if (!used[to])
self(self, to);
}
vs.emplace_back(from);
};
for (int v = 0; v < M; ++v) {
if (!used[v])
dfs(dfs, v);
}
reverse(vs.begin(), vs.end());
vector<int> scc_id(M, -1);
int K = 0;
auto rdfs = [&](auto &&self, int from) -> void {
scc_id[from] = K;
for (int to : rev[from]) {
if (scc_id[to] == -1)
self(self, to);
}
};
for (int v : vs) {
if (scc_id[v] == -1) {
rdfs(rdfs, v);
++K;
}
}
vector<vector<int>> scc_set(K);
for (int i = 0; i < M; ++i) {
scc_set[scc_id[i]].emplace_back(i);
}
ll ans = X;
--N;
X = graph[X][0];
while (N > 0) {
if (X == 0)
break;
if (scc_set[scc_id[X]].size() == 1) {
if (X == graph[X][0]) {
ans += X * N;
N = 0;
} else {
ans += X;
X = graph[X][0];
--N;
}
} else {
int loop = scc_set[scc_id[X]].size();
ll total = 0;
for (int v : scc_set[scc_id[X]]) {
total += v;
}
ans += total * (N / loop);
N %= loop;
while (N-- > 0) {
if (X == 0) {
N = 0;
break;
}
ans += X;
X = graph[X][0];
}
}
}
cout << ans << endl;
} | replace | 53 | 54 | 53 | 54 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double LD;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 4e18;
const double INFD = 1e30;
const double EPS = 1e-10;
const long double PI = acosl(-1);
const int MOD = 1e9 + 7;
template <typename T> inline T read() {
T X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch))
X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
const int MAXN = 7777;
const int MAXV = 100005;
int n, m, k;
int dr[4] = {1, 0, -1, 0};
int dc[4] = {0, 1, 0, -1};
int dr2[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int dc2[8] = {1, 0, -1, 1, 0, -1, 1, -1};
int CASE = 1;
int rem[MAXN];
int app[MAXV];
ll pref[MAXN];
int main() {
#ifdef LOCALLL
freopen("in", "r", stdin);
freopen("out", "w", stdout);
#endif
ll a = read<ll>();
int x = read<int>();
int m = read<int>();
rem[1] = x % m;
app[rem[1]] = 1;
int base = 1;
int length = 0;
for (ll i = 2; i <= a; i++) {
rem[i] = (ll)rem[i - 1] * rem[i - 1] % m;
if (app[rem[i]]) {
base = app[rem[i]];
length = i - base;
break;
}
app[rem[i]] = i;
}
if (!length)
length = a;
for (int i = 1; i < base + length; i++) {
pref[i] = pref[i - 1] + rem[i];
}
ll ans = 0;
if (a >= base - 1) {
ans += pref[base - 1];
a -= base - 1;
}
ll cyc = pref[base + length - 1] - pref[base - 1];
ans += cyc * (a / length);
ans += (pref[(a % length) + base - 1] - pref[base - 1]);
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double LD;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 4e18;
const double INFD = 1e30;
const double EPS = 1e-10;
const long double PI = acosl(-1);
const int MOD = 1e9 + 7;
template <typename T> inline T read() {
T X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch))
X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
const int MAXN = 117777;
const int MAXV = 100005;
int n, m, k;
int dr[4] = {1, 0, -1, 0};
int dc[4] = {0, 1, 0, -1};
int dr2[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int dc2[8] = {1, 0, -1, 1, 0, -1, 1, -1};
int CASE = 1;
int rem[MAXN];
int app[MAXV];
ll pref[MAXN];
int main() {
#ifdef LOCALLL
freopen("in", "r", stdin);
freopen("out", "w", stdout);
#endif
ll a = read<ll>();
int x = read<int>();
int m = read<int>();
rem[1] = x % m;
app[rem[1]] = 1;
int base = 1;
int length = 0;
for (ll i = 2; i <= a; i++) {
rem[i] = (ll)rem[i - 1] * rem[i - 1] % m;
if (app[rem[i]]) {
base = app[rem[i]];
length = i - base;
break;
}
app[rem[i]] = i;
}
if (!length)
length = a;
for (int i = 1; i < base + length; i++) {
pref[i] = pref[i - 1] + rem[i];
}
ll ans = 0;
if (a >= base - 1) {
ans += pref[base - 1];
a -= base - 1;
}
ll cyc = pref[base + length - 1] - pref[base - 1];
ans += cyc * (a / length);
ans += (pref[(a % length) + base - 1] - pref[base - 1]);
printf("%lld\n", ans);
return 0;
} | replace | 40 | 41 | 40 | 41 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int x, m;
vector<int> check(m + 5, 0);
vector<long long> store(m + 5, 0);
cin >> n >> x >> m;
check[x] = 1;
store[1] = x;
long long next = x;
long long ans = x;
for (long long i = 2; i <= n; i++) {
next = (next * next) % m;
if (check[next]) {
long long sum = 0;
for (long long j = check[next]; j < i; j++) {
sum += store[j];
}
long long length = i - check[next];
long long togo = n - i + 1;
ans += (togo / length) * sum;
for (long long j = check[next]; j < check[next] + togo % length; j++) {
ans += store[j];
}
break;
} else {
ans += next;
check[next] = i;
store[i] = next;
}
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int x, m;
vector<int> check(200001, 0);
vector<long long> store(200001, 0);
cin >> n >> x >> m;
check[x] = 1;
store[1] = x;
long long next = x;
long long ans = x;
for (long long i = 2; i <= n; i++) {
next = (next * next) % m;
if (check[next]) {
long long sum = 0;
for (long long j = check[next]; j < i; j++) {
sum += store[j];
}
long long length = i - check[next];
long long togo = n - i + 1;
ans += (togo / length) * sum;
for (long long j = check[next]; j < check[next] + togo % length; j++) {
ans += store[j];
}
break;
} else {
ans += next;
check[next] = i;
store[i] = next;
}
}
cout << ans << '\n';
return 0;
}
| replace | 5 | 7 | 5 | 7 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define Fast cin.tie(0), ios::sync_with_stdio(0)
#define All(x) x.begin(), x.end()
#define louisfghbvc \
int t; \
cin >> t; \
while (t--)
#define sz(x) (int)(x).size()
using namespace std;
typedef long long LL;
typedef pair<LL, LL> ii;
typedef vector<LL> vi;
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep = "";
for (const auto &x : v)
os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << "\n"; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int N = 2e5 + 5;
void solve() {
LL n, x, m;
cin >> n >> x >> m;
LL res = 0;
LL slow = x, fast = x;
do {
slow = slow * slow % m;
fast = fast * fast % m;
fast = fast * fast % m;
} while (slow != fast);
fast = x;
int L = 0;
while (slow != fast) {
res += fast;
L++;
if (L == n)
break;
slow = slow * slow % m;
fast = fast * fast % m;
}
n -= L;
vi cyc;
do {
cyc.push_back(slow);
slow = slow * slow % m;
} while (slow != fast);
LL cyclen = sz(cyc);
for (int i = 0; i < cyclen; ++i) {
res += (n / cyclen) * cyc[i];
}
n %= cyclen;
for (int i = 0; i < n; ++i) {
res += cyc[i];
}
cout << res << "\n";
}
int main() {
Fast;
// louisfghbvc{
solve();
//}
return 0;
}
| #include <bits/stdc++.h>
#define Fast cin.tie(0), ios::sync_with_stdio(0)
#define All(x) x.begin(), x.end()
#define louisfghbvc \
int t; \
cin >> t; \
while (t--)
#define sz(x) (int)(x).size()
using namespace std;
typedef long long LL;
typedef pair<LL, LL> ii;
typedef vector<LL> vi;
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep = "";
for (const auto &x : v)
os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << "\n"; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int N = 2e5 + 5;
void solve() {
LL n, x, m;
cin >> n >> x >> m;
LL res = 0;
LL slow = x, fast = x;
do {
slow = slow * slow % m;
fast = fast * fast % m;
fast = fast * fast % m;
} while (slow != fast);
fast = x;
int L = 0;
while (slow != fast) {
res += fast;
L++;
if (L == n) {
cout << res << "\n";
return;
}
slow = slow * slow % m;
fast = fast * fast % m;
}
n -= L;
vi cyc;
do {
cyc.push_back(slow);
slow = slow * slow % m;
} while (slow != fast);
LL cyclen = sz(cyc);
for (int i = 0; i < cyclen; ++i) {
res += (n / cyclen) * cyc[i];
}
n %= cyclen;
for (int i = 0; i < n; ++i) {
res += cyc[i];
}
cout << res << "\n";
}
int main() {
Fast;
// louisfghbvc{
solve();
//}
return 0;
}
| replace | 56 | 58 | 56 | 60 | TLE | |
p02550 | C++ | Time Limit Exceeded | #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;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
const double PI = acos(-1);
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
/*-------------------------------------------*/
ll n, x, m;
int t[100009];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> x >> m;
ll ans = 0;
int time = 0;
while (!t[x]) {
t[x] = ++time;
ans += x;
x = (x * x) % m;
n--;
}
int cy = 0;
ll cost = 0, y = x;
do {
cost += y;
y = (y * y) % m;
cy++;
} while (y != x);
ans += (n / cy) * cost;
n %= cy;
while (n--) {
ans += x;
x = (x * x) % m;
}
cout << ans << 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;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
const double PI = acos(-1);
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
/*-------------------------------------------*/
ll n, x, m;
int t[100009];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> x >> m;
ll ans = 0;
int time = 0;
while (!t[x]) {
t[x] = ++time;
ans += x;
x = (x * x) % m;
n--;
if (n == 0) {
cout << ans << endl;
return 0;
}
}
int cy = 0;
ll cost = 0, y = x;
do {
cost += y;
y = (y * y) % m;
cy++;
} while (y != x);
ans += (n / cy) * cost;
n %= cy;
while (n--) {
ans += x;
x = (x * x) % m;
}
cout << ans << endl;
return 0;
} | insert | 36 | 36 | 36 | 40 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll f(ll n, ll x, ll m) {
ll ref = x;
ll now = x * x % m;
int cnt = 1;
vector<ll> d(m + 1);
d[0] = 0;
while (now != x) {
d[cnt] = ref;
ref += now;
now = now * now % m;
++cnt;
}
ref = n / cnt * ref + d[n % cnt];
return ref;
}
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> ok(n, true);
ll cnt = 0;
ll ans = 0;
while (cnt < n) {
if (!ok[x])
break;
ans += x;
ok[x] = false;
x = x * x % m;
++cnt;
}
ans += f(n - cnt, x, m);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll f(ll n, ll x, ll m) {
ll ref = x;
ll now = x * x % m;
int cnt = 1;
vector<ll> d(m + 1);
d[0] = 0;
while (now != x) {
d[cnt] = ref;
ref += now;
now = now * now % m;
++cnt;
}
ref = n / cnt * ref + d[n % cnt];
return ref;
}
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> ok(m, true);
ll cnt = 0;
ll ans = 0;
while (cnt < n) {
if (!ok[x])
break;
ans += x;
ok[x] = false;
x = x * x % m;
++cnt;
}
ans += f(n - cnt, x, m);
cout << ans << endl;
} | replace | 23 | 24 | 23 | 24 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#pragma GCC optimize("-O3")
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL); \
cerr.tie(NULL);
#define tolower(s) transform(s.begin(), s.end(), s.begin(), ::tolower);
#define toupper(s) transform(s.begin(), s.end(), s.begin(), ::toupper);
#define ll long long int
ll max(ll a, ll b) { return a > b ? a : b; }
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return b == 0 ? a : gcd(b, a % b);
}
#define case(i) cout << "Case #" << i << ": ";
#define debug(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
cerr << '\n'; \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << "[ " << *it << " = " << a << " ]";
err(++it, args...);
}
#define pii pair<ll, ll>
#define pb push_back
#define PRECISION 10
const ll inf = 9223372036854775800;
const int MAXN = 100001;
const int LOGN = 22;
const int MAXBIT = 62;
const long double PI = 3.141592653589793;
const int DIGITSIZE = 18;
ll mod = 1e9 + 7;
ll MOD = 998244353;
int x4[] = {1, -1, 0, 0};
int y4[] = {0, 0, 1, -1};
int x8[] = {1, 1, 1, -1, -1, -1, 0, 0};
int y8[] = {1, 0, -1, 1, 0, -1, 1, -1};
bool takeTestCases = 0;
bool printCaseNo = 0;
void getac(int T) {
ll n, x, m;
cin >> n >> x >> m;
ll arr[n + 1];
arr[1] = x;
map<int, int> mp;
mp[x] = 1;
ll startCycle = -1;
ll ans = x;
if (n == 1) {
cout << x << '\n';
return;
}
for (int i = 2; i <= n; i++) {
arr[i] = 0;
ll val = arr[i - 1] * arr[i - 1];
val %= m;
if (mp[val] == 0) {
mp[val] = i;
ans += val;
arr[i] = val;
} else {
ll cycleLength = i - mp[val];
startCycle = mp[val];
ll remValues = n - i + 1;
ll totalCycles = remValues / cycleLength;
ll totalCycleVal = 0;
ll remCycle = remValues - cycleLength * totalCycles;
// debug(cycleLength, i, remCycle, remValues, startCycle, totalCycles);
int k = 0;
for (int j = startCycle; j < i; j++) {
if (k < remCycle) {
ans += arr[j];
k++;
}
totalCycleVal += arr[j];
}
ans += totalCycleVal * totalCycles;
break;
}
}
// for (int i = 1; i <= n; i++) {
// cout << arr[i] << ' ';
// }
cout << ans << '\n';
}
int main() {
fastio;
int t = 1;
if (takeTestCases) {
cin >> t;
}
int t_t = 1;
while (t--) {
if (printCaseNo)
case (t_t);
getac(t_t);
t_t++;
}
cerr << "Total time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms" << '\n';
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#pragma GCC optimize("-O3")
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL); \
cerr.tie(NULL);
#define tolower(s) transform(s.begin(), s.end(), s.begin(), ::tolower);
#define toupper(s) transform(s.begin(), s.end(), s.begin(), ::toupper);
#define ll long long int
ll max(ll a, ll b) { return a > b ? a : b; }
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
}
return b == 0 ? a : gcd(b, a % b);
}
#define case(i) cout << "Case #" << i << ": ";
#define debug(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
cerr << '\n'; \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << "[ " << *it << " = " << a << " ]";
err(++it, args...);
}
#define pii pair<ll, ll>
#define pb push_back
#define PRECISION 10
const ll inf = 9223372036854775800;
const int MAXN = 100001;
const int LOGN = 22;
const int MAXBIT = 62;
const long double PI = 3.141592653589793;
const int DIGITSIZE = 18;
ll mod = 1e9 + 7;
ll MOD = 998244353;
int x4[] = {1, -1, 0, 0};
int y4[] = {0, 0, 1, -1};
int x8[] = {1, 1, 1, -1, -1, -1, 0, 0};
int y8[] = {1, 0, -1, 1, 0, -1, 1, -1};
bool takeTestCases = 0;
bool printCaseNo = 0;
void getac(int T) {
ll n, x, m;
cin >> n >> x >> m;
map<int, ll> arr;
arr[1] = x;
map<int, int> mp;
mp[x] = 1;
ll startCycle = -1;
ll ans = x;
if (n == 1) {
cout << x << '\n';
return;
}
for (int i = 2; i <= n; i++) {
arr[i] = 0;
ll val = arr[i - 1] * arr[i - 1];
val %= m;
if (mp[val] == 0) {
mp[val] = i;
ans += val;
arr[i] = val;
} else {
ll cycleLength = i - mp[val];
startCycle = mp[val];
ll remValues = n - i + 1;
ll totalCycles = remValues / cycleLength;
ll totalCycleVal = 0;
ll remCycle = remValues - cycleLength * totalCycles;
// debug(cycleLength, i, remCycle, remValues, startCycle, totalCycles);
int k = 0;
for (int j = startCycle; j < i; j++) {
if (k < remCycle) {
ans += arr[j];
k++;
}
totalCycleVal += arr[j];
}
ans += totalCycleVal * totalCycles;
break;
}
}
// for (int i = 1; i <= n; i++) {
// cout << arr[i] << ' ';
// }
cout << ans << '\n';
}
int main() {
fastio;
int t = 1;
if (takeTestCases) {
cin >> t;
}
int t_t = 1;
while (t--) {
if (printCaseNo)
case (t_t);
getac(t_t);
t_t++;
}
cerr << "Total time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms" << '\n';
return 0;
}
| replace | 85 | 86 | 85 | 86 | 0 | Total time elapsed :20.696 ms
|
p02550 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<string> VS;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<PII> VPI;
typedef vector<PLL> VPL;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define pf push_front
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define ub upper_bound
#define lb lower_bound
int main() {
ll N, X, M;
cin >> N >> X >> M;
VL A(M, -1), Y(min(M, N));
ll tmp = X;
ll P = min(N, M) - 1;
rep(i, min(N, M)) {
if (A[tmp] >= 0) {
P = i;
break;
} else {
Y[i] = tmp;
A[tmp] = i;
tmp = tmp * tmp % M;
}
}
ll ans = 0;
rep(i, P + 1) ans += Y[i];
ll ans2 = 0;
if (P + 1 != N) {
rep(i, P - A[tmp]) ans2 += Y[A[tmp] + i];
ans2 = ans2 * ((N - P) / (P - A[tmp]));
ans += ans2;
rep(i, (N - P) % (P - A[tmp])) ans += Y[A[tmp] + i];
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<string> VS;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<PII> VPI;
typedef vector<PLL> VPL;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define pf push_front
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define ub upper_bound
#define lb lower_bound
int main() {
ll N, X, M;
cin >> N >> X >> M;
VL A(M, -1), Y(min(M, N));
ll tmp = X;
ll P = min(N, M) - 1;
if (X == 0) {
cout << 0 << endl;
return 0;
}
rep(i, min(N, M)) {
if (A[tmp] >= 0) {
P = i;
break;
} else {
Y[i] = tmp;
A[tmp] = i;
tmp = tmp * tmp % M;
}
}
ll ans = 0;
rep(i, P + 1) ans += Y[i];
ll ans2 = 0;
if (P + 1 != N) {
rep(i, P - A[tmp]) ans2 += Y[A[tmp] + i];
ans2 = ans2 * ((N - P) / (P - A[tmp]));
ans += ans2;
rep(i, (N - P) % (P - A[tmp])) ans += Y[A[tmp] + i];
}
cout << ans << endl;
}
| insert | 40 | 40 | 40 | 44 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define PB push_back
#define MP make_pair
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define INF (1 << 28)
#define LLINF (1LL << 60)
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
typedef pair<int, int> P;
int main() {
ll n, x, m;
cin >> n >> x >> m;
ll num[10005] = {};
ll roopstart = -INF, roopend;
num[0] = x;
ll i = 1;
while (1) {
x = (x * x) % m;
num[i] = x;
for (ll j = 0; j < i; j++) {
if (num[j] == x) {
roopstart = j;
roopend = i - 1;
}
}
i++;
if (roopstart != -INF)
break;
}
ll ans = 0, roopsum = 0;
for (ll i = 0; i < roopstart; i++) {
ans += num[i];
}
for (ll i = roopstart; i <= roopend; i++) {
roopsum += num[i];
}
ans += roopsum * ((n - roopstart) / (roopend - roopstart + 1));
ll remain = n - (roopstart + (n - roopstart) / (roopend - roopstart + 1) *
(roopend - roopstart + 1));
for (ll i = roopstart; i < roopstart + remain; i++) {
ans += num[i];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define PB push_back
#define MP make_pair
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define INF (1 << 28)
#define LLINF (1LL << 60)
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
typedef pair<int, int> P;
int main() {
ll n, x, m;
cin >> n >> x >> m;
ll num[100005] = {};
ll roopstart = -INF, roopend;
num[0] = x;
ll i = 1;
while (1) {
x = (x * x) % m;
num[i] = x;
for (ll j = 0; j < i; j++) {
if (num[j] == x) {
roopstart = j;
roopend = i - 1;
}
}
i++;
if (roopstart != -INF)
break;
}
ll ans = 0, roopsum = 0;
for (ll i = 0; i < roopstart; i++) {
ans += num[i];
}
for (ll i = roopstart; i <= roopend; i++) {
roopsum += num[i];
}
ans += roopsum * ((n - roopstart) / (roopend - roopstart + 1));
ll remain = n - (roopstart + (n - roopstart) / (roopend - roopstart + 1) *
(roopend - roopstart + 1));
for (ll i = roopstart; i < roopstart + remain; i++) {
ans += num[i];
}
cout << ans << endl;
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, X, M;
cin >> N >> X >> M;
long long sum1 = 0;
long long sum2 = 0;
vector<long long> L(M);
vector<long long> count(M, 0);
L.at(0) = X;
count.at(X)++;
long long A = -1;
long long B = -1;
long long Y = -1;
if (N == 1) {
cout << X << endl;
return 0;
}
for (int i = 1; i < M; i++) {
L.at(i) = (L.at(i - 1) * L.at(i - 1)) % M;
count.at(L.at(i))++;
if (count.at(L.at(i)) > 1) {
A = i + 1;
Y = L.at(i);
break;
}
}
long long ans = 0;
if (A == -1) {
for (int i = 0; i < N; i++) {
ans += L.at(i);
}
cout << ans << endl;
return 0;
}
long long judge = 0;
for (int i = 0; i < A; i++) {
if (L.at(i) == Y) {
judge++;
if (judge == 1) {
B = i + 1;
}
}
if (judge == 0) {
sum1 += L.at(i);
} else if (judge == 1) {
sum2 += L.at(i);
}
}
if (N < A) {
for (int i = 0; i < N; i++) {
ans += L.at(i);
}
} else {
long long C = (N - B + 1) / (A - B);
long long D = (N - B + 1) % (A - B);
for (int i = B - 1; i < B + D - 1; i++) {
ans += L.at(i);
}
ans += sum1 + C * sum2;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, X, M;
cin >> N >> X >> M;
if (M == 1) {
cout << 0 << endl;
return 0;
}
long long sum1 = 0;
long long sum2 = 0;
vector<long long> L(M);
vector<long long> count(M, 0);
L.at(0) = X;
count.at(X)++;
long long A = -1;
long long B = -1;
long long Y = -1;
if (N == 1) {
cout << X << endl;
return 0;
}
for (int i = 1; i < M; i++) {
L.at(i) = (L.at(i - 1) * L.at(i - 1)) % M;
count.at(L.at(i))++;
if (count.at(L.at(i)) > 1) {
A = i + 1;
Y = L.at(i);
break;
}
}
long long ans = 0;
if (A == -1) {
for (int i = 0; i < N; i++) {
ans += L.at(i);
}
cout << ans << endl;
return 0;
}
long long judge = 0;
for (int i = 0; i < A; i++) {
if (L.at(i) == Y) {
judge++;
if (judge == 1) {
B = i + 1;
}
}
if (judge == 0) {
sum1 += L.at(i);
} else if (judge == 1) {
sum2 += L.at(i);
}
}
if (N < A) {
for (int i = 0; i < N; i++) {
ans += L.at(i);
}
} else {
long long C = (N - B + 1) / (A - B);
long long D = (N - B + 1) % (A - B);
for (int i = B - 1; i < B + D - 1; i++) {
ans += L.at(i);
}
ans += sum1 + C * sum2;
}
cout << ans << endl;
} | insert | 6 | 6 | 6 | 11 | 0 | |
p02550 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <array>
#include <bitset>
#include <chrono>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define make_unique(x) \
sort(all((x))); \
(x).resize(unique(all((x))) - (x).begin())
typedef long long ll;
typedef long double ld;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, x, m;
cin >> n >> x >> m;
ll ans = 0;
ll cycle = 0, tot = 0, left = n;
vector<char> u(m + 1);
while (true) {
ans += x;
left--;
if (left == 0)
break;
if (u[x])
break;
u[x] = true;
x = (x * x) % m;
}
ll stop = x;
do {
tot += x;
cycle++;
x = (x * x) % m;
} while (x != stop);
ans += tot * (left / cycle);
left %= cycle;
while (left--) {
x = (x * x) % m;
ans += x;
}
cout << ans;
return 0;
}
/*
*/
| #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <array>
#include <bitset>
#include <chrono>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define make_unique(x) \
sort(all((x))); \
(x).resize(unique(all((x))) - (x).begin())
typedef long long ll;
typedef long double ld;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, x, m;
cin >> n >> x >> m;
ll ans = 0;
ll cycle = 0, tot = 0, left = n;
vector<char> u(m + 1);
while (true) {
ans += x;
left--;
if (left == 0) {
cout << ans;
return 0;
}
if (u[x])
break;
u[x] = true;
x = (x * x) % m;
}
ll stop = x;
do {
tot += x;
cycle++;
x = (x * x) % m;
} while (x != stop);
ans += tot * (left / cycle);
left %= cycle;
while (left--) {
x = (x * x) % m;
ans += x;
}
cout << ans;
return 0;
}
/*
*/
| replace | 51 | 53 | 51 | 55 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int x, m;
cin >> n >> x >> m;
vector<int> cir;
int cur = x;
vector<bool> vis(m);
int start = -1;
long long ans = 0;
long long sum = 0;
while (n > 0) {
if (cur == 0) {
cout << ans << '\n';
exit(0);
}
if (vis[cur]) {
start = cur;
break;
}
n -= 1;
ans += cur;
vis[cur] = true;
cur = 1LL * cur * cur % m;
}
vis.assign(n, false);
while (!vis[start]) {
cir.emplace_back(start);
vis[start] = true;
sum += start;
start = 1LL * start * start % m;
}
int s = cir.size();
ans += n / s * sum;
for (int i = 0; i < n % s; ++i) {
ans += cir[i];
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int x, m;
cin >> n >> x >> m;
vector<int> cir;
int cur = x;
vector<bool> vis(m);
int start = -1;
long long ans = 0;
long long sum = 0;
while (n > 0) {
if (cur == 0) {
cout << ans << '\n';
exit(0);
}
if (vis[cur]) {
start = cur;
break;
}
n -= 1;
ans += cur;
vis[cur] = true;
cur = 1LL * cur * cur % m;
}
if (n == 0) {
cout << ans << '\n';
exit(0);
}
for (int i = 0; i < m; ++i) {
vis[i] = false;
}
while (!vis[start]) {
cir.emplace_back(start);
vis[start] = true;
sum += start;
start = 1LL * start * start % m;
}
int s = cir.size();
ans += n / s * sum;
for (int i = 0; i < n % s; ++i) {
ans += cir[i];
}
cout << ans << '\n';
return 0;
} | replace | 30 | 31 | 30 | 38 | -6 | double free or corruption (out)
|
p02550 | C++ | Runtime Error | // Bismillah Hir Rehmanir Rahim
// Allah knows best
using namespace std;
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
#define mini -10000000000000000
#define start \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define f(i, a, n) for (i = a; i < n; i++)
#define ll long long
#define pi 3.141592653589793
#define vi vector<int>
#define si set<int>
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define rr return 0
#define ff first
#define in insert
#define ss second
#define setbits(x) __builtin_popcountll(x)
#define zrbits(x) __builtin_ctzll(x)
#define deb(x) cout << #x << " = " << x << endl
int main() {
start;
ll i, j, k, n, m;
cin >> n >> k >> m;
vector<ll> ami;
ll ans = 0;
for (i = k, j = 0; j < m; j++) {
if (j <= n - 1) {
ans += (i % m);
}
ami.pb(i % m);
if (j == n - 1) {
cout << ans << endl;
rr;
}
i = i % m;
i = i * i;
i %= m;
}
ll ajob = ami.size();
ll st;
for (i = 0; i < ajob; i++) {
if (ami[i] == ami[ajob - 1]) {
st = i;
break;
}
}
ll len;
for (i = st + 1; i < ajob; i++) {
if (ami[st] == ami[i]) {
len = i - st;
break;
}
}
i -= len;
ans = 0;
for (j = 0; j < i; j++)
ans += ami[j];
ll l_sum = 0;
for (i = st, j = 0; j < len; i++, j++) {
l_sum += ami[i];
}
ll bad = n - st;
ll ro = bad / len;
ans = ans + ro * l_sum;
bad = (n - st) % len;
for (i = st, j = 0; j < bad; i++, j++)
ans += ami[i];
cout << ans << endl;
rr;
} | // Bismillah Hir Rehmanir Rahim
// Allah knows best
using namespace std;
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
#define mini -10000000000000000
#define start \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define f(i, a, n) for (i = a; i < n; i++)
#define ll long long
#define pi 3.141592653589793
#define vi vector<int>
#define si set<int>
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define rr return 0
#define ff first
#define in insert
#define ss second
#define setbits(x) __builtin_popcountll(x)
#define zrbits(x) __builtin_ctzll(x)
#define deb(x) cout << #x << " = " << x << endl
int main() {
start;
ll i, j, k, n, m;
cin >> n >> k >> m;
vector<ll> ami;
ll ans = 0;
for (i = k, j = 0; j < m + 5; j++) {
if (j <= n - 1) {
ans += (i % m);
}
ami.pb(i % m);
if (j == n - 1) {
cout << ans << endl;
rr;
}
i = i % m;
i = i * i;
i %= m;
}
ll ajob = ami.size();
ll st;
for (i = 0; i < ajob; i++) {
if (ami[i] == ami[ajob - 1]) {
st = i;
break;
}
}
ll len;
for (i = st + 1; i < ajob; i++) {
if (ami[st] == ami[i]) {
len = i - st;
break;
}
}
i -= len;
ans = 0;
for (j = 0; j < i; j++)
ans += ami[j];
ll l_sum = 0;
for (i = st, j = 0; j < len; i++, j++) {
l_sum += ami[i];
}
ll bad = n - st;
ll ro = bad / len;
ans = ans + ro * l_sum;
bad = (n - st) % len;
for (i = st, j = 0; j < bad; i++, j++)
ans += ami[i];
cout << ans << endl;
rr;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p02550 | C++ | Runtime Error | // Bismillah Hir Rehmanir Rahim
// Allah knows best
using namespace std;
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
#define mini -10000000000000000
#define start \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define f(i, a, n) for (i = a; i < n; i++)
#define ll long long
#define pi 3.141592653589793
#define vi vector<int>
#define si set<int>
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define rr return 0
#define ff first
#define in insert
#define ss second
#define setbits(x) __builtin_popcountll(x)
#define zrbits(x) __builtin_ctzll(x)
#define deb(x) cout << #x << " = " << x << endl
int main() {
start;
ll i, j, k, n, m;
cin >> n >> k >> m;
vector<ll> ami;
ll ans = 0;
for (i = k, j = 0; j < 10000; j++) {
if (j <= n - 1) {
ans += (i % m);
}
ami.pb(i % m);
if (j == n - 1) {
cout << ans << endl;
rr;
}
i = i % m;
i = i * i;
i %= m;
}
ll ajob = ami.size();
ll st;
for (i = 0; i < ajob; i++) {
if (ami[i] == ami[ajob - 1]) {
st = i;
break;
}
}
ll len;
for (i = st + 1; i < ajob; i++) {
if (ami[st] == ami[i]) {
len = i - st;
break;
}
}
i -= len;
ans = 0;
for (j = 0; j < i; j++)
ans += ami[j];
ll l_sum = 0;
for (i = st, j = 0; j < len; i++, j++) {
l_sum += ami[i];
}
ll bad = n - st;
ll ro = bad / len;
ans = ans + ro * l_sum;
bad = (n - st) % len;
for (i = st, j = 0; j < bad; i++, j++)
ans += ami[i];
cout << ans << endl;
rr;
} | // Bismillah Hir Rehmanir Rahim
// Allah knows best
using namespace std;
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define endl "\n"
#define mini -10000000000000000
#define start \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define f(i, a, n) for (i = a; i < n; i++)
#define ll long long
#define pi 3.141592653589793
#define vi vector<int>
#define si set<int>
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define rr return 0
#define ff first
#define in insert
#define ss second
#define setbits(x) __builtin_popcountll(x)
#define zrbits(x) __builtin_ctzll(x)
#define deb(x) cout << #x << " = " << x << endl
int main() {
start;
ll i, j, k, n, m;
cin >> n >> k >> m;
vector<ll> ami;
ll ans = 0;
for (i = k, j = 0; j < 100000; j++) {
if (j <= n - 1) {
ans += (i % m);
}
ami.pb(i % m);
if (j == n - 1) {
cout << ans << endl;
rr;
}
i = i % m;
i = i * i;
i %= m;
}
ll ajob = ami.size();
ll st;
for (i = 0; i < ajob; i++) {
if (ami[i] == ami[ajob - 1]) {
st = i;
break;
}
}
ll len;
for (i = st + 1; i < ajob; i++) {
if (ami[st] == ami[i]) {
len = i - st;
break;
}
}
i -= len;
ans = 0;
for (j = 0; j < i; j++)
ans += ami[j];
ll l_sum = 0;
for (i = st, j = 0; j < len; i++, j++) {
l_sum += ami[i];
}
ll bad = n - st;
ll ro = bad / len;
ans = ans + ro * l_sum;
bad = (n - st) % len;
for (i = st, j = 0; j < bad; i++, j++)
ans += ami[i];
cout << ans << endl;
rr;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p02550 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, x, m;
cin >> n >> x >> m;
if (m == 0 || x == 0)
return cout << 0, 0;
ll ans = 0;
ll a = x % m;
vector<ll> v;
set<ll> s;
while (n > 0) {
if (s.find(a) != s.end())
break;
ans += a;
v.push_back(a);
s.insert(a);
a = (a * a) % m;
n--;
}
if ((int)v.size() > 0) {
reverse(v.begin(), v.end());
while (v.back() != a && (int)v.size())
v.pop_back();
reverse(v.begin(), v.end());
ll fp = n / ((int)v.size());
n -= fp * ((int)v.size());
ans += fp * accumulate(v.begin(), v.end(), 0LL);
for (int i = 0; i < n; i++)
ans += v[i];
}
cout << ans;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, x, m;
cin >> n >> x >> m;
if (m == 0 || x == 0)
return cout << 0, 0;
ll ans = 0;
ll a = x % m;
vector<ll> v;
set<ll> s;
while (n > 0) {
if (s.find(a) != s.end())
break;
ans += a;
v.push_back(a);
s.insert(a);
a = (a * a) % m;
n--;
}
if ((int)v.size() > 0 && n > 0) {
reverse(v.begin(), v.end());
while (v.back() != a && (int)v.size())
v.pop_back();
reverse(v.begin(), v.end());
ll fp = n / ((int)v.size());
n -= fp * ((int)v.size());
ans += fp * accumulate(v.begin(), v.end(), 0LL);
for (int i = 0; i < n; i++)
ans += v[i];
}
cout << ans;
return 0;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, X, M, c = 0, lp, st, lpp;
cin >> N >> X >> M;
map<ll, ll> mp;
mp[X] = c;
vector<ll> A(M + 100), S(M + 100);
A[0] = X;
S[0] = X;
while (1) {
c++;
X = (X * X) % M;
if (mp.count(X)) {
lp = c - mp.at(X);
st = mp.at(X);
lpp = S.at(c - 1);
if (st > 0)
lpp -= S.at(st - 1);
break;
}
mp[X] = c;
A[c] = X;
S[c] = S[c - 1] + A[c];
// cout << A[c] << "--";
}
ll ans = 0, lpc = (N - st) / lp;
ans += lpc * lpp;
// cout << ";;" << lpp << endl;
if (st > 0)
ans += S.at(st - 1);
ll ret = (N - st) % lp;
ans += S.at(ret + st - 1);
if (st > 0)
ans -= S.at(st - 1);
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, X, M, c = 0, lp, st, lpp;
cin >> N >> X >> M;
map<ll, ll> mp;
mp[X] = c;
vector<ll> A(M + 100), S(M + 100);
A[0] = X;
S[0] = X;
while (1) {
c++;
X = (X * X) % M;
if (mp.count(X)) {
lp = c - mp.at(X);
st = mp.at(X);
lpp = S.at(c - 1);
if (st > 0)
lpp -= S.at(st - 1);
break;
}
mp[X] = c;
A[c] = X;
S[c] = S[c - 1] + A[c];
// cout << A[c] << "--";
}
ll ans = 0, lpc = (N - st) / lp;
ans += lpc * lpp;
// cout << ";;" << lpp << endl;
if (st > 0)
ans += S.at(st - 1);
ll ret = (N - st) % lp;
if (ret + st > 0)
ans += S.at(ret + st - 1);
if (st > 0)
ans -= S.at(st - 1);
cout << ans;
return 0;
} | replace | 35 | 36 | 35 | 37 | 0 | |
p02550 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dd;
#define all(v) v.begin(), v.end()
#define all(v) v.begin(), v.end()
#define endl "\n"
#define clr(n, r) memset(n, r, sizeof(n))
typedef bitset<13> MASK;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<vector<int>> vvi;
// set iterator can be increamnted and decreamnted
void fast() {
cin.tie(0);
cin.sync_with_stdio(0);
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int main() {
fast();
// freopen("input.txt","r",stdin);
// freopen("out.txt","w",stdout);
ll n, x, m;
cin >> n >> x >> m;
ll total = 0;
ll arr[2 * m + 1];
clr(arr, 0);
arr[0] = x;
int i = 1, s;
bool b = 0;
map<ll, int> freq;
for (i = 1; i < m; ++i) {
arr[i] = binpow(arr[i - 1], 2, m);
if (freq[arr[i]]) {
s = freq[arr[i]];
break;
}
freq[arr[i]] = i;
}
if (n <= i) {
ll t = 0;
for (int j = 0; j < n; ++j) {
t += arr[j];
}
cout << t;
} else {
ll t = 0;
for (int j = 0; j < i; ++j) {
t += arr[j];
}
ll now = 0;
for (int j = s; j < i; ++j) {
now += arr[j];
}
n -= i;
if (i - s) {
ll r = n / (i - s);
t += (r)*now;
for (int k = s; k < s + n % (i - s); ++k) {
t += arr[k];
}
}
cout << t;
}
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dd;
#define all(v) v.begin(), v.end()
#define all(v) v.begin(), v.end()
#define endl "\n"
#define clr(n, r) memset(n, r, sizeof(n))
typedef bitset<13> MASK;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<vector<int>> vvi;
// set iterator can be increamnted and decreamnted
void fast() {
cin.tie(0);
cin.sync_with_stdio(0);
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int main() {
fast();
// freopen("input.txt","r",stdin);
// freopen("out.txt","w",stdout);
ll n, x, m;
cin >> n >> x >> m;
ll total = 0;
ll arr[2 * m + 1];
clr(arr, 0);
arr[0] = x;
int i = 1, s;
bool b = 0;
map<ll, int> freq;
for (i = 1; i < m; ++i) {
arr[i] = binpow(arr[i - 1], 2, m);
if (freq[arr[i]]) {
s = freq[arr[i]];
break;
}
freq[arr[i]] = i;
}
if (n <= i) {
ll t = 0;
for (int j = 0; j < n; ++j) {
t += arr[j];
}
cout << t;
} else {
ll t = 0;
for (int j = 0; j < i; ++j) {
t += arr[j];
}
ll now = 0;
for (int j = s; j < i; ++j) {
now += arr[j];
}
n -= i;
if (i - s > 0) {
ll r = n / (i - s);
t += (r)*now;
for (int k = s; k < s + n % (i - s); ++k) {
t += arr[k];
}
}
cout << t;
}
} | replace | 75 | 76 | 75 | 76 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
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;
}
using ll = long long;
using P = pair<ll, ll>;
const long double PI = acos(-1.0L);
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
// auto mod int
int mod;
// 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; }
// bool operator==(const mint a) { return x == a.x; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
ll n, x;
int main() {
cin >> n >> x >> mod;
vector<ll> avec;
avec.emplace_back(x);
vector<bool> abvec(mod + 1, false);
vector<ll> amvec;
vector<int> abivec(mod + 1, -1);
int pre = -1, last = -1;
for (int i = 1;; ++i) {
if (avec[i - 1] == 0)
break;
ll ai = avec[i - 1] * avec[i - 1];
ai %= mod;
if (abvec[ai]) {
// cout << ai << endl;
pre = abivec[ai];
last = i - 1;
break;
}
abvec[ai] = true;
amvec.emplace_back(ai);
avec.emplace_back(ai);
abivec[ai] = i - 1;
}
// 止まることを確認
int amlen = amvec.size();
// cout << "now " << amlen << endl;
long long sum = x;
if (amvec[amlen - 1] == 0) {
for (int i = 0; i < amlen; ++i)
sum += amvec[i];
} else {
// ループする
for (int i = 0; i < pre; ++i)
sum += amvec[i];
ll rest = n - 1 - (pre);
ll rlen = last - pre;
ll rsum = 0;
ll cnt = rest / rlen;
ll rcnt = rest - rlen * cnt;
for (int i = pre; i < last; ++i)
rsum += amvec[i];
// cout << "rsum " << rsum << endl;
sum += rsum * cnt;
for (int i = 0; i < rcnt; ++i)
sum += amvec[pre + i];
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
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;
}
using ll = long long;
using P = pair<ll, ll>;
const long double PI = acos(-1.0L);
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
// auto mod int
int mod;
// 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; }
// bool operator==(const mint a) { return x == a.x; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
ll n, x;
int main() {
cin >> n >> x >> mod;
vector<ll> avec;
avec.emplace_back(x);
vector<bool> abvec(mod + 1, false);
vector<ll> amvec;
vector<int> abivec(mod + 1, -1);
int pre = -1, last = -1;
for (int i = 1;; ++i) {
if (avec[i - 1] == 0)
break;
ll ai = avec[i - 1] * avec[i - 1];
ai %= mod;
if (abvec[ai]) {
// cout << ai << endl;
pre = abivec[ai];
last = i - 1;
break;
}
abvec[ai] = true;
amvec.emplace_back(ai);
avec.emplace_back(ai);
abivec[ai] = i - 1;
}
// 止まることを確認
int amlen = amvec.size();
// cout << "now " << amlen << endl;
if (amlen == 0) {
cout << 0 << endl;
return 0;
}
long long sum = x;
if (amvec[amlen - 1] == 0) {
for (int i = 0; i < amlen; ++i)
sum += amvec[i];
} else {
// ループする
for (int i = 0; i < pre; ++i)
sum += amvec[i];
ll rest = n - 1 - (pre);
ll rlen = last - pre;
ll rsum = 0;
ll cnt = rest / rlen;
ll rcnt = rest - rlen * cnt;
for (int i = pre; i < last; ++i)
rsum += amvec[i];
// cout << "rsum " << rsum << endl;
sum += rsum * cnt;
for (int i = 0; i < rcnt; ++i)
sum += amvec[pre + i];
}
cout << sum << endl;
} | insert | 97 | 97 | 97 | 101 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pa pair<int, int>
#define pal pair<long long, long long>
#define pali pair<long long, int>
#define pad pair<double, double>
#define pb push_back
#define mp make_pair
#define COUT(v) \
for (int64_t i = 0; i < (v).size(); ++i) { \
cout << v.at(i) << endl; \
}
#define REP(i, n) for (int64_t i = 0; i < n; ++i)
#define FOR(i, r, n) for (int64_t i = (r); i < n; ++i)
#define VIN(v) \
for (int64_t i = 0; i < (v).size(); ++i) { \
cin >> (v).at(i); \
}
typedef vector<bool> bvec;
typedef vector<int> ivec;
typedef vector<long long> lvec;
typedef vector<double> dvec;
typedef vector<pa> pavec;
typedef vector<pali> palivec;
typedef vector<pal> palvec;
typedef vector<vector<bool>> bmat;
typedef vector<vector<int>> imat;
typedef vector<vector<long long>> lmat;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
const ll infll = (1LL << 60) - 1;
const int inf = (1 << 30) - 1;
const ll MOD = 1000000007;
ll gcd(ll x, ll y) {
ll r = x % y;
if (r == 0)
return y;
else
return gcd(y, r);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
lvec mfactor(ll n) {
bvec ip(n, true);
lvec mf(n, -1);
ip[0] = false;
ip[1] = false;
mf[0] = 0;
mf[1] = 1;
REP(i, n) {
if (ip[i]) {
mf[i] = i;
for (ll j = i * i; j < n; j += i) {
ip[j] = false;
if (mf[j] == -1)
mf[j] = i;
}
}
}
return mf;
}
palivec get_prime(ll n, const lvec &mf) {
palivec plist;
while (n != 1) {
int cnt = 0;
ll m = mf[n];
while (mf[n] == m) {
cnt++;
n /= m;
}
plist.pb(pali(m, cnt));
}
return plist;
}
void COMinit(int m, lvec &fac, lvec &finv) {
lvec inv(m);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < m; 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 pow_mod(ll a, ll n) {
ll x = 1;
while (n > 0) {
if (n & 1) {
x = x * a % MOD;
}
a = a * a % MOD;
n >>= 1;
}
return x;
}
ll pow_mod2(ll a, ll n) {
ll x = 1;
while (n > 0) {
if (n & 1) {
x = x * a;
}
a = a * a;
n >>= 1;
}
return x;
}
ll COM(int n, int k, const lvec &fac, const lvec &finv) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fac[n] * (finv[k] * finv[n - k] % MOD)) % MOD;
}
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// union by size + path having
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
// Member Function
// Find
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { return root(x) == root(y); }
ll size(ll x) { return siz[root(x)]; }
};
ll naive(ll n, ll x, ll m) {
ll a = x;
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a;
a *= a;
a %= m;
}
return ans;
}
ll solve(ll n, ll x, ll m) {
lvec s(m, -1);
lvec c(m, -1);
ll a = x;
ll cum = 0;
for (ll i = 0; i < n; i++) {
if (a == 0) {
return cum;
}
if (s[a] != -1) {
ll ans = cum + (cum + a - s[a]) * ((n - i) / (i - c[a]));
ll r = ((n - i) % (i - c[a]));
for (ll j = 0; j < r; j++) {
ans += a;
a *= a;
a %= m;
}
return ans;
}
cum += a;
s[a] = cum;
c[a] = i;
a *= a;
a %= m;
}
return cum;
}
void test() {
default_random_engine gen;
uniform_int_distribution<int> distn(1, 100);
uniform_int_distribution<int> distx(0, 100);
for (int i = 0; i < 100; i++) {
int n = distn(gen);
int x = distx(gen);
uniform_int_distribution<int> distm(x + 1, 1000);
int m = distm(gen);
ll ans = naive(n, x, m);
ll solved = solve(n, x, m);
if (ans != solved) {
cout << "Faield! Prob " << i + 1 << endl;
cout << n << ' ' << x << ' ' << m << endl;
cout << "ans: " << ans << " solved: " << solved << endl;
} else {
cout << "Succeeded! Prob " << i + 1 << endl;
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
ll siz = ceil(log2(n));
lmat to(siz, lvec(m));
lmat val(siz, lvec(m));
for (ll i = 0; i < m; i++) {
to[0][i] = (i * i) % m;
val[0][i] = i;
}
for (ll i = 0; i < siz - 1; i++) {
for (ll j = 0; j < m; j++) {
to[i + 1][j] = to[i][to[i][j]];
val[i + 1][j] = val[i][j] + val[i][to[i][j]];
}
}
ll ans = 0;
for (ll i = 0; i < siz; i++) {
if (n & 1) {
ans += val[i][x];
x = to[i][x];
}
n >>= 1;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pa pair<int, int>
#define pal pair<long long, long long>
#define pali pair<long long, int>
#define pad pair<double, double>
#define pb push_back
#define mp make_pair
#define COUT(v) \
for (int64_t i = 0; i < (v).size(); ++i) { \
cout << v.at(i) << endl; \
}
#define REP(i, n) for (int64_t i = 0; i < n; ++i)
#define FOR(i, r, n) for (int64_t i = (r); i < n; ++i)
#define VIN(v) \
for (int64_t i = 0; i < (v).size(); ++i) { \
cin >> (v).at(i); \
}
typedef vector<bool> bvec;
typedef vector<int> ivec;
typedef vector<long long> lvec;
typedef vector<double> dvec;
typedef vector<pa> pavec;
typedef vector<pali> palivec;
typedef vector<pal> palvec;
typedef vector<vector<bool>> bmat;
typedef vector<vector<int>> imat;
typedef vector<vector<long long>> lmat;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
const ll infll = (1LL << 60) - 1;
const int inf = (1 << 30) - 1;
const ll MOD = 1000000007;
ll gcd(ll x, ll y) {
ll r = x % y;
if (r == 0)
return y;
else
return gcd(y, r);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
lvec mfactor(ll n) {
bvec ip(n, true);
lvec mf(n, -1);
ip[0] = false;
ip[1] = false;
mf[0] = 0;
mf[1] = 1;
REP(i, n) {
if (ip[i]) {
mf[i] = i;
for (ll j = i * i; j < n; j += i) {
ip[j] = false;
if (mf[j] == -1)
mf[j] = i;
}
}
}
return mf;
}
palivec get_prime(ll n, const lvec &mf) {
palivec plist;
while (n != 1) {
int cnt = 0;
ll m = mf[n];
while (mf[n] == m) {
cnt++;
n /= m;
}
plist.pb(pali(m, cnt));
}
return plist;
}
void COMinit(int m, lvec &fac, lvec &finv) {
lvec inv(m);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < m; 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 pow_mod(ll a, ll n) {
ll x = 1;
while (n > 0) {
if (n & 1) {
x = x * a % MOD;
}
a = a * a % MOD;
n >>= 1;
}
return x;
}
ll pow_mod2(ll a, ll n) {
ll x = 1;
while (n > 0) {
if (n & 1) {
x = x * a;
}
a = a * a;
n >>= 1;
}
return x;
}
ll COM(int n, int k, const lvec &fac, const lvec &finv) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fac[n] * (finv[k] * finv[n - k] % MOD)) % MOD;
}
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// union by size + path having
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
// Member Function
// Find
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { return root(x) == root(y); }
ll size(ll x) { return siz[root(x)]; }
};
ll naive(ll n, ll x, ll m) {
ll a = x;
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a;
a *= a;
a %= m;
}
return ans;
}
ll solve(ll n, ll x, ll m) {
lvec s(m, -1);
lvec c(m, -1);
ll a = x;
ll cum = 0;
for (ll i = 0; i < n; i++) {
if (a == 0) {
return cum;
}
if (s[a] != -1) {
ll ans = cum + (cum + a - s[a]) * ((n - i) / (i - c[a]));
ll r = ((n - i) % (i - c[a]));
for (ll j = 0; j < r; j++) {
ans += a;
a *= a;
a %= m;
}
return ans;
}
cum += a;
s[a] = cum;
c[a] = i;
a *= a;
a %= m;
}
return cum;
}
void test() {
default_random_engine gen;
uniform_int_distribution<int> distn(1, 100);
uniform_int_distribution<int> distx(0, 100);
for (int i = 0; i < 100; i++) {
int n = distn(gen);
int x = distx(gen);
uniform_int_distribution<int> distm(x + 1, 1000);
int m = distm(gen);
ll ans = naive(n, x, m);
ll solved = solve(n, x, m);
if (ans != solved) {
cout << "Faield! Prob " << i + 1 << endl;
cout << n << ' ' << x << ' ' << m << endl;
cout << "ans: " << ans << " solved: " << solved << endl;
} else {
cout << "Succeeded! Prob " << i + 1 << endl;
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
ll siz = ceil(log2(n)) + 1;
lmat to(siz, lvec(m));
lmat val(siz, lvec(m));
for (ll i = 0; i < m; i++) {
to[0][i] = (i * i) % m;
val[0][i] = i;
}
for (ll i = 0; i < siz - 1; i++) {
for (ll j = 0; j < m; j++) {
to[i + 1][j] = to[i][to[i][j]];
val[i + 1][j] = val[i][j] + val[i][to[i][j]];
}
}
ll ans = 0;
for (ll i = 0; i < siz; i++) {
if (n & 1) {
ans += val[i][x];
x = to[i][x];
}
n >>= 1;
}
cout << ans << endl;
} | replace | 259 | 260 | 259 | 260 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define INF 1 << 30
using namespace std;
typedef long long ll;
typedef pair<int, int> pp;
int main(void) {
ll i, j, num, x, m, ans, a = 0, b = 0, k = 0;
cin >> num >> x >> m;
vector<ll> d(m, 0), s(m, 0);
rep(i, num) {
k++;
a += x;
if (d[x]) {
k -= s[x];
b = a - d[x];
a = d[x];
int c = (num - s[x]) % k;
k = (num - s[x]) / k;
rep(j, c) {
x *= x;
x %= m;
a += x;
}
break;
}
d[x] = a;
s[x] = k;
x *= x;
x %= m;
}
if (i == num)
ans = a;
else
ans = a + b * k;
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define INF 1 << 30
using namespace std;
typedef long long ll;
typedef pair<int, int> pp;
int main(void) {
ll i, j, num, x, m, ans, a = 0, b = 0, k = 0;
cin >> num >> x >> m;
if (m == 1) {
printf("0\n");
return 0;
}
vector<ll> d(m, 0), s(m, 0);
rep(i, num) {
k++;
a += x;
if (d[x]) {
k -= s[x];
b = a - d[x];
a = d[x];
int c = (num - s[x]) % k;
k = (num - s[x]) / k;
rep(j, c) {
x *= x;
x %= m;
a += x;
}
break;
}
d[x] = a;
s[x] = k;
x *= x;
x %= m;
}
if (i == num)
ans = a;
else
ans = a + b * k;
cout << ans << "\n";
return 0;
} | insert | 20 | 20 | 20 | 24 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
ll f(ll n, ll m) { return (n * n) % m; }
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll A, preA, ans = 0;
ll loopcnt = 0, cnt = 0, sum_loop = 0, rec_A;
vector<bool> visit(100001, false);
bool dub;
for (int i = 1; i <= N; i++) {
if (i == 1) {
A = X;
ans += A;
visit[A] = true;
cnt++;
continue;
}
preA = A;
A = f(A, M);
if (dub) {
if (A == rec_A)
break;
ans += A;
sum_loop += A;
loopcnt++;
cnt++;
} else {
if (visit[A]) {
dub = true;
rec_A = A;
sum_loop += A;
loopcnt++;
}
ans += A;
cnt++;
visit[A] = true;
}
}
A = preA;
if (dub) {
ans += sum_loop * ((N - cnt) / loopcnt);
ll rem = (N - cnt) % loopcnt;
for (int i = 0; i < rem; i++) {
A = f(A, M);
ans += A;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
ll f(ll n, ll m) { return (n * n) % m; }
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll A, preA, ans = 0;
ll loopcnt = 0, cnt = 0, sum_loop = 0, rec_A;
vector<bool> visit(1000010, false);
bool dub = false;
for (int i = 1; i <= N; i++) {
if (i == 1) {
A = X;
ans += A;
visit[A] = true;
cnt++;
continue;
}
preA = A;
A = f(A, M);
if (dub) {
if (A == rec_A)
break;
ans += A;
sum_loop += A;
loopcnt++;
cnt++;
} else {
if (visit[A]) {
dub = true;
rec_A = A;
sum_loop += A;
loopcnt++;
}
ans += A;
cnt++;
visit[A] = true;
}
}
A = preA;
if (dub) {
ans += sum_loop * ((N - cnt) / loopcnt);
ll rem = (N - cnt) % loopcnt;
for (int i = 0; i < rem; i++) {
A = f(A, M);
ans += A;
}
}
cout << ans << endl;
return 0;
}
| replace | 21 | 23 | 21 | 23 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long int N, X, M;
cin >> N >> X >> M;
if (M > 1) {
vector<long int> vec(2 * M);
vec.at(0) = X % M;
for (long int i = 1; i <= 2 * M - 1; i++) {
long int k = vec.at(i - 1) % M;
long int l = (k * k) % M;
vec.at(i) = l;
}
long int s = 0;
long int t = 0;
for (long int p = 0; p < 2 * M - 2; p++) {
if (s > 0) {
break;
}
for (long int q = p + 1; q < 2 * M - 1; q++) {
if (vec.at(p) == vec.at(q)) {
s = p;
t = q;
break;
}
}
}
long int r = t - s;
long int a = 0;
if (r > 1) {
for (long int b = s; b < t; b++) {
a += vec.at(b);
}
} else {
a = vec.at(s);
}
long int A = 0;
for (long int w = 0; w < s; w++) {
A += vec.at(w);
}
long int f = 0;
f = (N - s) / r;
long int d = 0;
if ((N - s) % r != 0) {
for (long int y = s; y <= s + (N - s) % r - 1; y++) {
d += vec.at(y);
}
}
A += a * f + d;
cout << A << endl;
} else if (M == 1) {
int o = X;
for (int h = 1; h <= N - 1; h++) {
o += pow(X, 2 * h);
}
cout << o << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long int N, X, M;
cin >> N >> X >> M;
if (M > 1) {
vector<long int> vec(2 * M);
vec.at(0) = X % M;
for (long int i = 1; i <= 2 * M - 1; i++) {
long int k = vec.at(i - 1) % M;
long int l = (k * k) % M;
vec.at(i) = l;
}
long int s = 0;
long int t = 0;
for (long int p = 0; p < 2 * M - 2; p++) {
if (s > 0) {
break;
}
for (long int q = p + 1; q < 2 * M - 1; q++) {
if (vec.at(p) == vec.at(q)) {
s = p;
t = q;
break;
}
}
}
long int r = t - s;
long int a = 0;
if (r > 1) {
for (long int b = s; b < t; b++) {
a += vec.at(b);
}
} else {
a = vec.at(s);
}
long int A = 0;
for (long int w = 0; w < s; w++) {
A += vec.at(w);
}
long int f = 0;
f = (N - s) / r;
long int d = 0;
if ((N - s) % r != 0) {
for (long int y = s; y <= s + (N - s) % r - 1; y++) {
d += vec.at(y);
}
}
A += a * f + d;
cout << A << endl;
} else if (M == 1) {
cout << 0 << endl;
}
} | replace | 56 | 61 | 56 | 57 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 998244353
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define sum(a) (accumulate((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) (min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) (max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) (lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) (upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};
unordered_map<ll, ll> m1;
void solve() {
m1.clear();
ll n, x, m;
cin >> n >> x >> m;
vector<ll> arr1;
vector<ll> arr2;
arr1.pb(x);
arr2.pb(x);
m1[x] = 0;
for (ll i = 1; i < n; i++) {
arr1.pb(0);
arr2.pb(0);
arr1[i] = (arr1[i - 1] * arr1[i - 1]) % m;
arr2[i] = arr2[i - 1] + arr1[i];
if (m1.count(arr1[i]) != 0) {
// cout <<"hello" << endl;
ll len = i - m1[arr1[i]];
ll sum = arr2[i] - arr2[m1[arr1[i]]];
ll rem = n - i;
ll ans = 0;
ans = arr2[i - 1] + (rem / len) * sum;
ll x2 = m1[arr1[i]];
ll y = x + (rem % len) - 1;
ll x1 = x2 - 1 >= 0 ? arr2[x2 - 1] : 0;
ans += arr2[y] - x1;
cout << ans << endl;
return;
}
m1[arr1[i]] = i;
}
cout << arr2[n - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 998244353
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define sum(a) (accumulate((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) (min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) (max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) (lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) (upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};
unordered_map<ll, ll> m1;
void solve() {
m1.clear();
ll n, x, m;
cin >> n >> x >> m;
vector<ll> arr1;
vector<ll> arr2;
arr1.pb(x);
arr2.pb(x);
m1[x] = 0;
for (ll i = 1; i < n; i++) {
arr1.pb(0);
arr2.pb(0);
arr1[i] = (arr1[i - 1] * arr1[i - 1]) % m;
arr2[i] = arr2[i - 1] + arr1[i];
if (m1.count(arr1[i]) != 0) {
// cout <<"hello" << endl;
ll len = i - m1[arr1[i]];
ll sum = arr2[i] - arr2[m1[arr1[i]]];
ll rem = n - i;
ll ans = 0;
ans = arr2[i - 1] + (rem / len) * sum;
ll a = m1[arr1[i]];
ll b = a + (rem % len) - 1;
for (ll j = a; j <= b; j++)
ans += arr1[j];
cout << ans << endl;
return;
}
m1[arr1[i]] = i;
}
cout << arr2[n - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| replace | 47 | 51 | 47 | 51 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define PI 3.14159265358979
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll mod = 1e9 + 7LL;
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll f = X;
ll ans = 0;
map<ll, ll> m;
vector<ll> sum(2 * M + 1);
sum.at(0) = X;
m[X] = 0;
bool flag = false;
rep(i, N) {
if (i == 0)
continue;
f = f * f % M;
sum.at(i) = sum.at(i - 1) + f;
if (m.count(f)) {
flag = true;
ll x = i - m[f];
ll tmp = sum.at(i) - sum.at(m[f]);
ll a = 0;
if (m[f] != 0)
a = sum.at(m[f] - 1);
ll b = tmp * ((N - m[f]) / x);
ll c = 0;
if ((N - m[f]) % x != 0)
c = sum.at((N - m[f]) % x + m[f] - 1) - sum.at(m[f] - 1);
ans = a + b + c;
break;
} else
m[f] = i;
}
if (!flag)
ans = sum.at(N - 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define PI 3.14159265358979
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll mod = 1e9 + 7LL;
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll f = X;
ll ans = 0;
map<ll, ll> m;
vector<ll> sum(2 * M + 1);
sum.at(0) = X;
m[X] = 0;
bool flag = false;
rep(i, N) {
if (i == 0)
continue;
f = f * f % M;
sum.at(i) = sum.at(i - 1) + f;
if (m.count(f)) {
flag = true;
ll x = i - m[f];
ll tmp = sum.at(i) - sum.at(m[f]);
ll a = 0;
if (m[f] != 0)
a = sum.at(m[f] - 1);
ll b = tmp * ((N - m[f]) / x);
ll c = 0;
if ((N - m[f]) % x != 0) {
c = sum.at((N - m[f]) % x + m[f] - 1);
if (m[f] != 0)
c -= sum.at(m[f] - 1);
}
ans = a + b + c;
break;
} else
m[f] = i;
}
if (!flag)
ans = sum.at(N - 1);
cout << ans << endl;
} | replace | 36 | 38 | 36 | 41 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
using ll = long long;
const ll mod = (ll)998244353;
ll powmod(ll a, ll k, ll m) {
if (k == 0)
return 1;
ll t = powmod(a, k / 2, m);
t = (t * t) % mod;
if (k % 2 == 1)
t = (t * a) % mod;
return t;
}
int vis[1 << 17];
long pre[1 << 17];
int main() {
ll n;
ll x, m;
cin >> n >> x >> m;
map<ll, int> mp;
vector<ll> val;
int idx = 0;
auto it = mp.end();
ll idxsum = 0;
while ((it = mp.find(x)) == mp.end() && n > 0) {
val.push_back(x);
mp[x] = idx++;
idxsum += x;
x = (x * x) % m;
n--;
}
int loop = idx - it->second;
// n -= idx;
ll loopsum = 0;
for (int i = it->second; i < idx; i++) {
loopsum += val[i];
}
ll mult = n / loop;
n -= loop * mult;
ll modsum = 0;
for (int i = it->second; --n >= 0; i++) {
modsum += val[i];
}
ll ans = idxsum + loopsum * mult + modsum;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
using ll = long long;
const ll mod = (ll)998244353;
ll powmod(ll a, ll k, ll m) {
if (k == 0)
return 1;
ll t = powmod(a, k / 2, m);
t = (t * t) % mod;
if (k % 2 == 1)
t = (t * a) % mod;
return t;
}
int vis[1 << 17];
long pre[1 << 17];
int main() {
ll n;
ll x, m;
cin >> n >> x >> m;
map<ll, int> mp;
vector<ll> val;
int idx = 0;
auto it = mp.end();
ll idxsum = 0;
while ((it = mp.find(x)) == mp.end() && n > 0) {
val.push_back(x);
mp[x] = idx++;
idxsum += x;
x = (x * x) % m;
n--;
}
if (n == 0) {
cout << idxsum << endl;
return 0;
}
int loop = idx - it->second;
// n -= idx;
ll loopsum = 0;
for (int i = it->second; i < idx; i++) {
loopsum += val[i];
}
ll mult = n / loop;
n -= loop * mult;
ll modsum = 0;
for (int i = it->second; --n >= 0; i++) {
modsum += val[i];
}
ll ans = idxsum + loopsum * mult + modsum;
cout << ans << endl;
return 0;
}
| insert | 35 | 35 | 35 | 39 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <cstdlib>
#include <deque> // deque
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <limits>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define rep(i, N) for (ll i = 0; i < (N); i++)
#define repone(i, N) for (ll i = 1; i < (N); i++)
#define REP(i, N) for (ll i = (N)-1; i >= 0; i--)
#define FOR(j, i, N) for (ll j = (N)-1; j > (i); j--)
#define repsqrt(i, N) for (ll i = 1; i * i <= (N); i++)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define ST string
#define vec vector<ll>
#define vecs vector<string>
#define outb(s) cout << fixed << setprecision(15) << s << endl;
#define out(s) cout << s << endl;
#define SZ(x) ((ll)(x).size())
#define Graph vector<vector<ll>>
#define vecb vector<lb>
#define P pair<ll, ll>
#define F first
#define S second
#define vecbool vector<bool>
using ll = long long;
using lb = long double;
using ll = long long;
using lb = long double;
using namespace std;
const ll mod = 1000000007;
const ll zero = 0;
const ll one = 1;
const ll INF = 1e8;
const lb pi = 3.14159265358979;
ll nCk(ll N, ll K) {
if (N > 1) {
ll kid = 1;
for (ll i = N; i > N - K; i--) {
kid = kid * i;
}
for (ll i = 1; i < K + 1; i++) {
kid = kid / i;
}
return kid;
} else {
return 0;
}
}
ll stair_pow(ll N) { // 階乗
ll sum = 1;
for (ll i = 1; i <= N; i++) {
sum = sum * i % mod;
}
return sum % mod;
}
ll gcd(ll p, ll q) { return q ? gcd(q, p % q) : p; }
ll lcm(ll p, ll q) { return p / gcd(p, q) * q; }
bool is_prime(ll x) {
if (x <= 1) {
return false;
}
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
ll sum_of_num(ll num) { // 各位の和
ll dig;
ll sum = 0;
while (num) {
dig = num % 10;
sum = sum + dig;
num = num / 10;
}
return sum;
}
ll how_many_break(ll n, ll m) { // 何回割れるか
ll counter = 0;
while (n % m == 0) {
n = n / m;
counter++;
}
return counter;
}
ll many_pow(ll N, ll M) { // NのM乗
if (M == 0)
return 1;
else {
ll sum = 1;
for (ll i = 0; i < M; i++) {
sum *= N;
}
return sum;
}
}
ll one_to_i(ll i) { // 1からiまでの和
if (i < 0) {
return 0;
} else {
return i * (i + 1) / 2;
}
}
ll how_many_yaku(ll num) {
ll ans = 0;
repsqrt(i, num) {
if (num % i == 0) {
ans++;
if (i != num / i) {
ans++;
}
}
}
return ans;
}
ll digit(ll num) {
ll digit = 0;
while (num != 0) {
num /= 10;
digit++;
}
return digit;
}
ll digitsum(ll num) {
ll dig = 0, sum = 0;
while (num) {
dig = num % 10;
sum += dig;
num /= 10;
}
return sum;
}
struct UnionFind {
vec d;
UnionFind(ll n = 0) : d(n, -1) {}
ll find(ll x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(ll x, ll y) { return find(x) == find(y); }
int size(ll x) { return -d[find(x)]; }
};
vecbool seen;
void dfs(const Graph &G, ll v) {
seen[v] = true;
for (auto next_v : G[v]) {
if (seen[next_v])
continue;
dfs(G, next_v);
}
}
ll LCS(ST s, ST t) {
ll s1 = s.size();
ll s2 = t.size();
Graph p(s1 + 1, vec(s2 + 2));
rep(i, s1 + 1) {
rep(j, s2 + 1) {
if (i > 0 && j > 0) {
if (s[i - 1] == t[j - 1]) {
p[i][j] = max(p[i - 1][j - 1] + 1, max(p[i][j - 1], p[i - 1][j]));
} else {
p[i][j] = max(p[i - 1][j], p[i][j - 1]);
}
} else {
p[i][j] = 0;
}
}
}
ll ans = p[s1][s2];
return ans;
}
ll modpow(ll x, ll y) {
ll res = 1;
rep(i, y) { res = res * x % mod; }
return res;
}
struct modint {
ll x;
modint(ll x = 0) : x((x % mod + mod) % mod) {}
modint operator-() const { return modint(-x); }
modint &operator+=(const modint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
modint &operator-=(const modint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
modint &operator*=(const modint a) {
(x *= a.x) %= mod;
return *this;
}
modint operator+(const modint a) const { return modint(*this) += a; }
modint operator-(const modint a) const { return modint(*this) -= a; }
modint operator*(const modint a) const { return modint(*this) *= a; }
modint pow(ll t) const {
if (!t)
return 1;
modint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
modint inv() const { return pow(mod - 2); }
modint &operator/=(const modint a) { return *this *= a.inv(); }
modint operator/(const modint a) const { return modint(*this) /= a; }
};
istream &operator>>(istream &is, modint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const modint &a) { return os << a.x; }
vector<P> prime_factorize(ll N) {
vector<P> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
/*-----------------------------------------------------------------------------------*/
// cout << fixed << setprecision(15)
// continue
// count(S.begin(),S.end(),'');
// reverse(S.begin(), S.end());
// s.substr(8, 8)
// sort(p.begin(), p.end());
// reverse(s.begin(), s.end());
// sort(p.rbegin(), p.rend()); ← 降順sort.
// getline(cin,s);
// transform (s.begin(), s.end(), s.begin(), toupper); ←大文字変換
// transform (s.begin(), s.end(), s.begin(), tolower); ←小文字変換
/*-----------------------------------------------------------------------------------*/
ll maximam = 1e8;
int main() {
ll n, x, m, count = 0;
cin >> n >> x >> m;
vec p(m);
p[0] = x;
bool is = false;
rep(i, m - 1) {
count++;
if (p[i] == 0) {
is = true;
break;
}
p[i + 1] = p[i] * p[i] % m;
}
if (n <= m) {
ll ans = 0;
rep(i, n) { ans += p[i]; }
out(ans);
} else if (is) {
ll ans = 0;
rep(i, count) { ans += p[i]; }
out(ans);
} else {
bool is = true, po = false, ppp = true;
ll counter = 1, ok = 0;
vec q, r(m), s;
q.push_back(x);
ll i = 0;
while (ppp) {
if (q[i] * q[i] % m == 0) {
po = true;
break;
}
q.push_back(q[i] * q[i] % m);
if (is) {
counter++;
} else {
ok++;
s.push_back(q[i] * q[i] % m);
}
if (r[q[i + 1] - 1] == 1) {
is = false;
}
if (r[q[i + 1] - 1] == 2) {
ppp = false;
}
r[q[i + 1] - 1]++;
i++;
}
ll ans = 0;
n -= counter;
rep(j, counter) { ans += q[j]; }
if (po) {
out(ans);
}
ll sum = 0;
rep(j, ok) { sum += s[j]; }
ans += sum * (n / ok);
ll qq = n % ok;
rep(j, qq) { ans += s[j]; }
out(ans);
}
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <cstdlib>
#include <deque> // deque
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <limits>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define rep(i, N) for (ll i = 0; i < (N); i++)
#define repone(i, N) for (ll i = 1; i < (N); i++)
#define REP(i, N) for (ll i = (N)-1; i >= 0; i--)
#define FOR(j, i, N) for (ll j = (N)-1; j > (i); j--)
#define repsqrt(i, N) for (ll i = 1; i * i <= (N); i++)
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define ST string
#define vec vector<ll>
#define vecs vector<string>
#define outb(s) cout << fixed << setprecision(15) << s << endl;
#define out(s) cout << s << endl;
#define SZ(x) ((ll)(x).size())
#define Graph vector<vector<ll>>
#define vecb vector<lb>
#define P pair<ll, ll>
#define F first
#define S second
#define vecbool vector<bool>
using ll = long long;
using lb = long double;
using ll = long long;
using lb = long double;
using namespace std;
const ll mod = 1000000007;
const ll zero = 0;
const ll one = 1;
const ll INF = 1e8;
const lb pi = 3.14159265358979;
ll nCk(ll N, ll K) {
if (N > 1) {
ll kid = 1;
for (ll i = N; i > N - K; i--) {
kid = kid * i;
}
for (ll i = 1; i < K + 1; i++) {
kid = kid / i;
}
return kid;
} else {
return 0;
}
}
ll stair_pow(ll N) { // 階乗
ll sum = 1;
for (ll i = 1; i <= N; i++) {
sum = sum * i % mod;
}
return sum % mod;
}
ll gcd(ll p, ll q) { return q ? gcd(q, p % q) : p; }
ll lcm(ll p, ll q) { return p / gcd(p, q) * q; }
bool is_prime(ll x) {
if (x <= 1) {
return false;
}
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
ll sum_of_num(ll num) { // 各位の和
ll dig;
ll sum = 0;
while (num) {
dig = num % 10;
sum = sum + dig;
num = num / 10;
}
return sum;
}
ll how_many_break(ll n, ll m) { // 何回割れるか
ll counter = 0;
while (n % m == 0) {
n = n / m;
counter++;
}
return counter;
}
ll many_pow(ll N, ll M) { // NのM乗
if (M == 0)
return 1;
else {
ll sum = 1;
for (ll i = 0; i < M; i++) {
sum *= N;
}
return sum;
}
}
ll one_to_i(ll i) { // 1からiまでの和
if (i < 0) {
return 0;
} else {
return i * (i + 1) / 2;
}
}
ll how_many_yaku(ll num) {
ll ans = 0;
repsqrt(i, num) {
if (num % i == 0) {
ans++;
if (i != num / i) {
ans++;
}
}
}
return ans;
}
ll digit(ll num) {
ll digit = 0;
while (num != 0) {
num /= 10;
digit++;
}
return digit;
}
ll digitsum(ll num) {
ll dig = 0, sum = 0;
while (num) {
dig = num % 10;
sum += dig;
num /= 10;
}
return sum;
}
struct UnionFind {
vec d;
UnionFind(ll n = 0) : d(n, -1) {}
ll find(ll x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(ll x, ll y) { return find(x) == find(y); }
int size(ll x) { return -d[find(x)]; }
};
vecbool seen;
void dfs(const Graph &G, ll v) {
seen[v] = true;
for (auto next_v : G[v]) {
if (seen[next_v])
continue;
dfs(G, next_v);
}
}
ll LCS(ST s, ST t) {
ll s1 = s.size();
ll s2 = t.size();
Graph p(s1 + 1, vec(s2 + 2));
rep(i, s1 + 1) {
rep(j, s2 + 1) {
if (i > 0 && j > 0) {
if (s[i - 1] == t[j - 1]) {
p[i][j] = max(p[i - 1][j - 1] + 1, max(p[i][j - 1], p[i - 1][j]));
} else {
p[i][j] = max(p[i - 1][j], p[i][j - 1]);
}
} else {
p[i][j] = 0;
}
}
}
ll ans = p[s1][s2];
return ans;
}
ll modpow(ll x, ll y) {
ll res = 1;
rep(i, y) { res = res * x % mod; }
return res;
}
struct modint {
ll x;
modint(ll x = 0) : x((x % mod + mod) % mod) {}
modint operator-() const { return modint(-x); }
modint &operator+=(const modint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
modint &operator-=(const modint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
modint &operator*=(const modint a) {
(x *= a.x) %= mod;
return *this;
}
modint operator+(const modint a) const { return modint(*this) += a; }
modint operator-(const modint a) const { return modint(*this) -= a; }
modint operator*(const modint a) const { return modint(*this) *= a; }
modint pow(ll t) const {
if (!t)
return 1;
modint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
modint inv() const { return pow(mod - 2); }
modint &operator/=(const modint a) { return *this *= a.inv(); }
modint operator/(const modint a) const { return modint(*this) /= a; }
};
istream &operator>>(istream &is, modint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const modint &a) { return os << a.x; }
vector<P> prime_factorize(ll N) {
vector<P> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
/*-----------------------------------------------------------------------------------*/
// cout << fixed << setprecision(15)
// continue
// count(S.begin(),S.end(),'');
// reverse(S.begin(), S.end());
// s.substr(8, 8)
// sort(p.begin(), p.end());
// reverse(s.begin(), s.end());
// sort(p.rbegin(), p.rend()); ← 降順sort.
// getline(cin,s);
// transform (s.begin(), s.end(), s.begin(), toupper); ←大文字変換
// transform (s.begin(), s.end(), s.begin(), tolower); ←小文字変換
/*-----------------------------------------------------------------------------------*/
ll maximam = 1e8;
int main() {
ll n, x, m, count = 0;
cin >> n >> x >> m;
vec p(m);
p[0] = x;
bool is = false;
rep(i, m - 1) {
count++;
if (p[i] == 0) {
is = true;
break;
}
p[i + 1] = p[i] * p[i] % m;
}
if (n <= m) {
ll ans = 0;
rep(i, n) { ans += p[i]; }
out(ans);
} else if (is) {
ll ans = 0;
rep(i, count) { ans += p[i]; }
out(ans);
} else {
bool is = true, po = false, ppp = true;
ll counter = 1, ok = 0;
vec q, r(m), s;
q.push_back(x);
ll i = 0;
while (ppp) {
if (q[i] * q[i] % m == 0) {
po = true;
break;
}
q.push_back(q[i] * q[i] % m);
if (is) {
counter++;
} else {
ok++;
s.push_back(q[i] * q[i] % m);
}
if (r[q[i + 1] - 1] == 1) {
is = false;
}
if (r[q[i + 1] - 1] == 2) {
ppp = false;
}
r[q[i + 1] - 1]++;
i++;
}
ll ans = 0;
n -= counter;
rep(j, counter) { ans += q[j]; }
if (po) {
out(ans);
return 0;
}
ll sum = 0;
rep(j, ok) { sum += s[j]; }
ans += sum * (n / ok);
ll qq = n % ok;
rep(j, qq) { ans += s[j]; }
out(ans);
}
}
| insert | 357 | 357 | 357 | 358 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
inline int popcount(ll x) { return __builtin_popcountll(x); }
inline int div2num(ll x) { return __builtin_ctzll(x); }
inline bool bit(ll x, int b) { return (x >> b) & 1; }
template <class T> string to_string(T s);
template <class S, class T> string to_string(pair<S, T> p);
string to_string(string s) { return s; }
string to_string(const char s[]) { return to_string(string(s)); }
template <class T> string to_string(T v) {
if (v.empty())
return "{}";
string ret = "{";
for (auto x : v)
ret += to_string(x) + ",";
ret.back() = '}';
return ret;
}
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + ":" + to_string(p.second) + "}";
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
std::string separator = " ";
template <class T> inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus)
x = -x;
}
inline void read(std::string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T> inline void read(std::vector<T> &v) {
for (auto &x : v)
read(x);
}
template <class S, class T> inline void read(std::pair<S, T> &p) {
read(p.first);
read(p.second);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &...tail) {
read(head);
read(tail...);
}
template <class T> inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0)
putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(std::string x) {
for (char c : x)
putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i)
putchar_unlocked(s[i]);
}
template <class T> inline void write(std::vector<T> v) {
if (v.empty())
return;
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
template <class Head, class... Tail>
inline void writeln(Head head, Tail... tail) {
write(head, tail...);
write("\n");
}
void set_separator(std::string s) { separator = s; }
} io;
struct Prime {
int n;
vector<int> table;
vector<int> primes;
Prime(int _n = 100000) {
n = _n + 1;
table.resize(n, -1);
table[0] = 0;
table[1] = -1;
for (int i = 2; i * i < n; ++i) {
if (table[i] == -1) {
for (int j = i * i; j < n; j += i) {
table[j] = i;
}
}
}
}
void enumerate_primes() {
primes.clear();
for (int i = 2; i < n; ++i) {
if (table[i] == -1)
primes.push_back(i);
}
}
vector<pair<long long, int>> prime_factor(long long x) {
map<long long, int> mp;
long long div = 2;
int p = 0;
while (n <= x && div * div <= x) {
if (x % div == 0) {
mp[div]++;
x /= div;
} else {
if (p + 1 < primes.size()) {
div = primes[++p];
} else {
div++;
}
}
}
if (x < n) {
while (table[x] != -1) {
mp[table[x]]++;
x /= table[x];
}
}
if (x > 1)
mp[x]++;
vector<pair<long long, int>> ret;
for (auto p : mp)
ret.push_back(p);
return ret;
}
};
template <int MOD = 1000000007> struct Math {
vector<long long> fact, factinv, inv;
Math(int n = 100000) {
fact.resize(n + 1);
factinv.resize(n + 1);
inv.resize(n + 1);
fact[0] = fact[1] = 1;
factinv[0] = factinv[1] = 1;
inv[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
factinv[i] = factinv[i - 1] * inv[i] % MOD;
}
}
long long C(int n, int r) {
if (n < r || n < 0 || r < 0) {
return 0;
} else {
return fact[n] * (factinv[r] * factinv[n - r] % MOD) % MOD;
}
}
long long P(int n, int r) {
if (n < r || n < 0 || r < 0) {
return 0;
} else {
return fact[n] * factinv[n - r] % MOD;
}
}
long long H(int n, int r) { return C(n + r - 1, r); }
};
struct UnionFind {
vector<int> data;
vector<vector<int>> groups;
UnionFind(int n) : data(n, -1) {}
int root(int v) { return data[v] < 0 ? v : data[v] = root(data[v]); }
bool unite(int u, int v) {
if ((u = root(u)) == (v = root(v))) {
return 1;
} else {
if (-data[u] < -data[v])
swap(u, v);
data[u] += data[v];
data[v] = u;
return 0;
}
}
int size(int v) { return -data[root(v)]; }
void make_groups() {
map<int, vector<int>> mp;
for (int i = 0; i < data.size(); ++i)
mp[root(i)].push_back(i);
groups.clear();
for (auto p : mp)
groups.push_back(p.second);
}
};
namespace phc {
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
long long modinv(long long a) {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
long long gcd(long long a, long long b) { return b != 0 ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
} // namespace phc
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>;
constexpr int dy[4] = {-1, 0, 1, 0}, dx[4] = {0, -1, 0, 1};
int main() {
ll N, X, M;
io.read(N, X, M);
N--;
ll ans = X;
ll now = X;
ll turn = 0;
vector<ll> last(M, -1);
while (N > 0) {
last[now] = turn;
now = now * now % M;
ans += now;
turn++;
N--;
if (last[now] != -1) {
ll loopl = turn - last[now];
ll loopn = N / loopl;
ll sum = now;
ll t = now * now % M;
while (t != now) {
sum += t;
t = t * t % M;
}
ans += sum * loopn;
N %= loopl;
}
}
io.writeln(ans);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
inline int popcount(ll x) { return __builtin_popcountll(x); }
inline int div2num(ll x) { return __builtin_ctzll(x); }
inline bool bit(ll x, int b) { return (x >> b) & 1; }
template <class T> string to_string(T s);
template <class S, class T> string to_string(pair<S, T> p);
string to_string(string s) { return s; }
string to_string(const char s[]) { return to_string(string(s)); }
template <class T> string to_string(T v) {
if (v.empty())
return "{}";
string ret = "{";
for (auto x : v)
ret += to_string(x) + ",";
ret.back() = '}';
return ret;
}
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + ":" + to_string(p.second) + "}";
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
std::string separator = " ";
template <class T> inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus)
x = -x;
}
inline void read(std::string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T> inline void read(std::vector<T> &v) {
for (auto &x : v)
read(x);
}
template <class S, class T> inline void read(std::pair<S, T> &p) {
read(p.first);
read(p.second);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &...tail) {
read(head);
read(tail...);
}
template <class T> inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0)
putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(std::string x) {
for (char c : x)
putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i)
putchar_unlocked(s[i]);
}
template <class T> inline void write(std::vector<T> v) {
if (v.empty())
return;
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
template <class Head, class... Tail>
inline void writeln(Head head, Tail... tail) {
write(head, tail...);
write("\n");
}
void set_separator(std::string s) { separator = s; }
} io;
struct Prime {
int n;
vector<int> table;
vector<int> primes;
Prime(int _n = 100000) {
n = _n + 1;
table.resize(n, -1);
table[0] = 0;
table[1] = -1;
for (int i = 2; i * i < n; ++i) {
if (table[i] == -1) {
for (int j = i * i; j < n; j += i) {
table[j] = i;
}
}
}
}
void enumerate_primes() {
primes.clear();
for (int i = 2; i < n; ++i) {
if (table[i] == -1)
primes.push_back(i);
}
}
vector<pair<long long, int>> prime_factor(long long x) {
map<long long, int> mp;
long long div = 2;
int p = 0;
while (n <= x && div * div <= x) {
if (x % div == 0) {
mp[div]++;
x /= div;
} else {
if (p + 1 < primes.size()) {
div = primes[++p];
} else {
div++;
}
}
}
if (x < n) {
while (table[x] != -1) {
mp[table[x]]++;
x /= table[x];
}
}
if (x > 1)
mp[x]++;
vector<pair<long long, int>> ret;
for (auto p : mp)
ret.push_back(p);
return ret;
}
};
template <int MOD = 1000000007> struct Math {
vector<long long> fact, factinv, inv;
Math(int n = 100000) {
fact.resize(n + 1);
factinv.resize(n + 1);
inv.resize(n + 1);
fact[0] = fact[1] = 1;
factinv[0] = factinv[1] = 1;
inv[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
factinv[i] = factinv[i - 1] * inv[i] % MOD;
}
}
long long C(int n, int r) {
if (n < r || n < 0 || r < 0) {
return 0;
} else {
return fact[n] * (factinv[r] * factinv[n - r] % MOD) % MOD;
}
}
long long P(int n, int r) {
if (n < r || n < 0 || r < 0) {
return 0;
} else {
return fact[n] * factinv[n - r] % MOD;
}
}
long long H(int n, int r) { return C(n + r - 1, r); }
};
struct UnionFind {
vector<int> data;
vector<vector<int>> groups;
UnionFind(int n) : data(n, -1) {}
int root(int v) { return data[v] < 0 ? v : data[v] = root(data[v]); }
bool unite(int u, int v) {
if ((u = root(u)) == (v = root(v))) {
return 1;
} else {
if (-data[u] < -data[v])
swap(u, v);
data[u] += data[v];
data[v] = u;
return 0;
}
}
int size(int v) { return -data[root(v)]; }
void make_groups() {
map<int, vector<int>> mp;
for (int i = 0; i < data.size(); ++i)
mp[root(i)].push_back(i);
groups.clear();
for (auto p : mp)
groups.push_back(p.second);
}
};
namespace phc {
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
long long modinv(long long a) {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
long long gcd(long long a, long long b) { return b != 0 ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
} // namespace phc
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>;
constexpr int dy[4] = {-1, 0, 1, 0}, dx[4] = {0, -1, 0, 1};
int main() {
ll N, X, M;
io.read(N, X, M);
N--;
ll ans = X;
ll now = X;
ll turn = 0;
vector<ll> last(M, -1);
while (N > 0) {
last[now] = turn;
now = now * now % M;
ans += now;
turn++;
N--;
if (N > M && last[now] != -1) {
ll loopl = turn - last[now];
ll loopn = N / loopl;
ll sum = now;
ll t = now * now % M;
while (t != now) {
sum += t;
t = t * t % M;
}
ans += sum * loopn;
N %= loopl;
}
}
io.writeln(ans);
return 0;
} | replace | 396 | 397 | 396 | 397 | TLE | |
p02550 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// end
int main() {
ll n;
cin >> n;
int x, m;
cin >> x >> m;
if (n <= 10101010) {
ll res = 0;
int cur = x;
while (n) {
res += cur;
cur = (1LL * cur * cur) % m;
n--;
}
cout << res << endl;
return 0;
}
map<int, int> rs;
int idx = 0, cur = x, eq = -1;
while (1) {
if (rs.count(cur)) {
eq = cur;
break;
}
rs[cur] = idx;
cur = (1LL * cur * cur) % m;
idx++;
}
ll res = 0;
if (cur == 0) {
cur = x;
goto fail;
}
if ((int)rs.size() <= n) {
for (auto &add : rs)
res += add.first;
n -= rs.size();
cur = eq;
idx = 0;
rs.clear();
while (1) {
if (rs.count(cur))
break;
rs[cur] = idx++;
cur = (1LL * cur * cur) % m;
}
ll cir = 0;
for (auto &add : rs)
cir += add.first;
res += cir * (n / (int)rs.size());
n %= rs.size();
} else
cur = x;
fail:;
while (n) {
res += cur;
cur = (1LL * cur * cur) % m;
n--;
}
cout << res << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// end
int main() {
ll n;
cin >> n;
int x, m;
cin >> x >> m;
if (n <= 10101010) {
ll res = 0;
int cur = x;
while (n) {
res += cur;
cur = (1LL * cur * cur) % m;
n--;
}
cout << res << endl;
return 0;
}
map<int, int> rs;
int idx = 0, cur = x, eq = -1;
while (1) {
if (rs.count(cur)) {
eq = cur;
break;
}
rs[cur] = idx;
cur = (1LL * cur * cur) % m;
idx++;
}
ll res = 0;
if (cur == 0) {
cur = x;
goto fail;
}
if ((int)rs.size() <= n) {
for (auto &add : rs)
res += add.first;
n -= rs.size();
cur = eq;
idx = 0;
rs.clear();
while (1) {
if (rs.count(cur))
break;
rs[cur] = idx++;
cur = (1LL * cur * cur) % m;
}
ll cir = 0;
for (auto &add : rs)
cir += add.first;
res += cir * (n / (int)rs.size());
n %= rs.size();
} else
cur = x;
fail:;
while (n) {
res += cur;
cur = (1LL * cur * cur) % m;
n--;
if (cur == 0)
break;
}
cout << res << endl;
return 0;
}
| insert | 84 | 84 | 84 | 86 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <atcoder/all>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
#define all(v) v.begin(), v.end()
#define rall(x) (x).rbegin(), (x).rend()
#define pll pair<long long, long long>
#define pb emplace_back
#define mp make_pair
#define mt make_tuple
#define vc vector<char>
#define vvc vector<vc>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<long long>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vvb = vector<vb>;
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;
}
// snippets:tmp,cl,cvl,cs,co,coy,con,cov,setp
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n;
cin >> n;
ll x;
cin >> x;
ll m;
cin >> m;
ll c = 1;
vll d(m + 10);
ll count = 0;
ll sum = 0;
vll s(m + 10);
while (true) {
if (count != 0)
c = c * c % m;
else
c = x % m;
if (d[c] != 0)
break;
count++;
d[c] = count;
sum = sum + c;
s[count] = sum;
}
ll ans = 0;
ll sum2 = s[count] - s[d[c] - 1];
ans = sum + sum2 * ((n - count) / (count - d[c] + 1));
ans += s[d[c] - 1 + (n - count) % (count - d[c] + 1)] - s[d[c] - 1];
cout << ans << endl;
}
| #include <bits/stdc++.h>
// #include <atcoder/all>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
#define all(v) v.begin(), v.end()
#define rall(x) (x).rbegin(), (x).rend()
#define pll pair<long long, long long>
#define pb emplace_back
#define mp make_pair
#define mt make_tuple
#define vc vector<char>
#define vvc vector<vc>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<long long>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vvb = vector<vb>;
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;
}
// snippets:tmp,cl,cvl,cs,co,coy,con,cov,setp
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n;
cin >> n;
ll x;
cin >> x;
ll m;
cin >> m;
ll c = 1;
vll d(m + 10);
ll count = 0;
ll sum = 0;
vll s(m + 10);
while (true) {
if (count != 0)
c = c * c % m;
else
c = x % m;
if (d[c] != 0)
break;
count++;
d[c] = count;
sum = sum + c;
s[count] = sum;
if (count == n) {
cout << sum << endl;
return 0;
}
}
ll ans = 0;
ll sum2 = s[count] - s[d[c] - 1];
ans = sum + sum2 * ((n - count) / (count - d[c] + 1));
ans += s[d[c] - 1 + (n - count) % (count - d[c] + 1)] - s[d[c] - 1];
cout << ans << endl;
}
| insert | 62 | 62 | 62 | 66 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define st first
#define nd second
#define pb push_back
#define lwb lower_bound
#define upb upper_bound
#define Size(a) int((a).size())
#define reset(s, n) memset(s, n, sizeof(s))
#define bit(n, i) (((n) >> (i)) & 1)
#define cntbit(n) __builtin_popcountll(n)
#define all(a) (a).begin(), (a).end()
#define unique(a) (a).resize(unique(all(a)) - (a).begin())
#define Max(a, b, c) max(max((ll)(a), (ll)(b)), (ll)(c))
#define Min(a, b, c) min(min((ll)(a), (ll)(b)), (ll)(c))
typedef long double ld;
typedef long long ll;
const int MOD = 1e9 + 7;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const ld EPS = 1e-7;
inline ll fpow(ll n, ll k, ll p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
inline int inv(int a, ll p = MOD) { return fpow(a, p - 2, p); }
inline ll lcm(ll a, ll b) { return a / __gcd(a, b) * b; }
inline void onbit(ll &a, int i) { a |= 1LL << i; }
inline void offbit(ll &a, int i) { onbit(a, i), a -= (1LL << i); }
const int N = 3e5 + 5;
ll n, m, k;
int visited[N];
vector<long long> clique;
vector<long long> a;
vector<ll> f;
ll size_clique = 1;
ll root;
void dfs(ll u) {
visited[u] = 1;
if (visited[f[u]] == 0) {
dfs(f[u]);
} else {
u = f[u];
root = u;
clique[0] = u;
while (f[u] != root) {
u = f[u];
clique[size_clique++] = u;
}
}
}
void solve() {
clique.assign(N, 0);
a.assign(N, 0);
f.assign(N, 0);
ll x;
cin >> n >> x >> m;
a[1] = x;
for (int i = 2; i < N; i++) {
long long value = (a[i - 1] * a[i - 1]) % m;
a[i] = value;
if (a[i] == 0) {
long long res = 0;
for (int i = 1; i <= n; i++) {
res += a[i];
}
cout << res << "\n";
return;
}
f[a[i - 1]] = a[i];
if (f[a[i]] != 0) {
break;
}
}
dfs(x);
ll cnt = 0;
long long res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != root) {
res += a[i];
cnt++;
} else {
break;
}
}
for (int i = 1; i < size_clique; i++) {
clique[i] += clique[i - 1];
}
n -= cnt;
ll p = n / size_clique;
res += p * clique[size_clique - 1];
n %= size_clique;
if (n > 0)
res += clique[n - 1];
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int query = 1;
// cin >> query;
int start = 1000 * clock() / CLOCKS_PER_SEC;
while (query--)
solve();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC - start
<< "ms\n";
}
| #include <bits/stdc++.h>
using namespace std;
#define st first
#define nd second
#define pb push_back
#define lwb lower_bound
#define upb upper_bound
#define Size(a) int((a).size())
#define reset(s, n) memset(s, n, sizeof(s))
#define bit(n, i) (((n) >> (i)) & 1)
#define cntbit(n) __builtin_popcountll(n)
#define all(a) (a).begin(), (a).end()
#define unique(a) (a).resize(unique(all(a)) - (a).begin())
#define Max(a, b, c) max(max((ll)(a), (ll)(b)), (ll)(c))
#define Min(a, b, c) min(min((ll)(a), (ll)(b)), (ll)(c))
typedef long double ld;
typedef long long ll;
const int MOD = 1e9 + 7;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const ld EPS = 1e-7;
inline ll fpow(ll n, ll k, ll p = MOD) {
ll r = 1;
for (; k; k >>= 1) {
if (k & 1)
r = r * n % p;
n = n * n % p;
}
return r;
}
inline int inv(int a, ll p = MOD) { return fpow(a, p - 2, p); }
inline ll lcm(ll a, ll b) { return a / __gcd(a, b) * b; }
inline void onbit(ll &a, int i) { a |= 1LL << i; }
inline void offbit(ll &a, int i) { onbit(a, i), a -= (1LL << i); }
const int N = 3e5 + 5;
ll n, m, k;
int visited[N];
vector<long long> clique;
vector<long long> a;
vector<ll> f;
ll size_clique = 1;
ll root;
void dfs(ll u) {
visited[u] = 1;
if (visited[f[u]] == 0) {
dfs(f[u]);
} else {
u = f[u];
root = u;
clique[0] = u;
while (f[u] != root) {
u = f[u];
clique[size_clique++] = u;
}
}
}
void solve() {
clique.assign(N, 0);
a.assign(N, 0);
f.assign(N, 0);
ll x;
cin >> n >> x >> m;
if (m == 1) {
cout << 0 << "\n";
return;
}
a[1] = x;
for (int i = 2; i < N; i++) {
long long value = (a[i - 1] * a[i - 1]) % m;
a[i] = value;
if (a[i] == 0) {
long long res = 0;
for (int i = 1; i <= n; i++) {
res += a[i];
}
cout << res << "\n";
return;
}
f[a[i - 1]] = a[i];
if (f[a[i]] != 0) {
break;
}
}
dfs(x);
ll cnt = 0;
long long res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != root) {
res += a[i];
cnt++;
} else {
break;
}
}
for (int i = 1; i < size_clique; i++) {
clique[i] += clique[i - 1];
}
n -= cnt;
ll p = n / size_clique;
res += p * clique[size_clique - 1];
n %= size_clique;
if (n > 0)
res += clique[n - 1];
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int query = 1;
// cin >> query;
int start = 1000 * clock() / CLOCKS_PER_SEC;
while (query--)
solve();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC - start
<< "ms\n";
}
| insert | 70 | 70 | 70 | 74 | 0 |
Time elapsed: 9ms
|
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define X \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define FIXED_FLOAT(x) std::fixed << std::setprecision(2) << (x)
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
// long long p = 1e9+7;
typedef long long ll;
typedef pair<ll, ll> pl;
typedef vector<int> VI;
typedef vector<pair<ll, ll>> VP;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef vector<bool> VB;
// typedef pair<ll, ll> PL;
typedef unordered_map<ll, ll> UMP;
#define FOR(i, b, init) for (i = init; i < b; i++)
#define pb push_back
#define fi first
#define se second
#define mp make_pair
// typedef unordered_set<ll>;
// void printa(VI &x,ll n){
// ll i;
// FOR(i, n){
// cout<<x[i]<<" ";
// }
// cout<<endl;
// }
/////GLOABLS VARS
ll MOD = 1e9 + 7;
ll gmx = 1e6 + 7;
VL fact(gmx, 1);
//////FUNCTIONS
ll powp(ll val, ll deg) {
// debug(val, deg);
if (!deg)
return 1;
if (deg & 1)
return (powp(val, deg - 1) * val) % MOD;
ll res = powp(val, deg >> 1);
// debug(res);
return (res * res) % MOD;
}
ll mx = 2 * 1e5 + 7;
vector<VL> adj;
VL sub;
// VL igno;
ll n;
void dfs(ll r, ll parent) {
sub[r] = 1;
// if(igno[r]==1){return;}
// debug(r,parent);
for (auto k : adj[r]) {
if (k == parent) {
continue;
}
dfs(k, r);
sub[r] += sub[k];
}
return;
}
// It is not easy but it can be fun, if you think!!!
ll gcd(ll a, ll b) {
// debug(a,b);
if (a > b) {
swap(a, b);
}
if (a == 0) {
return b;
}
return gcd(a, b % a);
}
int centroid(ll u, ll p) {
// debug(u,p);
for (auto v : adj[u])
if (v != p and sub[v] > n / 2)
return centroid(v, u);
return u;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#endif
// ll tc,t;
// cin>>tc;
// while(tc--){
ll n, x, m, k, i, j, o;
// cin>>n;
cin >> n >> x >> m;
VL last(m, -1);
ll ai = x;
last[x % m] = 0;
ll st = 0, period = 0;
VL l;
l.pb(ai);
FOR(i, m, 1) {
ai = (ai * ai) % m;
l.pb(ai);
if (last[ai] != -1) {
st = last[ai];
period = i - last[ai];
break;
}
last[ai] = i;
}
// debug(l,st,period);
ll ans = 0;
FOR(i, st, 0) {
ans += l[i];
n -= 1;
if (n == 0) {
cout << ans;
exit(0);
}
}
VL mp;
ll sum_cycle = 0;
FOR(i, st + period, st) {
sum_cycle += l[i];
mp.pb(sum_cycle);
}
ans += (n / period) * sum_cycle;
n = n - (period * (n / period));
if (n > 0) {
ans += mp[n - 1];
}
cout << ans;
// }
} | #include <bits/stdc++.h>
using namespace std;
#define X \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define FIXED_FLOAT(x) std::fixed << std::setprecision(2) << (x)
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
// long long p = 1e9+7;
typedef long long ll;
typedef pair<ll, ll> pl;
typedef vector<int> VI;
typedef vector<pair<ll, ll>> VP;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef vector<bool> VB;
// typedef pair<ll, ll> PL;
typedef unordered_map<ll, ll> UMP;
#define FOR(i, b, init) for (i = init; i < b; i++)
#define pb push_back
#define fi first
#define se second
#define mp make_pair
// typedef unordered_set<ll>;
// void printa(VI &x,ll n){
// ll i;
// FOR(i, n){
// cout<<x[i]<<" ";
// }
// cout<<endl;
// }
/////GLOABLS VARS
ll MOD = 1e9 + 7;
ll gmx = 1e6 + 7;
VL fact(gmx, 1);
//////FUNCTIONS
ll powp(ll val, ll deg) {
// debug(val, deg);
if (!deg)
return 1;
if (deg & 1)
return (powp(val, deg - 1) * val) % MOD;
ll res = powp(val, deg >> 1);
// debug(res);
return (res * res) % MOD;
}
ll mx = 2 * 1e5 + 7;
vector<VL> adj;
VL sub;
// VL igno;
ll n;
void dfs(ll r, ll parent) {
sub[r] = 1;
// if(igno[r]==1){return;}
// debug(r,parent);
for (auto k : adj[r]) {
if (k == parent) {
continue;
}
dfs(k, r);
sub[r] += sub[k];
}
return;
}
// It is not easy but it can be fun, if you think!!!
ll gcd(ll a, ll b) {
// debug(a,b);
if (a > b) {
swap(a, b);
}
if (a == 0) {
return b;
}
return gcd(a, b % a);
}
int centroid(ll u, ll p) {
// debug(u,p);
for (auto v : adj[u])
if (v != p and sub[v] > n / 2)
return centroid(v, u);
return u;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#endif
// ll tc,t;
// cin>>tc;
// while(tc--){
ll n, x, m, k, i, j, o;
// cin>>n;
cin >> n >> x >> m;
VL last(m, -1);
ll ai = x;
last[x % m] = 0;
ll st = 0, period = 0;
VL l;
l.pb(ai);
FOR(i, m + 1, 1) {
ai = (ai * ai) % m;
l.pb(ai);
if (last[ai] != -1) {
st = last[ai];
period = i - last[ai];
break;
}
last[ai] = i;
}
// debug(l,st,period);
ll ans = 0;
FOR(i, st, 0) {
ans += l[i];
n -= 1;
if (n == 0) {
cout << ans;
exit(0);
}
}
VL mp;
ll sum_cycle = 0;
FOR(i, st + period, st) {
sum_cycle += l[i];
mp.pb(sum_cycle);
}
ans += (n / period) * sum_cycle;
n = n - (period * (n / period));
if (n > 0) {
ans += mp[n - 1];
}
cout << ans;
// }
} | replace | 154 | 155 | 154 | 155 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02550 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rrep(i, s, n) for (int i = (int)(n)-1; (s) <= i; i--)
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> used(m * 2);
vector<ll> one_cycle;
int start = 0;
ll now = x;
rep(i, 0, n) {
used[now] = true;
one_cycle.push_back(now);
now = now * now % m;
if (used[now]) {
rep(j, 0, one_cycle.size()) if (one_cycle[j] == now) {
start = j;
break;
}
break;
}
}
ll s1 = 0, s2 = 0, loop = one_cycle.size() - start;
rep(i, 0, start) s1 += one_cycle[i];
rep(i, start, one_cycle.size()) s2 += one_cycle[i];
ll ans = s1 + (n - start) / loop * s2;
rep(i, 0, (n - start) % loop) {
ans += now;
now = now * now % m;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (n); ++i)
int main() {
ll n, x, m;
cin >> n >> x >> m;
vector<bool> used(m * 2);
vector<ll> one_cycle;
int start = 0;
ll now = x;
rep(i, 0, n) {
used[now] = true;
one_cycle.push_back(now);
now = now * now % m;
if (used[now]) {
rep(j, 0, one_cycle.size()) if (one_cycle[j] == now) {
start = j;
break;
}
break;
}
}
ll s1 = 0, s2 = 0, loop = one_cycle.size() - start;
rep(i, 0, start) s1 += one_cycle[i];
rep(i, start, one_cycle.size()) s2 += one_cycle[i];
ll ans = s1 + (n - start) / loop * s2;
rep(i, 0, (n - start) % loop) {
ans += now;
now = now * now % m;
}
cout << ans << endl;
return 0;
}
| replace | 12 | 14 | 12 | 13 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define llint long long int
using namespace std;
int main() {
llint N, X, M;
cin >> N >> X >> M;
// ループするまで
vector<bool> sumi(M, false);
llint sum = 0;
llint A;
bool loop = false;
llint loop_start = -1;
for (int i = 1; i <= N; i++) {
if (i == 1) {
A = X;
} else {
A = (A * A) % M;
}
sum += A;
loop_start = A;
if (sumi[A] == false) {
sumi[A] = true;
} else {
loop = true;
break;
}
}
if (loop = false) {
cout << sum << endl;
return 0;
}
// ループの開始まで
sum = 0;
llint i = 1;
while (true) {
if (i == 1) {
A = X;
} else {
A = (A * A) % M;
}
sum += A;
i++;
if (A == loop_start) {
break;
}
}
// ループの長さ
llint count = 0;
llint sum_part = 0;
while (true) {
A = (A * A) % M;
sum_part += A;
count++;
i++;
if (A == loop_start) {
break;
}
}
i -= count;
sum += ((N + 1 - i) / count) * sum_part;
i += ((N + 1 - i) / count) * count;
// ループの終了から
for (; i <= N; i++) {
A = (A * A) % M;
sum += A;
}
cout << sum << endl;
} | #include <bits/stdc++.h>
#define llint long long int
using namespace std;
int main() {
llint N, X, M;
cin >> N >> X >> M;
if (N == 1) {
cout << X << endl;
return 0;
}
// ループするまで
vector<bool> sumi(M, false);
llint sum = 0;
llint A;
bool loop = false;
llint loop_start = -1;
for (int i = 1; i <= N; i++) {
if (i == 1) {
A = X;
} else {
A = (A * A) % M;
}
sum += A;
loop_start = A;
if (sumi[A] == false) {
sumi[A] = true;
} else {
loop = true;
break;
}
}
if (loop = false) {
cout << sum << endl;
return 0;
}
// ループの開始まで
sum = 0;
llint i = 1;
while (true) {
if (i == 1) {
A = X;
} else {
A = (A * A) % M;
}
sum += A;
i++;
if (A == loop_start) {
break;
}
}
// ループの長さ
llint count = 0;
llint sum_part = 0;
while (true) {
A = (A * A) % M;
sum_part += A;
count++;
i++;
if (A == loop_start) {
break;
}
}
i -= count;
sum += ((N + 1 - i) / count) * sum_part;
i += ((N + 1 - i) / count) * count;
// ループの終了から
for (; i <= N; i++) {
A = (A * A) % M;
sum += A;
}
cout << sum << endl;
} | insert | 11 | 11 | 11 | 16 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define fbo find_by_order
#define ook order_of_key
#define fi first
#define se second
#define long long long
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set; mt19937_64
// rng(std::chrono::system_clock::now().time_since_epoch().count());
// /mnt/c/Users/vince/Desktop/POST-IOI/
long n, x, m;
vector<long> vec;
int visited[100003];
int main() {
// ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("input.in", "r", stdin);
// scanf("%lld %lld %lld", &n, &x, &m);
long a = x;
while (1) {
visited[a] = vec.size();
vec.push_back(a);
a = (a * a) % m;
if (visited[a]) {
// printf("%lld\n", a);
break;
}
}
int sz1 = 0, sz2 = vec.size();
long sum = 0;
for (int i = visited[a]; i < vec.size(); i++) {
sz2--;
sz1++;
sum += vec[i];
}
// printf("%lld\n", sum);
// for(auto x : vec) printf("%lld ", x); printf("\n");
long res = 0;
if (n <= sz2) {
for (int i = 0; i < n; i++)
res += vec[i];
} else {
for (int i = 0; i < sz2; i++)
res += vec[i];
n -= sz2;
res += sum * (n / sz1);
n %= sz1;
for (int i = 0; i < n; i++)
res += vec[visited[a] + i];
}
printf("%lld\n", res);
} | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define fbo find_by_order
#define ook order_of_key
#define fi first
#define se second
#define long long long
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> ordered_set; mt19937_64
// rng(std::chrono::system_clock::now().time_since_epoch().count());
// /mnt/c/Users/vince/Desktop/POST-IOI/
long n, x, m;
vector<long> vec;
int visited[100003];
int main() {
// ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("input.in", "r", stdin);
scanf("%lld %lld %lld", &n, &x, &m);
long a = x;
while (1) {
visited[a] = vec.size();
vec.push_back(a);
a = (a * a) % m;
if (visited[a]) {
// printf("%lld\n", a);
break;
}
}
int sz1 = 0, sz2 = vec.size();
long sum = 0;
for (int i = visited[a]; i < vec.size(); i++) {
sz2--;
sz1++;
sum += vec[i];
}
// printf("%lld\n", sum);
// for(auto x : vec) printf("%lld ", x); printf("\n");
long res = 0;
if (n <= sz2) {
for (int i = 0; i < n; i++)
res += vec[i];
} else {
for (int i = 0; i < sz2; i++)
res += vec[i];
n -= sz2;
res += sum * (n / sz1);
n %= sz1;
for (int i = 0; i < n; i++)
res += vec[visited[a] + i];
}
printf("%lld\n", res);
} | replace | 30 | 31 | 30 | 31 | -8 | |
p02550 | C++ | Time Limit Exceeded | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cassert>
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <limits>
#include <list>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvll vector<vector<long long>>
#define vvc vector<vector<char>>
#define vll vector<long long>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define sysp system("PAUSE")
#define pno cout << "no" << endl
#define pyes cout << "yes" << endl
#define pYes cout << "Yes" << endl
#define pNo cout << "No" << endl
#define pNO cout << "NO" << endl
#define pYES cout << "YES" << endl
#define endl "\n"
#define pi 3.14159265358979
using namespace std;
using ll = long long;
#define int ll
signed main() {
int ans = 0;
int N, X, M;
cin >> N >> X >> M;
vector<int> ordVisit(M, -1);
int val = X;
int Lcycle = -1;
int Sumcycle = 0;
int Startcycle = -1;
// Aの値で既出があればおしまい
// ordvistのvaluesは1-indexed
for (int i = 1; i < M + 1; i++) {
// とりあえずループ探し
if (ordVisit[val] > 0) {
Startcycle = val;
Lcycle = i - ordVisit[val];
break;
}
ordVisit[val] = i;
val *= val;
val %= M;
}
int ind = Startcycle;
for (int p = 0; p < Lcycle; p++) {
Sumcycle += ind;
ind *= ind;
ind %= M;
}
// [X,loopind)の数を数える
int Dfirst = 0;
int tmp = X;
while (tmp != Startcycle) {
Dfirst++;
ans += tmp;
tmp *= tmp;
tmp %= M;
}
int rem = N - Dfirst;
int Tloop = rem / Lcycle;
int Dsecond = rem % Lcycle;
ans += Tloop * Sumcycle;
int tmpp = Startcycle;
for (int i = 0; i < Dsecond; i++) {
ans += tmpp;
tmpp *= tmpp;
tmpp %= M;
}
cout << ans << endl;
} | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cassert>
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <limits>
#include <list>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvll vector<vector<long long>>
#define vvc vector<vector<char>>
#define vll vector<long long>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define sysp system("PAUSE")
#define pno cout << "no" << endl
#define pyes cout << "yes" << endl
#define pYes cout << "Yes" << endl
#define pNo cout << "No" << endl
#define pNO cout << "NO" << endl
#define pYES cout << "YES" << endl
#define endl "\n"
#define pi 3.14159265358979
using namespace std;
using ll = long long;
#define int ll
signed main() {
int ans = 0;
int N, X, M;
cin >> N >> X >> M;
if (X == 0 && M == 1) {
cout << 0 << endl;
return 0;
}
vector<int> ordVisit(M, -1);
int val = X;
int Lcycle = -1;
int Sumcycle = 0;
int Startcycle = -1;
// Aの値で既出があればおしまい
// ordvistのvaluesは1-indexed
for (int i = 1; i < M + 1; i++) {
// とりあえずループ探し
if (ordVisit[val] > 0) {
Startcycle = val;
Lcycle = i - ordVisit[val];
break;
}
ordVisit[val] = i;
val *= val;
val %= M;
}
int ind = Startcycle;
for (int p = 0; p < Lcycle; p++) {
Sumcycle += ind;
ind *= ind;
ind %= M;
}
// [X,loopind)の数を数える
int Dfirst = 0;
int tmp = X;
while (tmp != Startcycle) {
Dfirst++;
ans += tmp;
tmp *= tmp;
tmp %= M;
}
int rem = N - Dfirst;
int Tloop = rem / Lcycle;
int Dsecond = rem % Lcycle;
ans += Tloop * Sumcycle;
int tmpp = Startcycle;
for (int i = 0; i < Dsecond; i++) {
ans += tmpp;
tmpp *= tmpp;
tmpp %= M;
}
cout << ans << endl;
} | insert | 51 | 51 | 51 | 55 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cmath>
#include <string>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<ll> vll;
#define all(v) v.begin(), v.end()
#define test() \
int t; \
cin >> t; \
while (t--)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ff first
#define ss second
#define pb push_back
const int mod = 998244353;
const ll INF = -(ll)1e10;
int main() {
ll n, x, m;
cin >> n >> x >> m;
vll pfx_sum(m);
vll rem(m);
pfx_sum[1] = x;
rem[x] = 1;
ll prev = x;
ll ans = 0;
for (int i = 2; i <= min(n, m); i++) {
prev = (prev * prev) % m;
if (prev == 0) {
cout << pfx_sum[i - 1] << endl;
return (0);
}
if (rem[prev]) {
ans = pfx_sum[i - 1];
ll left = n - i + 1;
ll div = left / (i - rem[prev]);
ll remainder = left % (i - rem[prev]);
ans += ((pfx_sum[i - 1] - pfx_sum[rem[prev] - 1]) * div);
ans += (pfx_sum[rem[prev] + remainder - 1] - pfx_sum[rem[prev] - 1]);
cout << ans << endl;
return (0);
} else {
rem[prev] = i;
pfx_sum[i] = (pfx_sum[i - 1] + prev);
}
}
cout << pfx_sum[n] << endl;
} | #include <bits/stdc++.h>
#include <cmath>
#include <string>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<ll> vll;
#define all(v) v.begin(), v.end()
#define test() \
int t; \
cin >> t; \
while (t--)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ff first
#define ss second
#define pb push_back
const int mod = 998244353;
const ll INF = -(ll)1e10;
int main() {
ll n, x, m;
cin >> n >> x >> m;
vll pfx_sum(m);
vll rem(m);
pfx_sum[1] = x;
rem[x] = 1;
ll prev = x;
ll ans = 0;
for (int i = 2; i <= min(n, m + 1); i++) {
prev = (prev * prev) % m;
if (prev == 0) {
cout << pfx_sum[i - 1] << endl;
return (0);
}
if (rem[prev]) {
ans = pfx_sum[i - 1];
ll left = n - i + 1;
ll div = left / (i - rem[prev]);
ll remainder = left % (i - rem[prev]);
ans += ((pfx_sum[i - 1] - pfx_sum[rem[prev] - 1]) * div);
ans += (pfx_sum[rem[prev] + remainder - 1] - pfx_sum[rem[prev] - 1]);
cout << ans << endl;
return (0);
} else {
rem[prev] = i;
pfx_sum[i] = (pfx_sum[i - 1] + prev);
}
}
cout << pfx_sum[n] << endl;
} | replace | 38 | 39 | 38 | 39 | 0 | |
p02550 | C++ | Runtime Error | /*بِسْمِ اللَّهِ الرَّحْمَنِ الرَّحِيم*/
// #pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef long long ll;
using pii = pair<int, int>;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
// const ll mod = 998244353;
inline void normal(ll &a) {
a %= mod;
(a < 0) && (a += mod);
}
inline ll modMul(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a * b) % mod;
}
inline ll modAdd(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a + b) % mod;
}
inline ll modSub(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, mod - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
#define si(x) scanf("%d", &x)
#define sii(x, y) scanf("%d %d", &x, &y)
#define siii(x, y, z) scanf("%d %d %d", &x, &y, &z)
#define sl(x) scanf("%lld", &x)
#define sll(x, y) scanf("%lld %lld", &x, &y)
#define slll(x, y, z) scanf("%lld %lld %lld", &x, &y, &z)
#define ss(ch) scanf("%s", ch)
#define pi(x) printf("%d", x)
#define pii(x, y) printf("%d %d", x, y)
#define piii(x, y, z) printf("%d %d %d", x, y, z)
#define pl(x) printf("%lld", x)
#define pll(x, y) printf("%lld %lld", x, y)
#define plll(x, y, z) printf("%lld %lld %lld", x, y, z)
#define ps(ch) printf("%s", ch)
#define F(i, a, b) for (int i = a; i <= b; i++)
#define R(i, b, a) for (int i = b; i >= a; i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
/* for Random Number generate
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
*/
///**
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
#define dbg(args...) \
do { \
cerr << #args << " : "; \
faltu(args); \
} while (0)
clock_t tStart = clock();
#define timeStamp \
dbg("Execution Time: ", (double)(clock() - tStart) / CLOCKS_PER_SEC)
void faltu() { cerr << endl; }
template <typename T> void faltu(T a[], int n) {
for (int i = 0; i < n; ++i)
cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
// Program showing a policy-based data structure.
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
using namespace __gnu_pbds;
// GNU link : https://goo.gl/WVDL6g
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
// find_by_order(k) – ফাংশনটি kth ordered element এর একটা পয়েন্টার রিটার্ন করে।
// অর্থাৎ তুমি চাইলেই kth ইন্ডেক্সে কি আছে, সেটা জেনে ফেলতে পারছো! order_of_key(x) –
// ফাংশনটি x এলিমেন্টটা কোন পজিশনে আছে সেটা বলে দেয়।
//*//**___________________________________________________**/
const int N = 1000006;
ll cycle_len, cycle_sm;
vector<int> g[N];
bitset<N> vis;
int main() {
FASTIO
/*
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
//*/
ll n, m, x;
cin >> n >> x >> m;
// dbg(n,x,m);
for (int i = 0; i < m; i++) {
ll j = (i * i) % m;
// dbg(i,j);
g[i].push_back(j);
}
ll ans = 0;
while (n > 0) {
if (vis[x])
break;
ans += x;
vis[x] = 1;
x = g[x][0];
n--;
}
// dbg(n);
if (n > 0) {
vis = 0;
ll y = x;
while (!vis[y]) {
cycle_len++;
cycle_sm += y;
vis[y] = 1;
y = g[y][0];
}
ll d = n / cycle_len, r = n % cycle_len;
// dbg(r);
ans += (d * cycle_sm);
for (ll i = 0; i < r; i++) {
ans += x;
x = g[x][0];
}
}
cout << ans << "\n";
return 0;
} | /*بِسْمِ اللَّهِ الرَّحْمَنِ الرَّحِيم*/
// #pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef long long ll;
using pii = pair<int, int>;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
// const ll mod = 998244353;
inline void normal(ll &a) {
a %= mod;
(a < 0) && (a += mod);
}
inline ll modMul(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a * b) % mod;
}
inline ll modAdd(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
return (a + b) % mod;
}
inline ll modSub(ll a, ll b) {
a %= mod, b %= mod;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, mod - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
#define si(x) scanf("%d", &x)
#define sii(x, y) scanf("%d %d", &x, &y)
#define siii(x, y, z) scanf("%d %d %d", &x, &y, &z)
#define sl(x) scanf("%lld", &x)
#define sll(x, y) scanf("%lld %lld", &x, &y)
#define slll(x, y, z) scanf("%lld %lld %lld", &x, &y, &z)
#define ss(ch) scanf("%s", ch)
#define pi(x) printf("%d", x)
#define pii(x, y) printf("%d %d", x, y)
#define piii(x, y, z) printf("%d %d %d", x, y, z)
#define pl(x) printf("%lld", x)
#define pll(x, y) printf("%lld %lld", x, y)
#define plll(x, y, z) printf("%lld %lld %lld", x, y, z)
#define ps(ch) printf("%s", ch)
#define F(i, a, b) for (int i = a; i <= b; i++)
#define R(i, b, a) for (int i = b; i >= a; i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
/* for Random Number generate
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
*/
///**
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
#define dbg(args...) \
do { \
cerr << #args << " : "; \
faltu(args); \
} while (0)
clock_t tStart = clock();
#define timeStamp \
dbg("Execution Time: ", (double)(clock() - tStart) / CLOCKS_PER_SEC)
void faltu() { cerr << endl; }
template <typename T> void faltu(T a[], int n) {
for (int i = 0; i < n; ++i)
cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
// Program showing a policy-based data structure.
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
using namespace __gnu_pbds;
// GNU link : https://goo.gl/WVDL6g
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
// find_by_order(k) – ফাংশনটি kth ordered element এর একটা পয়েন্টার রিটার্ন করে।
// অর্থাৎ তুমি চাইলেই kth ইন্ডেক্সে কি আছে, সেটা জেনে ফেলতে পারছো! order_of_key(x) –
// ফাংশনটি x এলিমেন্টটা কোন পজিশনে আছে সেটা বলে দেয়।
//*//**___________________________________________________**/
const int N = 1000006;
ll cycle_len, cycle_sm;
vector<int> g[N];
bitset<N> vis;
int main() {
FASTIO
/*
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
//*/
ll n, m, x;
cin >> n >> x >> m;
// dbg(n,x,m);
for (ll i = 0; i < m; i++) { // int i lekhar jonno RTE khaisi
ll j = (i * i) % m;
// dbg(i,j);
g[i].push_back(j);
}
ll ans = 0;
while (n > 0) {
if (vis[x])
break;
ans += x;
vis[x] = 1;
x = g[x][0];
n--;
}
// dbg(n);
if (n > 0) {
vis = 0;
ll y = x;
while (!vis[y]) {
cycle_len++;
cycle_sm += y;
vis[y] = 1;
y = g[y][0];
}
ll d = n / cycle_len, r = n % cycle_len;
// dbg(r);
ans += (d * cycle_sm);
for (ll i = 0; i < r; i++) {
ans += x;
x = g[x][0];
}
}
cout << ans << "\n";
return 0;
} | replace | 159 | 160 | 159 | 160 | 0 | |
p02550 | C++ | Runtime Error | #define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0)
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define LLINF 0x3f3f3f3f3f3f3f3f
#define INF 0x3f3f3f3f
#define LOCAL
// Copied from Gennady-Korotkevich's template
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}\n";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}\n";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
template <typename A, typename B, typename C, typename D, typename E>
string to_string(tuple<A, B, C, D, E> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + "," +
to_string(get<4>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) \
cerr << "\n[" << #__VA_ARGS__ << "]:\n", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// End of Gennady-Korotkevich's template
using llong = long long;
using PII = pair<int, int>;
const llong MOD = 998244353LL;
const double PI = acos(-1);
int main() {
IOS;
llong n, x, m;
cin >> n >> x >> m;
vector<llong> pos(m, -1);
pos[x] = 1;
llong cur = x;
vector<llong> seq;
int cnt = 0;
seq.push_back(x);
int s, e;
while (1) {
cur *= cur;
cur %= m;
if (pos[cur] != -1) {
s = pos[cur];
e = cnt;
break;
}
cnt++;
pos[cur] = cnt;
seq.push_back(cur);
}
vector<llong> init, cycle;
for (int i = 0; i < s; i++)
init.push_back(seq[i]);
for (int i = s; i <= e; i++)
cycle.push_back(seq[i]);
if (n <= (int)init.size()) {
llong sum = 0;
for (int i = 0; i < n; i++)
sum += init[i];
cout << sum;
return 0;
} else {
llong sum = 0;
for (int i = 0; i < init.size(); i++)
sum += init[i];
n -= init.size();
llong cyclesum = 0;
for (int i = 0; i < cycle.size(); i++)
cyclesum += cycle[i];
sum += (n / cycle.size()) * cyclesum;
n %= (int)cycle.size();
for (int i = 0; i < n; i++)
sum += cycle[i];
cout << sum;
}
} | #define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0)
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define LLINF 0x3f3f3f3f3f3f3f3f
#define INF 0x3f3f3f3f
#define LOCAL
// Copied from Gennady-Korotkevich's template
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}\n";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}\n";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
template <typename A, typename B, typename C, typename D, typename E>
string to_string(tuple<A, B, C, D, E> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + "," +
to_string(get<4>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) \
cerr << "\n[" << #__VA_ARGS__ << "]:\n", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// End of Gennady-Korotkevich's template
using llong = long long;
using PII = pair<int, int>;
const llong MOD = 998244353LL;
const double PI = acos(-1);
int main() {
IOS;
llong n, x, m;
cin >> n >> x >> m;
vector<llong> pos(m, -1);
pos[x] = 0;
llong cur = x;
vector<llong> seq;
int cnt = 0;
seq.push_back(x);
int s, e;
while (1) {
cur *= cur;
cur %= m;
if (pos[cur] != -1) {
s = pos[cur];
e = cnt;
break;
}
cnt++;
pos[cur] = cnt;
seq.push_back(cur);
}
vector<llong> init, cycle;
for (int i = 0; i < s; i++)
init.push_back(seq[i]);
for (int i = s; i <= e; i++)
cycle.push_back(seq[i]);
if (n <= (int)init.size()) {
llong sum = 0;
for (int i = 0; i < n; i++)
sum += init[i];
cout << sum;
return 0;
} else {
llong sum = 0;
for (int i = 0; i < init.size(); i++)
sum += init[i];
n -= init.size();
llong cyclesum = 0;
for (int i = 0; i < cycle.size(); i++)
cyclesum += cycle[i];
sum += (n / cycle.size()) * cyclesum;
n %= (int)cycle.size();
for (int i = 0; i < n; i++)
sum += cycle[i];
cout << sum;
}
} | replace | 119 | 120 | 119 | 120 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int, int>, int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// 最大公約数
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
// 最小公倍数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cout << fixed << setprecision(15);
ll N, X, M;
cin >> N >> X >> M;
map<ll, ll> T;
vector<ll> A;
ll ans = 0;
ll now;
ll d = 0;
ll count = 0;
ll loop = 0;
ll start = 0;
ll end = 0;
bool check = false;
for (ll i = 1; i <= min(N, M); i++) {
// cout << i << endl;
if (check == true && count == d)
break;
if (i == 1) {
now = X;
ans += X;
T[now] = i;
continue;
}
now = (now * now) % M;
// nowがすでに存在しているなら
if (check == false && (T[now] > 0)) {
// cout << "end" << endl;
check = true;
start = T[now];
end = i;
d = i - T[now] - 1;
A.resize(d);
continue;
}
T[now] = i;
if (check) {
if (count == 0) {
A[count] = now;
} else {
A[count] = A[count - 1] + now;
}
count++;
}
}
ans = 0;
if (check == false) {
for (ll i = 1; i <= N; i++) {
if (i == 1) {
now = X;
ans += now;
} else {
now = (now * now) % M;
ans += now;
}
}
cout << ans << endl;
return 0;
}
// cout << start << " " << end << endl;
ll dis = end - start;
vector<ll> B(end + 1, 0);
ans = 0;
for (ll i = 1; i <= end; i++) {
if (i == 1) {
now = X;
ans += now;
B[i] = X;
} else {
now = (now * now) % M;
ans += now;
B[i] = B[i - 1] + now;
}
}
ans += ((N - end) / dis) * (B[end] - B[start]);
if ((N - end) % dis != 0) {
ll c = (N - end) % dis;
ans += B[start + c] - B[start];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int, int>, int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// 最大公約数
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
// 最小公倍数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
cout << fixed << setprecision(15);
ll N, X, M;
cin >> N >> X >> M;
map<ll, ll> T;
vector<ll> A;
ll ans = 0;
ll now;
ll d = 0;
ll count = 0;
ll loop = 0;
ll start = 0;
ll end = 0;
bool check = false;
for (ll i = 1; i <= min(N, M); i++) {
// cout << i << endl;
if (check == true && count == d)
break;
if (i == 1) {
now = X;
ans += X;
T[now] = i;
continue;
}
now = (now * now) % M;
// nowがすでに存在しているなら
if (check == false && (T[now] > 0)) {
// cout << "end" << endl;
check = true;
start = T[now];
end = i;
d = i - T[now] - 1;
A.resize(d);
continue;
}
T[now] = i;
if (check) {
if (count == 0) {
A[count] = now;
} else {
A[count] = A[count - 1] + now;
}
count++;
}
}
ans = 0;
if (check == false) {
for (ll i = 1; i <= min(N, M); i++) {
if (i == 1) {
now = X;
ans += now;
} else {
now = (now * now) % M;
ans += now;
}
}
cout << ans << endl;
return 0;
}
// cout << start << " " << end << endl;
ll dis = end - start;
vector<ll> B(end + 1, 0);
ans = 0;
for (ll i = 1; i <= end; i++) {
if (i == 1) {
now = X;
ans += now;
B[i] = X;
} else {
now = (now * now) % M;
ans += now;
B[i] = B[i - 1] + now;
}
}
ans += ((N - end) / dis) * (B[end] - B[start]);
if ((N - end) % dis != 0) {
ll c = (N - end) % dis;
ans += B[start + c] - B[start];
}
cout << ans << endl;
return 0;
} | replace | 91 | 92 | 91 | 92 | TLE | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(i, a) for (ll i = ll(a - 1); i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(), (V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
using ull = unsigned 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;
}
inline void Yes(bool condition) {
if (condition)
PRINT("Yes");
else
PRINT("No");
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class itr> void array_output(itr start, itr goal) {
string ans = "", k = " ";
for (auto i = start; i != goal; i++)
ans += to_string(*i) + k;
if (!ans.empty())
ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) { return a ? gcd(b % a, a) : b; }
const ll INF = 1e18;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const ll MOD3 = 1e6;
const ll EPS = 1e-10;
int sgn(const double a) { return (a < -EPS ? -1 : (a > EPS ? +1 : 0)); }
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> tri;
typedef pair<long double, long double> point;
typedef complex<long double> Point;
const ll MAX = 3000;
constexpr ll nx[4] = {-1, 0, 1, 0};
constexpr ll ny[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
vector<ll> done(100005, 0);
ll a = x, cnt = 0;
done[a] = 1;
while (true) {
a = a * a % m;
if (done[a]) {
cnt++;
break;
}
cnt++;
done[a] = cnt;
}
ll sum = a, ans = x;
ll s = a;
while (true) {
s = s * s % m;
if (s == a)
break;
sum += s;
}
ll len = cnt - done[a];
if (n <= done[a]) {
rep(i, n - 1) {
x = x * x % m;
ans += x;
}
PRINT(ans);
return 0;
} else {
rep(i, done[a] - 1) {
x = x * x % m;
ans += x;
}
n -= done[a];
ans += sum * (n / len);
n %= len;
rep(i, n) {
ans += a;
a = a * a % m;
}
PRINT(ans);
}
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(i, a) for (ll i = ll(a - 1); i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(), (V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
using ull = unsigned 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;
}
inline void Yes(bool condition) {
if (condition)
PRINT("Yes");
else
PRINT("No");
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class itr> void array_output(itr start, itr goal) {
string ans = "", k = " ";
for (auto i = start; i != goal; i++)
ans += to_string(*i) + k;
if (!ans.empty())
ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) { return a ? gcd(b % a, a) : b; }
const ll INF = 1e18;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const ll MOD3 = 1e6;
const ll EPS = 1e-10;
int sgn(const double a) { return (a < -EPS ? -1 : (a > EPS ? +1 : 0)); }
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> tri;
typedef pair<long double, long double> point;
typedef complex<long double> Point;
const ll MAX = 3000;
constexpr ll nx[4] = {-1, 0, 1, 0};
constexpr ll ny[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
vector<ll> done(100005, 0);
ll a = x, cnt = 0;
done[a] = 0;
while (true) {
a = a * a % m;
if (done[a]) {
cnt++;
break;
}
cnt++;
done[a] = cnt;
}
ll sum = a, ans = x;
ll s = a;
while (true) {
s = s * s % m;
if (s == a)
break;
sum += s;
}
ll len = cnt - done[a];
if (n <= done[a]) {
rep(i, n - 1) {
x = x * x % m;
ans += x;
}
PRINT(ans);
return 0;
} else {
rep(i, done[a] - 1) {
x = x * x % m;
ans += x;
}
n -= done[a];
ans += sum * (n / len);
n %= len;
rep(i, n) {
ans += a;
a = a * a % m;
}
PRINT(ans);
}
}
| replace | 86 | 87 | 86 | 87 | 0 | |
p02550 | C++ | Runtime Error | #include <cstdio>
#include <map>
using namespace std;
long long n, x, m;
long long a[200005];
map<long long, int> ma;
int l, r;
long long sum, asum;
int main() {
scanf("%lld%lld%lld", &n, &x, &m);
a[1] = x;
for (int i = 2;; ++i) {
a[i] = a[i - 1] * a[i - 1] % m;
if (ma.count(a[i])) {
l = ma[a[i]];
r = i;
break;
}
ma[a[i]] = i;
}
if (n < l) {
for (int i = 1; i <= n; ++i)
sum += a[i];
printf("%lld\n", sum);
return 0;
}
for (int i = 1; i < l; ++i) {
sum += a[i];
}
n -= l;
++n;
for (int i = l; i < r; ++i)
asum += a[i];
sum += asum * (n / (r - l));
for (int i = l; i < l + n; ++i)
sum += a[i];
printf("%lld\n", sum);
return 0;
}
| #include <cstdio>
#include <map>
using namespace std;
long long n, x, m;
long long a[200005];
map<long long, int> ma;
int l, r;
long long sum, asum;
int main() {
scanf("%lld%lld%lld", &n, &x, &m);
a[1] = x;
for (int i = 2;; ++i) {
a[i] = a[i - 1] * a[i - 1] % m;
if (ma.count(a[i])) {
l = ma[a[i]];
r = i;
break;
}
ma[a[i]] = i;
}
if (n < l) {
for (int i = 1; i <= n; ++i)
sum += a[i];
printf("%lld\n", sum);
return 0;
}
for (int i = 1; i < l; ++i) {
sum += a[i];
}
n -= l;
++n;
for (int i = l; i < r; ++i)
asum += a[i];
sum += asum * (n / (r - l));
n %= r - l;
for (int i = l; i < l + n; ++i)
sum += a[i];
printf("%lld\n", sum);
return 0;
}
| insert | 34 | 34 | 34 | 35 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
// using ll = long long;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f64 = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
// #ifndef ONLINE_JUDGE
#define FWRITE
// #endif
namespace io {
#ifndef FWRITE
#include <unistd.h>
auto unistd_read = read;
auto unistd_write = write;
#endif
const int BUFSIZE = 1 << 20;
int isize, osize;
char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
char *is, *it, *os = obuf, *ot = obuf + BUFSIZE;
char getchar() {
if (is == it) {
is = ibuf;
#ifdef FWRITE
it = ibuf + fread(ibuf, 1, BUFSIZE, stdin);
#else
it = ibuf + unistd_read(STDIN_FILENO, ibuf, BUFSIZE);
#endif
if (is == it)
return EOF;
}
return *is++;
}
char getalpha() {
char c = getchar();
while (!isalpha(c))
c = getchar();
return c;
}
void putchar(char c) {
*os++ = c;
if (os == ot) {
#ifdef FWRITE
fwrite(obuf, 1, BUFSIZE, stdout);
#else
unistd_write(STDOUT_FILENO, obuf, BUFSIZE);
#endif
os = obuf;
}
}
int inp() {
int x = 0, f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return -1;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
ll inp_ll() {
ll x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = 1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
template <class T> bool read(T &x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return 0;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f)
x = -x;
return 1;
}
bool read(char *s) {
char *t = s;
char ch = getchar();
for (; ch == ' ' || ch == '\n'; ch = getchar())
;
for (; ch != ' ' && ch != '\n' && ch != EOF; ch = getchar())
*t++ = ch;
*t = 0;
return s != t;
}
template <class T, class... Args> bool read(T &x, Args &...args) {
return read(x) && read(args...);
}
template <class T> bool readln(T &x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return 0;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f)
x = -x;
for (; ch != '\n' && ch != EOF; ch = getchar())
;
return 1;
}
bool readln(char *s) {
char *t = s;
while (1) {
char ch = getchar();
if (ch == '\n' || ch == EOF)
break;
*t++ = ch;
}
*t = 0;
return s != t;
}
template <class T, class... Args> bool readln(T &x, Args &...args) {
return read(x) && readln(args...);
}
template <class T> void write(T x) {
static char s[22];
static char *it = s + 20;
static char *end = s + 20;
if (x < 0) {
putchar('-');
x = -x;
}
do {
*--it = x % 10 + '0';
x /= 10;
} while (x);
/*
if (!x)
*-- it = '0';
while (x)
{
*-- it = x%10+'0';
x /= 10;
}
*/
for (; it < end; ++it)
putchar(*it);
}
void write(const char *s) {
for (; *s; ++s)
putchar(*s);
}
template <> void write(char *s) { write((const char *)s); }
template <> void write(char c) { putchar(c); }
template <class T, class... Args> void write(T x, Args... args) {
write(x);
write(args...);
}
void writeln() { putchar('\n'); }
template <class T, class... Args> void writeln(T x, Args... args) {
write(x);
writeln(args...);
}
template <class Iterator> bool input(Iterator st, Iterator ed) {
for (; st != ed; ++st) {
if (!read(*st))
return false;
}
return true;
}
template <class T> bool input(T &a) { return input(a.begin(), a.end()); }
template <class Iterator>
void print(Iterator st, Iterator ed, const char *c = " ") {
int flag = 0;
for (; st != ed; ++st) {
if (flag)
write(c);
flag = 1;
write(*st);
}
writeln();
}
template <class T> void print(const T &a, const char *c = " ") {
print(a.begin(), a.end(), c);
}
struct ender {
~ender() {
if (os != obuf)
#ifdef FWRITE
fwrite(obuf, 1, os - obuf, stdout);
#else
unistd_write(STDOUT_FILENO, obuf, os - obuf);
#endif
}
} __ender;
} // namespace io
int64_t power(int64_t a, int64_t b, int64_t p) {
if (!b)
return 1;
int64_t t = power(a, b >> 1, p);
t = t * t % p;
if (b & 1)
t = t * a % p;
return t;
}
pll exgcd(ll a, ll b) {
if (b == 0)
return {1, 0};
// auto [x, y] = exgcd(b, a % b);
auto e = exgcd(b, a % b);
ll x = e.first;
ll y = e.second;
return {y, x - a / b * y};
}
mt19937_64 rd(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rd(678);
using namespace io;
template <class T> inline bool freshmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <class T> inline bool freshmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T> auto arr(int n = 0) { return vector<T>(n); }
template <class T, class... Args> auto arr(int n, Args... args) {
return vector<decltype(arr<T>(args...))>(n, arr<T>(args...));
}
// int dx[] = { -1, 1, 0, 0, -1, -1, 1, 1 };
// int dy[] = { 0, 0, -1, 1, -1, 1, -1, 1 };
template <class T> T det(T x1, T y1, T x2, T y2, T x3, T y3) {
return x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
}
/*
template<class T>
T dis(T x1, T y1, T x2, T y2)
{
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
*/
#ifdef ONLINE_JUDGE
const int OJ = 1;
#else
const int OJ = 0;
#endif
const int MAXN = 600010;
void init() {}
const int MOD = 998244353;
struct mod_int {
int val;
mod_int(long long v = 0) {
if (v < 0)
v = v % MOD + MOD;
if (v >= MOD)
v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
// https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Example
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
mod_int &operator+=(const mod_int &other) {
val += other.val;
if (val >= MOD)
val -= MOD;
return *this;
}
mod_int &operator-=(const mod_int &other) {
val -= other.val;
if (val < 0)
val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) { return x % m; }
mod_int &operator*=(const mod_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
mod_int &operator/=(const mod_int &other) { return *this *= other.inv(); }
friend mod_int operator+(const mod_int &a, const mod_int &b) {
return mod_int(a) += b;
}
friend mod_int operator-(const mod_int &a, const mod_int &b) {
return mod_int(a) -= b;
}
friend mod_int operator*(const mod_int &a, const mod_int &b) {
return mod_int(a) *= b;
}
friend mod_int operator/(const mod_int &a, const mod_int &b) {
return mod_int(a) /= b;
}
mod_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
mod_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
mod_int operator++(int) {
mod_int before = *this;
++*this;
return before;
}
mod_int operator--(int) {
mod_int before = *this;
--*this;
return before;
}
mod_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const mod_int &other) const { return val == other.val; }
bool operator!=(const mod_int &other) const { return val != other.val; }
mod_int inv() const { return mod_inv(val); }
mod_int pow(long long p) const {
assert(p >= 0);
mod_int a = *this, result = 1;
while (p > 0) {
if (p & 1)
result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &stream, const mod_int &m) {
return stream << m.val;
}
};
ll phi(ll n) {
ll res = 1;
for (int i = 2; i <= n; ++i) {
if (n % i == 0) {
res *= i - 1;
n /= i;
while (n % i == 0) {
res *= i;
n /= i;
}
}
}
return res;
}
void solve() {
ll n, x, m;
read(n, x, m);
ll cycle = phi(m);
ll res = 0;
for (int i = 0; i < 20 && i < n; ++i) {
res += power(x, 1 << i, m);
}
if (n <= 20) {
writeln(res);
return;
}
x = power(x, 1 << 20, m);
n -= 20;
vector<int> u(cycle, -1);
int idx = -1;
vector<int> path;
for (int i = 0, e = 1;; i += 1, e = e * 2 % cycle) {
if (u[e] != -1) {
idx = e;
break;
}
u[e] = i;
path.push_back(e);
}
assert(idx != -1);
for (int i = 0; i < u[idx]; ++i) {
res += power(x, path[i] + cycle, m);
}
n -= u[idx];
int len = int(path.size()) - u[idx];
ll tmp = 0;
for (int i = u[idx]; i < path.size(); ++i) {
tmp += power(x, path[i] + cycle, m);
}
res += n / len * tmp;
n %= len;
for (int i = 0; i < n; ++i) {
res += power(x, path[u[idx] + i] + cycle, m);
}
writeln(res);
}
int main() {
if (!OJ) {
freopen("try.in", "r", stdin);
freopen("try.out", "w", stdout);
}
int T = 1;
// read(T);
// init();
for (int test = 1; test <= T; ++test) {
// write("Case #", test, ": ");
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
// using ll = long long;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f64 = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
// #ifndef ONLINE_JUDGE
#define FWRITE
// #endif
namespace io {
#ifndef FWRITE
#include <unistd.h>
auto unistd_read = read;
auto unistd_write = write;
#endif
const int BUFSIZE = 1 << 20;
int isize, osize;
char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
char *is, *it, *os = obuf, *ot = obuf + BUFSIZE;
char getchar() {
if (is == it) {
is = ibuf;
#ifdef FWRITE
it = ibuf + fread(ibuf, 1, BUFSIZE, stdin);
#else
it = ibuf + unistd_read(STDIN_FILENO, ibuf, BUFSIZE);
#endif
if (is == it)
return EOF;
}
return *is++;
}
char getalpha() {
char c = getchar();
while (!isalpha(c))
c = getchar();
return c;
}
void putchar(char c) {
*os++ = c;
if (os == ot) {
#ifdef FWRITE
fwrite(obuf, 1, BUFSIZE, stdout);
#else
unistd_write(STDOUT_FILENO, obuf, BUFSIZE);
#endif
os = obuf;
}
}
int inp() {
int x = 0, f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return -1;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
ll inp_ll() {
ll x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-')
f = 1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return f ? -x : x;
}
template <class T> bool read(T &x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return 0;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f)
x = -x;
return 1;
}
bool read(char *s) {
char *t = s;
char ch = getchar();
for (; ch == ' ' || ch == '\n'; ch = getchar())
;
for (; ch != ' ' && ch != '\n' && ch != EOF; ch = getchar())
*t++ = ch;
*t = 0;
return s != t;
}
template <class T, class... Args> bool read(T &x, Args &...args) {
return read(x) && read(args...);
}
template <class T> bool readln(T &x) {
x = 0;
int f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF)
return 0;
if (ch == '-')
f = 1;
}
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
if (f)
x = -x;
for (; ch != '\n' && ch != EOF; ch = getchar())
;
return 1;
}
bool readln(char *s) {
char *t = s;
while (1) {
char ch = getchar();
if (ch == '\n' || ch == EOF)
break;
*t++ = ch;
}
*t = 0;
return s != t;
}
template <class T, class... Args> bool readln(T &x, Args &...args) {
return read(x) && readln(args...);
}
template <class T> void write(T x) {
static char s[22];
static char *it = s + 20;
static char *end = s + 20;
if (x < 0) {
putchar('-');
x = -x;
}
do {
*--it = x % 10 + '0';
x /= 10;
} while (x);
/*
if (!x)
*-- it = '0';
while (x)
{
*-- it = x%10+'0';
x /= 10;
}
*/
for (; it < end; ++it)
putchar(*it);
}
void write(const char *s) {
for (; *s; ++s)
putchar(*s);
}
template <> void write(char *s) { write((const char *)s); }
template <> void write(char c) { putchar(c); }
template <class T, class... Args> void write(T x, Args... args) {
write(x);
write(args...);
}
void writeln() { putchar('\n'); }
template <class T, class... Args> void writeln(T x, Args... args) {
write(x);
writeln(args...);
}
template <class Iterator> bool input(Iterator st, Iterator ed) {
for (; st != ed; ++st) {
if (!read(*st))
return false;
}
return true;
}
template <class T> bool input(T &a) { return input(a.begin(), a.end()); }
template <class Iterator>
void print(Iterator st, Iterator ed, const char *c = " ") {
int flag = 0;
for (; st != ed; ++st) {
if (flag)
write(c);
flag = 1;
write(*st);
}
writeln();
}
template <class T> void print(const T &a, const char *c = " ") {
print(a.begin(), a.end(), c);
}
struct ender {
~ender() {
if (os != obuf)
#ifdef FWRITE
fwrite(obuf, 1, os - obuf, stdout);
#else
unistd_write(STDOUT_FILENO, obuf, os - obuf);
#endif
}
} __ender;
} // namespace io
int64_t power(int64_t a, int64_t b, int64_t p) {
if (!b)
return 1;
int64_t t = power(a, b >> 1, p);
t = t * t % p;
if (b & 1)
t = t * a % p;
return t;
}
pll exgcd(ll a, ll b) {
if (b == 0)
return {1, 0};
// auto [x, y] = exgcd(b, a % b);
auto e = exgcd(b, a % b);
ll x = e.first;
ll y = e.second;
return {y, x - a / b * y};
}
mt19937_64 rd(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
// mt19937 rd(678);
using namespace io;
template <class T> inline bool freshmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <class T> inline bool freshmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T> auto arr(int n = 0) { return vector<T>(n); }
template <class T, class... Args> auto arr(int n, Args... args) {
return vector<decltype(arr<T>(args...))>(n, arr<T>(args...));
}
// int dx[] = { -1, 1, 0, 0, -1, -1, 1, 1 };
// int dy[] = { 0, 0, -1, 1, -1, 1, -1, 1 };
template <class T> T det(T x1, T y1, T x2, T y2, T x3, T y3) {
return x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
}
/*
template<class T>
T dis(T x1, T y1, T x2, T y2)
{
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
*/
#ifdef ONLINE_JUDGE
const int OJ = 1;
#else
const int OJ = 0;
#endif
const int MAXN = 600010;
void init() {}
const int MOD = 998244353;
struct mod_int {
int val;
mod_int(long long v = 0) {
if (v < 0)
v = v % MOD + MOD;
if (v >= MOD)
v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
// https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Example
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
mod_int &operator+=(const mod_int &other) {
val += other.val;
if (val >= MOD)
val -= MOD;
return *this;
}
mod_int &operator-=(const mod_int &other) {
val -= other.val;
if (val < 0)
val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) { return x % m; }
mod_int &operator*=(const mod_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
mod_int &operator/=(const mod_int &other) { return *this *= other.inv(); }
friend mod_int operator+(const mod_int &a, const mod_int &b) {
return mod_int(a) += b;
}
friend mod_int operator-(const mod_int &a, const mod_int &b) {
return mod_int(a) -= b;
}
friend mod_int operator*(const mod_int &a, const mod_int &b) {
return mod_int(a) *= b;
}
friend mod_int operator/(const mod_int &a, const mod_int &b) {
return mod_int(a) /= b;
}
mod_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
mod_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
mod_int operator++(int) {
mod_int before = *this;
++*this;
return before;
}
mod_int operator--(int) {
mod_int before = *this;
--*this;
return before;
}
mod_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const mod_int &other) const { return val == other.val; }
bool operator!=(const mod_int &other) const { return val != other.val; }
mod_int inv() const { return mod_inv(val); }
mod_int pow(long long p) const {
assert(p >= 0);
mod_int a = *this, result = 1;
while (p > 0) {
if (p & 1)
result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &stream, const mod_int &m) {
return stream << m.val;
}
};
ll phi(ll n) {
ll res = 1;
for (int i = 2; i <= n; ++i) {
if (n % i == 0) {
res *= i - 1;
n /= i;
while (n % i == 0) {
res *= i;
n /= i;
}
}
}
return res;
}
void solve() {
ll n, x, m;
read(n, x, m);
ll cycle = phi(m);
ll res = 0;
for (int i = 0; i < 20 && i < n; ++i) {
res += power(x, 1 << i, m);
}
if (n <= 20) {
writeln(res);
return;
}
x = power(x, 1 << 20, m);
n -= 20;
vector<int> u(cycle, -1);
int idx = -1;
vector<int> path;
for (int i = 0, e = 1 % cycle;; i += 1, e = e * 2 % cycle) {
if (u[e] != -1) {
idx = e;
break;
}
u[e] = i;
path.push_back(e);
}
assert(idx != -1);
for (int i = 0; i < u[idx]; ++i) {
res += power(x, path[i] + cycle, m);
}
n -= u[idx];
int len = int(path.size()) - u[idx];
ll tmp = 0;
for (int i = u[idx]; i < path.size(); ++i) {
tmp += power(x, path[i] + cycle, m);
}
res += n / len * tmp;
n %= len;
for (int i = 0; i < n; ++i) {
res += power(x, path[u[idx] + i] + cycle, m);
}
writeln(res);
}
int main() {
if (!OJ) {
freopen("try.in", "r", stdin);
freopen("try.out", "w", stdout);
}
int T = 1;
// read(T);
// init();
for (int test = 1; test <= T; ++test) {
// write("Case #", test, ": ");
solve();
}
return 0;
} | replace | 468 | 469 | 468 | 469 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define debug(x) cerr << "[(" << __LINE__ << ") " << #x << "]: " << (x) << endl;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n, x, MOD;
cin >> n >> x >> MOD;
vector<pair<ll, int>> m(MOD + 1);
ll ans = 0;
ll i = 1;
while (!m[x].first && i <= n) {
m[x] = {ans, i++};
ans += x;
x = x * x % MOD;
}
n -= i;
if (n < 0) {
cout << ans << "\n";
return 0;
}
ll duh = n / (i - m[x].second);
ans += duh * (ans - m[x].first);
n %= i - m[x].second;
n++;
while (n-- > 0) {
ans += x;
x = x * x % MOD;
}
cout << ans << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define debug(x) cerr << "[(" << __LINE__ << ") " << #x << "]: " << (x) << endl;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n, x, MOD;
cin >> n >> x >> MOD;
vector<pair<ll, int>> m(MOD + 1);
ll ans = 0;
ll i = 1;
while (!m[x].second && i <= n) {
m[x] = {ans, i++};
ans += x;
x = x * x % MOD;
}
n -= i;
if (n < 0) {
cout << ans << "\n";
return 0;
}
ll duh = n / (i - m[x].second);
ans += duh * (ans - m[x].first);
n %= i - m[x].second;
n++;
while (n-- > 0) {
ans += x;
x = x * x % MOD;
}
cout << ans << "\n";
}
| replace | 16 | 17 | 16 | 17 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define rep(i, n) repl(i, 0, n)
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
const ll MOD = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 4e18 + 10;
const int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
vector<ll> a(m * 2 + 5);
a[0] = x;
rep(i, m * 2 + 4) a[i + 1] = a[i] * a[i] % m;
int s = 0;
for (int i = m * 2 + 3; i >= 0; i--) {
if (a[i] == a[m * 2 + 4]) {
s = m * 2 + 4 - i;
break;
}
}
int st = -1;
rep(i, m * 2 - s) {
if (a[i] == a[i + s]) {
st = i;
break;
}
}
rep(i, m * 2 + 4) a[i + 1] += a[i];
if (n <= 2 * m + 4)
cout << a[n - 1] << endl;
else if (st == 0) {
assert(st < 0);
ll ans = a[s - 1] * n / s;
if (n % s)
ans += a[n % s - 1];
cout << ans << endl;
} else {
ll ans = (a[st + s] - a[st]) * ((n - st) / s) + a[st - 1];
if ((n - st) % s != 0)
ans += a[(n - st) % s + st - 1] - a[st - 1];
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define rep(i, n) repl(i, 0, n)
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
const ll MOD = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 4e18 + 10;
const int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
vector<ll> a(m * 2 + 5);
a[0] = x;
rep(i, m * 2 + 4) a[i + 1] = a[i] * a[i] % m;
int s = 0;
for (int i = m * 2 + 3; i >= 0; i--) {
if (a[i] == a[m * 2 + 4]) {
s = m * 2 + 4 - i;
break;
}
}
int st = -1;
rep(i, m * 2 - s) {
if (a[i] == a[i + s]) {
st = i;
break;
}
}
rep(i, m * 2 + 4) a[i + 1] += a[i];
if (n <= 2 * m + 4)
cout << a[n - 1] << endl;
else if (st == 0) {
ll ans = a[s - 1] * (n / s);
if (n % s)
ans += a[n % s - 1];
cout << ans << endl;
} else {
ll ans = (a[st + s] - a[st]) * ((n - st) / s) + a[st - 1];
if ((n - st) % s != 0)
ans += a[(n - st) % s + st - 1] - a[st - 1];
cout << ans << endl;
}
return 0;
} | replace | 42 | 44 | 42 | 43 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <algorithm>
#include <array>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value, __uint128_t,
unsigned __int128>;
template <class T>
using is_integral =
typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_signed_int =
typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value, make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned =
typename std::conditional<is_signed_int<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)> * = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0)
x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
static_modint(bool v) { _v = ((unsigned int)(v) % umod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v -= rhs._v;
if (_v >= umod())
_v += umod();
return *this;
}
mint &operator*=(const mint &rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0)
x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
dynamic_modint(bool v) { _v = ((unsigned int)(v) % mod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v += mod() - rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator*=(const mint &rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt = 998244353;
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <type_traits>
#include <vector>
namespace atcoder {
namespace internal {
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now;
now *= ies[i];
}
}
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p] * now;
a[i + offset] = l + r;
a[i + offset + p] = l - r;
}
now *= sum_e[bsf(~(unsigned int)(s))];
}
}
}
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly_inv(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_ie[30]; // sum_ie[i] = es[0] * ... * es[i - 1] * ies[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now;
now *= es[i];
}
}
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p];
a[i + offset] = l + r;
a[i + offset + p] =
(unsigned long long)(mint::mod() + l.val() - r.val()) * inow.val();
}
inow *= sum_ie[bsf(~(unsigned int)(s))];
}
}
}
} // namespace internal
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
std::vector<mint> convolution(std::vector<mint> a, std::vector<mint> b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
if (std::min(n, m) <= 60) {
if (n < m) {
std::swap(n, m);
std::swap(a, b);
}
std::vector<mint> ans(n + m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[i + j] += a[i] * b[j];
}
}
return ans;
}
int z = 1 << internal::ceil_pow2(n + m - 1);
a.resize(z);
internal::butterfly(a);
b.resize(z);
internal::butterfly(b);
for (int i = 0; i < z; i++) {
a[i] *= b[i];
}
internal::butterfly_inv(a);
a.resize(n + m - 1);
mint iz = mint(z).inv();
for (int i = 0; i < n + m - 1; i++)
a[i] *= iz;
return a;
}
template <unsigned int mod = 998244353, class T,
std::enable_if_t<internal::is_integral<T>::value> * = nullptr>
std::vector<T> convolution(const std::vector<T> &a, const std::vector<T> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
using mint = static_modint<mod>;
std::vector<mint> a2(n), b2(m);
for (int i = 0; i < n; i++) {
a2[i] = mint(a[i]);
}
for (int i = 0; i < m; i++) {
b2[i] = mint(b[i]);
}
auto c2 = convolution(move(a2), move(b2));
std::vector<T> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
c[i] = c2[i].val();
}
return c;
}
std::vector<long long> convolution_ll(const std::vector<long long> &a,
const std::vector<long long> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
static constexpr unsigned long long MOD1 = 754974721; // 2^24
static constexpr unsigned long long MOD2 = 167772161; // 2^25
static constexpr unsigned long long MOD3 = 469762049; // 2^26
static constexpr unsigned long long M2M3 = MOD2 * MOD3;
static constexpr unsigned long long M1M3 = MOD1 * MOD3;
static constexpr unsigned long long M1M2 = MOD1 * MOD2;
static constexpr unsigned long long M1M2M3 = MOD1 * MOD2 * MOD3;
static constexpr unsigned long long i1 =
internal::inv_gcd(MOD2 * MOD3, MOD1).second;
static constexpr unsigned long long i2 =
internal::inv_gcd(MOD1 * MOD3, MOD2).second;
static constexpr unsigned long long i3 =
internal::inv_gcd(MOD1 * MOD2, MOD3).second;
auto c1 = convolution<MOD1>(a, b);
auto c2 = convolution<MOD2>(a, b);
auto c3 = convolution<MOD3>(a, b);
std::vector<long long> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
unsigned long long x = 0;
x += (c1[i] * i1) % MOD1 * M2M3;
x += (c2[i] * i2) % MOD2 * M1M3;
x += (c3[i] * i3) % MOD3 * M1M2;
// B = 2^63, -B <= x, r(real value) < B
// (x, x - M, x - 2M, or x - 3M) = r (mod 2B)
// r = c1[i] (mod MOD1)
// focus on MOD1
// r = x, x - M', x - 2M', x - 3M' (M' = M % 2^64) (mod 2B)
// r = x,
// x - M' + (0 or 2B),
// x - 2M' + (0, 2B or 4B),
// x - 3M' + (0, 2B, 4B or 6B) (without mod!)
// (r - x) = 0, (0)
// - M' + (0 or 2B), (1)
// -2M' + (0 or 2B or 4B), (2)
// -3M' + (0 or 2B or 4B or 6B) (3) (mod MOD1)
// we checked that
// ((1) mod MOD1) mod 5 = 2
// ((2) mod MOD1) mod 5 = 3
// ((3) mod MOD1) mod 5 = 4
long long diff =
c1[i] - internal::safe_mod((long long)(x), (long long)(MOD1));
if (diff < 0)
diff += MOD1;
static constexpr unsigned long long offset[5] = {0, 0, M1M2M3, 2 * M1M2M3,
3 * M1M2M3};
x -= offset[diff % 5];
c[i] = x;
}
return c;
}
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y)
return x;
if (-parent_or_size[x] < -parent_or_size[y])
std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0)
return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int> &v) { return v.empty(); }),
result.end());
return result;
}
private:
int _n;
// root node: -1 * component size
// otherwise: parent
std::vector<int> parent_or_size;
};
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference: https://en.wikipedia.org/wiki/Fenwick_tree
template <class T> struct fenwick_tree {
using U = internal::to_unsigned_t<T>;
public:
fenwick_tree() : _n(0) {}
fenwick_tree(int n) : _n(n), data(n) {}
void add(int p, T x) {
assert(0 <= p && p < _n);
p++;
while (p <= _n) {
data[p - 1] += U(x);
p += p & -p;
}
}
T sum(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
return sum(r) - sum(l);
}
private:
int _n;
std::vector<U> data;
U sum(int r) {
U s = 0;
while (r > 0) {
s += data[r - 1];
r -= r & -r;
}
return s;
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
#include <algorithm>
#include <vector>
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T &t) { payload.push_back(t); }
T &front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap> struct mf_graph {
public:
mf_graph() : _n(0) {}
mf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result;
for (int i = 0; i < m; i++) {
result.push_back(get_edge(i));
}
return result;
}
void change_edge(int i, Cap new_cap, Cap new_flow) {
int m = int(pos.size());
assert(0 <= i && i < m);
assert(0 <= new_flow && new_flow <= new_cap);
auto &_e = g[pos[i].first][pos[i].second];
auto &_re = g[_e.to][_e.rev];
_e.cap = new_cap - new_flow;
_re.cap = new_flow;
}
Cap flow(int s, int t) { return flow(s, t, std::numeric_limits<Cap>::max()); }
Cap flow(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
std::vector<int> level(_n), iter(_n);
internal::simple_queue<int> que;
auto bfs = [&]() {
std::fill(level.begin(), level.end(), -1);
level[s] = 0;
que.clear();
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto e : g[v]) {
if (e.cap == 0 || level[e.to] >= 0)
continue;
level[e.to] = level[v] + 1;
if (e.to == t)
return;
que.push(e.to);
}
}
};
auto dfs = [&](auto self, int v, Cap up) {
if (v == s)
return up;
Cap res = 0;
int level_v = level[v];
for (int &i = iter[v]; i < int(g[v].size()); i++) {
_edge &e = g[v][i];
if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0)
continue;
Cap d = self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
if (d <= 0)
continue;
g[v][i].cap += d;
g[e.to][e.rev].cap -= d;
res += d;
if (res == up)
break;
}
return res;
};
Cap flow = 0;
while (flow < flow_limit) {
bfs();
if (level[t] == -1)
break;
std::fill(iter.begin(), iter.end(), 0);
while (flow < flow_limit) {
Cap f = dfs(dfs, t, flow_limit - flow);
if (!f)
break;
flow += f;
}
}
return flow;
}
std::vector<bool> min_cut(int s) {
std::vector<bool> visited(_n);
internal::simple_queue<int> que;
que.push(s);
while (!que.empty()) {
int p = que.front();
que.pop();
visited[p] = true;
for (auto e : g[p]) {
if (e.cap && !visited[e.to]) {
visited[e.to] = true;
que.push(e.to);
}
}
}
return visited;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap, class Cost> struct mcf_graph {
public:
mcf_graph() {}
mcf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap, cost});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result(m);
for (int i = 0; i < m; i++) {
result[i] = get_edge(i);
}
return result;
}
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
std::vector<Cost> dual(_n, 0), dist(_n);
std::vector<int> pv(_n), pe(_n);
std::vector<bool> vis(_n);
auto dual_ref = [&]() {
std::fill(dist.begin(), dist.end(), std::numeric_limits<Cost>::max());
std::fill(pv.begin(), pv.end(), -1);
std::fill(pe.begin(), pe.end(), -1);
std::fill(vis.begin(), vis.end(), false);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::priority_queue<Q> que;
dist[s] = 0;
que.push(Q{0, s});
while (!que.empty()) {
int v = que.top().to;
que.pop();
if (vis[v])
continue;
vis[v] = true;
if (v == t)
break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
for (int i = 0; i < int(g[v].size()); i++) {
auto e = g[v][i];
if (vis[e.to] || !e.cap)
continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
que.push(Q{dist[e.to], e.to});
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v])
continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
// (shortest(s, v) + dual[s] - dual[v]) = - shortest(s, t) +
// dual[t] + shortest(s, v) = shortest(s, v) - shortest(s, t) >=
// 0 - (n-1)C
dual[v] -= dist[t] - dist[v];
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost = -1;
std::vector<std::pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (!dual_ref())
break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = pv[v]) {
c = std::min(c, g[pv[v]][pe[v]].cap);
}
for (int v = t; v != s; v = pv[v]) {
auto &e = g[pv[v]][pe[v]];
e.cap -= c;
g[v][e.rev].cap += c;
}
Cost d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost = cost;
}
return result;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <algorithm>
#include <utility>
#include <vector>
namespace atcoder {
namespace internal {
template <class E> struct csr {
std::vector<int> start;
std::vector<E> elist;
csr(int n, const std::vector<std::pair<int, E>> &edges)
: start(n + 1), elist(edges.size()) {
for (auto e : edges) {
start[e.first + 1]++;
}
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
auto counter = start;
for (auto e : edges) {
elist[counter[e.first]++] = e.second;
}
}
};
// Reference:
// R. Tarjan,
// Depth-First Search and Linear Graph Algorithms
struct scc_graph {
public:
scc_graph(int n) : _n(n) {}
int num_vertices() { return _n; }
void add_edge(int from, int to) { edges.push_back({from, {to}}); }
// @return pair of (# of scc, scc id)
std::pair<int, std::vector<int>> scc_ids() {
auto g = csr<edge>(_n, edges);
int now_ord = 0, group_num = 0;
std::vector<int> visited, low(_n), ord(_n, -1), ids(_n);
visited.reserve(_n);
auto dfs = [&](auto self, int v) -> void {
low[v] = ord[v] = now_ord++;
visited.push_back(v);
for (int i = g.start[v]; i < g.start[v + 1]; i++) {
auto to = g.elist[i].to;
if (ord[to] == -1) {
self(self, to);
low[v] = std::min(low[v], low[to]);
} else {
low[v] = std::min(low[v], ord[to]);
}
}
if (low[v] == ord[v]) {
while (true) {
int u = visited.back();
visited.pop_back();
ord[u] = _n;
ids[u] = group_num;
if (u == v)
break;
}
group_num++;
}
};
for (int i = 0; i < _n; i++) {
if (ord[i] == -1)
dfs(dfs, i);
}
for (auto &x : ids) {
x = group_num - 1 - x;
}
return {group_num, ids};
}
std::vector<std::vector<int>> scc() {
auto ids = scc_ids();
int group_num = ids.first;
std::vector<int> counts(group_num);
for (auto x : ids.second)
counts[x]++;
std::vector<std::vector<int>> groups(ids.first);
for (int i = 0; i < group_num; i++) {
groups[i].reserve(counts[i]);
}
for (int i = 0; i < _n; i++) {
groups[ids.second[i]].push_back(i);
}
return groups;
}
private:
int _n;
struct edge {
int to;
};
std::vector<std::pair<int, edge>> edges;
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
struct scc_graph {
public:
scc_graph() : internal(0) {}
scc_graph(int n) : internal(n) {}
void add_edge(int from, int to) {
int n = internal.num_vertices();
assert(0 <= from && from < n);
assert(0 <= to && to < n);
internal.add_edge(from, to);
}
std::vector<std::vector<int>> scc() { return internal.scc(); }
private:
internal::scc_graph internal;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <numeric>
#include <string>
#include <vector>
namespace atcoder {
namespace internal {
std::vector<int> sa_naive(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n);
std::iota(sa.begin(), sa.end(), 0);
std::sort(sa.begin(), sa.end(), [&](int l, int r) {
if (l == r)
return false;
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] < s[r];
l++;
r++;
}
return l == n;
});
return sa;
}
std::vector<int> sa_doubling(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n), rnk = s, tmp(n);
std::iota(sa.begin(), sa.end(), 0);
for (int k = 1; k < n; k *= 2) {
auto cmp = [&](int x, int y) {
if (rnk[x] != rnk[y])
return rnk[x] < rnk[y];
int rx = x + k < n ? rnk[x + k] : -1;
int ry = y + k < n ? rnk[y + k] : -1;
return rx < ry;
};
std::sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp(sa[i - 1], sa[i]) ? 1 : 0);
}
std::swap(tmp, rnk);
}
return sa;
}
// SA-IS, linear-time suffix array construction
// Reference:
// G. Nong, S. Zhang, and W. H. Chan,
// Two Efficient Algorithms for Linear Time Suffix Array Construction
template <int THRESHOLD_NAIVE = 10, int THRESHOLD_DOUBLING = 40>
std::vector<int> sa_is(const std::vector<int> &s, int upper) {
int n = int(s.size());
if (n == 0)
return {};
if (n == 1)
return {0};
if (n == 2) {
if (s[0] < s[1]) {
return {0, 1};
} else {
return {1, 0};
}
}
if (n < THRESHOLD_NAIVE) {
return sa_naive(s);
}
if (n < THRESHOLD_DOUBLING) {
return sa_doubling(s);
}
std::vector<int> sa(n);
std::vector<bool> ls(n);
for (int i = n - 2; i >= 0; i--) {
ls[i] = (s[i] == s[i + 1]) ? ls[i + 1] : (s[i] < s[i + 1]);
}
std::vector<int> sum_l(upper + 1), sum_s(upper + 1);
for (int i = 0; i < n; i++) {
if (!ls[i]) {
sum_s[s[i]]++;
} else {
sum_l[s[i] + 1]++;
}
}
for (int i = 0; i <= upper; i++) {
sum_s[i] += sum_l[i];
if (i < upper)
sum_l[i + 1] += sum_s[i];
}
auto induce = [&](const std::vector<int> &lms) {
std::fill(sa.begin(), sa.end(), -1);
std::vector<int> buf(upper + 1);
std::copy(sum_s.begin(), sum_s.end(), buf.begin());
for (auto d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
std::vector<int> lms_map(n + 1, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms_map[i] = m++;
}
}
std::vector<int> lms;
lms.reserve(m);
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms.push_back(i);
}
}
induce(lms);
if (m) {
std::vector<int> sorted_lms;
sorted_lms.reserve(m);
for (int v : sa) {
if (lms_map[v] != -1)
sorted_lms.push_back(v);
}
std::vector<int> rec_s(m);
int rec_upper = 0;
rec_s[lms_map[sorted_lms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sorted_lms[i - 1], r = sorted_lms[i];
int end_l = (lms_map[l] + 1 < m) ? lms[lms_map[l] + 1] : n;
int end_r = (lms_map[r] + 1 < m) ? lms[lms_map[r] + 1] : n;
bool same = true;
if (end_l - l != end_r - r) {
same = false;
} else {
while (l < end_l) {
if (s[l] != s[r]) {
break;
}
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same)
rec_upper++;
rec_s[lms_map[sorted_lms[i]]] = rec_upper;
}
auto rec_sa = sa_is<THRESHOLD_NAIVE, THRESHOLD_DOUBLING>(rec_s, rec_upper);
for (int i = 0; i < m; i++) {
sorted_lms[i] = lms[rec_sa[i]];
}
induce(sorted_lms);
}
return sa;
}
} // namespace internal
std::vector<int> suffix_array(const std::vector<int> &s, int upper) {
assert(0 <= upper);
for (int d : s) {
assert(0 <= d && d <= upper);
}
auto sa = internal::sa_is(s, upper);
return sa;
}
template <class T> std::vector<int> suffix_array(const std::vector<T> &s) {
int n = int(s.size());
std::vector<int> idx(n);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(), [&](int l, int r) { return s[l] < s[r]; });
std::vector<int> s2(n);
int now = 0;
for (int i = 0; i < n; i++) {
if (i && s[idx[i - 1]] != s[idx[i]])
now++;
s2[idx[i]] = now;
}
return internal::sa_is(s2, now);
}
std::vector<int> suffix_array(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return internal::sa_is(s2, 255);
}
// Reference:
// T. Kasai, G. Lee, H. Arimura, S. Arikawa, and K. Park,
// Linear-Time Longest-Common-Prefix Computation in Suffix Arrays and Its
// Applications
template <class T>
std::vector<int> lcp_array(const std::vector<T> &s,
const std::vector<int> &sa) {
int n = int(s.size());
assert(n >= 1);
std::vector<int> rnk(n);
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
std::vector<int> lcp(n - 1);
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0)
continue;
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
std::vector<int> lcp_array(const std::string &s, const std::vector<int> &sa) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcp_array(s2, sa);
}
// Reference:
// D. Gusfield,
// Algorithms on Strings, Trees, and Sequences: Computer Science and
// Computational Biology
template <class T> std::vector<int> z_algorithm(const std::vector<T> &s) {
int n = int(s.size());
if (n == 0)
return {};
std::vector<int> z(n);
z[0] = 0;
for (int i = 1, j = 0; i < n; i++) {
int &k = z[i];
k = (j + z[j] <= i) ? 0 : std::min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
std::vector<int> z_algorithm(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return z_algorithm(s2);
}
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference:
// B. Aspvall, M. Plass, and R. Tarjan,
// A Linear-Time Algorithm for Testing the Truth of Certain Quantified Boolean
// Formulas
struct two_sat {
public:
two_sat() : _n(0), scc(0) {}
two_sat(int n) : _n(n), _answer(n), scc(2 * n) {}
void add_clause(int i, bool f, int j, bool g) {
assert(0 <= i && i < _n);
assert(0 <= j && j < _n);
scc.add_edge(2 * i + (f ? 0 : 1), 2 * j + (g ? 1 : 0));
scc.add_edge(2 * j + (g ? 0 : 1), 2 * i + (f ? 1 : 0));
}
bool satisfiable() {
auto id = scc.scc_ids().second;
for (int i = 0; i < _n; i++) {
if (id[2 * i] == id[2 * i + 1])
return false;
_answer[i] = id[2 * i] < id[2 * i + 1];
}
return true;
}
std::vector<bool> answer() { return _answer; }
private:
int _n;
std::vector<bool> _answer;
internal::scc_graph scc;
};
} // namespace atcoder
using namespace std;
using namespace atcoder;
using usize = ::std::size_t;
// using u64 = ::std::int_least64_t;
using u64 = long long;
static constexpr u64 Inf = ::std::numeric_limits<u64>::max() / 2;
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
u64 N, X, M;
cin >> N >> X >> M;
modint::set_mod((int)M);
vector<u64> dp(M + 1, 0), index(M + 1, -1);
modint a1 = X;
modint a2 = a1.pow(2);
vector<u64> sum(1, 0);
modint current = a1;
sum.push_back((u64)a1.val());
index[a1.val()] = 1;
u64 freq, start, end;
for (u64 i = 2; i <= M; i++) {
current = current.pow(2);
if (dp[current.val()] > 0) {
start = index[current.val()];
break;
}
dp[current.val()]++;
index[current.val()] = i;
sum.push_back((u64)sum[i - 1] + current.val());
end = i;
}
freq = end - start + 1;
u64 ans = 0;
ans += sum[start - 1];
ans += (sum[end] - sum[start - 1]) * ((N - start + 1) / freq);
ans += (sum[(N - start + 1) % freq + start - 1] - sum[start - 1]);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <algorithm>
#include <array>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n))
x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <utility>
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
// Fast moduler by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) <
// 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v)
v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1)
return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1)
r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1)
return false;
if (n == 2 || n == 7 || n == 61)
return true;
if (n % 2 == 0)
return false;
long long d = n - 1;
while (d % 2 == 0)
d /= 2;
for (long long a : {2, 7, 61}) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0)
return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0)
m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type, std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value, __uint128_t,
unsigned __int128>;
template <class T>
using is_integral =
typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_signed_int =
typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value, make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type, std::false_type>::type;
template <class T>
using to_unsigned =
typename std::conditional<is_signed_int<T>::value, std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <numeric>
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)> * = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0)
x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
static_modint(bool v) { _v = ((unsigned int)(v) % umod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v -= rhs._v;
if (_v >= umod())
_v += umod();
return *this;
}
mint &operator*=(const mint &rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T> * = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0)
x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T> * = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
dynamic_modint(bool v) { _v = ((unsigned int)(v) % mod()); }
unsigned int val() const { return _v; }
mint &operator++() {
_v++;
if (_v == umod())
_v = 0;
return *this;
}
mint &operator--() {
if (_v == 0)
_v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint &operator+=(const mint &rhs) {
_v += rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator-=(const mint &rhs) {
_v += mod() - rhs._v;
if (_v >= umod())
_v -= umod();
return *this;
}
mint &operator*=(const mint &rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint &operator/=(const mint &rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint &lhs, const mint &rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint &lhs, const mint &rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint &lhs, const mint &rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint &lhs, const mint &rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint &lhs, const mint &rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint &lhs, const mint &rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt = 998244353;
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <type_traits>
#include <vector>
namespace atcoder {
namespace internal {
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now;
now *= ies[i];
}
}
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p] * now;
a[i + offset] = l + r;
a[i + offset + p] = l - r;
}
now *= sum_e[bsf(~(unsigned int)(s))];
}
}
}
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
void butterfly_inv(std::vector<mint> &a) {
static constexpr int g = internal::primitive_root<mint::mod()>;
int n = int(a.size());
int h = internal::ceil_pow2(n);
static bool first = true;
static mint sum_ie[30]; // sum_ie[i] = es[0] * ... * es[i - 1] * ies[i]
if (first) {
first = false;
mint es[30], ies[30]; // es[i]^(2^(2+i)) == 1
int cnt2 = bsf(mint::mod() - 1);
mint e = mint(g).pow((mint::mod() - 1) >> cnt2), ie = e.inv();
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
mint now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now;
now *= es[i];
}
}
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
mint inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
auto l = a[i + offset];
auto r = a[i + offset + p];
a[i + offset] = l + r;
a[i + offset + p] =
(unsigned long long)(mint::mod() + l.val() - r.val()) * inow.val();
}
inow *= sum_ie[bsf(~(unsigned int)(s))];
}
}
}
} // namespace internal
template <class mint, internal::is_static_modint_t<mint> * = nullptr>
std::vector<mint> convolution(std::vector<mint> a, std::vector<mint> b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
if (std::min(n, m) <= 60) {
if (n < m) {
std::swap(n, m);
std::swap(a, b);
}
std::vector<mint> ans(n + m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[i + j] += a[i] * b[j];
}
}
return ans;
}
int z = 1 << internal::ceil_pow2(n + m - 1);
a.resize(z);
internal::butterfly(a);
b.resize(z);
internal::butterfly(b);
for (int i = 0; i < z; i++) {
a[i] *= b[i];
}
internal::butterfly_inv(a);
a.resize(n + m - 1);
mint iz = mint(z).inv();
for (int i = 0; i < n + m - 1; i++)
a[i] *= iz;
return a;
}
template <unsigned int mod = 998244353, class T,
std::enable_if_t<internal::is_integral<T>::value> * = nullptr>
std::vector<T> convolution(const std::vector<T> &a, const std::vector<T> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
using mint = static_modint<mod>;
std::vector<mint> a2(n), b2(m);
for (int i = 0; i < n; i++) {
a2[i] = mint(a[i]);
}
for (int i = 0; i < m; i++) {
b2[i] = mint(b[i]);
}
auto c2 = convolution(move(a2), move(b2));
std::vector<T> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
c[i] = c2[i].val();
}
return c;
}
std::vector<long long> convolution_ll(const std::vector<long long> &a,
const std::vector<long long> &b) {
int n = int(a.size()), m = int(b.size());
if (!n || !m)
return {};
static constexpr unsigned long long MOD1 = 754974721; // 2^24
static constexpr unsigned long long MOD2 = 167772161; // 2^25
static constexpr unsigned long long MOD3 = 469762049; // 2^26
static constexpr unsigned long long M2M3 = MOD2 * MOD3;
static constexpr unsigned long long M1M3 = MOD1 * MOD3;
static constexpr unsigned long long M1M2 = MOD1 * MOD2;
static constexpr unsigned long long M1M2M3 = MOD1 * MOD2 * MOD3;
static constexpr unsigned long long i1 =
internal::inv_gcd(MOD2 * MOD3, MOD1).second;
static constexpr unsigned long long i2 =
internal::inv_gcd(MOD1 * MOD3, MOD2).second;
static constexpr unsigned long long i3 =
internal::inv_gcd(MOD1 * MOD2, MOD3).second;
auto c1 = convolution<MOD1>(a, b);
auto c2 = convolution<MOD2>(a, b);
auto c3 = convolution<MOD3>(a, b);
std::vector<long long> c(n + m - 1);
for (int i = 0; i < n + m - 1; i++) {
unsigned long long x = 0;
x += (c1[i] * i1) % MOD1 * M2M3;
x += (c2[i] * i2) % MOD2 * M1M3;
x += (c3[i] * i3) % MOD3 * M1M2;
// B = 2^63, -B <= x, r(real value) < B
// (x, x - M, x - 2M, or x - 3M) = r (mod 2B)
// r = c1[i] (mod MOD1)
// focus on MOD1
// r = x, x - M', x - 2M', x - 3M' (M' = M % 2^64) (mod 2B)
// r = x,
// x - M' + (0 or 2B),
// x - 2M' + (0, 2B or 4B),
// x - 3M' + (0, 2B, 4B or 6B) (without mod!)
// (r - x) = 0, (0)
// - M' + (0 or 2B), (1)
// -2M' + (0 or 2B or 4B), (2)
// -3M' + (0 or 2B or 4B or 6B) (3) (mod MOD1)
// we checked that
// ((1) mod MOD1) mod 5 = 2
// ((2) mod MOD1) mod 5 = 3
// ((3) mod MOD1) mod 5 = 4
long long diff =
c1[i] - internal::safe_mod((long long)(x), (long long)(MOD1));
if (diff < 0)
diff += MOD1;
static constexpr unsigned long long offset[5] = {0, 0, M1M2M3, 2 * M1M2M3,
3 * M1M2M3};
x -= offset[diff % 5];
c[i] = x;
}
return c;
}
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y)
return x;
if (-parent_or_size[x] < -parent_or_size[y])
std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0)
return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int> &v) { return v.empty(); }),
result.end());
return result;
}
private:
int _n;
// root node: -1 * component size
// otherwise: parent
std::vector<int> parent_or_size;
};
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference: https://en.wikipedia.org/wiki/Fenwick_tree
template <class T> struct fenwick_tree {
using U = internal::to_unsigned_t<T>;
public:
fenwick_tree() : _n(0) {}
fenwick_tree(int n) : _n(n), data(n) {}
void add(int p, T x) {
assert(0 <= p && p < _n);
p++;
while (p <= _n) {
data[p - 1] += U(x);
p += p & -p;
}
}
T sum(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
return sum(r) - sum(l);
}
private:
int _n;
std::vector<U> data;
U sum(int r) {
U s = 0;
while (r > 0) {
s += data[r - 1];
r -= r & -r;
}
return s;
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--)
push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++)
update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r)
return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l)
push(l >> i);
if (((r >> i) << i) != r)
push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1)
all_apply(l++, f);
if (r & 1)
all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l)
update(l >> i);
if (((r >> i) << i) != r)
update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n)
return _n;
l += size;
for (int i = log; i >= 1; i--)
push(l >> i);
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0)
return 0;
r += size;
for (int i = log; i >= 1; i--)
push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size)
lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1)
return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1)
r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long> &r,
const std::vector<long long> &m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g)
return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0)
r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
#include <algorithm>
#include <vector>
namespace atcoder {
namespace internal {
template <class T> struct simple_queue {
std::vector<T> payload;
int pos = 0;
void reserve(int n) { payload.reserve(n); }
int size() const { return int(payload.size()) - pos; }
bool empty() const { return pos == int(payload.size()); }
void push(const T &t) { payload.push_back(t); }
T &front() { return payload[pos]; }
void clear() {
payload.clear();
pos = 0;
}
void pop() { pos++; }
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap> struct mf_graph {
public:
mf_graph() : _n(0) {}
mf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result;
for (int i = 0; i < m; i++) {
result.push_back(get_edge(i));
}
return result;
}
void change_edge(int i, Cap new_cap, Cap new_flow) {
int m = int(pos.size());
assert(0 <= i && i < m);
assert(0 <= new_flow && new_flow <= new_cap);
auto &_e = g[pos[i].first][pos[i].second];
auto &_re = g[_e.to][_e.rev];
_e.cap = new_cap - new_flow;
_re.cap = new_flow;
}
Cap flow(int s, int t) { return flow(s, t, std::numeric_limits<Cap>::max()); }
Cap flow(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
std::vector<int> level(_n), iter(_n);
internal::simple_queue<int> que;
auto bfs = [&]() {
std::fill(level.begin(), level.end(), -1);
level[s] = 0;
que.clear();
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto e : g[v]) {
if (e.cap == 0 || level[e.to] >= 0)
continue;
level[e.to] = level[v] + 1;
if (e.to == t)
return;
que.push(e.to);
}
}
};
auto dfs = [&](auto self, int v, Cap up) {
if (v == s)
return up;
Cap res = 0;
int level_v = level[v];
for (int &i = iter[v]; i < int(g[v].size()); i++) {
_edge &e = g[v][i];
if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0)
continue;
Cap d = self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
if (d <= 0)
continue;
g[v][i].cap += d;
g[e.to][e.rev].cap -= d;
res += d;
if (res == up)
break;
}
return res;
};
Cap flow = 0;
while (flow < flow_limit) {
bfs();
if (level[t] == -1)
break;
std::fill(iter.begin(), iter.end(), 0);
while (flow < flow_limit) {
Cap f = dfs(dfs, t, flow_limit - flow);
if (!f)
break;
flow += f;
}
}
return flow;
}
std::vector<bool> min_cut(int s) {
std::vector<bool> visited(_n);
internal::simple_queue<int> que;
que.push(s);
while (!que.empty()) {
int p = que.front();
que.pop();
visited[p] = true;
for (auto e : g[p]) {
if (e.cap && !visited[e.to]) {
visited[e.to] = true;
que.push(e.to);
}
}
}
return visited;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
namespace atcoder {
template <class Cap, class Cost> struct mcf_graph {
public:
mcf_graph() {}
mcf_graph(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
g[from].push_back(_edge{to, int(g[to].size()), cap, cost});
g[to].push_back(_edge{from, int(g[from].size()) - 1, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result(m);
for (int i = 0; i < m; i++) {
result[i] = get_edge(i);
}
return result;
}
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
std::vector<Cost> dual(_n, 0), dist(_n);
std::vector<int> pv(_n), pe(_n);
std::vector<bool> vis(_n);
auto dual_ref = [&]() {
std::fill(dist.begin(), dist.end(), std::numeric_limits<Cost>::max());
std::fill(pv.begin(), pv.end(), -1);
std::fill(pe.begin(), pe.end(), -1);
std::fill(vis.begin(), vis.end(), false);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::priority_queue<Q> que;
dist[s] = 0;
que.push(Q{0, s});
while (!que.empty()) {
int v = que.top().to;
que.pop();
if (vis[v])
continue;
vis[v] = true;
if (v == t)
break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
for (int i = 0; i < int(g[v].size()); i++) {
auto e = g[v][i];
if (vis[e.to] || !e.cap)
continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
que.push(Q{dist[e.to], e.to});
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v])
continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
// (shortest(s, v) + dual[s] - dual[v]) = - shortest(s, t) +
// dual[t] + shortest(s, v) = shortest(s, v) - shortest(s, t) >=
// 0 - (n-1)C
dual[v] -= dist[t] - dist[v];
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost = -1;
std::vector<std::pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (!dual_ref())
break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = pv[v]) {
c = std::min(c, g[pv[v]][pe[v]].cap);
}
for (int v = t; v != s; v = pv[v]) {
auto &e = g[pv[v]][pe[v]];
e.cap -= c;
g[v][e.rev].cap += c;
}
Cost d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost = cost;
}
return result;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
} // namespace atcoder
#include <algorithm>
#include <algorithm>
#include <utility>
#include <vector>
namespace atcoder {
namespace internal {
template <class E> struct csr {
std::vector<int> start;
std::vector<E> elist;
csr(int n, const std::vector<std::pair<int, E>> &edges)
: start(n + 1), elist(edges.size()) {
for (auto e : edges) {
start[e.first + 1]++;
}
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
auto counter = start;
for (auto e : edges) {
elist[counter[e.first]++] = e.second;
}
}
};
// Reference:
// R. Tarjan,
// Depth-First Search and Linear Graph Algorithms
struct scc_graph {
public:
scc_graph(int n) : _n(n) {}
int num_vertices() { return _n; }
void add_edge(int from, int to) { edges.push_back({from, {to}}); }
// @return pair of (# of scc, scc id)
std::pair<int, std::vector<int>> scc_ids() {
auto g = csr<edge>(_n, edges);
int now_ord = 0, group_num = 0;
std::vector<int> visited, low(_n), ord(_n, -1), ids(_n);
visited.reserve(_n);
auto dfs = [&](auto self, int v) -> void {
low[v] = ord[v] = now_ord++;
visited.push_back(v);
for (int i = g.start[v]; i < g.start[v + 1]; i++) {
auto to = g.elist[i].to;
if (ord[to] == -1) {
self(self, to);
low[v] = std::min(low[v], low[to]);
} else {
low[v] = std::min(low[v], ord[to]);
}
}
if (low[v] == ord[v]) {
while (true) {
int u = visited.back();
visited.pop_back();
ord[u] = _n;
ids[u] = group_num;
if (u == v)
break;
}
group_num++;
}
};
for (int i = 0; i < _n; i++) {
if (ord[i] == -1)
dfs(dfs, i);
}
for (auto &x : ids) {
x = group_num - 1 - x;
}
return {group_num, ids};
}
std::vector<std::vector<int>> scc() {
auto ids = scc_ids();
int group_num = ids.first;
std::vector<int> counts(group_num);
for (auto x : ids.second)
counts[x]++;
std::vector<std::vector<int>> groups(ids.first);
for (int i = 0; i < group_num; i++) {
groups[i].reserve(counts[i]);
}
for (int i = 0; i < _n; i++) {
groups[ids.second[i]].push_back(i);
}
return groups;
}
private:
int _n;
struct edge {
int to;
};
std::vector<std::pair<int, edge>> edges;
};
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
struct scc_graph {
public:
scc_graph() : internal(0) {}
scc_graph(int n) : internal(n) {}
void add_edge(int from, int to) {
int n = internal.num_vertices();
assert(0 <= from && from < n);
assert(0 <= to && to < n);
internal.add_edge(from, to);
}
std::vector<std::vector<int>> scc() { return internal.scc(); }
private:
internal::scc_graph internal;
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++)
d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++)
update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1)
sml = op(sml, d[l++]);
if (r & 1)
smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n)
return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0)
l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0)
return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2))
r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
#include <algorithm>
#include <cassert>
#include <numeric>
#include <string>
#include <vector>
namespace atcoder {
namespace internal {
std::vector<int> sa_naive(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n);
std::iota(sa.begin(), sa.end(), 0);
std::sort(sa.begin(), sa.end(), [&](int l, int r) {
if (l == r)
return false;
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] < s[r];
l++;
r++;
}
return l == n;
});
return sa;
}
std::vector<int> sa_doubling(const std::vector<int> &s) {
int n = int(s.size());
std::vector<int> sa(n), rnk = s, tmp(n);
std::iota(sa.begin(), sa.end(), 0);
for (int k = 1; k < n; k *= 2) {
auto cmp = [&](int x, int y) {
if (rnk[x] != rnk[y])
return rnk[x] < rnk[y];
int rx = x + k < n ? rnk[x + k] : -1;
int ry = y + k < n ? rnk[y + k] : -1;
return rx < ry;
};
std::sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp(sa[i - 1], sa[i]) ? 1 : 0);
}
std::swap(tmp, rnk);
}
return sa;
}
// SA-IS, linear-time suffix array construction
// Reference:
// G. Nong, S. Zhang, and W. H. Chan,
// Two Efficient Algorithms for Linear Time Suffix Array Construction
template <int THRESHOLD_NAIVE = 10, int THRESHOLD_DOUBLING = 40>
std::vector<int> sa_is(const std::vector<int> &s, int upper) {
int n = int(s.size());
if (n == 0)
return {};
if (n == 1)
return {0};
if (n == 2) {
if (s[0] < s[1]) {
return {0, 1};
} else {
return {1, 0};
}
}
if (n < THRESHOLD_NAIVE) {
return sa_naive(s);
}
if (n < THRESHOLD_DOUBLING) {
return sa_doubling(s);
}
std::vector<int> sa(n);
std::vector<bool> ls(n);
for (int i = n - 2; i >= 0; i--) {
ls[i] = (s[i] == s[i + 1]) ? ls[i + 1] : (s[i] < s[i + 1]);
}
std::vector<int> sum_l(upper + 1), sum_s(upper + 1);
for (int i = 0; i < n; i++) {
if (!ls[i]) {
sum_s[s[i]]++;
} else {
sum_l[s[i] + 1]++;
}
}
for (int i = 0; i <= upper; i++) {
sum_s[i] += sum_l[i];
if (i < upper)
sum_l[i + 1] += sum_s[i];
}
auto induce = [&](const std::vector<int> &lms) {
std::fill(sa.begin(), sa.end(), -1);
std::vector<int> buf(upper + 1);
std::copy(sum_s.begin(), sum_s.end(), buf.begin());
for (auto d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
std::copy(sum_l.begin(), sum_l.end(), buf.begin());
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
std::vector<int> lms_map(n + 1, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms_map[i] = m++;
}
}
std::vector<int> lms;
lms.reserve(m);
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms.push_back(i);
}
}
induce(lms);
if (m) {
std::vector<int> sorted_lms;
sorted_lms.reserve(m);
for (int v : sa) {
if (lms_map[v] != -1)
sorted_lms.push_back(v);
}
std::vector<int> rec_s(m);
int rec_upper = 0;
rec_s[lms_map[sorted_lms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sorted_lms[i - 1], r = sorted_lms[i];
int end_l = (lms_map[l] + 1 < m) ? lms[lms_map[l] + 1] : n;
int end_r = (lms_map[r] + 1 < m) ? lms[lms_map[r] + 1] : n;
bool same = true;
if (end_l - l != end_r - r) {
same = false;
} else {
while (l < end_l) {
if (s[l] != s[r]) {
break;
}
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same)
rec_upper++;
rec_s[lms_map[sorted_lms[i]]] = rec_upper;
}
auto rec_sa = sa_is<THRESHOLD_NAIVE, THRESHOLD_DOUBLING>(rec_s, rec_upper);
for (int i = 0; i < m; i++) {
sorted_lms[i] = lms[rec_sa[i]];
}
induce(sorted_lms);
}
return sa;
}
} // namespace internal
std::vector<int> suffix_array(const std::vector<int> &s, int upper) {
assert(0 <= upper);
for (int d : s) {
assert(0 <= d && d <= upper);
}
auto sa = internal::sa_is(s, upper);
return sa;
}
template <class T> std::vector<int> suffix_array(const std::vector<T> &s) {
int n = int(s.size());
std::vector<int> idx(n);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(), [&](int l, int r) { return s[l] < s[r]; });
std::vector<int> s2(n);
int now = 0;
for (int i = 0; i < n; i++) {
if (i && s[idx[i - 1]] != s[idx[i]])
now++;
s2[idx[i]] = now;
}
return internal::sa_is(s2, now);
}
std::vector<int> suffix_array(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return internal::sa_is(s2, 255);
}
// Reference:
// T. Kasai, G. Lee, H. Arimura, S. Arikawa, and K. Park,
// Linear-Time Longest-Common-Prefix Computation in Suffix Arrays and Its
// Applications
template <class T>
std::vector<int> lcp_array(const std::vector<T> &s,
const std::vector<int> &sa) {
int n = int(s.size());
assert(n >= 1);
std::vector<int> rnk(n);
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
std::vector<int> lcp(n - 1);
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0)
continue;
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
std::vector<int> lcp_array(const std::string &s, const std::vector<int> &sa) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcp_array(s2, sa);
}
// Reference:
// D. Gusfield,
// Algorithms on Strings, Trees, and Sequences: Computer Science and
// Computational Biology
template <class T> std::vector<int> z_algorithm(const std::vector<T> &s) {
int n = int(s.size());
if (n == 0)
return {};
std::vector<int> z(n);
z[0] = 0;
for (int i = 1, j = 0; i < n; i++) {
int &k = z[i];
k = (j + z[j] <= i) ? 0 : std::min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
std::vector<int> z_algorithm(const std::string &s) {
int n = int(s.size());
std::vector<int> s2(n);
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return z_algorithm(s2);
}
} // namespace atcoder
#include <cassert>
#include <vector>
namespace atcoder {
// Reference:
// B. Aspvall, M. Plass, and R. Tarjan,
// A Linear-Time Algorithm for Testing the Truth of Certain Quantified Boolean
// Formulas
struct two_sat {
public:
two_sat() : _n(0), scc(0) {}
two_sat(int n) : _n(n), _answer(n), scc(2 * n) {}
void add_clause(int i, bool f, int j, bool g) {
assert(0 <= i && i < _n);
assert(0 <= j && j < _n);
scc.add_edge(2 * i + (f ? 0 : 1), 2 * j + (g ? 1 : 0));
scc.add_edge(2 * j + (g ? 0 : 1), 2 * i + (f ? 1 : 0));
}
bool satisfiable() {
auto id = scc.scc_ids().second;
for (int i = 0; i < _n; i++) {
if (id[2 * i] == id[2 * i + 1])
return false;
_answer[i] = id[2 * i] < id[2 * i + 1];
}
return true;
}
std::vector<bool> answer() { return _answer; }
private:
int _n;
std::vector<bool> _answer;
internal::scc_graph scc;
};
} // namespace atcoder
using namespace std;
using namespace atcoder;
using usize = ::std::size_t;
// using u64 = ::std::int_least64_t;
using u64 = long long;
static constexpr u64 Inf = ::std::numeric_limits<u64>::max() / 2;
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
u64 N, X, M;
cin >> N >> X >> M;
modint::set_mod((int)M);
vector<u64> dp(M + 1, 0), index(M + 1, -1);
modint a1 = X;
modint a2 = a1.pow(2);
vector<u64> sum(1, 0);
modint current = a1;
sum.push_back((u64)a1.val());
index[a1.val()] = 1;
u64 freq, start = 1, end = 1;
for (u64 i = 2; i <= M; i++) {
current = current.pow(2);
if (dp[current.val()] > 0) {
start = index[current.val()];
break;
}
dp[current.val()]++;
index[current.val()] = i;
sum.push_back((u64)sum[i - 1] + current.val());
end = i;
}
freq = end - start + 1;
u64 ans = 0;
ans += sum[start - 1];
ans += (sum[end] - sum[start - 1]) * ((N - start + 1) / freq);
ans += (sum[(N - start + 1) % freq + start - 1] - sum[start - 1]);
cout << ans << endl;
return 0;
}
| replace | 2,174 | 2,175 | 2,174 | 2,175 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
/*
struct Edge
{
int to;
ll weight;
Edge(int t, ll w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
*/
using Graph = vector<vector<int>>;
const long long INF = 1LL << 60;
const int INT_INF = 1000000000;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
// int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, 1, 0, -1};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, X, M;
cin >> N >> X >> M;
vector<int> occur(M, -1);
ll A = X;
occur[A] = 1;
int start_loop = 0;
int second = 0;
int loop_size = 0;
int cnt = 0;
for (int i = 0; i < M; i++) {
A = (A * A) % M;
cnt++;
if (occur[A] != -1) {
loop_size = cnt - occur[A];
second = cnt;
start_loop = occur[A];
break;
} else {
occur[A] = cnt;
}
}
A = X;
for (int i = 0; i < start_loop; i++) {
A = (A * A) % M;
}
vector<ll> loop_sum(loop_size + 1);
for (int i = start_loop; i < second; i++) {
loop_sum[i - start_loop + 1] = loop_sum[i - start_loop] + A;
A = (A * A) % M;
}
// cerr << loop_sum.size() << endl;
if (second >= N) {
A = X;
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A;
A = (A * A) % M;
}
cout << ans << endl;
} else {
A = X;
ll ans = 0;
for (int i = 0; i < start_loop; i++) {
ans += A;
A = (A * A) % M;
}
ans += (N - start_loop) / loop_size * loop_sum[loop_size];
cerr << ans << endl;
ll rem = (N - start_loop) % loop_size;
ans += loop_sum[rem];
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <cassert>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
/*
struct Edge
{
int to;
ll weight;
Edge(int t, ll w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
*/
using Graph = vector<vector<int>>;
const long long INF = 1LL << 60;
const int INT_INF = 1000000000;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
// int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, 1, 0, -1};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll N, X, M;
cin >> N >> X >> M;
vector<int> occur(M, -1);
ll A = X;
occur[A] = 0;
int start_loop = 0;
int second = 0;
int loop_size = 0;
int cnt = 0;
for (int i = 0; i < M; i++) {
A = (A * A) % M;
cnt++;
if (occur[A] != -1) {
loop_size = cnt - occur[A];
second = cnt;
start_loop = occur[A];
break;
} else {
occur[A] = cnt;
}
}
A = X;
for (int i = 0; i < start_loop; i++) {
A = (A * A) % M;
}
vector<ll> loop_sum(loop_size + 1);
for (int i = start_loop; i < second; i++) {
loop_sum[i - start_loop + 1] = loop_sum[i - start_loop] + A;
A = (A * A) % M;
}
// cerr << loop_sum.size() << endl;
if (second >= N) {
A = X;
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A;
A = (A * A) % M;
}
cout << ans << endl;
} else {
A = X;
ll ans = 0;
for (int i = 0; i < start_loop; i++) {
ans += A;
A = (A * A) % M;
}
ans += (N - start_loop) / loop_size * loop_sum[loop_size];
cerr << ans << endl;
ll rem = (N - start_loop) % loop_size;
ans += loop_sum[rem];
cout << ans << endl;
}
return 0;
}
| replace | 31 | 32 | 31 | 32 | 0 | |
p02550 | C++ | Runtime Error |
#define INF 10000000000
#define MOD 1000000007
#if 1 // use_templates
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define rep(i, up) for (ll i = 0; i < (up); ++i)
#define repp(i, up) for (ll i = 0; i <= (up); ++i)
#define rrep(i, lo, up) for (ll i = (lo); i < (up); ++i)
#define rrepp(i, lo, up) for (ll i = (lo); i <= (up); ++i)
#define eep(i, lo, up) for ((i) = (lo); (i) < (up); ++(i))
#define eepp(i, lo, up) for ((i) = (lo); (i) <= (up); ++(i))
#define feach(it, vec) for (auto it = (vec).begin(); it != (vec).end(); ++it)
#define emax(l, r) l = max(l, r)
#define vmin(l, r) l = min(l, r)
template <class T, class U> bool contains(const T &vec, const U &value) {
return vec.find(value) != vec.end();
}
ll gcd(ll a, ll b);
ll gcd(ll a, ll b) {
if (a < b) {
return gcd(b, a);
}
ll r;
while (r = a % b) {
a = b;
b = r;
}
return b;
}
#endif // end of use_templates
int main() {
ll n, x, m;
cin >> n >> x >> m;
map<ll, ll> work;
ll a = x;
work[a] = 1;
ll off, loop;
rrepp(i, 2, m) {
a = a * a % m;
auto it = work.find(a);
if (it != work.end()) {
off = it->second - 1;
loop = i - it->second;
break;
}
work[a] = i;
}
ll sum = 0;
ll ii;
for (a = x, ii = 0; ii < off; a = a * a % m, ++ii) {
sum += a;
}
ll ls = 0;
for (ii = 0; ii < loop; a = a * a % m, ++ii) {
ls += a;
}
sum += ((n - off) / loop) * ls;
for (ii = ((n - off) / loop) * loop + off; ii < n; a = a * a % m, ++ii) {
sum += a;
}
cout << sum << endl;
return 0;
}
|
#define INF 10000000000
#define MOD 1000000007
#if 1 // use_templates
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define rep(i, up) for (ll i = 0; i < (up); ++i)
#define repp(i, up) for (ll i = 0; i <= (up); ++i)
#define rrep(i, lo, up) for (ll i = (lo); i < (up); ++i)
#define rrepp(i, lo, up) for (ll i = (lo); i <= (up); ++i)
#define eep(i, lo, up) for ((i) = (lo); (i) < (up); ++(i))
#define eepp(i, lo, up) for ((i) = (lo); (i) <= (up); ++(i))
#define feach(it, vec) for (auto it = (vec).begin(); it != (vec).end(); ++it)
#define emax(l, r) l = max(l, r)
#define vmin(l, r) l = min(l, r)
template <class T, class U> bool contains(const T &vec, const U &value) {
return vec.find(value) != vec.end();
}
ll gcd(ll a, ll b);
ll gcd(ll a, ll b) {
if (a < b) {
return gcd(b, a);
}
ll r;
while (r = a % b) {
a = b;
b = r;
}
return b;
}
#endif // end of use_templates
int main() {
ll n, x, m;
cin >> n >> x >> m;
if (x == 0 || m == 1) {
cout << 0 << endl;
return 0;
}
map<ll, ll> work;
ll a = x;
work[a] = 1;
ll off, loop;
rrepp(i, 2, m) {
a = a * a % m;
auto it = work.find(a);
if (it != work.end()) {
off = it->second - 1;
loop = i - it->second;
break;
}
work[a] = i;
}
ll sum = 0;
ll ii;
for (a = x, ii = 0; ii < off; a = a * a % m, ++ii) {
sum += a;
}
ll ls = 0;
for (ii = 0; ii < loop; a = a * a % m, ++ii) {
ls += a;
}
sum += ((n - off) / loop) * ls;
for (ii = ((n - off) / loop) * loop + off; ii < n; a = a * a % m, ++ii) {
sum += a;
}
cout << sum << endl;
return 0;
}
| insert | 60 | 60 | 60 | 64 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
#define For(i, a, b) for (int i = a; i <= b; i++)
#define Forr(i, a, b) for (int i = a; i >= b; i--)
#define F first
#define S second
#define int ll
#define sz(x) ((ll)x.size())
#define all(x) x.begin(), x.end()
#define eb emplace_back
#define mkp make_pair
#define INF (ll)(1e17)
#define MOD (ll)(998244353)
int app[100010];
int sum[100010];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
memset(app, -1, sizeof(app));
memset(sum, 0, sizeof(sum));
int n, x, m;
cin >> n >> x >> m;
int now = x;
app[now] = 1;
sum[1] = x;
int end = -1;
int len = -1;
For(i, 2, m + 5) {
now = (now * now) % m;
if (app[now] != -1) {
end = i;
len = i - app[now];
break;
}
sum[i] = now + sum[i - 1];
app[now] = i;
}
if (len == 0) {
cout << "e04\n";
return 0;
}
int k = (n - end + 1) / len + 1;
int s = sum[end - 1] - sum[end - len - 1];
int left = (n - end + 1) % len;
int ans = (k * s + sum[left + end - len - 1]);
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
#define For(i, a, b) for (int i = a; i <= b; i++)
#define Forr(i, a, b) for (int i = a; i >= b; i--)
#define F first
#define S second
#define int ll
#define sz(x) ((ll)x.size())
#define all(x) x.begin(), x.end()
#define eb emplace_back
#define mkp make_pair
#define INF (ll)(1e17)
#define MOD (ll)(998244353)
int app[100010];
int sum[100010];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
// I won't misunderstand the problem statement anymore.
memset(app, -1, sizeof(app));
memset(sum, 0, sizeof(sum));
int n, x, m;
cin >> n >> x >> m;
int now = x;
app[now] = 1;
sum[1] = x;
int end = -1;
int len = -1;
For(i, 2, m + 5) {
now = (now * now) % m;
if (app[now] != -1) {
end = i;
len = i - app[now];
break;
}
sum[i] = now + sum[i - 1];
app[now] = i;
}
if (n <= len) {
cout << sum[n] << "\n";
return 0;
}
int k = (n - end + 1) / len + 1;
int s = sum[end - 1] - sum[end - len - 1];
int left = (n - end + 1) % len;
int ans = (k * s + sum[left + end - len - 1]);
cout << ans << "\n";
return 0;
}
| replace | 51 | 53 | 51 | 53 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
int n, mod, x, ans;
int a[1000005];
int a2[1000005];
signed main() {
cin >> n >> x >> mod;
int pos = 0, len = 0, pos2 = n, sum = 0;
for (int i = 1; i <= n; i++) {
ans += x;
a[x] = i;
a2[i] = x;
x = (x * x) % mod;
if (a[x]) {
pos = a[x];
pos2 -= i;
len = max(1LL, i - pos + 1);
for (int k = pos; k <= i; k++)
sum += a2[k];
break;
}
}
ans += (pos2 / len) * sum;
pos2 %= len;
for (int i = 1; i <= pos2; i++) {
ans += x;
x = (x * x) % mod;
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
int n, mod, x, ans;
int a[1000005];
int a2[1000005];
signed main() {
cin >> n >> x >> mod;
int pos = 0, len = 0, pos2 = n, sum = 0;
if (n <= 100000) {
for (int i = 1; i <= pos2; i++) {
ans += x;
x = (x * x) % mod;
}
cout << ans;
return 0;
}
for (int i = 1; i <= n; i++) {
ans += x;
a[x] = i;
a2[i] = x;
x = (x * x) % mod;
if (a[x]) {
pos = a[x];
pos2 -= i;
len = max(1LL, i - pos + 1);
for (int k = pos; k <= i; k++)
sum += a2[k];
break;
}
}
ans += (pos2 / len) * sum;
pos2 %= len;
for (int i = 1; i <= pos2; i++) {
ans += x;
x = (x * x) % mod;
}
cout << ans;
return 0;
}
| insert | 9 | 9 | 9 | 17 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define X first
#define Y second
#define nl '\n'
#define AC return 0
#define pb(a) push_back(a)
#define mst(a, b) memset(a, b, sizeof a)
#define rep(i, n) for (int i = 0; (i) < (n); i++)
#define rep1(i, n) for (int i = 1; (i) <= (n); i++)
#define scd(a) scanf("%lld", &a)
#define scdd(a, b) scanf("%lld%lld", &a, &b)
#define scs(s) scanf("%s", s)
// #pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = (ll)0x3f3f3f3f3f3f3f, MAX = 9e18, MIN = -9e18;
const int N = 1e6 + 10, M = 2e6 + 10, mod = 998244353, inf = 0x3f3f3f;
ll v[N], sum[N], mm[N];
int main() {
IOS;
ll n, m, x, ans = 0, cnt = 0;
cin >> n >> x >> m;
while (n--) {
ans += x;
v[x]++;
if (v[x] > 1)
mm[++cnt] = x;
x = x * x % m;
if (v[x] > 2 || !x)
break;
}
if (!x) {
cout << ans << nl;
AC;
}
rep1(i, cnt) sum[i] = sum[i - 1] + mm[i];
ans += (n / cnt) * sum[cnt] + sum[n % cnt];
cout << ans << nl;
AC;
} | #include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define X first
#define Y second
#define nl '\n'
#define AC return 0
#define pb(a) push_back(a)
#define mst(a, b) memset(a, b, sizeof a)
#define rep(i, n) for (int i = 0; (i) < (n); i++)
#define rep1(i, n) for (int i = 1; (i) <= (n); i++)
#define scd(a) scanf("%lld", &a)
#define scdd(a, b) scanf("%lld%lld", &a, &b)
#define scs(s) scanf("%s", s)
// #pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = (ll)0x3f3f3f3f3f3f3f, MAX = 9e18, MIN = -9e18;
const int N = 1e6 + 10, M = 2e6 + 10, mod = 998244353, inf = 0x3f3f3f;
ll v[N], sum[N], mm[N];
int main() {
IOS;
ll n, m, x, ans = 0, cnt = 0;
cin >> n >> x >> m;
while (n--) {
ans += x;
v[x]++;
if (v[x] > 1)
mm[++cnt] = x;
x = x * x % m;
if (v[x] > 2 || !x)
break;
}
if (!x) {
cout << ans << nl;
AC;
}
rep1(i, cnt) sum[i] = sum[i - 1] + mm[i];
if (cnt)
ans += (n / cnt) * sum[cnt] + sum[n % cnt];
cout << ans << nl;
AC;
} | replace | 42 | 43 | 42 | 44 | -8 | |
p02550 | Python | Runtime Error | import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
def main():
N, X, M = [int(x) for x in input().split()]
x = {}
ruiseki = [0] * (M + 1)
cnt = 1
ans = X
c = X
ruiseki[1] = ans
while cnt < N:
next = c**2 % M
if next in x.keys():
y = x[next]
# print(ruiseki)
# print(cnt, y)
if N == cnt:
print(ans + next)
return
loop = ruiseki[cnt] - ruiseki[y - 1]
loopcnt = cnt - y + 1
ans += ((N - cnt) // loopcnt) * loop
# print(ans)
amari = (N - cnt) % loopcnt
# print(amari, loop, loopcnt)
if amari != 0:
ans += ruiseki[y - 1 + amari] - ruiseki[y - 1]
# print(ans)
break
ans += next
cnt += 1
ruiseki[cnt] = next
ruiseki[cnt] += ruiseki[cnt - 1]
c = next
x[next] = cnt
print(ans)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
def main():
N, X, M = [int(x) for x in input().split()]
x = {}
ruiseki = [0] * (M + 1)
cnt = 1
ans = X
c = X
ruiseki[1] = ans
while cnt < N:
if c == 0:
print(ans)
return
next = c**2 % M
if next in x.keys():
y = x[next]
# print(ruiseki)
# print(cnt, y)
if N == cnt:
print(ans + next)
return
loop = ruiseki[cnt] - ruiseki[y - 1]
loopcnt = cnt - y + 1
ans += ((N - cnt) // loopcnt) * loop
# print(ans)
amari = (N - cnt) % loopcnt
# print(amari, loop, loopcnt)
if amari != 0:
ans += ruiseki[y - 1 + amari] - ruiseki[y - 1]
# print(ans)
break
ans += next
cnt += 1
ruiseki[cnt] = next
ruiseki[cnt] += ruiseki[cnt - 1]
c = next
x[next] = cnt
print(ans)
if __name__ == "__main__":
main()
| insert | 19 | 19 | 19 | 22 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
/// ----------------------------- (Debug) ------------------------------
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef ONLINE_JUDGE
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while (token = strtok(NULL, ", "))
v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
void debugg(vector<char *> args) { cerr << "\b\b "; }
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
#define harg(...) #__VA_ARGS__
#ifndef ONLINE_JUDGE
#define dbg(...) \
{ \
debugg(tokenizer(harg(__VA_ARGS__, \b\t-- > Line)), __VA_ARGS__, \
__LINE__); \
cerr << endl; \
}
#else
#define dbg(...) \
{}
#endif
/// -----------------------------------------------------------------------
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define REP(i, a, b) for (i = a; i <= b; i++)
#define RAP(i, a, b) for (i = a; i >= b; i--)
#define spa << " " <<
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)x.size()
ll mod = 998244353;
const int MX = 0x3f3f3f3f;
int main() {
IOS;
ll n, x, cnt = 1, ans;
int m, i;
cin >> n >> x >> m;
ans = x;
vi v;
set<int> s;
s.insert(x);
dbg(x, s);
while (cnt < n && s.find((x * x) % m) == s.end()) {
x = (x * x) % m;
// dbg(x,s,ans);
s.insert(x);
v.EB(x);
ans += x;
cnt++;
}
if (cnt < n) {
ll sum = 0;
int num = 0;
x = (x * x) % m;
// dbg(v);
RAP(i, sz(v) - 1, 0) {
sum += v[i];
num++;
if (v[i] == x)
break;
}
// dbg(i,num,cnt);
ans += ((n - cnt) / num) * sum;
num = (n - cnt) % num;
sum = 0;
while (num--) {
sum += v[i];
i++;
};
ans += sum;
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
/// ----------------------------- (Debug) ------------------------------
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef ONLINE_JUDGE
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while (token = strtok(NULL, ", "))
v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
void debugg(vector<char *> args) { cerr << "\b\b "; }
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
#define harg(...) #__VA_ARGS__
#ifndef ONLINE_JUDGE
#define dbg(...) \
{ \
debugg(tokenizer(harg(__VA_ARGS__, \b\t-- > Line)), __VA_ARGS__, \
__LINE__); \
cerr << endl; \
}
#else
#define dbg(...) \
{}
#endif
/// -----------------------------------------------------------------------
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define REP(i, a, b) for (i = a; i <= b; i++)
#define RAP(i, a, b) for (i = a; i >= b; i--)
#define spa << " " <<
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)x.size()
ll mod = 998244353;
const int MX = 0x3f3f3f3f;
int main() {
IOS;
ll n, x, cnt = 1, ans;
int m, i;
cin >> n >> x >> m;
ans = x;
vi v;
set<int> s;
s.insert(x);
v.EB(x);
while (cnt < n && s.find((x * x) % m) == s.end()) {
x = (x * x) % m;
// dbg(x,s,ans);
s.insert(x);
v.EB(x);
ans += x;
cnt++;
}
if (cnt < n) {
ll sum = 0;
int num = 0;
x = (x * x) % m;
// dbg(v);
RAP(i, sz(v) - 1, 0) {
sum += v[i];
num++;
if (v[i] == x)
break;
}
// dbg(i,num,cnt);
ans += ((n - cnt) / num) * sum;
num = (n - cnt) % num;
sum = 0;
while (num--) {
sum += v[i];
i++;
};
ans += sum;
}
cout << ans;
return 0;
} | replace | 96 | 97 | 96 | 97 | 0 | [x: 2] [s: [2]] [ -->Line: 68]
|
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using pii = pair<int, int>;
using pll = pair<long, long>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
vll rem(1e5 + 5, 0), vec(1e5 + 5, 0);
int main() {
ll n, x, m, first = 0, period = 0;
cin >> n >> x >> m;
ll sum = 0, ans = 0;
for (ll i = 1; i <= m - 1; i++) {
rem[i] = x;
if (vec[x] != 0) {
first = vec[x];
period = i - first;
}
vec[x] = i;
x *= x;
x %= m;
}
if (first != 0) {
for (ll i = first; i <= first + period - 1; i++)
sum += rem[i];
} else {
for (ll i = 1; i <= m - 1; i++)
sum += rem[i];
ans += sum * (n / (m - 1));
n %= (m - 1);
// for(ll i=1;i<=n;i++) ans+=rem[i];
cout << ans << endl;
return 0;
}
if (n <= first) {
for (ll i = 1; i <= n; i++)
ans += rem[i];
} else {
for (ll i = 1; i <= first - 1; i++)
ans += rem[i];
n -= first - 1;
ans += sum * (n / period);
n %= period;
for (ll i = first; i <= first + n - 1; i++)
ans += rem[i];
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using pii = pair<int, int>;
using pll = pair<long, long>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
vll rem(1e5 + 5, 0), vec(1e5 + 5, 0);
int main() {
ll n, x, m, first = 0, period = 0;
cin >> n >> x >> m;
ll sum = 0, ans = 0;
for (ll i = 1; i <= m - 1; i++) {
rem[i] = x;
if (vec[x] != 0) {
first = vec[x];
period = i - first;
}
vec[x] = i;
x *= x;
x %= m;
}
if (first != 0) {
for (ll i = first; i <= first + period - 1; i++)
sum += rem[i];
} else {
if (m == 1) {
ans = 0;
} else {
for (ll i = 1; i <= m - 1; i++)
sum += rem[i];
ans += sum * (n / (m - 1));
n %= (m - 1);
for (ll i = 1; i <= n; i++)
ans += rem[i];
}
cout << ans << endl;
return 0;
}
if (n <= first) {
for (ll i = 1; i <= n; i++)
ans += rem[i];
} else {
for (ll i = 1; i <= first - 1; i++)
ans += rem[i];
n -= first - 1;
ans += sum * (n / period);
n %= period;
for (ll i = first; i <= first + n - 1; i++)
ans += rem[i];
}
cout << ans << endl;
}
| replace | 32 | 37 | 32 | 42 | 0 | |
p02550 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Graph = vector<vector<int>>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
#define rep(i, N) for (int i = 0; i < N; i++)
#define rep2(i, l, r) for (ll i = (ll)l; i < (ll)(r); i++)
#define INF 1000000000000000
#define MAX 200001
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const ll MOD = 998244353;
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll ans = 0;
if (N <= M) {
rep(i, N) {
ans += X;
X *= X;
X %= M;
}
cout << ans << endl;
} else {
map<ll, ll> m;
bool flag = false;
ll cnt = M - 1;
m[X] = 1;
rep(i, M - 1) {
ans += X;
X *= X;
X %= M;
if (m[X] > 0) {
N -= m[X] - 1;
cnt = i + 1 - m[X] + 1;
break;
}
m[X] = i + 2;
if (X == 0)
flag = true;
}
if (flag)
cout << ans << endl;
else {
ll original = X;
ll res = 0;
while (true) {
X *= X;
X %= M;
res += X;
if (X == original)
break;
}
ans -= res;
ans += res * (N / cnt);
N %= cnt;
rep(i, N) {
ans += X;
X *= X;
X %= M;
}
cout << ans << endl;
}
}
} | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Graph = vector<vector<int>>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
#define rep(i, N) for (int i = 0; i < N; i++)
#define rep2(i, l, r) for (ll i = (ll)l; i < (ll)(r); i++)
#define INF 1000000000000000
#define MAX 200001
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const ll MOD = 998244353;
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
int main() {
ll N, X, M;
cin >> N >> X >> M;
ll ans = 0;
if (X == 0)
cout << 0 << endl;
else if (N <= M) {
rep(i, N) {
ans += X;
X *= X;
X %= M;
}
cout << ans << endl;
} else {
map<ll, ll> m;
bool flag = false;
ll cnt = M - 1;
m[X] = 1;
rep(i, M - 1) {
ans += X;
X *= X;
X %= M;
if (m[X] > 0) {
N -= m[X] - 1;
cnt = i + 1 - m[X] + 1;
break;
}
m[X] = i + 2;
if (X == 0)
flag = true;
}
if (flag)
cout << ans << endl;
else {
ll original = X;
ll res = 0;
while (true) {
X *= X;
X %= M;
res += X;
if (X == original)
break;
}
ans -= res;
ans += res * (N / cnt);
N %= cnt;
rep(i, N) {
ans += X;
X *= X;
X %= M;
}
cout << ans << endl;
}
}
} | replace | 39 | 40 | 39 | 42 | 0 | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI; // 大きい順
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<PII>> PQLP;
// priority_queue<T,vector<T>,decltype(f)> pq{f};
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EB emplace_back
#define EF emplace_front
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a) * (a))
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define Vmin(a) *min_element((a).begin(), (a).end())
#define Vmax(a) *max_element((a).begin(), (a).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REPR(i, n) FORR(i, 0, n)
#define CFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define CREP(i, n) CFOR(i, 0, n)
#define CFORR(i, a, b) for (int i = (b); i >= (a); i--)
#define CREPR(i, n) CFORR(i, 0, n)
#define BFOR(bit, a, b) for (int bit = (a); bit < (1 << (b)); ++bit)
#define BREP(bit, n) BFOR(bit, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 2;
const LL LINF = LLONG_MAX / 3;
const int RINF = INT_MIN / 2;
const LL RLINF = LLONG_MIN / 3;
const LL MOD = 1e9 + 7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
// other
//-------------------------------------------
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;
}
#define COUT(x) cout << (x) << endl
#define COUT2(x, y) cout << (x) << " " << (y) << endl
#define COUT3(x, y, z) cout << (x) << " " << (y) << " " << (z) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
VI dx = {1, 0, -1, 0, 1, 1, -1, -1};
VI dy = {0, 1, 0, -1, 1, -1, 1, -1};
LL Gcd(LL a, LL b) { return __gcd(a, b); }
LL Lcm(LL a, LL b) { return a / Gcd(a, b) * b; }
LL ModPow(LL A, LL N, LL M = MOD) {
LL res = 1;
while (N > 0) {
if (N & 1)
res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < SZ(v); i++) {
os << v[i] << (i + 1 != SZ(v) ? " " : "");
}
return os;
}
template <typename T> vector<T> make_v(size_t a, T b) {
return vector<T>(a, b);
}
template <typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
struct ArbitraryModInt {
int x;
ArbitraryModInt() : x(0) {}
ArbitraryModInt(int64_t y)
: x(y >= 0 ? y % get_mod() : (get_mod() - (-y) % get_mod()) % get_mod()) {
}
static int &get_mod() {
static int mod = 0;
return mod;
}
static void set_mod(int md) { get_mod() = md; }
ArbitraryModInt &operator+=(const ArbitraryModInt &p) {
if ((x += p.x) >= get_mod())
x -= get_mod();
return *this;
}
ArbitraryModInt &operator-=(const ArbitraryModInt &p) {
if ((x += get_mod() - p.x) >= get_mod())
x -= get_mod();
return *this;
}
ArbitraryModInt &operator*=(const ArbitraryModInt &p) {
x = (int)(1LL * x * p.x % get_mod());
return *this;
}
ArbitraryModInt &operator/=(const ArbitraryModInt &p) {
*this *= p.inverse();
return *this;
}
ArbitraryModInt operator-() const { return ArbitraryModInt(-x); }
ArbitraryModInt operator+(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) += p;
}
ArbitraryModInt operator-(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) -= p;
}
ArbitraryModInt operator*(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) *= p;
}
ArbitraryModInt operator/(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) /= p;
}
bool operator==(const ArbitraryModInt &p) const { return x == p.x; }
bool operator!=(const ArbitraryModInt &p) const { return x != p.x; }
ArbitraryModInt inverse() const {
int a = x, b = get_mod(), u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ArbitraryModInt(u);
}
ArbitraryModInt pow(int64_t n) const {
ArbitraryModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ArbitraryModInt &p) {
return os << p.x;
}
friend istream &operator>>(istream &is, ArbitraryModInt &a) {
int64_t t;
is >> t;
a = ArbitraryModInt(t);
return (is);
}
};
using amint = ArbitraryModInt;
using VMA = vector<amint>;
using VVMA = vector<VMA>;
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
LL N;
int X, M;
cin >> N >> X >> M;
amint::set_mod(M);
amint t = X;
VI len(M, -1), a;
int d = 1;
LL sum = 0;
while (len.at(t.x) < 0) {
len.at(t.x) = d++;
a.PB(t.x);
sum += t.x;
t = t.pow(2);
}
int l = d - len.at(t.x);
if (N <= d) {
LL ans = 0;
REP(i, N) { ans += a.at(i); }
COUT(ans);
} else {
LL ans = sum;
N -= d;
sum = 0;
FOR(i, len.at(t.x), d) { sum += a.at(i); }
ans += sum * (N / l);
int L = N % l;
REP(i, L) { ans += a.at(len.at(t.x) + i); }
COUT(ans);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI; // 大きい順
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<PII>> PQLP;
// priority_queue<T,vector<T>,decltype(f)> pq{f};
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EB emplace_back
#define EF emplace_front
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a) * (a))
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define Vmin(a) *min_element((a).begin(), (a).end())
#define Vmax(a) *max_element((a).begin(), (a).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REPR(i, n) FORR(i, 0, n)
#define CFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define CREP(i, n) CFOR(i, 0, n)
#define CFORR(i, a, b) for (int i = (b); i >= (a); i--)
#define CREPR(i, n) CFORR(i, 0, n)
#define BFOR(bit, a, b) for (int bit = (a); bit < (1 << (b)); ++bit)
#define BREP(bit, n) BFOR(bit, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 2;
const LL LINF = LLONG_MAX / 3;
const int RINF = INT_MIN / 2;
const LL RLINF = LLONG_MIN / 3;
const LL MOD = 1e9 + 7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
// other
//-------------------------------------------
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;
}
#define COUT(x) cout << (x) << endl
#define COUT2(x, y) cout << (x) << " " << (y) << endl
#define COUT3(x, y, z) cout << (x) << " " << (y) << " " << (z) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
VI dx = {1, 0, -1, 0, 1, 1, -1, -1};
VI dy = {0, 1, 0, -1, 1, -1, 1, -1};
LL Gcd(LL a, LL b) { return __gcd(a, b); }
LL Lcm(LL a, LL b) { return a / Gcd(a, b) * b; }
LL ModPow(LL A, LL N, LL M = MOD) {
LL res = 1;
while (N > 0) {
if (N & 1)
res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < SZ(v); i++) {
os << v[i] << (i + 1 != SZ(v) ? " " : "");
}
return os;
}
template <typename T> vector<T> make_v(size_t a, T b) {
return vector<T>(a, b);
}
template <typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
struct ArbitraryModInt {
int x;
ArbitraryModInt() : x(0) {}
ArbitraryModInt(int64_t y)
: x(y >= 0 ? y % get_mod() : (get_mod() - (-y) % get_mod()) % get_mod()) {
}
static int &get_mod() {
static int mod = 0;
return mod;
}
static void set_mod(int md) { get_mod() = md; }
ArbitraryModInt &operator+=(const ArbitraryModInt &p) {
if ((x += p.x) >= get_mod())
x -= get_mod();
return *this;
}
ArbitraryModInt &operator-=(const ArbitraryModInt &p) {
if ((x += get_mod() - p.x) >= get_mod())
x -= get_mod();
return *this;
}
ArbitraryModInt &operator*=(const ArbitraryModInt &p) {
x = (int)(1LL * x * p.x % get_mod());
return *this;
}
ArbitraryModInt &operator/=(const ArbitraryModInt &p) {
*this *= p.inverse();
return *this;
}
ArbitraryModInt operator-() const { return ArbitraryModInt(-x); }
ArbitraryModInt operator+(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) += p;
}
ArbitraryModInt operator-(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) -= p;
}
ArbitraryModInt operator*(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) *= p;
}
ArbitraryModInt operator/(const ArbitraryModInt &p) const {
return ArbitraryModInt(*this) /= p;
}
bool operator==(const ArbitraryModInt &p) const { return x == p.x; }
bool operator!=(const ArbitraryModInt &p) const { return x != p.x; }
ArbitraryModInt inverse() const {
int a = x, b = get_mod(), u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ArbitraryModInt(u);
}
ArbitraryModInt pow(int64_t n) const {
ArbitraryModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ArbitraryModInt &p) {
return os << p.x;
}
friend istream &operator>>(istream &is, ArbitraryModInt &a) {
int64_t t;
is >> t;
a = ArbitraryModInt(t);
return (is);
}
};
using amint = ArbitraryModInt;
using VMA = vector<amint>;
using VVMA = vector<VMA>;
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
LL N;
int X, M;
cin >> N >> X >> M;
amint::set_mod(M);
amint t = X;
VI len(M, -1), a;
int d = 0;
LL sum = 0;
while (len.at(t.x) < 0) {
len.at(t.x) = d++;
a.PB(t.x);
sum += t.x;
t = t.pow(2);
}
int l = d - len.at(t.x);
if (N <= d) {
LL ans = 0;
REP(i, N) { ans += a.at(i); }
COUT(ans);
} else {
LL ans = sum;
N -= d;
sum = 0;
FOR(i, len.at(t.x), d) { sum += a.at(i); }
ans += sum * (N / l);
int L = N % l;
REP(i, L) { ans += a.at(len.at(t.x) + i); }
COUT(ans);
}
return 0;
} | replace | 273 | 274 | 273 | 274 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int li;
typedef long double ld;
typedef vector<li> vi;
typedef pair<li, li> pi;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define B begin()
#define E end()
#define f(i, l, r) for (li i = l; i <= r; ++i)
#define fr(i, l, r) for (li i = l; i >= r; --i)
#define u_map unordered_map
#define endl "\n"
#define debug(x) cerr << #x << " = " << x << endl
li fastpow(li base, li exp, li M) {
li res = 1;
while (exp > 0) {
if (exp & 1)
res = (res * base) % M;
base = (base * base) % M;
exp >>= 1;
}
return res;
}
void solve() {
li n, x, M;
cin >> n >> x >> M;
if (x == 1) {
cout << n;
return;
}
if (n == 0) {
cout << 0;
return;
}
vi v(2e5);
li ans = 0;
while (n > 0) {
ans += x;
x *= x;
if (x >= M) {
n--;
break;
}
n--;
}
if (n <= 0) {
cout << ans;
return;
}
vi freq(2e5, -1);
li pos = 0;
while (n > 0) {
n--;
x %= M;
if (freq[x] == -1) {
ans += x;
debug(ans);
freq[x] = pos++;
v[pos - 1] = x;
} else {
n++;
break;
}
x *= x;
// n--;
}
if (n <= 0) {
cout << ans;
return;
}
debug(ans);
li sz = pos;
pos = freq[x];
li sum = 0, deno = 0;
f(i, pos, sz - 1) {
sum += v[i];
deno++;
}
li tp = n / deno;
li rem = n % deno;
ans += tp * (sum);
f(i, pos, pos + rem - 1) { ans += v[i]; }
// ans+=pre[rem-1];
cout << ans;
}
int main() {
// remove this in kickstart
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
li t = 1;
// cin>>t;
f(i, 1, t) {
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int li;
typedef long double ld;
typedef vector<li> vi;
typedef pair<li, li> pi;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define B begin()
#define E end()
#define f(i, l, r) for (li i = l; i <= r; ++i)
#define fr(i, l, r) for (li i = l; i >= r; --i)
#define u_map unordered_map
#define endl "\n"
#define debug(x) cerr << #x << " = " << x << endl
li fastpow(li base, li exp, li M) {
li res = 1;
while (exp > 0) {
if (exp & 1)
res = (res * base) % M;
base = (base * base) % M;
exp >>= 1;
}
return res;
}
void solve() {
li n, x, M;
cin >> n >> x >> M;
if (x == 1) {
cout << n;
return;
}
if (x == 0) {
cout << 0;
return;
}
vi v(2e5);
li ans = 0;
while (n > 0) {
ans += x;
x *= x;
if (x >= M) {
n--;
break;
}
n--;
}
if (n <= 0) {
cout << ans;
return;
}
vi freq(2e5, -1);
li pos = 0;
while (n > 0) {
n--;
x %= M;
if (freq[x] == -1) {
ans += x;
debug(ans);
freq[x] = pos++;
v[pos - 1] = x;
} else {
n++;
break;
}
x *= x;
// n--;
}
if (n <= 0) {
cout << ans;
return;
}
debug(ans);
li sz = pos;
pos = freq[x];
li sum = 0, deno = 0;
f(i, pos, sz - 1) {
sum += v[i];
deno++;
}
li tp = n / deno;
li rem = n % deno;
ans += tp * (sum);
f(i, pos, pos + rem - 1) { ans += v[i]; }
// ans+=pre[rem-1];
cout << ans;
}
int main() {
// remove this in kickstart
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
li t = 1;
// cin>>t;
f(i, 1, t) {
// cout<<"Case #"<<i<<": ";
solve();
}
return 0;
}
| replace | 42 | 43 | 42 | 43 | TLE | |
p02550 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long n, x, m, ans = 0;
cin >> n >> x >> m;
vector<long> k, s(m);
map<long, long> mp;
long cur = x, d = 0, e = 0;
k.push_back(cur);
mp[cur] = 1;
for (int i = 2; i <= m; i++) {
cur = (cur * cur) % m;
k.push_back(cur);
if (1 <= mp[cur]) {
d = mp[cur];
e = i;
break;
}
mp[cur] = i;
}
// cout << d << e << endl;
long fsum = 0, cirsum = 0, resum = 0;
for (int i = 0; i < d - 1; i++)
fsum += k[i];
for (int i = d - 1; i < e - 1; i++)
cirsum += k[i];
for (int i = 0; i <= (n - d) % (e - d); i++)
resum += k[d - 1 + i];
// cout << fsum << ' ' << cirsum <<' '<<resum << endl;
cout << fsum + (n - d) / (e - d) * cirsum + resum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long n, x, m, ans = 0;
cin >> n >> x >> m;
if (x == 0) {
cout << 0 << endl;
return 0;
}
vector<long> k, s(m);
map<long, long> mp;
long cur = x, d = 0, e = 0;
k.push_back(cur);
mp[cur] = 1;
for (int i = 2; i <= m; i++) {
cur = (cur * cur) % m;
k.push_back(cur);
if (1 <= mp[cur]) {
d = mp[cur];
e = i;
break;
}
mp[cur] = i;
}
// cout << d << e << endl;
long fsum = 0, cirsum = 0, resum = 0;
for (int i = 0; i < d - 1; i++)
fsum += k[i];
for (int i = d - 1; i < e - 1; i++)
cirsum += k[i];
for (int i = 0; i <= (n - d) % (e - d); i++)
resum += k[d - 1 + i];
// cout << fsum << ' ' << cirsum <<' '<<resum << endl;
cout << fsum + (n - d) / (e - d) * cirsum + resum << endl;
}
| insert | 6 | 6 | 6 | 10 | 0 | |
p02550 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<ll, ll>;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct edge {
ll to, cost;
};
int main() {
ll N;
cin >> N;
ll X, M;
cin >> X >> M;
ll S = 0; // 最終的に答えとなる和
vector<P> memo(M); // その値Xが { 何番目に出現したか, それまでの計算結果(和) }
for (int i = 0; i < N; ++i) {
if (memo[X].first) { // もしその値がすでに配列にあれば
// 今の順番と、かつてXが出てきた番号の差。これがループ1周分の長さになる
const auto t = i - memo[X].first;
// ループ1周分の残りの長さ
const auto c = (N - i - 1) / t;
i += t * c; // ループをスキップ?
S += (S - memo[X].second) * c;
} else { // もし配列にまだXが無ければ
memo[X] = P(i, S); // 配列のX番目にpairを格納する。
}
// 必ずSとXを更新する
S += X;
(X *= X) %= M;
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<ll, ll>;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct edge {
ll to, cost;
};
int main() {
ll N;
cin >> N;
ll X, M;
cin >> X >> M;
ll S = 0; // 最終的に答えとなる和
vector<P> memo(M); // その値Xが { 何番目に出現したか, それまでの計算結果(和) }
for (ll i = 0; i < N; ++i) {
if (memo[X].first) { // もしその値がすでに配列にあれば
// 今の順番と、かつてXが出てきた番号の差。これがループ1周分の長さになる
const auto t = i - memo[X].first;
// ループ1周分の残りの長さ
const auto c = (N - i - 1) / t;
i += t * c; // ループをスキップ?
S += (S - memo[X].second) * c;
} else { // もし配列にまだXが無ければ
memo[X] = P(i, S); // 配列のX番目にpairを格納する。
}
// 必ずSとXを更新する
S += X;
(X *= X) %= M;
}
cout << S << endl;
} | replace | 34 | 35 | 34 | 35 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.