text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
uint64_t minmul(uint64_t l, uint64_t r, uint64_t d) {
if (d < l || d > r) return d;
uint64_t mod = r % d;
return r + (d - mod);
}
int main() {
uint64_t q;
cin >> q;
uint64_t l, r, d;
for (uint64_t i = 0; i < q; i++) {
cin >> l >> r >> d;
cout << minmul(l, r, d) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() { return getchar(); }
template <class T>
int read(T &ans) {
ans = 0;
char ch = gc();
T f = 1;
while (!isdigit(ch)) {
if (ch == EOF) return -1;
if (ch == '-') f = -1;
ch = gc();
}
while (isdigit(ch)) ans = ans * 10 + ch - '0', ch = gc();
ans *= f;
return 1;
}
template <class T1, class T2>
int read(T1 &a, T2 &b) {
return read(a) != EOF && read(b) != EOF ? 2 : EOF;
}
template <class T1, class T2, class T3>
int read(T1 &a, T2 &b, T3 &c) {
return read(a, b) != EOF && read(c) != EOF ? 3 : EOF;
}
const int Maxn = 1100000;
const int inf = 0x3f3f3f3f;
signed main() {
long long q, l, r, d;
read(q);
while (q--) {
read(l, r, d);
if (l > d)
printf("%I64d\n", d);
else
printf("%I64d\n", d * (r / d + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d, l, r, n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l >> r >> d;
if (l > d) {
cout << d << endl;
continue;
}
cout << (r / d + 1) * d << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
int i;
for (i = 0; i < q; i++) {
int l, r, d;
cin >> l >> r >> d;
long long int x;
if (d < l)
x = d;
else {
int a = r % d;
x = (d - a) + r;
}
cout << x << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int __ = 1e5 + 5;
int a[__];
int main() {
int q;
for (scanf("%d", &q); q; --q) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
if (d < l || d > r) {
printf("%d\n", d);
continue;
}
printf("%d\n", (r / d + 1) * d);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << endl;
else {
int w = r % d;
cout << r + d - w << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r, d;
cin >> l >> r >> d;
if (d == 1) {
if (l > 1)
cout << 1;
else
cout << r + 1;
cout << endl;
continue;
}
int p = l / d;
int q = r / d;
if ((p == 1) && (l % d != 0))
cout << d;
else if (p > 1)
cout << d;
else
cout << (q + 1) * d;
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int l, r, a;
cin >> l >> r >> a;
if (l > a)
cout << a << endl;
else
cout << ((r / a + 1) * a) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16;
const long long MAXN = 1e6;
long long n, i, x, l, r;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> l >> r >> x;
if (x < l)
cout << x << endl;
else {
cout << r / x * x + x << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int l, r, d, m, s;
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
} else {
s = ((r / d) + 1) * d;
cout << s << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, x;
cin >> l >> r >> x;
if (x < l or x > r)
cout << x << endl;
else
cout << x - r % x + r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long l, d, r, temp = 0, temp2, i;
int main() {
int q;
cin >> q;
while (q--) {
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << endl;
continue;
}
temp = ((r + d) / d) * d;
cout << temp << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void testcase() {
int n;
cin >> n;
int l, r, d;
while (n--) {
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << "\n";
} else {
int x = r / d;
cout << (x + 1) * d << "\n";
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
testcase();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
long long a, b;
if (d < l)
cout << d << endl;
else {
a = r / d;
b = (a + 1) * d;
cout << b << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long mo = 1e9 + 7;
long long sx, sy, ex, ey, dx[6] = {0, 1, 0, -1, 0, 0},
dy[6] = {1, 0, -1, 0, 0, 0}, m, n, k,
dz[6]{0, 0, 0, 0, -1, 1}, sg, re;
long long p, no, v, ans, w;
int par[55];
long long a[400005], b[400006], c[500006], d[400006], dp[2005][2005];
struct mat {
long long a[40][40];
};
mat init, unit;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
set<long long> se;
long long qu(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans % m * a % m;
}
b >>= 1;
a = a % m * a % m;
}
return ans;
}
int su(int n) {
if (n == 1 || n == 0) return 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int fi(int a) {
if (a == par[a])
return a;
else
return par[a] = fi(par[a]);
}
vector<long long> ve, ve1;
map<long long, long long> mp, mp1;
pair<long long, long long> a1[400000];
int vis[400005], vis2[406][6];
vector<long long> g[400000], g1[400000];
struct node {
long long x, y, co, t;
} aa[200005];
int cmp(node a, node b) { return a.co > b.co; }
int cmp1(node a, node b) { return a.t < b.t; }
int main() {
int t, p2, p3;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string ss, sss, s;
long long l, r, n1;
while (cin >> n) {
while (n--) {
cin >> l >> r >> p;
if (p < l || p > r) {
cout << p << endl;
} else {
cout << r + p - (r % p) << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
continue;
}
int cnt = (r + d) / d;
cout << cnt * d << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int l, r, i, t, d, p, k, x;
double div;
scanf("%lld", &(t));
while (t--) {
scanf("%lld", &(l));
scanf("%lld", &(r));
scanf("%lld", &(d));
if (d < l)
x = d;
else {
div = d;
p = ceil((r + 1) / div);
x = d * p;
}
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int main(void) {
int q;
scanf("%d", &q);
while (q--) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
if (d < l) {
printf("%d\n", d);
continue;
}
printf("%d\n", ((r / d) + 1) * d);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > AdjList;
vector<int> dfs_num, ts;
const int UNVISITED = -1;
const int VISITED = 1;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
} else
cout << d * (r / d + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l > d)
cout << d << endl;
else
cout << (r + d) - (r % d) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, n, i, j, k, l, r, d;
cin >> t;
while (t--) {
cin >> l >> r >> d;
if (l > d)
cout << d << endl;
else {
m = r / d;
if (d * m > r)
cout << d * m << endl;
else
cout << d * (m + 1) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) + 7;
const int N = 1e5 + 7;
int main() {
ios::sync_with_stdio(false);
int q, l, r, d, ans;
cin >> q;
while (q--) {
cin >> l >> r >> d;
ans = (r / d + 1) * d;
if (d < l)
ans = d;
else
ans = (r / d + 1) * d;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l / d != 0 && l != d)
cout << d << "\n";
else
cout << (r / d + 1) * d << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (auto x : v) cout << x << " ";
puts("");
}
int main() {
int t;
cin >> t;
while (t--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l or d > r)
cout << d << endl;
else
cout << d * ((r / d) + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r, k;
cin >> l >> r >> k;
if (k < l) {
cout << k << endl;
} else {
cout << (r / k + 1) * k << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, l, m, g, i;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> q >> l >> m;
if (q > m) {
cout << m << "\n";
} else {
cout << (l / m) * m + m << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005];
int main() {
int q, l, r, d;
cin >> q;
while (q--) {
cin >> l >> r >> d;
if (d < l)
cout << d;
else
cout << r + d - r % d;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int a, b, c, d, e, i, j, k, l, n, m;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b >> c;
if (c < a)
cout << c << endl;
else
cout << ((b / c) + 1) * c << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int x1, x2, y;
int ats[N];
for (int i = 0; i < N; i++) {
cin >> x1 >> x2 >> y;
if (y < x1) {
ats[i] = y;
} else {
ats[i] = y * ((x2 / y) + 1);
}
}
for (int i = 0; i < N; i++) {
cout << ats[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T, typename TT>
ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto &i : t) os << i << " ";
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (l > d) {
cout << d << '\n';
continue;
}
cout << r - (r % d) + d << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q;
cin >> q;
while (q--) {
long long a, b, d;
cin >> a >> b >> d;
long long temp = a / d;
long long temp2 = b / d;
if (d < a || d > b) {
cout << d << endl;
} else {
long long num1 = (temp2 + 1) * d;
cout << num1 << endl;
}
}
}
|
#include <bits/stdc++.h>
int main() {
int t, l, r, d, m, n, i;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d %d %d", &l, &r, &d);
if (l > d || r < d) {
printf("%d\n", d);
} else {
m = (r / d) + 1;
n = d * m;
printf("%d\n", n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << endl;
else {
cout << (r / d + 1) * d << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
if ((double)l / d > 1)
printf("%d\n", d);
else {
int f = ((double)r / d) + 1;
printf("%d\n", f * d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int l, r, d;
cin >> l >> r >> d;
long long int ls, rs;
ls = d;
if (ls < l) {
printf("%d\n", ls);
continue;
}
if (r % d == 0) {
rs = d + r;
} else {
rs = d * (r / d + 1);
}
printf("%lld\n", rs);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long l, r, d;
while (t--) {
cin >> l >> r >> d;
if (d >= l && d <= r) {
long long oo = (r + d) / d;
cout << oo * d << endl;
} else {
cout << d << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
long long int l, r, d;
int main() {
cin >> t;
while (t--) {
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << endl;
continue;
}
if (r % d == 0) {
cout << r + d << endl;
continue;
}
cout << ((r / d) + 1) * d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t, l, r, d;
cin >> t;
while (t--) {
cin >> l >> r >> d;
long long int y = r / d;
if (d < l) {
cout << d << endl;
} else {
cout << (y + 1) * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
while (n--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << endl;
else {
cout << (long long)(ceil(r / d) * d) + d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, d, x, q;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> l >> r >> d;
if (d > r) {
cout << d << endl;
continue;
}
if (d < l) {
cout << d << endl;
continue;
}
x = ((r / d) + 1) * d;
cout << x << endl;
}
}
|
#include <bits/stdc++.h>
int d, l, q, r;
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &l, &r, &d);
printf("%d\n", l > d ? d : (r / d + 1) * d);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modd = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, l, r, d;
cin >> t;
int x;
while (t--) {
cin >> l >> r >> d;
if (d < l)
x = d;
else
x = d * ((r / d) + 1);
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << endl;
continue;
} else {
cout << (r / d) * d + d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q, l, r, d;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> l >> r >> d;
if (l <= d && r >= d) {
cout << (((r / d) + 1) * d) << "\n";
} else {
cout << d << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long int l, r, d;
cin >> l >> r >> d;
long long int curr = r;
if (l > d)
curr = d;
else if (r >= d) {
int k = (curr + d - 1) / d;
curr = d * k;
if (curr == r) curr += d;
} else if (d > r)
curr = d;
cout << curr << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q, l, r, d, p;
cin >> q;
while (q--) {
cin >> l >> r >> d;
p = d < l ? d : (r / d + 1) * d;
cout << p << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long int l, r, d;
for (int i = 0; i < q; i++) {
cin >> l >> r >> d;
if (d < l)
cout << d << endl;
else if (d > r)
cout << d << endl;
else
cout << ((r / d) + 1) * d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 1000005;
const double EPS = 1e-8;
const int INT_INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
int main() {
int q;
cin >> q;
int l, r, num;
while (q--) {
cin >> l >> r >> num;
if (num < l) {
cout << num << endl;
} else if (num > r) {
cout << num << endl;
} else {
cout << (r / num + 1) * num << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a;
while (a--) {
cin >> b >> c >> d;
if (d < b || d > c) {
cout << d << endl;
} else
cout << ((c / d) + 1) * d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
set<long long int> s1;
set<long long int> s2;
vector<long long int> v1;
vector<long long int> v2;
vector<long long int> v3;
vector<long long int> v4;
vector<long long int> v5;
vector<pair<long long int, long long int> > v6;
vector<string> v7;
list<long long int> l;
int main() {
long long int t;
cin >> t;
while (t-- > 0) {
long long int x, y, z;
cin >> x >> y >> z;
long long int i = 1;
if ((z * i) >= x && (z * i) <= y) {
cout << (((y / z) + 1) * z) << endl;
} else
cout << z << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r, d, s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l >> r >> d;
s = d;
if (s >= l && s <= r) {
s += (r - r % d);
}
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int solve(int l, int r, int d) {
if (d < l || d > r) return d;
return d * (r / d + 1);
}
int main() {
int n, l, r, d;
cin >> n;
while (n--) {
cin >> l >> r >> d;
cout << solve(l, r, d) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long unsigned l, r, d, t;
int main(int argc, char const *argv[]) {
cin >> t;
while (t--) {
cin >> l >> r >> d;
(d >= l) ? cout << (((r / d) + 1) * d) << endl : cout << d << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int a, b, c, n, i, m, x;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &a, &b, &c);
if (c < a)
printf("%d\n", c);
else {
m = b + 1;
if (m % c == 0)
printf("%d\n", m);
else {
x = m / c;
printf("%d\n", (x + 1) * c);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
int a, b, c;
int m;
cin >> a >> b >> c;
if (c < a)
arr[i] = c;
else {
m = b / c;
arr[i] = (m + 1) * c;
}
}
for (int i = 0; i < n; i++) cout << arr[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, n, x;
cin >> a >> b >> n;
if (n < a || n > b)
cout << n << endl;
else {
x = b / n;
cout << n * x + n << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
long long int i = 0;
while (1) {
if (l <= d) {
cout << d * (r / d + 1) << '\n';
break;
} else {
cout << d << '\n';
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n;
int i;
int l[n], r[n], d[n];
for (i = 0; i < n; i++) {
cin >> l[i] >> r[i] >> d[i];
}
for (i = 0; i < n; i++) {
if (d[i] < l[i]) {
cout << d[i] << endl;
} else {
p = r[i] % d[i];
r[i] = r[i] - p;
cout << r[i] + d[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long l, r, x;
while (q--) {
cin >> l >> r >> x;
if (l > r) swap(l, r);
if (x < l or x > r) {
cout << x << endl;
continue;
}
long long rp = r - r % x + x;
cout << rp << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l, r, d, n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &l, &r, &d);
if (l <= d) d = ((int)(r / d) + 1) * d;
printf("%d\n", d);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << endl;
} else {
int c = r / d;
cout << d * (c + 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int k = 0; k < q; k++) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l || d > r)
cout << d << " ";
else {
long long tmp = r % d;
cout << r + d - tmp << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
int l[500], r[500], d[500], ans[500];
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i] >> d[i];
int quo;
if (d[i] < l[i]) {
ans[i] = d[i];
} else {
quo = int(r[i] / d[i]);
ans[i] = d[i] * (quo + 1);
}
}
for (int i = 0; i < q; i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long modadd(long long n, long long m) {
long long sum = ((n + m) % 1000000007 + 1000000007) % 1000000007;
return sum;
}
inline long long modsub(long long n, long long m) {
long long diff =
((n - m + 1000000007) % 1000000007 + 1000000007) % 1000000007;
return diff;
}
inline long long modpro(long long n, long long m) {
long long pro = ((n * m) % 1000000007 + 1000000007) % 1000000007;
return pro;
}
inline long long pow(int x, int y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
inline long long powmod(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = modpro(res, x);
y = y >> 1;
x = modpro(x, x);
}
return res;
}
template <class T, class U>
bool comparep(const pair<T, U>& i, const pair<T, U>& j) {
return i.first > j.first;
}
template <class T, class U>
bool comparep2(const pair<T, U>& i, const pair<T, U>& j) {
return ((i.second < j.second) ||
((i.second == j.second) && i.first < j.first));
}
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
if (b == 0) return a;
T t;
while ((a > 0) && (b > 0)) {
t = a;
a = b % a;
b = t;
}
return max(a, b);
}
template <typename T>
T maxof(T n_args, ...) {
va_list ap;
va_start(ap, n_args);
T big = va_arg(ap, T);
for (int i = 2; i <= n_args; i++) {
T a = va_arg(ap, T);
if (a > big) big = a;
}
va_end(ap);
return big;
}
template <typename T>
T gcdarr(T a[], int n) {
T gc = gcd<T>(a[0], a[1]);
for (int i = 2; i < n; i++) {
gc = gcd<T>(gc, a[i]);
}
return gc;
}
template <typename T>
T maxarr(T a[], int n) {
T big = a[0];
for (int i = 1; i < n; i++) {
big = max(big, a[i]);
}
return big;
}
template <typename T>
T minarr(T a[], int n) {
T small = a[0];
for (int i = 1; i < n; i++) {
small = min(small, a[i]);
}
return small;
}
long long choose(long long n, int k) {
long long res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
class Graph {
public:
int V;
vector<int> v[25];
bool visited[25] = {0};
queue<int> q;
Graph(int V) { this->V = V; }
void addEdge(int a, int b) {
v[a].push_back(b);
v[b].push_back(a);
}
void dfs(int x) {
if (visited[x] == 0) {
visited[x] = 1;
for (int u : v[x]) {
dfs(u);
}
}
}
void bfs(int n, int x) {
visited[x] = 1;
q.push(x);
while (!q.empty()) {
int s = q.front();
q.pop();
for (int u : v[s]) {
if (visited[u] == 1) continue;
visited[u] = 1;
q.push(u);
}
}
}
int connectedcomponents(int n) {
int ans = 0;
for (int i = 1; i < n + 1; i++) {
if (!visited[i]) {
ans++;
dfs(i);
}
}
return ans;
}
};
template <typename T>
T findpower(T n, T p) {
T x = 0;
while (n) {
n /= p;
x += n;
}
return x;
}
void primeFactors(int n) {
while (n % 2 == 0) {
cout << 2 << " ";
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cout << i << " ";
n = n / i;
}
}
if (n > 2) cout << n << " ";
}
int main() {
int erer;
erer = 1;
cin >> erer;
while (erer--) {
int l, r, d;
cin >> l >> r >> d;
int temp;
temp = d;
if (temp == 0 || (temp >= l)) {
if (r % d == 0) {
temp = r + d;
} else
temp = ((r / d) + 1) * d;
}
cout << temp << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
struct edge {
int from, to;
double value;
edge(int f, int t, double v) { from = f, to = t, value = v; }
};
int n, m;
vector<edge> s;
bool cmp(edge x, edge y) { return x.value < y.value; }
bool cmp1(int x, int y) { return x > y; }
long long ans = 0;
int main() {
int T;
cin >> T;
while (T--) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
if (d < l) {
ans = d;
} else {
long long k = ceil((double)r / (double)d);
ans = (k)*d;
if (ans == r) {
ans += d;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int visit[5005], ans[5005];
int a[5005], b[5005];
int dap[5005][5005];
int main() {
int l, r, a;
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &l, &r, &a);
int tx = l / a, ty = r / a;
for (int i = 1;; i++) {
if (i * a < l || i * a > r) {
printf("%d\n", i * a);
break;
}
if (i >= tx) i = ty;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, i;
cin >> t;
while (t--) {
cin >> a >> b >> c;
if (c < a)
cout << c << endl;
else {
i = (b / c) + 1;
cout << i * c << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
cin >> t;
while (t--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l > d)
cout << d;
else if (l <= d) {
cout << ((r / d) + 1) * d;
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, i, l[500], r[500], d[500], j;
cin >> q;
for (i = 0; i < q; i++) {
cin >> l[i] >> r[i] >> d[i];
if (d[i] < l[i] || d[i] > r[i]) {
cout << d[i] << endl;
} else {
j = ((r[i] / d[i]) + 1) * d[i];
cout << j << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename T, typename... R>
void debug_out(const T &f, const R &...r) {
cerr << f << " ";
debug_out(r...);
}
inline long long read() {
long long x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x = f ? -x : x;
}
inline void write(long long x) {
if (x == 0) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
static char s[23];
int l = 0;
while (x != 0) s[l++] = x % 10 + 48, x /= 10;
while (l) putchar(s[--l]);
}
int lowbit(int x) { return x & (-x); }
template <class T>
T big(const T &a1, const T &a2) {
return a1 > a2 ? a1 : a2;
}
template <typename T, typename... R>
T big(const T &f, const R &...r) {
return big(f, big(r...));
}
template <class T>
T sml(const T &a1, const T &a2) {
return a1 < a2 ? a1 : a2;
}
template <typename T, typename... R>
T sml(const T &f, const R &...r) {
return sml(f, sml(r...));
}
template <class T, class U>
inline void checkMin(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void checkMax(T &x, U y) {
if (y > x) x = y;
}
const int M = 212345;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
void init() {
int _ = read();
while (_--) {
long long l = read();
long long r = read();
long long x = read();
long long now;
if (x > r) {
now = x;
} else if (x < l) {
now = x;
} else {
now = (r + x) / x * x;
}
write(now);
puts("");
}
}
void solve() {}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
while (n--) {
long long l, r, d;
cin >> l >> r >> d;
long long q = (l % d == 0 ? d : l % d), p = (d - r % d);
if (l - q > 0)
cout << d;
else
cout << r + p;
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
cout << (a > c ? c : (b / c + 1) * c) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long l, r, d, q;
int main() {
scanf("%lld", &q);
for (int i = 1; i <= q; i++) {
scanf("%lld%lld%lld", &l, &r, &d);
if (d < l)
printf("%lld\n", d);
else {
printf("%lld\n", (r / d + 1) * d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int q;
int main() {
int i, j;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
long long t1 = l / d, t2 = r / d;
if (t1 > 1) {
cout << d << endl;
} else if (t1 == 1 && l % d != 0) {
cout << d << endl;
} else {
cout << (t2 + 1) * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long get_pow(long long base, long long exp);
int main(int argc, char *argv[]) {
long long q, l, r, d, i;
scanf("%lld", &q);
while (q--) {
scanf("%lld %lld %lld", &l, &r, &d);
if (d < l) {
printf("%lld\n", d);
} else {
printf("%lld\n", (r + d) - (r + d) % d);
}
}
return 0;
}
long long get_pow(long long base, long long exp) {
long long ret = 1LL;
while (exp) {
if (exp % 2) {
ret *= base;
ret %= 1000000007LL;
}
base *= base;
base %= 1000000007LL;
exp /= 2LL;
}
return ret;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
scanf("%lld", &t);
while (t--) {
long long l, r, d;
scanf("%lld%lld%lld", &l, &r, &d);
if (d < l)
printf("%lld\n", d);
else if (d > r)
printf("%lld\n", d);
else
printf("%lld\n", (r / d + 1) * d);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void Solve() {
long long int l, r, d;
scanf("%lld %lld %lld", &l, &r, &d);
if (l <= d) {
if (r % d == 0)
r /= d;
else
r /= d;
r++;
d *= r;
printf("%lld\n", d);
} else
printf("%lld\n", d);
}
int main() {
long long int t;
scanf("%lld", &t);
while (t) {
t--;
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int l, r, d;
for (int i = 0; i < n; i++) {
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
continue;
}
cout << (r / d + 1) * d << endl;
}
}
|
#include <bits/stdc++.h>
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
int l, r, d, ans = 0;
scanf("%d %d %d", &l, &r, &d);
if (l > d)
ans = d;
else
ans = r + 1;
if (ans % d) ans += (d - ans % d);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
int Q;
cin >> Q;
while (Q--) {
int L, R, D;
cin >> L >> R >> D;
if (D < L)
cout << D << endl;
else {
int64_t u = R / D * D;
while (u <= R) u += D;
cout << u << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, l, r, d;
cin >> q;
while (q--) {
cin >> l >> r >> d;
if (d < l || d > r) {
cout << d << endl;
} else if (d == r) {
cout << 2 * d << endl;
} else if (d < r) {
cout << ((r / d) + 1) * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << "\n";
} else {
cout << r + d - r % d << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long int l, r, d, i, j;
scanf("%ld %ld %ld", &l, &r, &d);
if (d < l)
printf("%ld\n", d);
else {
i = r / d;
printf("%ld\n", (i + 1) * d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (l > r) swap(l, r);
long long temp = 1;
bool sign = true;
while (temp < l) {
if (temp % d == 0) {
cout << temp << endl;
sign = false;
break;
}
temp = temp * d;
}
if (sign) {
cout << ((r / d) + 1) * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q, l, r, d, x, y;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
} else {
y = r / d;
x = d * (y + 1);
cout << x << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, k;
cin >> q;
long long l, r, d, x;
for (k = 0; k < q; ++k) {
cin >> l >> r >> d;
if (d < l || d > r)
x = d;
else {
if (r % d == 0)
x = r + d;
else
x = r + (d - (r % d));
}
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 922337203685477;
const long long mininf = -922337203685477;
const long long nax = 0;
long long t, l, r, d;
void solve() {
cin >> l >> r >> d;
long long mini = (l + d - 1) / d;
long long maxi = r / d;
if (mini <= 1) {
cout << (maxi + 1) * d << '\n';
} else {
cout << d << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, x, n;
cin >> n;
while (n--) {
cin >> l >> r >> x;
if (x < l)
cout << x << endl;
else
cout << (r / x + 1) * x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
if (c < a || c > b) {
cout << c << endl;
} else {
cout << (b / c + 1) * c << endl;
}
}
}
|
#include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 500 - 1) / 500)],
dq[((100000 + 500 - 1) / 500)][500 + 1 + 500];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (500 + 1 + 500) * sizeof *qq);
for (i = (h + 1) * 500; i > h * 500; i--) {
t += bb[i];
qq[500 + t] = (qq[500 + t] + dp[i - 1]) % 998244353;
}
for (c = 1; c <= 500 + 500; c++) qq[c] = (qq[c] + qq[c - 1]) % 998244353;
}
int main() {
static int pp[1 + 100000], ii[1 + 100000];
int n, m, k, h, i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pp[i] = ii[a];
ii[a] = i;
}
dp[0] = 1;
for (j = 1; j <= n; j++) {
int p, x, t;
m = (j - 1) / 500;
ss[m] += 1 - bb[j];
bb[j] = 1;
if ((p = pp[j])) {
h = (p - 1) / 500;
ss[h] += -1 - bb[p];
bb[p] = -1;
if (p <= m * 500) update(h);
if ((p = pp[p])) {
h = (p - 1) / 500;
ss[h] += 0 - bb[p];
bb[p] = 0;
if (p <= m * 500) update(h);
}
}
x = 0;
t = 0;
for (i = j; i > m * 500; i--) {
t += bb[i];
if (t <= k) x = (x + dp[i - 1]) % 998244353;
}
for (h = m - 1; h >= 0; h--) {
if (k - t >= -500)
x = (x + dq[h][500 + (500 < k - t ? 500 : k - t)]) % 998244353;
t += ss[h];
}
dp[j] = x;
if (j % 500 == 0) update(m);
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
struct bucket {
long long size, minm;
vector<long long> off;
vector<long long> dps;
vector<long long> pre;
bucket(long long b) {
size = b;
off = vector<long long>(b);
pre = vector<long long>(b);
dps = vector<long long>(b);
minm = 0;
}
void updoff(long long p, long long l, long long r) {
assert(l >= 0 && l < size && r >= 0 && r < size && l <= r);
long long nmnm = INT_MAX;
for (long long j = l; j <= r; ++j) nmnm = min(nmnm, minm + off[j] + p);
for (long long j = 0; j < l; ++j) nmnm = min(nmnm, minm + off[j]);
for (long long j = r + 1; j < size; ++j) nmnm = min(nmnm, minm + off[j]);
for (long long j = 0; j < l; ++j) off[j] = off[j] + minm - nmnm;
for (long long j = l; j <= r; ++j) off[j] = off[j] + minm + p - nmnm;
for (long long j = r + 1; j < size; ++j) off[j] = off[j] + minm - nmnm;
minm = nmnm;
pre = vector<long long>(size);
for (long long j = 0; j < size; ++j)
pre[off[j]] = (pre[off[j]] + dps[j]) % mod;
for (long long j = 1; j < size; ++j) pre[j] = (pre[j] + pre[j - 1]) % mod;
}
void upddp(long long idx, long long newdp) {
dps[idx] = newdp;
pre = vector<long long>(size);
for (long long j = 0; j < size; ++j)
pre[off[j]] = (pre[off[j]] + dps[j]) % mod;
for (long long j = 1; j < size; ++j) pre[j] = (pre[j] + pre[j - 1]) % mod;
}
};
void update_offset(vector<bucket> &ds, long long n, long long l, long long r,
long long p, long long b) {
assert(l <= r);
long long j = r / b;
ds[j].updoff(p, max(l, j * b) - j * b, r - j * b);
j--;
while (j * b > l) {
ds[j].minm += p;
j--;
}
if (l >= j * b && l < (j + 1) * b) ds[j].updoff(p, l - j * b, b - 1);
}
long long query(vector<bucket> &ds, long long n, long long r, long long b,
long long k) {
long long j = r / b;
long long ret = 0;
while (j >= 0) {
long long idx = k - ds[j].minm;
if (idx >= 0) ret = (ret + ds[j].pre[min(idx, b - 1)]) % mod;
j--;
}
return ret;
}
int32_t main() {
long long n, k;
cin >> n >> k;
long long b = sqrt(n);
long long m = ceil((double)n / b);
vector<long long> a(n);
for (auto &x : a) cin >> x;
vector<bucket> ds;
for (long long i = 0; i < m; ++i) {
bucket B = bucket(b);
ds.push_back(B);
}
vector<long long> lo(n + 1, -1);
vector<long long> llo(n + 1, -1);
vector<long long> dp(n);
dp[0] = 1;
lo[a[0]] = 0;
ds[0].updoff(1, 0, 0);
ds[0].upddp(0, 1);
if ((1 / b) < m) ds[1 / b].upddp(1 - (1 / b) * b, 1);
for (long long i = 1; i < n; ++i) {
if (lo[a[i]] != -1) update_offset(ds, n, llo[a[i]] + 1, lo[a[i]], -1, b);
update_offset(ds, n, lo[a[i]] + 1, i, 1, b);
dp[i] = query(ds, n, i, b, k);
long long j = (i + 1) / b;
if (j < m) ds[j].upddp((i + 1) - j * b, dp[i]);
llo[a[i]] = lo[a[i]];
lo[a[i]] = i;
}
cout << dp[n - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100002;
const int MOD = 998244353;
const int MAGIC = 200;
const int MAX_BLOCK = MAX_N / MAGIC + 7;
const int INF = 1e9;
int n, k, prv[MAX_N], pos[MAX_N], a[MAX_N];
int nBlock, L[MAX_BLOCK], R[MAX_BLOCK], blockID[MAX_N];
int v[MAX_N], offset[MAX_BLOCK], head[MAX_BLOCK], ps[MAX_BLOCK][MAX_N];
int f[MAX_N];
vector<pair<int, int> > all, comp[MAX_BLOCK];
void readInput() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
void init() {
for (int i = 1; i <= n; ++i) {
prv[i] = pos[a[i]];
pos[a[i]] = i;
}
}
void sqrtDecompostion() {
for (int i = 1; i <= n; ++i) {
if (i % MAGIC == 1) {
R[nBlock] = i - 1;
L[++nBlock] = i;
}
}
R[nBlock] = n;
for (int i = 1; i <= nBlock; ++i) {
for (int j = L[i]; j <= R[i]; ++j) blockID[j] = i;
}
}
void upd(int idx, int l, int r, int delta) {
for (int i = L[idx]; i <= R[idx]; ++i) {
v[i] += offset[idx];
if (l <= i && i <= r) v[i] += delta;
}
offset[idx] = 0;
all.clear();
comp[idx].clear();
for (int i = L[idx]; i <= R[idx]; ++i) all.push_back({v[i], f[i - 1]});
sort(all.begin(), all.end());
comp[idx].push_back({-INF, 0});
for (auto x : all) {
if (x.first != comp[idx].back().first)
comp[idx].push_back(x);
else
comp[idx].back().second = (comp[idx].back().second + x.second) % MOD;
}
for (int i = 1; i < comp[idx].size(); ++i)
ps[idx][i] = (comp[idx][i].second + ps[idx][i - 1]) % MOD;
for (int i = 0; i < comp[idx].size(); ++i) {
if (comp[idx][i].first <= k) head[idx] = i;
}
}
void upd(int l, int r, int delta) {
if (l > r) return;
if (blockID[l] == blockID[r]) return upd(blockID[l], l, r, delta);
for (int i = blockID[l] + 1; i < blockID[r]; ++i) {
offset[i] += delta;
if (delta == -1) {
while (head[i] + 1 < comp[i].size() &&
comp[i][head[i] + 1].first + offset[i] <= k)
++head[i];
} else {
while (head[i] > 0 && comp[i][head[i]].first + offset[i] > k) --head[i];
}
}
upd(l, R[blockID[l]], delta);
upd(L[blockID[r]], r, delta);
}
int get() {
int res = 0;
for (int i = 1; i <= nBlock; ++i) res = (res + ps[i][head[i]]) % MOD;
return res;
}
void solve() {
for (int i = 1; i <= nBlock; ++i) upd(L[i], R[i], 0);
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int x1 = prv[i];
int x2 = prv[x1];
upd(x1 + 1, i, 1);
upd(x2 + 1, x1, -1);
f[i] = get();
upd(L[blockID[i]], R[blockID[i]], 0);
}
cout << f[n];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
readInput();
init();
sqrtDecompostion();
solve();
}
|
#include <bits/stdc++.h>
int const MOD = 998244353;
void add(int& a, int b) {
assert(0 <= a and a < MOD);
assert(0 <= b and b < MOD);
a += b;
if (a >= MOD) a -= MOD;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, maxu;
std::cin >> n >> maxu;
std::vector<int> a(n);
for (int& x : a) std::cin >> x;
std::vector<int> dp(n + 1);
std::vector<int> b(n);
std::map<int, std::pair<int, int>> lastind;
int const BLOCKSIZE = 300;
int const nblock = (n - 1) / BLOCKSIZE + 1;
std::vector<int> boffset(nblock);
std::vector<std::vector<int>> bsum(nblock);
auto const updateb = [&](int n, int delta) {
int const blockn = n / BLOCKSIZE;
for (int i = blockn; i--;) boffset[i] += delta;
if (n % BLOCKSIZE != 0) {
for (int j = n % BLOCKSIZE; j; --j) {
b[n - j] += delta;
}
auto first = begin(b) + BLOCKSIZE * blockn;
auto last = begin(b) + std::min((int)b.size(), BLOCKSIZE * (blockn + 1));
int of1 = *std::min_element(first, last);
if (of1) {
std::transform(first, last, first, [of1](int x) { return x - of1; });
boffset[blockn] += of1;
}
auto& bsum_cur = bsum[blockn];
bsum_cur.assign(*std::max_element(first, last) + 1, 0);
std::for_each(first, last,
[&](int& x) { add(bsum_cur[x], dp[&x - &b[0]]); });
std::for_each(++begin(bsum_cur), end(bsum_cur),
[&](int& x) { add(x, (&x)[-1]); });
}
};
auto const getle = [&]() {
int64_t ans = 0;
for (int blocki = 0; blocki < nblock; ++blocki)
if (not bsum[blocki].empty()) {
int x = maxu - boffset[blocki];
if (x >= 0)
ans += bsum[blocki][std::min(x, (int)bsum[blocki].size() - 1)];
}
return int(ans % MOD);
};
auto const setdp = [&](int i, int val) {
int const blocki = i / BLOCKSIZE;
assert(b[i] == 0 ||
!(std::cerr << b[i] << ' ' << i << ' ' << boffset[blocki] << '\n'));
assert(boffset[blocki] == 0);
if (bsum[blocki].empty())
bsum[blocki].assign(1, val);
else
std::transform(begin(bsum[blocki]), end(bsum[blocki]),
begin(bsum[blocki]), [val](int x) {
add(x, val);
return x;
});
};
setdp(0, dp[0] = 1);
for (int i = 1; i <= n; ++i) {
auto [iter, success] = lastind.insert({a[i - 1], {i - 1, -1}});
if (!success) {
updateb(iter->second.first + 1, -2);
if (iter->second.second >= 0) {
updateb(iter->second.second + 1, 1);
} else {
}
iter->second = {i - 1, iter->second.first};
} else {
}
updateb(i, 1);
dp[i] = getle();
if (i < n) {
setdp(i, dp[i]);
}
}
std::cout << dp[n] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct bucket {
int sz, szq, ptr, lz;
pair<int, int> u[250 + 5];
pair<int, int> el[250 + 5];
} B[100005 / 250 + 5];
int n, k, tot;
int a[100005], dp[100005], lnk[100005];
int add(int x, int y) {
x += y;
if (x >= 998244353) x -= 998244353;
if (x < 0) x += 998244353;
return x;
}
void lzit(int l, int r, int sg) {
for (int i = l; i <= r; i++) {
pair<int, int>* u = B[i].u;
int& szq = B[i].szq;
int& ptr = B[i].ptr;
int& lz = B[i].lz;
lz += sg;
if (sg == 1) {
while (ptr && u[ptr].first + lz > k) {
tot = add(tot, -u[ptr--].second);
}
} else {
while (ptr < szq && u[ptr + 1].first + lz <= k) {
tot = add(tot, u[++ptr].second);
}
}
}
}
void pure(int buc, int l, int r, int sg) {
vector<pair<int, int> > a, b;
pair<int, int>* el = B[buc].el;
pair<int, int>* u = B[buc].u;
int& sz = B[buc].sz;
int& szq = B[buc].szq;
int& ptr = B[buc].ptr;
int& lz = B[buc].lz;
for (int i = 1; i <= sz; i++) {
if (el[i].second >= l && el[i].second <= r)
b.push_back(el[i]);
else
a.push_back(el[i]);
}
for (int i = 1; i <= ptr; i++) {
tot = add(tot, -u[i].second);
}
ptr = 0;
for (pair<int, int>& x : b) x.first += sg;
int ca = 0, cb = 0;
sz = szq = 0;
while (ca < ((int)a.size()) || cb < ((int)b.size())) {
if (cb == ((int)b.size()) ||
(ca != ((int)a.size()) && a[ca].first < b[cb].first)) {
el[++sz] = a[ca++];
} else {
el[++sz] = b[cb++];
}
}
for (int i = 1; i <= sz; i++) {
int sum = 0;
while (i + 1 <= sz && el[i].first == el[i + 1].first) {
sum = add(sum, dp[el[i++].second - 1]);
}
sum = add(sum, dp[el[i].second - 1]);
u[++szq] = {el[i].first, sum};
if (el[i].first + lz <= k) ptr = szq, tot = add(tot, sum);
}
}
void chng(int l, int r, int sg) {
int bl = (l + 250 - 1) / 250;
int br = (r + 250 - 1) / 250;
if (bl == br)
pure(bl, l, r, sg);
else {
pure(bl, l, bl * 250, sg);
pure(br, (br - 1) * 250 + 1, r, sg);
lzit(bl + 1, br - 1, sg);
}
}
int main(int argc, char* argv[]) {
for (int i = 1; i < 100005 / 250 + 5; i++) B[i].sz = B[i].ptr = B[i].lz;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
map<int, int> prv;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int pr = prv[a[i]];
if (pr) chng(lnk[pr] + 1, pr, -1);
chng(pr + 1, i, 1);
lnk[i] = pr;
prv[a[i]] = i;
B[(i + 250 - 1) / 250].el[++B[(i + 250 - 1) / 250].sz] = {0, i};
chng(i, i, 1);
dp[i] = tot;
}
printf("%d", dp[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[100007];
long long dp[100007];
int prv1[100007];
int prv2[100007];
class bucket {
public:
int st, en;
long long pref[300 + 2];
int val[300 + 2];
int mn = 0;
void recalc() {
int curr = val[0];
for (int i = st; i <= en; ++i) {
curr = (curr < val[i - st]) ? curr : val[i - st];
}
mn += curr;
for (int i = st; i <= en; ++i) {
val[i - st] -= curr;
}
for (int i = 0; i <= 300; ++i) {
pref[i] = 0;
}
for (int i = st; i <= en; ++i) {
pref[val[i - st]] = pref[val[i - st]] + ((i > 0) ? dp[i - 1] : 1);
if (pref[val[i - st]] >= 998244353) {
pref[val[i - st]] -= 998244353;
}
}
for (int i = 1; i <= 300; ++i) {
pref[i] += pref[i - 1];
if (pref[i] >= 998244353) {
pref[i] -= 998244353;
}
}
}
void update(int add) { mn += add; }
long long ask() {
if (mn > k) {
return 0;
}
int id = (k - mn);
if (id > 300) {
id = 300;
}
return pref[id];
}
};
bucket f[2 * 300];
int NUM_BUCKETS;
void input() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
prv1[a[i]] = prv2[a[i]] = -1;
}
NUM_BUCKETS = (n / 300) + ((n % 300) != 0);
for (int i = 0; i < NUM_BUCKETS; ++i) {
f[i].st = i * 300;
f[i].en = min(f[i].st + 300 - 1, n - 1);
}
}
void upd_int(int st, int en, int val) {
if (en < st) {
return;
}
if (en - st <= 300) {
for (int i = st; i <= en; ++i) {
int id = (i / 300);
f[id].val[i - f[id].st] += val;
}
f[(st / 300)].recalc();
for (int i = st + 1; i <= en; ++i) {
if ((i / 300) != ((i - 1) / 300)) {
f[(i / 300)].recalc();
}
}
return;
}
for (int i = st; i <= en; ++i) {
if ((i / 300) != (st / 300)) {
break;
}
int id = (i / 300);
f[id].val[i - f[id].st] += val;
}
f[(st / 300)].recalc();
for (int i = en; i >= st; --i) {
if ((i / 300) != (en / 300)) {
break;
}
int id = (i / 300);
f[id].val[i - f[id].st] += val;
}
f[(en / 300)].recalc();
for (int i = (st / 300) + 1; i < (en / 300); ++i) {
f[i].update(val);
}
}
void solve() {
for (int i = 0; i < n; ++i) {
upd_int(prv2[a[i]] + 1, prv1[a[i]], -1);
prv2[a[i]] = prv1[a[i]];
upd_int(prv1[a[i]] + 1, i, 1);
prv1[a[i]] = i;
for (int j = 0; j <= (i / 300); ++j) {
dp[i] += f[j].ask();
dp[i] = (dp[i] < 998244353) ? dp[i] : dp[i] - 998244353;
}
}
printf("%I64d\n", dp[n - 1]);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
const int mod = 998244353;
int n, m, i, j, blk, bel[100005], a[100005], dp[100005], lst[100005],
cnt[100005], pos[100005];
int sum[455][100005], ans[455], tag[455];
void upd(int x, int y) {
int t = bel[x];
sum[t][cnt[x]] = (sum[t][cnt[x]] - dp[x] + mod) % mod;
if (cnt[x] + tag[t] <= m) ans[t] = (ans[t] - dp[x] + mod) % mod;
cnt[x] += y;
sum[t][cnt[x]] = (sum[t][cnt[x]] + dp[x]) % mod;
if (cnt[x] + tag[t] <= m) ans[t] = (ans[t] + dp[x]) % mod;
}
void update(int l, int r, int x) {
if (l > r) return;
int i;
if (bel[l] == bel[r]) {
for ((i) = (l); (i) <= (r); (i)++) upd(i, x);
return;
}
while (bel[l] == bel[l + 1]) {
upd(l, x);
l++;
}
while (bel[r] == bel[r - 1]) {
upd(r, x);
r--;
}
upd(l, x);
l++;
upd(r, x);
r--;
for ((i) = (bel[l]); (i) <= (bel[r]); (i)++) {
if (x > 0 && m - tag[i] >= 0) {
ans[i] = (ans[i] - sum[i][m - tag[i]] + mod) % mod;
}
tag[i] += x;
if (x < 0 && m - tag[i] >= 0) {
ans[i] = (ans[i] + sum[i][m - tag[i]]) % mod;
}
}
}
int main() {
read(n);
read(m);
blk = sqrt(n);
bel[0] = 1;
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
read(a[i]);
bel[i] = i / blk + 1;
}
dp[0] = sum[1][0] = ans[1] = 1;
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
lst[i] = pos[a[i]];
update(lst[lst[i]], lst[i] - 1, -1);
update(lst[i], i - 1, 1);
for (j = i - 1; j >= 0 && bel[j] == bel[i]; j--) {
if (cnt[j] + tag[bel[j]] <= m) {
dp[i] = (dp[i] + dp[j]) % mod;
}
}
for (j = bel[i] - 1; j; j--) {
dp[i] = (dp[i] + ans[j]) % mod;
}
sum[bel[i]][0] = (sum[bel[i]][0] + dp[i]) % mod;
if (tag[bel[i]] <= m) {
ans[bel[i]] = (ans[bel[i]] + dp[i]) % mod;
}
pos[a[i]] = i;
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkMax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
void chkMin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void inline read(T &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();
x *= f;
}
template <typename T>
void print(T x) {
if (x < 0) {
putchar('-');
print(-x);
return;
}
if (x >= 10) print(x / 10);
putchar((x % 10) + '0');
}
const int N = 1e5 + 5, S = 325, P = 998244353;
int n, k, a[N], tag[N], c[N], L[N], R[N], pos[N], t, pre[N], cnt[N];
int f[N];
vector<pair<int, int> > b[N];
void inline add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
void inline rebuild(int p) {
b[p].clear();
for (int i = L[p]; i <= R[p]; i++) {
c[i] += tag[p];
b[p].push_back(make_pair(c[i], f[i]));
}
tag[p] = 0;
sort(b[p].begin(), b[p].end());
for (int i = 1; i < b[p].size(); i++) add(b[p][i].second, b[p][i - 1].second);
}
void inline add(int l, int r, int k) {
if (l == 0) l++;
int p = pos[l], q = pos[r];
if (p == q) {
for (int i = l; i <= r; i++) {
c[i] += k;
}
rebuild(p);
} else {
for (int i = l; i <= R[p]; i++) c[i] += k;
rebuild(p);
for (int i = p + 1; i < q; i++) {
tag[i] += k;
}
for (int i = L[q]; i <= r; i++) c[i] += k;
rebuild(q);
}
}
int inline query(int l, int r) {
int p = pos[l], q = pos[r], res = 0;
if (p == q) {
for (int i = l; i <= r; i++)
if (c[i] + tag[p] <= k) add(res, f[i]);
} else {
for (int i = l; i <= R[p]; i++)
if (c[i] + tag[p] <= k) add(res, f[i]);
for (int i = L[q]; i <= r; i++)
if (c[i] + tag[p] <= k) add(res, f[i]);
for (int i = p + 1; i < q; i++) {
int t =
upper_bound(b[i].begin(), b[i].end(), make_pair(k - tag[i] + 1, 0)) -
b[i].begin() - 1;
if (t >= 0) add(res, b[i][t].second);
}
}
return res;
}
int main() {
read(n), read(k);
++n;
t = sqrt(n);
for (int i = 1; i <= n; i++) {
pos[i] = (i - 1) / t + 1;
if (!L[pos[i]]) L[pos[i]] = i;
R[pos[i]] = i;
}
for (int i = 2; i <= n; i++) {
read(a[i]);
pre[i] = cnt[a[i]];
cnt[a[i]] = i;
}
f[1] = 1;
for (int i = 2; i <= n; i++) {
if (pre[i]) {
int t = pre[i];
add(pre[t], t - 1, -1);
}
add(pre[i], i - 1, 1);
f[i] = query(1, i - 1);
if (R[pos[i]] == i) rebuild(pos[i]);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 183 + 3;
int bel[N], f[N], g[N], tag[M], s[M][183 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update(int p, int v) {
int *s = ::s[bel[p]];
for (int i = 183; i <= 183 << 1; ++i)
(s[i] += v) >= 998244353 && (s[i] -= 998244353);
}
void Modify(int p, int v) {
int bel = ::bel[p], *s = ::s[bel];
tag[bel] += v;
for (int i = bel * 183 + 1; i <= p; ++i) {
if (v == 1)
(s[g[i] + 183] += 998244353 - f[i - 1]) >= 998244353 &&
(s[g[i] + 183] -= 998244353);
else
(s[g[i] - 1 + 183] += f[i - 1]) >= 998244353 &&
(s[g[i] - 1 + 183] -= 998244353),
(s[g[i] - 2 + 183] += f[i - 1]) >= 998244353 &&
(s[g[i] - 2 + 183] -= 998244353);
g[i] += v;
}
}
int Query(int p, int K) {
int bel = ::bel[p], sum = tag[bel];
long long res = 0;
for (int i = bel * 183 + 1; i <= p; ++i) g[i] <= K && (res += f[i - 1]);
while (bel--) {
assert(sum >= 0);
if (std::abs(sum - K) <= 183)
res += s[bel][K - sum + 183];
else if (sum < K)
res += s[bel][183 << 1];
sum += tag[bel];
}
return res % 998244353;
}
int main() {
static int las[N], pre[N];
int n = read(), K = read();
for (int i = 1; i <= n; ++i) bel[i] = (i - 1) / 183;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int a = read();
las[i] = pre[a], pre[a] = i;
Update(i, f[i - 1]), Modify(i, 1);
if (las[i]) {
Modify(las[i], -2);
if (las[las[i]]) Modify(las[las[i]], 1);
}
f[i] = Query(i, K);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 140 + 3;
int bel[N], f[N], g[N], tag[M], s[M][140 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update(int p, int v) {
int *s = ::s[bel[p]];
for (int i = 140; i <= 140 << 1; ++i)
(s[i] += v) >= 998244353 && (s[i] -= 998244353);
}
void Modify(int p, int v) {
int bel = ::bel[p], *s = ::s[bel];
tag[bel] += v;
for (int i = bel * 140 + 1; i <= p; ++i) {
if (v == 1)
(s[g[i] + 140] += 998244353 - f[i - 1]) >= 998244353 &&
(s[g[i] + 140] -= 998244353);
else
(s[g[i] - 1 + 140] += f[i - 1]) >= 998244353 &&
(s[g[i] - 1 + 140] -= 998244353),
(s[g[i] - 2 + 140] += f[i - 1]) >= 998244353 &&
(s[g[i] - 2 + 140] -= 998244353);
g[i] += v;
}
}
int Query(int p, int K) {
int bel = ::bel[p], sum = tag[bel];
long long res = 0;
for (int i = bel * 140 + 1; i <= p; ++i) g[i] <= K && (res += f[i - 1]);
while (bel--) {
if (std::abs(sum - K) <= 140)
res += s[bel][K - sum + 140];
else if (sum < K)
res += s[bel][140 << 1];
sum += tag[bel];
}
return res % 998244353;
}
int main() {
static int las[N], pre[N];
int n = read(), K = read();
for (int i = 1; i <= n; ++i) bel[i] = (i - 1) / 140;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int a = read();
las[i] = pre[a], pre[a] = i;
Update(i, f[i - 1]), Modify(i, 1);
if (las[i]) {
Modify(las[i], -2);
if (las[las[i]]) Modify(las[las[i]], 1);
}
f[i] = Query(i, K);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 998244353;
int n, m, B;
int a[N], pos[N], bel[N], lst[N], f[N], cnt[N], delta[440], ans[440],
sum[440][N];
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x;
}
void update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + mod) % mod;
if (cnt[u] + delta[t] <= m) ans[t] = (ans[t] - f[u] + mod) % mod;
cnt[u] += v;
sum[t][cnt[u]] = (sum[t][cnt[u]] + f[u]) % mod;
if (cnt[u] + delta[t] <= m) ans[t] = (ans[t] + f[u]) % mod;
}
void add(int u, int v, int w) {
if (u > v) return;
int p = bel[u], q = bel[v];
if (p + 1 >= q) {
for (int i = u; i <= v; i++) update(i, w);
return;
}
for (int i = u; bel[i] == p; i++) update(i, w);
for (int i = v; bel[i] == q; i--) update(i, w);
for (int i = p + 1; i < q; i++) {
if (w > 0)
if (m - delta[i] >= 0)
ans[i] = (ans[i] - sum[i][m - delta[i]] + mod) % mod;
delta[i] += w;
if (w < 0)
if (m - delta[i] >= 0) ans[i] = (ans[i] + sum[i][m - delta[i]]) % mod;
}
}
int main() {
n = read();
m = read();
B = sqrt(n);
bel[0] = 1;
for (int i = 1; i <= n; i++) a[i] = read(), bel[i] = i / B + 1;
f[0] = sum[1][0] = ans[1] = 1;
for (int i = 1; i <= n; i++) {
lst[i] = pos[a[i]];
add(lst[lst[i]], lst[i] - 1, -1);
add(lst[i], i - 1, 1);
for (int j = i - 1; j >= 0 && bel[i] == bel[j]; j--)
if (cnt[j] + delta[bel[i]] <= m) f[i] = (f[i] + f[j]) % mod;
for (int j = bel[i] - 1; j; j--) f[i] = (f[i] + ans[j]) % mod;
sum[bel[i]][0] = (sum[bel[i]][0] + f[i]) % mod;
if (delta[bel[i]] <= m) ans[bel[i]] = (ans[bel[i]] + f[i]) % mod;
pos[a[i]] = i;
}
printf("%d", f[n]);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.