text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int main() {
int n;
double x, y;
double x1, y1;
double x2, y2;
double x0, y0;
double nei, wai;
double tem;
scanf("%d%lf%lf", &n, &x, &y);
scanf("%lf%lf", &x2, &y2);
x2 -= x;
y2 -= y;
x0 = x2;
y0 = y2;
nei = wai = x2 * x2 + y2 * y2;
for (int i = 1; i < n; i++) {
scanf("%lf%lf", &x1, &y1);
x1 -= x;
y1 -= y;
tem = x1 * x1 + y1 * y1;
if (tem > wai) wai = tem;
if (tem < nei) nei = tem;
if (x1 * (x2 - x1) + y1 * (y2 - y1) < 1e-7)
if (x2 * (x1 - x2) + y2 * (y1 - y2) < 1e-7) {
tem = (x1 * y2 - x2 * y1) * (x1 * y2 - x2 * y1) /
((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
if (tem < nei) nei = tem;
}
x2 = x1;
y2 = y1;
}
if (x1 * (x0 - x1) + y1 * (y0 - y1) < 1e-7)
if (x0 * (x1 - x0) + y0 * (y1 - y0) < 1e-7) {
tem = (x1 * y0 - x0 * y1) * (x1 * y0 - x0 * y1) /
((x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1));
if (tem < nei) nei = tem;
}
printf("%.10lf\n", 3.1415926535897 * (wai - nei));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
long double x[100010], y[100010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
long double x0, y0, d, maxx = -1e16, minn = 1e16, k, a, b, c, a1, b1, c1;
cin >> n >> x0 >> y0;
for (int i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
d = sqrt((x[i] - x0) * (x[i] - x0) + (y[i] - y0) * (y[i] - y0));
maxx = max(maxx, d);
minn = min(minn, d);
}
for (int i = 1; i <= n; ++i) {
int j = i + 1;
if (j > n) j = 1;
a = a1 =
sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
b = b1 = sqrt((x[i] - x0) * (x[i] - x0) + (y[i] - y0) * (y[i] - y0));
c = c1 = sqrt((x[j] - x0) * (x[j] - x0) + (y[j] - y0) * (y[j] - y0));
if (a1 > c1) swap(a1, c1);
if (b1 > c1) swap(b1, c1);
if (a1 * a1 + b1 * b1 > c1 * c1 || a == c1) {
if (abs(x[i] - x[j]) < 1e-9)
minn = min(minn, abs(x[i] - x0));
else {
k = (y[i] - y[j]) / (x[i] - x[j]);
minn = min(minn, abs(k * x0 - y0 + y[i] - k * x[i]) / sqrt(k * k + 1));
}
}
}
cout << setiosflags(ios::fixed) << setprecision(18)
<< pi * maxx * maxx - pi * minn * minn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
struct point_i {
int x, y;
point_i() {}
point_i(int _x, int _y) : x(_x), y(_y) {}
bool operator<(point_i other) const {
if (x != other.x) return x < other.x;
return y < other.y;
}
bool operator==(point_i other) const {
return (x == other.x && y == other.y);
}
};
struct point {
long double x, y;
point() {}
point(long double _x, long double _y) : x(_x), y(_y) {}
bool operator<(point other) const {
if (fabs(x - other.x) > EPS) return x < other.x;
return y < other.y;
}
bool operator==(point other) const {
return (fabs(x - other.x) < EPS && fabs(y - other.y) < EPS);
}
};
long double dist2(point p1, point p2) {
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
long double dist(point p1, point p2) { return sqrt(dist2(p1, p2)); }
int dist2(point_i p1, point_i p2) {
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
long double dist(point_i p1, point_i p2) { return sqrt(dist2(p1, p2)); }
point rotate(point p, long double theta) {
return point(p.x * cos(theta) - p.y * sin(theta),
p.x * sin(theta) + p.y * cos(theta));
}
struct line {
long double a, b, c;
};
void pointsToLine(point p1, point p2, line& l) {
if (fabs(p1.x - p2.x) < EPS) {
l.a = 1.0, l.b = 0.0, l.c = -p1.x;
} else {
l.a = -(long double)(p1.y - p2.y) / (p1.x - p2.x);
l.b = 1.0;
l.c = -(long double)(l.a * p1.x) - p1.y;
}
}
bool areParallel(line l1, line l2) {
return (fabs(l1.a - l2.a) < EPS && fabs(l1.b - l2.b) < EPS);
}
bool areSame(line l1, line l2) {
return (areParallel(l1, l2) && fabs(l1.c - l2.c) < EPS);
}
bool areIntersect(line l1, line l2, point& p) {
if (areParallel(l1, l2)) return false;
p.x = (l1.c * l2.b - l2.c * l1.b) / (l2.a * l1.b - l1.a * l2.b);
if (fabs(l1.b) > EPS)
p.y = -(l1.a * p.x + l1.c);
else
p.y = -(l2.a * p.x + l2.c);
return true;
}
struct vec {
long double x, y;
vec(long double _x, long double _y) : x(_x), y(_y) {}
};
vec toVec(point p1, point p2) { return vec(p2.x - p1.x, p2.y - p1.y); }
vec scale(vec v, long double s) { return vec(s * v.x, s * v.y); }
point translate(point p, vec v) { return point(p.x + v.x, p.y + v.y); }
long double dot(vec v1, vec v2) { return (v1.x * v2.x + v1.y * v2.y); }
long double norm2(vec v) { return dot(v, v); }
long double distToLine(point p, point a, point b, point& c) {
vec ap = toVec(a, p);
vec ab = toVec(a, b);
long double u = dot(ap, ab) / norm2(ab);
c = translate(a, scale(ab, u));
return dist(p, c);
}
long double distToSegment(point p, point a, point b, point& c) {
vec ap = toVec(a, p);
vec ab = toVec(a, b);
long double u = dot(ap, ab) / norm2(ab);
if (u < 0.0) {
c = point(a.x, a.y);
return dist(p, a);
} else if (u > 1.0) {
c = point(b.x, b.y);
return dist(p, b);
}
return distToLine(p, a, b, c);
}
const int MAX = 100009;
const long double oo = 1e12;
int n;
point arr[MAX];
point P;
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> n >> a >> b;
P = point(a, b);
for (int i = 0; i < n; i++) cin >> arr[i].x >> arr[i].y;
long double Min = oo, Max = 0.0;
for (int i = 0; i < n; i++) Max = max(Max, dist(P, arr[i]));
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
point r;
Min = min(Min, distToSegment(P, arr[i], arr[j], r));
}
cout << fixed << setprecision(15) << (Max * Max - Min * Min) * PI << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = acos(-1.0);
double max(double a, double b) { return a > b ? a : b; }
double min(double a, double b) { return a > b ? b : a; }
typedef struct {
double x, y;
} hehe;
int main() {
hehe p[100002], P;
int n;
double maxx = -1e10, minn = 1e10;
scanf("%d %lf %lf", &n, &P.x, &P.y);
for (int i = 0; i < n; i++) scanf("%lf %lf", &p[i].x, &p[i].y);
for (int i = 0; i < n; i++) {
double a = p[i].x - P.x, b = p[i].y - P.y;
double c = p[(i + 1) % n].x - P.x, d = p[(i + 1) % n].y - P.y;
double e = p[i].x - p[(i + 1) % n].x, f = p[i].y - p[(i + 1) % n].y;
double len1 = sqrt(a * a + b * b), len2 = sqrt(c * c + d * d),
len3 = sqrt(e * e + f * f);
maxx = max(maxx, max(len1, len2));
if (len1 * len1 >= len2 * len2 + len3 * len3)
minn = min(minn, len2);
else if (len2 * len2 >= len1 * len1 + len3 * len3)
minn = min(minn, len1);
else {
double C = (len1 + len2 + len3) / 2;
double S = (C - len1) * (C - len2) * (C - len3) * C;
S = sqrt(S);
minn = min(minn, S * 2 / len3);
}
}
double ans = maxx * maxx - minn * minn;
ans *= pi;
printf("%.18lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double dist(pair<long double, long double> a,
pair<long double, long double> b) {
return sqrtl((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
long double per(pair<long double, long double> a,
pair<long double, long double> b,
pair<long double, long double> c) {
long double A = (a.second - b.second);
long double B = -(a.first - b.first);
long double C = -(A * a.first + B * a.second);
long double t = (A * c.first + B * c.second + C) / sqrtl(A * A + B * B);
long double e = -(t / sqrtl(A * A + B * B)) * A + c.first;
if ((e >= a.first && e <= b.first) || (e <= a.first && e >= b.first)) {
return abs(t);
} else
return -1;
}
int main() {
long long int n;
long double x1, y1;
cin >> n >> x1 >> y1;
vector<pair<long double, long double>> ar;
long double a, b;
for (int x = 0; x < n; x++) {
cin >> a >> b;
ar.push_back({a, b});
}
long double ma = 0;
long double mi = 1000000000000000000;
for (int x = 0; x < n; x++) {
long double d = dist(ar[x], {x1, y1});
ma = max(d, ma);
mi = min(d, mi);
}
for (int x = 1; x < n; x++) {
long double y = per(ar[x - 1], ar[x], {x1, y1});
if (y > 0) {
ma = max(y, ma);
mi = min(y, mi);
}
}
long double ye = per(ar[n - 1], ar[0], {x1, y1});
if (ye > 0) {
ma = max(ye, ma);
mi = min(ye, mi);
}
long double g = 3.141592653589793 * (ma * ma - mi * mi);
cout << fixed;
cout << setprecision(15) << g;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t = 1;
long double dis(pair<long long, long long> x, pair<long long, long long> y) {
return (x.first - y.first) * (x.first - y.first) +
(x.second - y.second) * (x.second - y.second);
}
bool check(pair<long long, long long> x, pair<long long, long long> y,
pair<long long, long long> z) {
if (x.first == y.first) {
if ((x.second - z.second) * (y.second - z.second) <= 0)
return true;
else
return false;
}
if (x.second == y.second) {
if ((x.first - z.first) * (y.first - z.first) <= 0)
return true;
else
return false;
}
long double m = (x.second - y.second) / (x.first - y.first + 0.0);
long double m1 = -1 / (m);
if ((m1 * (x.first - z.first) - x.second + z.second) *
(m1 * (y.first - z.first) - y.second + z.second) <=
0)
return true;
else
return false;
}
long double shorestdis(pair<long long, long long> x,
pair<long long, long long> y,
pair<long long, long long> z) {
if (check(x, y, z) == false) {
return min(dis(x, z), dis(y, z));
}
if (x.first == y.first) {
return (z.first - x.first) * (z.first - x.first);
} else {
long double m = (x.second - y.second) / (x.first - y.first + 0.0);
long double d1 = m * z.first - z.second - m * x.first + x.second;
d1 = d1 * d1;
long double d2 = m * m + 1;
return d1 / (d2 + 0.0);
}
}
void solve() {
long long n, x, y;
pair<long long, long long> z;
vector<pair<long long, long long> > vv;
cin >> n >> z.first >> z.second;
for (long long i = 1; i < n + 1; i += 1) {
cin >> x >> y;
vv.push_back(make_pair(x, y));
}
long double r = 1e18, R = 0;
for (long long i = 0; i < n; i += 1) {
pair<long long, long long> x, y;
x = vv[i];
y = vv[(i + 1) % n];
r = min(r, shorestdis(x, y, z));
R = max(R, dis(x, z));
}
cout << setprecision(20) << 3.14159265358979323846 * (R - r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double INF = 1e18;
const int N = 1e5 + 1;
long double PI = 2 * acos(0);
long double EPS = 1e-7;
complex<long double> v[N];
long double dot(complex<long double> u, complex<long double> v) {
return u.real() * v.real() + u.imag() * v.imag();
}
void get_line(complex<long double> p1, complex<long double> p2, long double &a,
long double &b, long double &c) {
a = p2.imag() - p1.imag();
b = p1.real() - p2.real();
c = p1.imag() * p2.real() - p2.imag() * p1.real();
}
complex<long double> intersect(long double a, long double b, long double c,
long double e, long double f, long double g) {
return complex<long double>(-(b * g - c * f) / (b * e - a * f),
-(a * g - c * e) / (a * f - b * e));
}
bool is_inside(complex<long double> p, complex<long double> l1,
complex<long double> l2) {
long double a, b, c, e, f, g, m;
m = (l2.imag() - l1.imag()) / (l2.real() - l1.real());
m = -1 / m;
get_line(l1, l2, a, b, c);
get_line(p,
p + (l2.imag() == l1.imag()
? complex<long double>(0, 1)
: (l2.real() == l1.real() ? complex<long double>(1, 0)
: complex<long double>(1, m))),
e, f, g);
complex<long double> p2 = intersect(a, b, c, e, f, g);
long double d, d1, d2;
d = sqrt(dot(l2 - l1, l2 - l1));
d1 = sqrt(dot(p2 - l1, p2 - l1));
d2 = sqrt(dot(p2 - l2, p2 - l2));
return abs(d1 + d2 - d) < EPS;
}
long double dist(long double x, long double y, complex<long double> l1,
complex<long double> l2) {
long double a, b, c;
get_line(l1, l2, a, b, c);
return (a * x + b * y + c) * (a * x + b * y + c) / (a * a + b * b);
}
int main() {
ios::sync_with_stdio(0);
int n;
long double px, py;
while (cin >> n >> px >> py) {
complex<long double> p = complex<long double>(px, py);
long double r, rr;
r = INF;
rr = 0;
for (int i = 0; i < n; i++) {
long double x, y;
cin >> x >> y;
v[i] = complex<long double>(x, y);
long double d =
(x * x - 2 * x * px + px * px + py * py - 2 * y * py + y * y);
if (d < r) r = d;
if (d > rr) rr = d;
}
v[n] = v[0];
for (int i = 0; i < n; i++) {
long double d = dist(px, py, v[i], v[i + 1]);
if (d < r && is_inside(p, v[i], v[i + 1])) r = d;
}
cout << setprecision(13) << fixed << PI * (rr - r) << "\n\n";
}
}
|
#include <bits/stdc++.h>
const long double pi = acos(-1.0);
const long double eps = 1e-6;
using namespace std;
struct pt {
long double x, y;
pt() : x(0), y(0) {}
pt(long double x, long double y) : x(x), y(y) {}
void scan() { cin >> x >> y; }
void print() const { cout << x << " " << y << endl; }
pt operator+(const pt &p) const { return pt(x + p.x, y + p.y); }
pt operator-(const pt &p) const { return pt(x - p.x, y - p.y); }
pt operator*(long double k) const { return pt(x * k, y * k); }
pt operator/(long double k) const { return pt(x / k, y / k); }
};
long double sqr(long double a) { return a * a; }
long double triangle_are_2(pt r, pt pos, pt l) {
return (pos.x - r.x) * (l.y - r.y) - (pos.y - r.y) * (l.x - r.x);
}
long double skal(pt a, pt b) { return a.x * b.x + a.y * b.y; }
bool tupoy(pt a, pt b, pt c) {
return (skal(a - c, b - c) * skal(b - a, c - a)) <= 0;
}
struct seg {
pt left, right;
};
long double distPt(pt a, pt b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y)); }
long double get_dist(seg s, pt p) {
if (s.left.x == s.right.x && s.left.y == s.right.y) return distPt(p, s.left);
long double res = 0;
if (!tupoy(s.left, p, s.right))
res = abs(triangle_are_2(s.left, p, s.right)) / distPt(s.left, s.right);
else
res = min(distPt(p, s.left), distPt(p, s.right));
return res;
}
int n;
pt o;
void solve() {
cin >> n;
o.scan();
vector<pt> a(n);
for (int i = 0; i < n; i++) a[i].scan();
long double mx = 0, mn = 1e18;
for (int i = 0; i < n; i++) mx = max(mx, distPt(o, a[i]));
for (int i = 0; i < n; i++) {
seg s = {a[i], a[(i + 1) % n]};
mn = min(mn, get_dist(s, o));
}
cout << pi * mx * mx - pi * mn * mn << endl;
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(23);
int step;
step = 1;
for (int i = 1; i <= step; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 50;
int n, m, mod, a[maxn], len, F[maxn << 1];
int sz, bnum, cnt[maxn], belong[maxn], ans[maxn];
vector<int> v;
struct Tree {
int le, ri;
int shift, S1, S2;
} tree[maxn << 2];
void move(int& S1, int& S2, int k) {
int newS1 = (S1 * F[len + k - 1] + S2 * F[len + k]) % mod;
int newS2 = (S1 * F[len + k] + S2 * F[len + k + 1]) % mod;
S1 = newS1;
S2 = newS2;
}
void pushup(int id) {
tree[id].S1 = (tree[id << 1].S1 + tree[id << 1 | 1].S1) % mod;
tree[id].S2 = (tree[id << 1].S2 + tree[id << 1 | 1].S2) % mod;
}
void pushdown(int id) {
if (tree[id].shift) {
tree[id << 1].shift += tree[id].shift;
move(tree[id << 1].S1, tree[id << 1].S2, tree[id].shift);
tree[id << 1 | 1].shift += tree[id].shift;
move(tree[id << 1 | 1].S1, tree[id << 1 | 1].S2, tree[id].shift);
tree[id].shift = 0;
}
}
void build(int id, int le, int ri) {
tree[id].le = le;
tree[id].ri = ri;
tree[id].shift = tree[id].S1 = tree[id].S2 = 0;
if (le == ri) return;
int mid = (le + ri) >> 1;
build(id << 1, le, mid);
build(id << 1 | 1, mid + 1, ri);
}
void Insert(int id, int pos, int val) {
if (tree[id].le == tree[id].ri) {
tree[id].S1 = 1LL * val * F[len + tree[id].shift] % mod;
tree[id].S2 = 1LL * val * F[len + tree[id].shift + 1] % mod;
return;
}
pushdown(id);
int mid = (tree[id].le + tree[id].ri) >> 1;
if (pos <= mid) {
tree[id << 1 | 1].shift += 1;
move(tree[id << 1 | 1].S1, tree[id << 1 | 1].S2, 1);
Insert(id << 1, pos, val);
} else
Insert(id << 1 | 1, pos, val);
pushup(id);
}
void Remove(int id, int pos) {
if (tree[id].le == tree[id].ri) {
tree[id].S1 = tree[id].S2 = 0;
return;
}
pushdown(id);
int mid = (tree[id].le + tree[id].ri) >> 1;
if (pos <= mid) {
tree[id << 1 | 1].shift -= 1;
move(tree[id << 1 | 1].S1, tree[id << 1 | 1].S2, -1);
Remove(id << 1, pos);
} else
Remove(id << 1 | 1, pos);
pushup(id);
}
struct Node {
int id, le, ri;
} q[maxn];
bool cmp(Node x, Node y) {
return (belong[x.le] ^ belong[y.le])
? belong[x.le] < belong[y.le]
: ((belong[x.le] & 1) ? x.ri < y.ri : x.ri > y.ri);
}
void Add(int pos) {
pos = lower_bound(v.begin(), v.end(), a[pos]) - v.begin() + 1;
if (!cnt[pos]++) Insert(1, pos, v[pos - 1]);
}
void Del(int pos) {
pos = lower_bound(v.begin(), v.end(), a[pos]) - v.begin() + 1;
if (!--cnt[pos]) Remove(1, pos);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
v.push_back(a[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
len = v.size();
F[len] = 0;
F[len + 1] = 1;
for (int i = 2; i + len < (maxn << 1); ++i)
F[i + len] = (F[i + len - 1] + F[i + len - 2]) % mod;
for (int i = -1; i + len >= 0; --i)
F[i + len] = (F[i + len + 2] - F[i + len + 1] + mod) % mod;
build(1, 1, len);
sz = sqrt(n);
bnum = ceil(double(n / sz));
for (int i = 1; i <= bnum; ++i) {
for (int j = (i - 1) * sz + 1; j <= i * sz && j <= n; ++j) {
belong[j] = i;
}
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &q[i].le, &q[i].ri);
q[i].id = i;
}
sort(q, q + m, cmp);
int L = 1, R = 0;
for (int i = 0; i < m; ++i) {
while (L < q[i].le) Del(L++);
while (L > q[i].le) Add(--L);
while (R < q[i].ri) Add(++R);
while (R > q[i].ri) Del(R--);
ans[q[i].id] = tree[1].S2;
}
for (int i = 0; i < m; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3;
const int MAX_N = 30030;
int BLOCK = 200;
int MOD;
struct Matrix {
unsigned int a[N][N];
Matrix() { memset(a, 0, sizeof(a)); }
void make_identity() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
a[i][j] = (i == j);
}
}
}
void print() const {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cerr << a[i][j] << " ";
}
cerr << "\n";
}
cerr << "\n";
}
};
struct Query {
int l;
int r;
int id;
};
bool cmp_queries(const Query &a, const Query &b) {
return make_pair((a.l - 1) / BLOCK, a.r) < make_pair((b.l - 1) / BLOCK, b.r);
}
void multiply(const Matrix &a, const Matrix &b, Matrix &c) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
unsigned int value = 0ul;
for (int k = 0; k < N; k++) {
value += a.a[i][k] * b.a[k][j];
}
c.a[i][j] = value % MOD;
}
}
}
int a[MAX_N];
int real_a[MAX_N];
pair<int, int> buffer[MAX_N];
int compress_a(int n, int a[], int real_a[]) {
for (int i = 1; i <= n; i++) {
buffer[i] = make_pair(a[i], i);
}
sort(buffer + 1, buffer + n + 1);
int h = 1;
real_a[1] = buffer[1].first;
a[buffer[1].second] = 1;
for (int i = 2; i <= n; i++) {
if (real_a[h] < buffer[i].first) {
real_a[h + 1] = buffer[i].first;
h += 1;
}
a[buffer[i].second] = h;
}
return h;
}
Matrix tree[4 * MAX_N];
int counters[MAX_N];
int h;
void build_tree(int v, int l, int r) {
tree[v].make_identity();
if (l == r) {
return;
}
int x = (l + r) / 2;
build_tree(v + v, l, x);
build_tree(v + v + 1, x + 1, r);
}
void switch_on(int pos) {
int v = 1;
int l = 1;
int r = h;
while (l < r) {
int x = (l + r) / 2;
if (pos <= x) {
v = v + v;
r = x;
} else {
v = v + v + 1;
l = x + 1;
}
}
tree[v].a[0][0] = 0;
tree[v].a[0][1] = 1;
tree[v].a[0][2] = 0;
tree[v].a[1][0] = 1;
tree[v].a[1][1] = 1;
tree[v].a[1][2] = 0;
tree[v].a[2][0] = 0;
tree[v].a[2][1] = real_a[pos] % MOD;
tree[v].a[2][2] = 1;
v >>= 1;
while (v) {
tree[v].a[0][0] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[0][1] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[0][2] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[1][0] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[1][1] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[1][2] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[2][0] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[2][1] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[2][2] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][2]) %
MOD;
v >>= 1;
}
}
void switch_off(int pos) {
int v = 1;
int l = 1;
int r = h;
while (l < r) {
int x = (l + r) / 2;
if (pos <= x) {
v = v + v;
r = x;
} else {
v = v + v + 1;
l = x + 1;
}
}
tree[v].make_identity();
v >>= 1;
while (v) {
tree[v].a[0][0] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[0][1] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[0][2] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[1][0] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[1][1] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[1][2] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[2][0] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[2][1] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[2][2] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][2]) %
MOD;
v >>= 1;
}
}
void add_value(int x) {
if (counters[x] == 0) {
switch_on(x);
}
counters[x] += 1;
}
void delete_value(int x) {
if (counters[x] == 1) {
switch_off(x);
}
counters[x] -= 1;
}
int get_answer() { return (int)tree[1].a[2][1]; }
Query queries[MAX_N];
int answer[MAX_N];
void solve() {
int n;
scanf("%d%d", &n, &MOD);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
h = compress_a(n, a, real_a);
build_tree(1, 1, h);
int q;
scanf("%d", &q);
for (int it = 0; it < q; it++) {
int l, r;
scanf("%d%d", &l, &r);
queries[it].l = l;
queries[it].r = r;
queries[it].id = it;
}
sort(queries, queries + q, cmp_queries);
int l = queries[0].l;
int r = queries[0].r;
for (int i = l; i <= r; i++) {
add_value(a[i]);
}
answer[queries[0].id] = get_answer();
for (int i = 1; i < q; i++) {
while (r < queries[i].r) {
r += 1;
add_value(a[r]);
}
while (queries[i].l < l) {
l -= 1;
add_value(a[l]);
}
while (r > queries[i].r) {
delete_value(a[r]);
r -= 1;
}
while (queries[i].l > l) {
delete_value(a[l]);
l += 1;
}
answer[queries[i].id] = get_answer();
}
for (int i = 0; i < q; i++) {
printf("%d\n", answer[i]);
}
}
int main() {
int cases;
cases = 1;
for (int i = 0; i < cases; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) f = c == '-' ? 1 : 0;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return f ? -x : x;
}
const int N = 30005, B = 350;
int n, m, P, L, A[N], num[N], bl[N], ans[N], f[N], ct[N], sz[N * 4], s1[N * 4],
s2[N * 4];
struct na {
int l, r, id;
} e[N];
inline bool cmp(const na &a, const na &b) {
if (bl[a.l] != bl[b.l]) return a.l < b.l;
return (bl[a.l] & 1) ? (a.r < b.r) : (a.r > b.r);
}
inline void ins(int a) {
if (ct[a]++) return;
int o = 1, l = 1, r = L, mid;
while (l != r) {
if (a <= (mid = l + r >> 1))
o = (o << 1), r = mid;
else
o = (o << 1 | 1), l = mid + 1;
}
s1[o] = num[a], sz[o] = 1;
for (o >>= 1; o; o >>= 1) {
a = sz[(o << 1)], sz[o] = sz[(o << 1)] + sz[(o << 1 | 1)];
s1[o] =
(s1[(o << 1)] + f[a + 1] * s1[(o << 1 | 1)] + f[a] * s2[(o << 1 | 1)]) %
P;
s2[o] = (s2[(o << 1)] +
(a ? f[a] * s1[(o << 1 | 1)] + f[a - 1] * s2[(o << 1 | 1)]
: s2[(o << 1 | 1)])) %
P;
}
}
inline void del(int a) {
if (--ct[a]) return;
int o = 1, l = 1, r = L, mid;
while (l != r) {
if (a <= (mid = l + r >> 1))
o = (o << 1), r = mid;
else
o = (o << 1 | 1), l = mid + 1;
}
s1[o] = sz[o] = 0;
for (o >>= 1; o; o >>= 1) {
a = sz[(o << 1)], sz[o] = sz[(o << 1)] + sz[(o << 1 | 1)];
s1[o] =
(s1[(o << 1)] + f[a + 1] * s1[(o << 1 | 1)] + f[a] * s2[(o << 1 | 1)]) %
P;
s2[o] = (s2[(o << 1)] +
(a ? f[a] * s1[(o << 1 | 1)] + f[a - 1] * s2[(o << 1 | 1)]
: s2[(o << 1 | 1)])) %
P;
}
}
int main() {
n = read(), P = read();
for (int i = 1; i <= n; i++) A[i] = num[i] = read(), bl[i] = (i - 1) / B + 1;
for (int i = (f[1] = 1, 2); i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % P;
sort(num + 1, num + n + 1);
L = unique(num + 1, num + n + 1) - num - 1;
for (int i = 1; i <= n; i++)
A[i] = lower_bound(num + 1, num + L + 1, A[i]) - num;
m = read();
for (int i = 1; i <= m; i++) e[i].l = read(), e[i].r = read(), e[i].id = i;
sort(e + 1, e + m + 1, cmp);
for (int i = 1, l = 1, r = 0; i <= m; i++) {
while (e[i].l < l) ins(A[--l]);
while (r < e[i].r) ins(A[++r]);
while (l < e[i].l) del(A[l++]);
while (e[i].r < r) del(A[r--]);
ans[e[i].id] = s1[1];
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
srand(time(NULL));
int length(30000), modolu(rand() % 30000);
cin >> length >> modolu;
int fibonacci[30000];
fibonacci[0] = fibonacci[1] = 1;
for (int i = 2; i < 30000; ++i)
fibonacci[i] = (fibonacci[i - 1] + fibonacci[i - 2]) % modolu;
vector<pair<int, int> > values(length);
for (int i = 0; i < length; ++i) {
cin >> values[i].first;
values[i].second = i + 1;
}
sort(values.begin(), values.end());
vector<int> jump(length, length);
for (int i = 1; i < length; ++i) {
if (values[i].first != values[i - 1].first) {
for (int j = 1; j <= i && values[i - j].first == values[i - 1].first;
++j) {
jump[i - j] = j - 1;
}
}
}
for (int i = 0; i < length; ++i) values[i].first = values[i].first % modolu;
int queries(30000);
cin >> queries;
for (int q = 0; q < queries; ++q) {
unsigned long long int answer = 0;
int count = 0;
int l, r;
cin >> l >> r;
for (int i = 0; i < values.size(); ++i) {
if (values[i].second >= l & values[i].second <= r) {
answer += values[i].first * fibonacci[count];
i += jump[i];
++count;
}
}
cout << answer % modolu << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
int mod, n, m, a[maxn], b[maxn], c[maxn], used[maxn], block, ans[maxn];
struct query {
int l, r, id;
query(int l, int r, int id) : l(l), r(r), id(id) {}
bool operator<(const query &a) const { return r != a.r ? r < a.r : l < a.l; }
};
vector<query> Q[maxn];
struct segtree {
int node[maxn << 2][2][3];
void build(int rt, int l, int r) {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
}
void update(int rt, int l, int r, int x, int k) {
if (l == r) {
if (k) {
node[rt][0][0] = node[rt][0][1] = node[rt][1][0] = 1;
node[rt][1][1] = 0;
node[rt][0][2] = node[rt][1][2] = c[x];
} else {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
}
return;
}
int mid = (l + r) >> 1;
x <= mid ? update(rt << 1, l, mid, x, k)
: update(rt << 1 | 1, mid + 1, r, x, k);
node[rt][0][0] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][0][1] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][0][2] =
(node[rt << 1][0][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][2] + node[rt << 1][0][2]) %
mod;
node[rt][1][0] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][1][1] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][1][2] =
(node[rt << 1][1][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][2] + node[rt << 1][1][2]) %
mod;
}
} tree;
void add(int x) {
if (++used[x] == 1) tree.update(1, 1, m, x, 1);
}
void del(int x) {
if (--used[x] == 0) tree.update(1, 1, m, x, 0);
}
int main() {
while (~scanf("%d%d", &n, &mod)) {
block = sqrt(n + 0.5);
for (int i = 0; i <= n / block; ++i) Q[i].clear();
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= m; ++i) c[i] = b[i] % mod;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
Q[l / block].push_back(query(l, r, i));
}
for (int i = 0; i <= n / block; ++i) {
if (Q[i].empty()) continue;
memset(used, 0, sizeof(used));
sort(Q[i].begin(), Q[i].end());
tree.build(1, 1, m);
int l = Q[i][0].l, r = Q[i][0].r;
for (int j = l; j <= r; ++j) add(a[j]);
ans[Q[i][0].id] = tree.node[1][1][2];
for (int j = 1; j < Q[i].size(); ++j) {
while (r < Q[i][j].r) add(a[++r]);
while (l < Q[i][j].l) del(a[l++]);
while (l > Q[i][j].l) add(a[--l]);
ans[Q[i][j].id] = tree.node[1][1][2];
}
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4;
int n, aa[N + 2], fib[N + 2], con[N + 2], m;
void compress() {
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(aa[i]);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
map<int, int> mp;
for (int i = 0; i < v.size(); i++) {
mp[v[i]] = i + 1;
con[i + 1] = v[i] % m;
}
for (int i = 1; i <= n; i++) aa[i] = mp[aa[i]];
}
bool vs[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> aa[i];
compress();
fib[1] = 1;
fib[2] = 1;
for (int i = 3; i <= 30000; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
for (int i = l; i <= r; i++) vs[aa[i]] = 1;
long long ans = 0;
int cnt = 1;
for (int i = 1; i <= 30000; i++) {
if (vs[i]) {
ans += con[i] * fib[cnt++];
vs[i] = 0;
}
}
cout << ans % m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
void print(T x, char c) {
if (x < 0) putchar('-'), x = -x;
int s[20], top = 0;
while (s[++top] = x % 10, x /= 10)
;
while (top) putchar(s[top--] + '0');
putchar(c);
}
int n, m, mod, blk, tot, a[30005], lis[30005], f[30005], cnt[30005], ans[30005];
struct query {
int l, r, id;
bool operator<(const query &b) const {
return l / blk == b.l / blk ? l / blk & 1 ? r > b.r : r < b.r : l < b.l;
}
} q[30005];
int check(int x) { return x >= mod ? x - mod : x < 0 ? x + mod : x; }
struct Segment {
int siz;
int pre, now;
} tr[30005 << 2];
void pushup(int v) {
tr[v].siz = tr[v << 1].siz + tr[v << 1 | 1].siz;
int k = tr[v << 1].siz;
tr[v].pre = (tr[v << 1].pre + 1ll * tr[v << 1 | 1].pre * (k ? f[k - 1] : 1) +
1ll * tr[v << 1 | 1].now * f[k]) %
mod;
tr[v].now = (tr[v << 1].now + 1ll * tr[v << 1 | 1].pre * f[k] +
1ll * tr[v << 1 | 1].now * f[k + 1]) %
mod;
}
void Modify(int v, int l, int r, int pos, int d) {
if (l == r) {
tr[v].now = check(tr[v].now + lis[pos] * d);
tr[v].siz += d;
return;
}
int mid = l + r >> 1;
pos <= mid ? Modify(v << 1, l, mid, pos, d)
: Modify(v << 1 | 1, mid + 1, r, pos, d);
pushup(v);
}
void Add(int x) {
if (!cnt[x]++) Modify(1, 1, tot, x, 1);
}
void Del(int x) {
if (!--cnt[x]) Modify(1, 1, tot, x, -1);
}
int main() {
read(n), read(mod);
for (int i = 1; i <= n; ++i) read(a[i]), lis[i] = a[i];
sort(lis + 1, lis + n + 1);
tot = unique(lis + 1, lis + n + 1) - lis - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(lis + 1, lis + tot + 1, a[i]) - lis;
cerr << tot;
read(m);
blk = max(1.0, n / sqrt(2.0 * m / 3));
for (int i = 1; i <= m; ++i) read(q[i].l), read(q[i].r), q[i].id = i;
sort(q + 1, q + m + 1);
f[1] = f[2] = 1;
for (int i = 3; i <= tot; ++i) f[i] = check(f[i - 1] + f[i - 2]);
for (int i = 1, l = 1, r = 0; i <= m; ++i) {
while (r < q[i].r) Add(a[++r]);
while (l > q[i].l) Add(a[--l]);
while (r > q[i].r) Del(a[r--]);
while (l < q[i].l) Del(a[l++]);
ans[q[i].id] = tr[1].now;
}
for (int i = 1; i <= m; ++i) print(ans[i], '\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30010;
const int BUCKET = 200;
const int TOTAL = MAXN / BUCKET + 2;
int n, m, q;
int num[MAXN];
int f[MAXN], t[MAXN];
long long fib[MAXN];
vector<int> name;
int ans[MAXN];
vector<pair<pair<int, int>, int> > ask[TOTAL];
int cnt[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &num[i]);
scanf("%d", &q);
for (int i = 0; i < q; ++i) scanf("%d%d", &f[i], &t[i]), --f[i], --t[i];
fib[0] = fib[1] = 1 % m;
for (int i = 2; i < MAXN; ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
name = vector<int>(num, num + n);
sort(name.begin(), name.end());
name.erase(unique(name.begin(), name.end()), name.end());
for (int i = 0; i < n; ++i)
num[i] = lower_bound(name.begin(), name.end(), num[i]) - name.begin();
for (int i = 0; i < ((int)(name).size()); ++i) name[i] %= m;
for (int i = 0; i < q; ++i)
ask[t[i] / BUCKET].push_back(make_pair(make_pair(t[i], f[i]), i));
for (int i = 0; i < TOTAL; ++i) {
auto& buck = ask[i];
if (buck.empty()) continue;
sort(buck.begin(), buck.end());
memset(cnt, 0, sizeof cnt);
int lo = (i + 1) * BUCKET;
int end = lo - 1;
for (auto query : buck) {
int f = query.first.second;
int t = query.first.first;
int id = query.second;
while (lo <= t) ++cnt[num[lo]], ++lo;
for (int j = min(end, t); j >= f; --j) ++cnt[num[j]];
long long sum = 0;
for (int p = 0, s = 0; p < MAXN; ++p)
if (cnt[p] > 0) sum += fib[s++] * name[p];
ans[id] = sum % m;
for (int j = min(end, t); j >= f; --j) --cnt[num[j]];
}
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool Handsome;
inline int rd() {
register int x = 0;
register char o = getchar();
register bool O = 0;
for (; o < 48 || 57 < o; o = getchar())
if (o == '-') O = 1;
for (; 48 <= o && o <= 57; o = getchar()) x = (x << 1) + (x << 3) + (o ^ 48);
return O ? -x : x;
}
inline void Mi(int &x, int y) {
if (x > y && (x = y))
;
}
inline void Mx(int &x, int y) {
if (x < y && (x = y))
;
}
const int M = 3e4 + 5;
int n, P, sn, m, bl[M], a[M], c[M], f[M], f1[M][2], f2[M][2], l, r, ans[M],
tot[M];
struct node {
int x, y, id;
} A[M];
bool cmp(node a, node b) {
if (bl[a.x] == bl[b.x]) return bl[a.x] & 1 ? a.y < b.y : a.y > b.y;
return a.x < b.x;
}
int Mod(int x) {
if (x >= P) x -= P;
if (x < 0) x += P;
return x;
}
int s[M << 2], t[M << 2], tp[M << 2], k[M << 2];
void calc(int p, int s) {
int x, y;
if (s > 0) {
x = (1ll * f1[1 + s][0] * tp[p] + f1[1 + s][1] * t[p]) % P;
y = (1ll * f1[2 + s][0] * tp[p] + f1[2 + s][1] * t[p]) % P;
} else {
x = (1ll * f2[2 - s][0] * tp[p] + f2[2 - s][1] * t[p]) % P;
y = (1ll * f2[1 - s][0] * tp[p] + f2[1 - s][1] * t[p]) % P;
}
tp[p] = x;
t[p] = y;
}
void down(int p) {
if (!k[p]) return;
calc(p << 1, k[p]);
k[p << 1] += k[p];
calc(p << 1 | 1, k[p]);
k[p << 1 | 1] += k[p];
k[p] = 0;
}
void chg(int x, int y, int z = 1, int l = 1, int r = n, int p = 1) {
s[p] += y;
if (l == r) {
if (y == 1) {
tp[p] = 1ll * f[z - 1] * c[l] % P;
t[p] = 1ll * f[z] * c[l] % P;
} else
t[p] = tp[p] = 0;
return;
}
down(p);
int mid = (l + r) >> 1;
if (x <= mid)
chg(x, y, z, l, mid, p << 1), calc(p << 1 | 1, y), k[p << 1 | 1] += y;
else
chg(x, y, z + s[p << 1], mid + 1, r, p << 1 | 1);
t[p] = Mod(t[p << 1] + t[p << 1 | 1]);
tp[p] = Mod(tp[p << 1] + tp[p << 1 | 1]);
}
bool Most;
int main() {
n = rd();
P = rd();
sn = sqrt(n);
for (int i = 1, iend = n; i <= iend; ++i) bl[i] = (i - 1) / sn + 1;
for (int i = 1, iend = n; i <= iend; ++i) a[i] = c[i] = rd();
sort(c + 1, c + n + 1);
for (int i = 1, iend = n; i <= iend; ++i)
a[i] = lower_bound(c + 1, c + n + 1, a[i]) - c;
f[1] = f[2] = 1;
for (int i = 3, iend = n; i <= iend; ++i) f[i] = Mod(f[i - 2] + f[i - 1]);
f1[1][0] = f1[2][1] = 1;
for (int i = 3, iend = n; i <= iend; ++i) {
f1[i][0] = Mod(f1[i - 2][0] + f1[i - 1][0]);
f1[i][1] = Mod(f1[i - 2][1] + f1[i - 1][1]);
}
f2[1][1] = f2[2][0] = 1;
for (int i = 3, iend = n; i <= iend; ++i) {
f2[i][0] = Mod(f2[i - 2][0] - f2[i - 1][0]);
f2[i][1] = Mod(f2[i - 2][1] - f2[i - 1][1]);
}
m = rd();
for (int i = 1, iend = m; i <= iend; ++i)
A[i].x = rd(), A[i].y = rd(), A[i].id = i;
sort(A + 1, A + m + 1, cmp);
l = 1;
for (int i = 1, iend = m; i <= iend; ++i) {
while (r < A[i].y) {
++r;
if (++tot[a[r]] == 1) chg(a[r], 1);
}
while (l > A[i].x) {
--l;
if (++tot[a[l]] == 1) chg(a[l], 1);
}
while (r > A[i].y) {
if (!--tot[a[r]]) chg(a[r], -1);
--r;
}
while (l < A[i].x) {
if (!--tot[a[l]]) chg(a[l], -1);
++l;
}
ans[A[i].id] = Mod(t[1]);
}
for (int i = 1, iend = m; i <= iend; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 3e4 + 8;
int M;
int fibs[SZ], vals[SZ], ar[SZ];
int st[4 * SZ][2], lazy[4 * SZ];
void preprocess() {
fibs[0] = 0;
fibs[1] = 1;
for (int i = 2; i < SZ; i++) fibs[i] = (fibs[i - 1] + fibs[i - 2]) % M;
for (int i = 2; i < SZ; i += 2) fibs[i] = -fibs[i];
}
inline int modulo(int x, int m) {
x %= m;
if (x < 0) x += m;
return x;
}
void update(int s, int e, int x, int i, int n, bool toadd) {
if (lazy[i] != 0) {
int a, b, c, d;
if (lazy[i] > 0) {
a = abs(fibs[lazy[i] + 1]);
b = c = abs(fibs[lazy[i]]);
d = abs(fibs[lazy[i] - 1]);
} else if (lazy[i] < 0) {
a = fibs[-(lazy[i] + 1)];
b = c = fibs[-lazy[i]];
d = fibs[-(lazy[i] - 1)];
}
a = a * st[i][0];
b = b * st[i][1];
c = c * st[i][0];
d = d * st[i][1];
st[i][0] = modulo(a + b, M);
st[i][1] = modulo(c + d, M);
if (s != e) lazy[2 * i + 1] += lazy[i], lazy[2 * i + 2] += lazy[i];
lazy[i] = 0;
}
if (x > e) return;
if (x < s) {
int a = st[i][0];
int b = st[i][1];
if (toadd) {
st[i][0] = modulo(a + b, M);
st[i][1] = a;
if (s != e) lazy[2 * i + 1]++, lazy[2 * i + 2]++;
} else {
st[i][0] = b;
st[i][1] = modulo(a - b, M);
if (s != e) lazy[2 * i + 1]--, lazy[2 * i + 2]--;
}
return;
}
if (s == e) {
if (toadd) {
int xr = vals[s];
st[i][0] = (xr * abs(fibs[n])) % M;
st[i][1] = (xr * abs(fibs[n - 1])) % M;
} else
st[i][0] = st[i][1] = 0;
return;
}
int mid = (s + e) / 2;
update(s, mid, x, 2 * i + 1, n, toadd);
update(mid + 1, e, x, 2 * i + 2, n, toadd);
int a = st[2 * i + 1][0], b = st[2 * i + 1][1];
int c = st[2 * i + 2][0], d = st[2 * i + 2][1];
st[i][0] = (a + c) % M;
st[i][1] = (b + d) % M;
}
int sqn;
inline bool sub(pair<int, int> x, pair<int, int> y) {
double v1 = x.first;
v1 = ceil(v1 / sqn);
double v2 = y.first;
v2 = ceil(v2 / sqn);
if (v1 == v2)
return x.second < y.second;
else
return v1 < v2;
}
int bit[SZ];
int l = SZ;
void bit_update(int i, int val) {
while (i <= l) {
bit[i] = bit[i] + val;
i = i + (i & (-i));
}
}
int bit_summ(int a) {
int s = 0;
while (a > 0) {
s += bit[a];
a = a - (a & (-a));
}
return s;
}
bool compare(pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
int b = sqn;
pair<int, int> x, y;
x = p1.first;
y = p2.first;
if ((x.first / b) != (y.first / b)) return (x.first / b < y.first / b);
return (x.second < y.second);
}
int ans[SZ], num[SZ];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, Q, l, r;
cin >> N >> M;
preprocess();
sqn = sqrt(N);
for (int i = 1; i <= N; i++) {
cin >> ar[i];
vals[i - 1] = ar[i];
}
sort(vals, vals + N);
for (int i = 1; i <= N; i++)
ar[i] = lower_bound(vals, vals + N, ar[i]) - vals;
for (int i = 0; i < N; i++) vals[i] %= M;
cin >> Q;
vector<pair<pair<int, int>, int> > queries;
for (int i = 0; i < Q; i++) {
cin >> l >> r;
queries.push_back(make_pair(make_pair(l, r), i));
}
sort(queries.begin(), queries.end(), compare);
l = r = 1;
num[ar[1]]++;
bit_update(ar[1] + 1, 1);
update(0, N - 1, ar[1], 0, 1, true);
for (int i = 0; i < queries.size(); i++) {
pair<int, int> p = queries[i].first;
int ix = queries[i].second, pos;
while (l < p.first) {
num[ar[l]]--;
if (num[ar[l]] == 0) {
bit_update(ar[l] + 1, -1);
update(0, N - 1, ar[l], 0, 0, false);
}
l++;
}
while (l > p.first) {
l--;
num[ar[l]]++;
if (num[ar[l]] == 1) {
pos = bit_summ(ar[l]) + 1;
bit_update(ar[l] + 1, 1);
update(0, N - 1, ar[l], 0, pos, true);
}
}
while (r < p.second) {
r++;
num[ar[r]]++;
if (num[ar[r]] == 1) {
pos = bit_summ(ar[r]) + 1;
bit_update(ar[r] + 1, 1);
update(0, N - 1, ar[r], 0, pos, true);
}
}
while (r > p.second) {
num[ar[r]]--;
if (num[ar[r]] == 0) {
bit_update(ar[r] + 1, -1);
update(0, N - 1, ar[r], 0, 0, false);
}
r--;
}
ans[ix] = st[0][0];
}
for (int i = 0; i < Q; i++) cout << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 10;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
;
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
for (int i = int(0); i < int(1 << K); ++i) {
mb[i] = K;
while (mb[i] >= 0 && !(i & (1 << mb[i]))) {
--mb[i];
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
};
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
};
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
if (i) {
v[w][q | (1 << i)][0] = v[w][q | (1 << (i - 1))][0];
v[w][q | (1 << i)][1] = v[w][q | (1 << (i - 1))][1];
bt[w][q | (1 << i)] = bt[w][q | (1 << (i - 1))];
} else {
v[w][q | (1 << i)][0] = v[w][q][0];
v[w][q | (1 << i)][1] = v[w][q][1];
bt[w][q | (1 << i)] = bt[w][q];
}
} else {
v[w][q | (1 << i)][0] =
(v[w][q][0] + f[bt[w][q]] * (a[p[t * K + i]] % mod)) % mod;
v[w][q | (1 << i)][1] =
(v[w][q][1] + f[bt[w][q] + 1] * (a[p[t * K + i]] % mod)) %
mod;
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
ans[i] = (ans[i] + v[ttt][mmm][0] * f[cnt[i] + 2] +
v[ttt][mmm][1] * f[cnt[i] + 3]) %
mod;
;
;
;
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
;
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-12;
inline int read() {
static char ch;
bool sgn = false;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') sgn = true;
int res = ch - 48;
while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - 48;
return sgn ? -res : res;
}
const int N = 3e4 + 5;
int n, m, block;
int a[N], b[N], cnt[N], ans[N];
struct query {
int l, r, id;
bool operator<(const query &x) const {
if (l / block == (x.l) / block) return r / block < (x.r / block);
return l / block < x.l / block;
}
} Q[N];
struct Tree {
int s1, s2;
int a11, a12, a21, a22;
int l, r;
} tree[N * 4];
void build(int k, int l, int r) {
tree[k].a11 = tree[k].a22 = 1;
tree[k].l = l;
tree[k].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build((k << 1) + 1, mid + 1, r);
}
inline void update(int k) {
tree[k].s1 = tree[k << 1].s1 + tree[(k << 1) + 1].s1 * tree[k << 1].a11 +
tree[(k << 1) + 1].s2 * tree[k << 1].a12;
tree[k].s2 = tree[k << 1].s2 + tree[(k << 1) + 1].s1 * tree[k << 1].a21 +
tree[(k << 1) + 1].s2 * tree[k << 1].a22;
tree[k].a11 = tree[k << 1].a11 * tree[(k << 1) + 1].a11 +
tree[k << 1].a12 * tree[(k << 1) + 1].a21;
tree[k].a12 = tree[k << 1].a11 * tree[(k << 1) + 1].a12 +
tree[k << 1].a12 * tree[(k << 1) + 1].a22;
tree[k].a21 = tree[k << 1].a21 * tree[(k << 1) + 1].a11 +
tree[k << 1].a22 * tree[(k << 1) + 1].a21;
tree[k].a22 = tree[k << 1].a21 * tree[(k << 1) + 1].a12 +
tree[k << 1].a22 * tree[(k << 1) + 1].a22;
tree[k].s1 %= m;
tree[k].s2 %= m;
tree[k].a11 %= m;
tree[k].a12 %= m;
tree[k].a21 %= m;
tree[k].a22 %= m;
}
void Ins(int k, int p, bool flag) {
if (tree[k].l > p || tree[k].r < p) return;
if (tree[k].l == tree[k].r) {
if (flag) {
tree[k].s1 = b[p] * 1;
tree[k].s2 = 0;
tree[k].a11 = tree[k].a12 = tree[k].a21 = 1;
tree[k].a22 = 0;
} else {
tree[k].s1 = tree[k].s2 = 0;
tree[k].a11 = tree[k].a22 = 1;
tree[k].a12 = tree[k].a21 = 0;
}
return;
}
Ins(k << 1, p, flag);
Ins((k << 1) + 1, p, flag);
update(k);
}
inline void add(int x) {
x = a[x];
if (cnt[x] == 0) Ins(1, x, 1);
cnt[x]++;
}
inline void sub(int x) {
x = a[x];
if (cnt[x] == 1) Ins(1, x, 0);
cnt[x]--;
}
int main() {
n = read(), m = read();
block = sqrt(n);
for (int i = 1; i <= n; i++) a[i] = b[i] = read();
sort(b + 1, b + 1 + n);
int B = unique(b + 1, b + 1 + n) - b;
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(b + 1, b + B, a[i]) - b;
}
B--;
build(1, 1, B);
int q = read();
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q + 1, Q + 1 + q);
int l = 1, r = 0;
for (int i = 1; i <= q; i++) {
while (l < Q[i].l) sub(l), l++;
while (l > Q[i].l) l--, add(l);
while (r < Q[i].r) r++, add(r);
while (r > Q[i].r) sub(r), r--;
ans[Q[i].id] = tree[1].s1;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
pair<int, int> d[N], T[N];
int m, block, cnt, id[N], fab[N], ans[N], num[N], aid[N];
struct tree {
int a1, a2, lenth;
} S[N << 2];
bool cmp(int a, int b) {
int ta = T[a].first / block, tb = T[b].first / block;
return ta < tb || (ta == tb && T[a].second < T[b].second);
}
void pushup(int x) {
S[x].lenth = S[x << 1].lenth + S[x << 1 | 1].lenth;
S[x].a1 = (S[x << 1].a1 + S[x << 1 | 1].a1 * fab[S[x << 1].lenth + 1] +
S[x << 1 | 1].a2 * fab[S[x << 1].lenth]) %
m;
if (S[x << 1].lenth)
S[x].a2 = (S[x << 1].a2 + S[x << 1 | 1].a1 * fab[S[x << 1].lenth] +
S[x << 1 | 1].a2 * fab[S[x << 1].lenth - 1]) %
m;
else
S[x].a2 = S[x << 1 | 1].a2;
}
void build(int x, int l, int r) {
S[x].lenth = S[x].a1 = S[x].a2 = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
}
void Insert(int x, int l, int r, int lr, int val) {
if (l == r) {
S[x].a1 = val * d[l - 1].first % m;
S[x].lenth = val;
return;
}
int mid = (l + r) >> 1;
if (lr > mid)
Insert(x << 1 | 1, mid + 1, r, lr, val);
else
Insert(x << 1, l, mid, lr, val);
pushup(x);
}
void ins(int x) {
if (num[x] == 0) Insert(1, 1, cnt, x, 1);
num[x]++;
}
void del(int x) {
num[x]--;
if (num[x] == 0) Insert(1, 1, cnt, x, 0);
}
int main() {
int n, i, q;
scanf("%d%d", &n, &m);
memset(num, 0, sizeof(num));
for (fab[1] = fab[2] = 1, i = 3; i <= n; i++)
fab[i] = (fab[i - 1] + fab[i - 2]) % m;
for (i = 0; i < n; i++) {
scanf("%d", &d[i].first);
d[i].second = i;
}
sort(d, d + n);
block = (int)sqrt(n);
id[d[0].second] = cnt = 1;
for (i = 1; i < n; i++) {
if (d[i].first != d[i - 1].first) d[cnt++].first = d[i].first;
id[d[i].second] = cnt;
}
build(1, 1, cnt);
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d%d", &T[i].first, &T[i].second);
T[i].first--;
T[i].second--;
aid[i] = i;
}
sort(aid, aid + q, cmp);
int l, r;
l = r = 0;
ins(id[0]);
for (i = 0; i < q; i++) {
int t = aid[i];
while (r > T[t].second) del(id[r]), r--;
while (l < T[t].first) del(id[l]), l++;
while (r < T[t].second) r++, ins(id[r]);
while (l > T[t].first) l--, ins(id[l]);
ans[t] = S[1].a1;
}
for (i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
static const int T = 30016;
static_assert(T % 64 == 0, "");
struct bs {
union {
uint64_t bits[T / 64];
uint8_t ch[T / 8];
};
bs() : bits{} {}
bool operator[](int ind) { return ch[ind >> 3] & (1 << (ind & 7)); }
void set(int ind) { ch[ind >> 3] = 1 << (ind & 7); }
};
inline bs operator|(const bs& a, const bs& b) {
bs r;
for (int i = (0); i < (T / 64); i++) r.bits[i] = a.bits[i] | b.bits[i];
return r;
}
inline bs& operator|=(bs& a, const bs& b) { return a = a | b; }
int N;
vector<bs> v(2 * T);
bs get(int l, int r) {
bs ret;
for (l += N, r += N; l < r; l /= 2, r /= 2) {
if (l & 1) ret |= v[l++];
if (r & 1) ret |= v[--r];
}
return ret;
}
int num[T], fib[T];
template <int>
inline __attribute__((always_inline)) void deal(int nu, int& c, uint64_t& ans) {
ans += (uint32_t)fib[c] * (uint32_t)nu;
c++;
}
template <>
inline __attribute__((always_inline)) void deal<0>(int nu, int& c,
uint64_t& ans) {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q, mod;
ignore = scanf("%d%d", &N, &mod);
map<int, vector<int> > mp;
for (int i = (0); i < (N); i++) {
int k;
ignore = scanf("%d", &k);
mp[k].push_back(i);
}
int a = 0, mx = (int)mp.size();
for (auto it = mp.begin(); it != mp.end(); it++) {
for (int i : it->second) v[N + i].set(a);
num[a++] = (it->first) % mod;
}
for (int i = N; i-- > 0;) v[i] = v[2 * i] | v[(2 * i) ^ 1];
fib[0] = fib[1] = 1 % mod;
for (int i = (2); i < (T); i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
ignore = scanf("%d", &q);
vector<pair<int, int> > que(q);
for (int i = (0); i < (q); i++) {
ignore = scanf("%d%d", &(que[i].first), &(que[i].second));
que[i].first--;
}
for (int i = (0); i < (q); i++) {
bs b = get(que[i].first, que[i].second);
int c = 0;
uint64_t ans = 0;
for (int j = 0; j < mx; j += 8) {
int* nums = num + j;
switch (b.ch[j >> 3]) {
case 0: {
deal<0 & 1>(nums[0], c, ans);
deal<0 & 2>(nums[1], c, ans);
deal<0 & 4>(nums[2], c, ans);
deal<0 & 8>(nums[3], c, ans);
deal<0 & 16>(nums[4], c, ans);
deal<0 & 32>(nums[5], c, ans);
deal<0 & 64>(nums[6], c, ans);
deal<0 & 128>(nums[7], c, ans);
break;
};
case 1: {
deal<1 & 1>(nums[0], c, ans);
deal<1 & 2>(nums[1], c, ans);
deal<1 & 4>(nums[2], c, ans);
deal<1 & 8>(nums[3], c, ans);
deal<1 & 16>(nums[4], c, ans);
deal<1 & 32>(nums[5], c, ans);
deal<1 & 64>(nums[6], c, ans);
deal<1 & 128>(nums[7], c, ans);
break;
};
case 2: {
deal<2 & 1>(nums[0], c, ans);
deal<2 & 2>(nums[1], c, ans);
deal<2 & 4>(nums[2], c, ans);
deal<2 & 8>(nums[3], c, ans);
deal<2 & 16>(nums[4], c, ans);
deal<2 & 32>(nums[5], c, ans);
deal<2 & 64>(nums[6], c, ans);
deal<2 & 128>(nums[7], c, ans);
break;
};
case 3: {
deal<3 & 1>(nums[0], c, ans);
deal<3 & 2>(nums[1], c, ans);
deal<3 & 4>(nums[2], c, ans);
deal<3 & 8>(nums[3], c, ans);
deal<3 & 16>(nums[4], c, ans);
deal<3 & 32>(nums[5], c, ans);
deal<3 & 64>(nums[6], c, ans);
deal<3 & 128>(nums[7], c, ans);
break;
};
case 4: {
deal<4 & 1>(nums[0], c, ans);
deal<4 & 2>(nums[1], c, ans);
deal<4 & 4>(nums[2], c, ans);
deal<4 & 8>(nums[3], c, ans);
deal<4 & 16>(nums[4], c, ans);
deal<4 & 32>(nums[5], c, ans);
deal<4 & 64>(nums[6], c, ans);
deal<4 & 128>(nums[7], c, ans);
break;
};
case 5: {
deal<5 & 1>(nums[0], c, ans);
deal<5 & 2>(nums[1], c, ans);
deal<5 & 4>(nums[2], c, ans);
deal<5 & 8>(nums[3], c, ans);
deal<5 & 16>(nums[4], c, ans);
deal<5 & 32>(nums[5], c, ans);
deal<5 & 64>(nums[6], c, ans);
deal<5 & 128>(nums[7], c, ans);
break;
};
case 6: {
deal<6 & 1>(nums[0], c, ans);
deal<6 & 2>(nums[1], c, ans);
deal<6 & 4>(nums[2], c, ans);
deal<6 & 8>(nums[3], c, ans);
deal<6 & 16>(nums[4], c, ans);
deal<6 & 32>(nums[5], c, ans);
deal<6 & 64>(nums[6], c, ans);
deal<6 & 128>(nums[7], c, ans);
break;
};
case 7: {
deal<7 & 1>(nums[0], c, ans);
deal<7 & 2>(nums[1], c, ans);
deal<7 & 4>(nums[2], c, ans);
deal<7 & 8>(nums[3], c, ans);
deal<7 & 16>(nums[4], c, ans);
deal<7 & 32>(nums[5], c, ans);
deal<7 & 64>(nums[6], c, ans);
deal<7 & 128>(nums[7], c, ans);
break;
};
case 8: {
deal<8 & 1>(nums[0], c, ans);
deal<8 & 2>(nums[1], c, ans);
deal<8 & 4>(nums[2], c, ans);
deal<8 & 8>(nums[3], c, ans);
deal<8 & 16>(nums[4], c, ans);
deal<8 & 32>(nums[5], c, ans);
deal<8 & 64>(nums[6], c, ans);
deal<8 & 128>(nums[7], c, ans);
break;
};
case 9: {
deal<9 & 1>(nums[0], c, ans);
deal<9 & 2>(nums[1], c, ans);
deal<9 & 4>(nums[2], c, ans);
deal<9 & 8>(nums[3], c, ans);
deal<9 & 16>(nums[4], c, ans);
deal<9 & 32>(nums[5], c, ans);
deal<9 & 64>(nums[6], c, ans);
deal<9 & 128>(nums[7], c, ans);
break;
};
case 10: {
deal<10 & 1>(nums[0], c, ans);
deal<10 & 2>(nums[1], c, ans);
deal<10 & 4>(nums[2], c, ans);
deal<10 & 8>(nums[3], c, ans);
deal<10 & 16>(nums[4], c, ans);
deal<10 & 32>(nums[5], c, ans);
deal<10 & 64>(nums[6], c, ans);
deal<10 & 128>(nums[7], c, ans);
break;
};
case 11: {
deal<11 & 1>(nums[0], c, ans);
deal<11 & 2>(nums[1], c, ans);
deal<11 & 4>(nums[2], c, ans);
deal<11 & 8>(nums[3], c, ans);
deal<11 & 16>(nums[4], c, ans);
deal<11 & 32>(nums[5], c, ans);
deal<11 & 64>(nums[6], c, ans);
deal<11 & 128>(nums[7], c, ans);
break;
};
case 12: {
deal<12 & 1>(nums[0], c, ans);
deal<12 & 2>(nums[1], c, ans);
deal<12 & 4>(nums[2], c, ans);
deal<12 & 8>(nums[3], c, ans);
deal<12 & 16>(nums[4], c, ans);
deal<12 & 32>(nums[5], c, ans);
deal<12 & 64>(nums[6], c, ans);
deal<12 & 128>(nums[7], c, ans);
break;
};
case 13: {
deal<13 & 1>(nums[0], c, ans);
deal<13 & 2>(nums[1], c, ans);
deal<13 & 4>(nums[2], c, ans);
deal<13 & 8>(nums[3], c, ans);
deal<13 & 16>(nums[4], c, ans);
deal<13 & 32>(nums[5], c, ans);
deal<13 & 64>(nums[6], c, ans);
deal<13 & 128>(nums[7], c, ans);
break;
};
case 14: {
deal<14 & 1>(nums[0], c, ans);
deal<14 & 2>(nums[1], c, ans);
deal<14 & 4>(nums[2], c, ans);
deal<14 & 8>(nums[3], c, ans);
deal<14 & 16>(nums[4], c, ans);
deal<14 & 32>(nums[5], c, ans);
deal<14 & 64>(nums[6], c, ans);
deal<14 & 128>(nums[7], c, ans);
break;
};
case 15: {
deal<15 & 1>(nums[0], c, ans);
deal<15 & 2>(nums[1], c, ans);
deal<15 & 4>(nums[2], c, ans);
deal<15 & 8>(nums[3], c, ans);
deal<15 & 16>(nums[4], c, ans);
deal<15 & 32>(nums[5], c, ans);
deal<15 & 64>(nums[6], c, ans);
deal<15 & 128>(nums[7], c, ans);
break;
};
case 16: {
deal<16 & 1>(nums[0], c, ans);
deal<16 & 2>(nums[1], c, ans);
deal<16 & 4>(nums[2], c, ans);
deal<16 & 8>(nums[3], c, ans);
deal<16 & 16>(nums[4], c, ans);
deal<16 & 32>(nums[5], c, ans);
deal<16 & 64>(nums[6], c, ans);
deal<16 & 128>(nums[7], c, ans);
break;
};
case 17: {
deal<17 & 1>(nums[0], c, ans);
deal<17 & 2>(nums[1], c, ans);
deal<17 & 4>(nums[2], c, ans);
deal<17 & 8>(nums[3], c, ans);
deal<17 & 16>(nums[4], c, ans);
deal<17 & 32>(nums[5], c, ans);
deal<17 & 64>(nums[6], c, ans);
deal<17 & 128>(nums[7], c, ans);
break;
};
case 18: {
deal<18 & 1>(nums[0], c, ans);
deal<18 & 2>(nums[1], c, ans);
deal<18 & 4>(nums[2], c, ans);
deal<18 & 8>(nums[3], c, ans);
deal<18 & 16>(nums[4], c, ans);
deal<18 & 32>(nums[5], c, ans);
deal<18 & 64>(nums[6], c, ans);
deal<18 & 128>(nums[7], c, ans);
break;
};
case 19: {
deal<19 & 1>(nums[0], c, ans);
deal<19 & 2>(nums[1], c, ans);
deal<19 & 4>(nums[2], c, ans);
deal<19 & 8>(nums[3], c, ans);
deal<19 & 16>(nums[4], c, ans);
deal<19 & 32>(nums[5], c, ans);
deal<19 & 64>(nums[6], c, ans);
deal<19 & 128>(nums[7], c, ans);
break;
};
case 20: {
deal<20 & 1>(nums[0], c, ans);
deal<20 & 2>(nums[1], c, ans);
deal<20 & 4>(nums[2], c, ans);
deal<20 & 8>(nums[3], c, ans);
deal<20 & 16>(nums[4], c, ans);
deal<20 & 32>(nums[5], c, ans);
deal<20 & 64>(nums[6], c, ans);
deal<20 & 128>(nums[7], c, ans);
break;
};
case 21: {
deal<21 & 1>(nums[0], c, ans);
deal<21 & 2>(nums[1], c, ans);
deal<21 & 4>(nums[2], c, ans);
deal<21 & 8>(nums[3], c, ans);
deal<21 & 16>(nums[4], c, ans);
deal<21 & 32>(nums[5], c, ans);
deal<21 & 64>(nums[6], c, ans);
deal<21 & 128>(nums[7], c, ans);
break;
};
case 22: {
deal<22 & 1>(nums[0], c, ans);
deal<22 & 2>(nums[1], c, ans);
deal<22 & 4>(nums[2], c, ans);
deal<22 & 8>(nums[3], c, ans);
deal<22 & 16>(nums[4], c, ans);
deal<22 & 32>(nums[5], c, ans);
deal<22 & 64>(nums[6], c, ans);
deal<22 & 128>(nums[7], c, ans);
break;
};
case 23: {
deal<23 & 1>(nums[0], c, ans);
deal<23 & 2>(nums[1], c, ans);
deal<23 & 4>(nums[2], c, ans);
deal<23 & 8>(nums[3], c, ans);
deal<23 & 16>(nums[4], c, ans);
deal<23 & 32>(nums[5], c, ans);
deal<23 & 64>(nums[6], c, ans);
deal<23 & 128>(nums[7], c, ans);
break;
};
case 24: {
deal<24 & 1>(nums[0], c, ans);
deal<24 & 2>(nums[1], c, ans);
deal<24 & 4>(nums[2], c, ans);
deal<24 & 8>(nums[3], c, ans);
deal<24 & 16>(nums[4], c, ans);
deal<24 & 32>(nums[5], c, ans);
deal<24 & 64>(nums[6], c, ans);
deal<24 & 128>(nums[7], c, ans);
break;
};
case 25: {
deal<25 & 1>(nums[0], c, ans);
deal<25 & 2>(nums[1], c, ans);
deal<25 & 4>(nums[2], c, ans);
deal<25 & 8>(nums[3], c, ans);
deal<25 & 16>(nums[4], c, ans);
deal<25 & 32>(nums[5], c, ans);
deal<25 & 64>(nums[6], c, ans);
deal<25 & 128>(nums[7], c, ans);
break;
};
case 26: {
deal<26 & 1>(nums[0], c, ans);
deal<26 & 2>(nums[1], c, ans);
deal<26 & 4>(nums[2], c, ans);
deal<26 & 8>(nums[3], c, ans);
deal<26 & 16>(nums[4], c, ans);
deal<26 & 32>(nums[5], c, ans);
deal<26 & 64>(nums[6], c, ans);
deal<26 & 128>(nums[7], c, ans);
break;
};
case 27: {
deal<27 & 1>(nums[0], c, ans);
deal<27 & 2>(nums[1], c, ans);
deal<27 & 4>(nums[2], c, ans);
deal<27 & 8>(nums[3], c, ans);
deal<27 & 16>(nums[4], c, ans);
deal<27 & 32>(nums[5], c, ans);
deal<27 & 64>(nums[6], c, ans);
deal<27 & 128>(nums[7], c, ans);
break;
};
case 28: {
deal<28 & 1>(nums[0], c, ans);
deal<28 & 2>(nums[1], c, ans);
deal<28 & 4>(nums[2], c, ans);
deal<28 & 8>(nums[3], c, ans);
deal<28 & 16>(nums[4], c, ans);
deal<28 & 32>(nums[5], c, ans);
deal<28 & 64>(nums[6], c, ans);
deal<28 & 128>(nums[7], c, ans);
break;
};
case 29: {
deal<29 & 1>(nums[0], c, ans);
deal<29 & 2>(nums[1], c, ans);
deal<29 & 4>(nums[2], c, ans);
deal<29 & 8>(nums[3], c, ans);
deal<29 & 16>(nums[4], c, ans);
deal<29 & 32>(nums[5], c, ans);
deal<29 & 64>(nums[6], c, ans);
deal<29 & 128>(nums[7], c, ans);
break;
};
case 30: {
deal<30 & 1>(nums[0], c, ans);
deal<30 & 2>(nums[1], c, ans);
deal<30 & 4>(nums[2], c, ans);
deal<30 & 8>(nums[3], c, ans);
deal<30 & 16>(nums[4], c, ans);
deal<30 & 32>(nums[5], c, ans);
deal<30 & 64>(nums[6], c, ans);
deal<30 & 128>(nums[7], c, ans);
break;
};
case 31: {
deal<31 & 1>(nums[0], c, ans);
deal<31 & 2>(nums[1], c, ans);
deal<31 & 4>(nums[2], c, ans);
deal<31 & 8>(nums[3], c, ans);
deal<31 & 16>(nums[4], c, ans);
deal<31 & 32>(nums[5], c, ans);
deal<31 & 64>(nums[6], c, ans);
deal<31 & 128>(nums[7], c, ans);
break;
};
case 32: {
deal<32 & 1>(nums[0], c, ans);
deal<32 & 2>(nums[1], c, ans);
deal<32 & 4>(nums[2], c, ans);
deal<32 & 8>(nums[3], c, ans);
deal<32 & 16>(nums[4], c, ans);
deal<32 & 32>(nums[5], c, ans);
deal<32 & 64>(nums[6], c, ans);
deal<32 & 128>(nums[7], c, ans);
break;
};
case 33: {
deal<33 & 1>(nums[0], c, ans);
deal<33 & 2>(nums[1], c, ans);
deal<33 & 4>(nums[2], c, ans);
deal<33 & 8>(nums[3], c, ans);
deal<33 & 16>(nums[4], c, ans);
deal<33 & 32>(nums[5], c, ans);
deal<33 & 64>(nums[6], c, ans);
deal<33 & 128>(nums[7], c, ans);
break;
};
case 34: {
deal<34 & 1>(nums[0], c, ans);
deal<34 & 2>(nums[1], c, ans);
deal<34 & 4>(nums[2], c, ans);
deal<34 & 8>(nums[3], c, ans);
deal<34 & 16>(nums[4], c, ans);
deal<34 & 32>(nums[5], c, ans);
deal<34 & 64>(nums[6], c, ans);
deal<34 & 128>(nums[7], c, ans);
break;
};
case 35: {
deal<35 & 1>(nums[0], c, ans);
deal<35 & 2>(nums[1], c, ans);
deal<35 & 4>(nums[2], c, ans);
deal<35 & 8>(nums[3], c, ans);
deal<35 & 16>(nums[4], c, ans);
deal<35 & 32>(nums[5], c, ans);
deal<35 & 64>(nums[6], c, ans);
deal<35 & 128>(nums[7], c, ans);
break;
};
case 36: {
deal<36 & 1>(nums[0], c, ans);
deal<36 & 2>(nums[1], c, ans);
deal<36 & 4>(nums[2], c, ans);
deal<36 & 8>(nums[3], c, ans);
deal<36 & 16>(nums[4], c, ans);
deal<36 & 32>(nums[5], c, ans);
deal<36 & 64>(nums[6], c, ans);
deal<36 & 128>(nums[7], c, ans);
break;
};
case 37: {
deal<37 & 1>(nums[0], c, ans);
deal<37 & 2>(nums[1], c, ans);
deal<37 & 4>(nums[2], c, ans);
deal<37 & 8>(nums[3], c, ans);
deal<37 & 16>(nums[4], c, ans);
deal<37 & 32>(nums[5], c, ans);
deal<37 & 64>(nums[6], c, ans);
deal<37 & 128>(nums[7], c, ans);
break;
};
case 38: {
deal<38 & 1>(nums[0], c, ans);
deal<38 & 2>(nums[1], c, ans);
deal<38 & 4>(nums[2], c, ans);
deal<38 & 8>(nums[3], c, ans);
deal<38 & 16>(nums[4], c, ans);
deal<38 & 32>(nums[5], c, ans);
deal<38 & 64>(nums[6], c, ans);
deal<38 & 128>(nums[7], c, ans);
break;
};
case 39: {
deal<39 & 1>(nums[0], c, ans);
deal<39 & 2>(nums[1], c, ans);
deal<39 & 4>(nums[2], c, ans);
deal<39 & 8>(nums[3], c, ans);
deal<39 & 16>(nums[4], c, ans);
deal<39 & 32>(nums[5], c, ans);
deal<39 & 64>(nums[6], c, ans);
deal<39 & 128>(nums[7], c, ans);
break;
};
case 40: {
deal<40 & 1>(nums[0], c, ans);
deal<40 & 2>(nums[1], c, ans);
deal<40 & 4>(nums[2], c, ans);
deal<40 & 8>(nums[3], c, ans);
deal<40 & 16>(nums[4], c, ans);
deal<40 & 32>(nums[5], c, ans);
deal<40 & 64>(nums[6], c, ans);
deal<40 & 128>(nums[7], c, ans);
break;
};
case 41: {
deal<41 & 1>(nums[0], c, ans);
deal<41 & 2>(nums[1], c, ans);
deal<41 & 4>(nums[2], c, ans);
deal<41 & 8>(nums[3], c, ans);
deal<41 & 16>(nums[4], c, ans);
deal<41 & 32>(nums[5], c, ans);
deal<41 & 64>(nums[6], c, ans);
deal<41 & 128>(nums[7], c, ans);
break;
};
case 42: {
deal<42 & 1>(nums[0], c, ans);
deal<42 & 2>(nums[1], c, ans);
deal<42 & 4>(nums[2], c, ans);
deal<42 & 8>(nums[3], c, ans);
deal<42 & 16>(nums[4], c, ans);
deal<42 & 32>(nums[5], c, ans);
deal<42 & 64>(nums[6], c, ans);
deal<42 & 128>(nums[7], c, ans);
break;
};
case 43: {
deal<43 & 1>(nums[0], c, ans);
deal<43 & 2>(nums[1], c, ans);
deal<43 & 4>(nums[2], c, ans);
deal<43 & 8>(nums[3], c, ans);
deal<43 & 16>(nums[4], c, ans);
deal<43 & 32>(nums[5], c, ans);
deal<43 & 64>(nums[6], c, ans);
deal<43 & 128>(nums[7], c, ans);
break;
};
case 44: {
deal<44 & 1>(nums[0], c, ans);
deal<44 & 2>(nums[1], c, ans);
deal<44 & 4>(nums[2], c, ans);
deal<44 & 8>(nums[3], c, ans);
deal<44 & 16>(nums[4], c, ans);
deal<44 & 32>(nums[5], c, ans);
deal<44 & 64>(nums[6], c, ans);
deal<44 & 128>(nums[7], c, ans);
break;
};
case 45: {
deal<45 & 1>(nums[0], c, ans);
deal<45 & 2>(nums[1], c, ans);
deal<45 & 4>(nums[2], c, ans);
deal<45 & 8>(nums[3], c, ans);
deal<45 & 16>(nums[4], c, ans);
deal<45 & 32>(nums[5], c, ans);
deal<45 & 64>(nums[6], c, ans);
deal<45 & 128>(nums[7], c, ans);
break;
};
case 46: {
deal<46 & 1>(nums[0], c, ans);
deal<46 & 2>(nums[1], c, ans);
deal<46 & 4>(nums[2], c, ans);
deal<46 & 8>(nums[3], c, ans);
deal<46 & 16>(nums[4], c, ans);
deal<46 & 32>(nums[5], c, ans);
deal<46 & 64>(nums[6], c, ans);
deal<46 & 128>(nums[7], c, ans);
break;
};
case 47: {
deal<47 & 1>(nums[0], c, ans);
deal<47 & 2>(nums[1], c, ans);
deal<47 & 4>(nums[2], c, ans);
deal<47 & 8>(nums[3], c, ans);
deal<47 & 16>(nums[4], c, ans);
deal<47 & 32>(nums[5], c, ans);
deal<47 & 64>(nums[6], c, ans);
deal<47 & 128>(nums[7], c, ans);
break;
};
case 48: {
deal<48 & 1>(nums[0], c, ans);
deal<48 & 2>(nums[1], c, ans);
deal<48 & 4>(nums[2], c, ans);
deal<48 & 8>(nums[3], c, ans);
deal<48 & 16>(nums[4], c, ans);
deal<48 & 32>(nums[5], c, ans);
deal<48 & 64>(nums[6], c, ans);
deal<48 & 128>(nums[7], c, ans);
break;
};
case 49: {
deal<49 & 1>(nums[0], c, ans);
deal<49 & 2>(nums[1], c, ans);
deal<49 & 4>(nums[2], c, ans);
deal<49 & 8>(nums[3], c, ans);
deal<49 & 16>(nums[4], c, ans);
deal<49 & 32>(nums[5], c, ans);
deal<49 & 64>(nums[6], c, ans);
deal<49 & 128>(nums[7], c, ans);
break;
};
case 50: {
deal<50 & 1>(nums[0], c, ans);
deal<50 & 2>(nums[1], c, ans);
deal<50 & 4>(nums[2], c, ans);
deal<50 & 8>(nums[3], c, ans);
deal<50 & 16>(nums[4], c, ans);
deal<50 & 32>(nums[5], c, ans);
deal<50 & 64>(nums[6], c, ans);
deal<50 & 128>(nums[7], c, ans);
break;
};
case 51: {
deal<51 & 1>(nums[0], c, ans);
deal<51 & 2>(nums[1], c, ans);
deal<51 & 4>(nums[2], c, ans);
deal<51 & 8>(nums[3], c, ans);
deal<51 & 16>(nums[4], c, ans);
deal<51 & 32>(nums[5], c, ans);
deal<51 & 64>(nums[6], c, ans);
deal<51 & 128>(nums[7], c, ans);
break;
};
case 52: {
deal<52 & 1>(nums[0], c, ans);
deal<52 & 2>(nums[1], c, ans);
deal<52 & 4>(nums[2], c, ans);
deal<52 & 8>(nums[3], c, ans);
deal<52 & 16>(nums[4], c, ans);
deal<52 & 32>(nums[5], c, ans);
deal<52 & 64>(nums[6], c, ans);
deal<52 & 128>(nums[7], c, ans);
break;
};
case 53: {
deal<53 & 1>(nums[0], c, ans);
deal<53 & 2>(nums[1], c, ans);
deal<53 & 4>(nums[2], c, ans);
deal<53 & 8>(nums[3], c, ans);
deal<53 & 16>(nums[4], c, ans);
deal<53 & 32>(nums[5], c, ans);
deal<53 & 64>(nums[6], c, ans);
deal<53 & 128>(nums[7], c, ans);
break;
};
case 54: {
deal<54 & 1>(nums[0], c, ans);
deal<54 & 2>(nums[1], c, ans);
deal<54 & 4>(nums[2], c, ans);
deal<54 & 8>(nums[3], c, ans);
deal<54 & 16>(nums[4], c, ans);
deal<54 & 32>(nums[5], c, ans);
deal<54 & 64>(nums[6], c, ans);
deal<54 & 128>(nums[7], c, ans);
break;
};
case 55: {
deal<55 & 1>(nums[0], c, ans);
deal<55 & 2>(nums[1], c, ans);
deal<55 & 4>(nums[2], c, ans);
deal<55 & 8>(nums[3], c, ans);
deal<55 & 16>(nums[4], c, ans);
deal<55 & 32>(nums[5], c, ans);
deal<55 & 64>(nums[6], c, ans);
deal<55 & 128>(nums[7], c, ans);
break;
};
case 56: {
deal<56 & 1>(nums[0], c, ans);
deal<56 & 2>(nums[1], c, ans);
deal<56 & 4>(nums[2], c, ans);
deal<56 & 8>(nums[3], c, ans);
deal<56 & 16>(nums[4], c, ans);
deal<56 & 32>(nums[5], c, ans);
deal<56 & 64>(nums[6], c, ans);
deal<56 & 128>(nums[7], c, ans);
break;
};
case 57: {
deal<57 & 1>(nums[0], c, ans);
deal<57 & 2>(nums[1], c, ans);
deal<57 & 4>(nums[2], c, ans);
deal<57 & 8>(nums[3], c, ans);
deal<57 & 16>(nums[4], c, ans);
deal<57 & 32>(nums[5], c, ans);
deal<57 & 64>(nums[6], c, ans);
deal<57 & 128>(nums[7], c, ans);
break;
};
case 58: {
deal<58 & 1>(nums[0], c, ans);
deal<58 & 2>(nums[1], c, ans);
deal<58 & 4>(nums[2], c, ans);
deal<58 & 8>(nums[3], c, ans);
deal<58 & 16>(nums[4], c, ans);
deal<58 & 32>(nums[5], c, ans);
deal<58 & 64>(nums[6], c, ans);
deal<58 & 128>(nums[7], c, ans);
break;
};
case 59: {
deal<59 & 1>(nums[0], c, ans);
deal<59 & 2>(nums[1], c, ans);
deal<59 & 4>(nums[2], c, ans);
deal<59 & 8>(nums[3], c, ans);
deal<59 & 16>(nums[4], c, ans);
deal<59 & 32>(nums[5], c, ans);
deal<59 & 64>(nums[6], c, ans);
deal<59 & 128>(nums[7], c, ans);
break;
};
case 60: {
deal<60 & 1>(nums[0], c, ans);
deal<60 & 2>(nums[1], c, ans);
deal<60 & 4>(nums[2], c, ans);
deal<60 & 8>(nums[3], c, ans);
deal<60 & 16>(nums[4], c, ans);
deal<60 & 32>(nums[5], c, ans);
deal<60 & 64>(nums[6], c, ans);
deal<60 & 128>(nums[7], c, ans);
break;
};
case 61: {
deal<61 & 1>(nums[0], c, ans);
deal<61 & 2>(nums[1], c, ans);
deal<61 & 4>(nums[2], c, ans);
deal<61 & 8>(nums[3], c, ans);
deal<61 & 16>(nums[4], c, ans);
deal<61 & 32>(nums[5], c, ans);
deal<61 & 64>(nums[6], c, ans);
deal<61 & 128>(nums[7], c, ans);
break;
};
case 62: {
deal<62 & 1>(nums[0], c, ans);
deal<62 & 2>(nums[1], c, ans);
deal<62 & 4>(nums[2], c, ans);
deal<62 & 8>(nums[3], c, ans);
deal<62 & 16>(nums[4], c, ans);
deal<62 & 32>(nums[5], c, ans);
deal<62 & 64>(nums[6], c, ans);
deal<62 & 128>(nums[7], c, ans);
break;
};
case 63: {
deal<63 & 1>(nums[0], c, ans);
deal<63 & 2>(nums[1], c, ans);
deal<63 & 4>(nums[2], c, ans);
deal<63 & 8>(nums[3], c, ans);
deal<63 & 16>(nums[4], c, ans);
deal<63 & 32>(nums[5], c, ans);
deal<63 & 64>(nums[6], c, ans);
deal<63 & 128>(nums[7], c, ans);
break;
};
case 64: {
deal<64 & 1>(nums[0], c, ans);
deal<64 & 2>(nums[1], c, ans);
deal<64 & 4>(nums[2], c, ans);
deal<64 & 8>(nums[3], c, ans);
deal<64 & 16>(nums[4], c, ans);
deal<64 & 32>(nums[5], c, ans);
deal<64 & 64>(nums[6], c, ans);
deal<64 & 128>(nums[7], c, ans);
break;
};
case 65: {
deal<65 & 1>(nums[0], c, ans);
deal<65 & 2>(nums[1], c, ans);
deal<65 & 4>(nums[2], c, ans);
deal<65 & 8>(nums[3], c, ans);
deal<65 & 16>(nums[4], c, ans);
deal<65 & 32>(nums[5], c, ans);
deal<65 & 64>(nums[6], c, ans);
deal<65 & 128>(nums[7], c, ans);
break;
};
case 66: {
deal<66 & 1>(nums[0], c, ans);
deal<66 & 2>(nums[1], c, ans);
deal<66 & 4>(nums[2], c, ans);
deal<66 & 8>(nums[3], c, ans);
deal<66 & 16>(nums[4], c, ans);
deal<66 & 32>(nums[5], c, ans);
deal<66 & 64>(nums[6], c, ans);
deal<66 & 128>(nums[7], c, ans);
break;
};
case 67: {
deal<67 & 1>(nums[0], c, ans);
deal<67 & 2>(nums[1], c, ans);
deal<67 & 4>(nums[2], c, ans);
deal<67 & 8>(nums[3], c, ans);
deal<67 & 16>(nums[4], c, ans);
deal<67 & 32>(nums[5], c, ans);
deal<67 & 64>(nums[6], c, ans);
deal<67 & 128>(nums[7], c, ans);
break;
};
case 68: {
deal<68 & 1>(nums[0], c, ans);
deal<68 & 2>(nums[1], c, ans);
deal<68 & 4>(nums[2], c, ans);
deal<68 & 8>(nums[3], c, ans);
deal<68 & 16>(nums[4], c, ans);
deal<68 & 32>(nums[5], c, ans);
deal<68 & 64>(nums[6], c, ans);
deal<68 & 128>(nums[7], c, ans);
break;
};
case 69: {
deal<69 & 1>(nums[0], c, ans);
deal<69 & 2>(nums[1], c, ans);
deal<69 & 4>(nums[2], c, ans);
deal<69 & 8>(nums[3], c, ans);
deal<69 & 16>(nums[4], c, ans);
deal<69 & 32>(nums[5], c, ans);
deal<69 & 64>(nums[6], c, ans);
deal<69 & 128>(nums[7], c, ans);
break;
};
case 70: {
deal<70 & 1>(nums[0], c, ans);
deal<70 & 2>(nums[1], c, ans);
deal<70 & 4>(nums[2], c, ans);
deal<70 & 8>(nums[3], c, ans);
deal<70 & 16>(nums[4], c, ans);
deal<70 & 32>(nums[5], c, ans);
deal<70 & 64>(nums[6], c, ans);
deal<70 & 128>(nums[7], c, ans);
break;
};
case 71: {
deal<71 & 1>(nums[0], c, ans);
deal<71 & 2>(nums[1], c, ans);
deal<71 & 4>(nums[2], c, ans);
deal<71 & 8>(nums[3], c, ans);
deal<71 & 16>(nums[4], c, ans);
deal<71 & 32>(nums[5], c, ans);
deal<71 & 64>(nums[6], c, ans);
deal<71 & 128>(nums[7], c, ans);
break;
};
case 72: {
deal<72 & 1>(nums[0], c, ans);
deal<72 & 2>(nums[1], c, ans);
deal<72 & 4>(nums[2], c, ans);
deal<72 & 8>(nums[3], c, ans);
deal<72 & 16>(nums[4], c, ans);
deal<72 & 32>(nums[5], c, ans);
deal<72 & 64>(nums[6], c, ans);
deal<72 & 128>(nums[7], c, ans);
break;
};
case 73: {
deal<73 & 1>(nums[0], c, ans);
deal<73 & 2>(nums[1], c, ans);
deal<73 & 4>(nums[2], c, ans);
deal<73 & 8>(nums[3], c, ans);
deal<73 & 16>(nums[4], c, ans);
deal<73 & 32>(nums[5], c, ans);
deal<73 & 64>(nums[6], c, ans);
deal<73 & 128>(nums[7], c, ans);
break;
};
case 74: {
deal<74 & 1>(nums[0], c, ans);
deal<74 & 2>(nums[1], c, ans);
deal<74 & 4>(nums[2], c, ans);
deal<74 & 8>(nums[3], c, ans);
deal<74 & 16>(nums[4], c, ans);
deal<74 & 32>(nums[5], c, ans);
deal<74 & 64>(nums[6], c, ans);
deal<74 & 128>(nums[7], c, ans);
break;
};
case 75: {
deal<75 & 1>(nums[0], c, ans);
deal<75 & 2>(nums[1], c, ans);
deal<75 & 4>(nums[2], c, ans);
deal<75 & 8>(nums[3], c, ans);
deal<75 & 16>(nums[4], c, ans);
deal<75 & 32>(nums[5], c, ans);
deal<75 & 64>(nums[6], c, ans);
deal<75 & 128>(nums[7], c, ans);
break;
};
case 76: {
deal<76 & 1>(nums[0], c, ans);
deal<76 & 2>(nums[1], c, ans);
deal<76 & 4>(nums[2], c, ans);
deal<76 & 8>(nums[3], c, ans);
deal<76 & 16>(nums[4], c, ans);
deal<76 & 32>(nums[5], c, ans);
deal<76 & 64>(nums[6], c, ans);
deal<76 & 128>(nums[7], c, ans);
break;
};
case 77: {
deal<77 & 1>(nums[0], c, ans);
deal<77 & 2>(nums[1], c, ans);
deal<77 & 4>(nums[2], c, ans);
deal<77 & 8>(nums[3], c, ans);
deal<77 & 16>(nums[4], c, ans);
deal<77 & 32>(nums[5], c, ans);
deal<77 & 64>(nums[6], c, ans);
deal<77 & 128>(nums[7], c, ans);
break;
};
case 78: {
deal<78 & 1>(nums[0], c, ans);
deal<78 & 2>(nums[1], c, ans);
deal<78 & 4>(nums[2], c, ans);
deal<78 & 8>(nums[3], c, ans);
deal<78 & 16>(nums[4], c, ans);
deal<78 & 32>(nums[5], c, ans);
deal<78 & 64>(nums[6], c, ans);
deal<78 & 128>(nums[7], c, ans);
break;
};
case 79: {
deal<79 & 1>(nums[0], c, ans);
deal<79 & 2>(nums[1], c, ans);
deal<79 & 4>(nums[2], c, ans);
deal<79 & 8>(nums[3], c, ans);
deal<79 & 16>(nums[4], c, ans);
deal<79 & 32>(nums[5], c, ans);
deal<79 & 64>(nums[6], c, ans);
deal<79 & 128>(nums[7], c, ans);
break;
};
case 80: {
deal<80 & 1>(nums[0], c, ans);
deal<80 & 2>(nums[1], c, ans);
deal<80 & 4>(nums[2], c, ans);
deal<80 & 8>(nums[3], c, ans);
deal<80 & 16>(nums[4], c, ans);
deal<80 & 32>(nums[5], c, ans);
deal<80 & 64>(nums[6], c, ans);
deal<80 & 128>(nums[7], c, ans);
break;
};
case 81: {
deal<81 & 1>(nums[0], c, ans);
deal<81 & 2>(nums[1], c, ans);
deal<81 & 4>(nums[2], c, ans);
deal<81 & 8>(nums[3], c, ans);
deal<81 & 16>(nums[4], c, ans);
deal<81 & 32>(nums[5], c, ans);
deal<81 & 64>(nums[6], c, ans);
deal<81 & 128>(nums[7], c, ans);
break;
};
case 82: {
deal<82 & 1>(nums[0], c, ans);
deal<82 & 2>(nums[1], c, ans);
deal<82 & 4>(nums[2], c, ans);
deal<82 & 8>(nums[3], c, ans);
deal<82 & 16>(nums[4], c, ans);
deal<82 & 32>(nums[5], c, ans);
deal<82 & 64>(nums[6], c, ans);
deal<82 & 128>(nums[7], c, ans);
break;
};
case 83: {
deal<83 & 1>(nums[0], c, ans);
deal<83 & 2>(nums[1], c, ans);
deal<83 & 4>(nums[2], c, ans);
deal<83 & 8>(nums[3], c, ans);
deal<83 & 16>(nums[4], c, ans);
deal<83 & 32>(nums[5], c, ans);
deal<83 & 64>(nums[6], c, ans);
deal<83 & 128>(nums[7], c, ans);
break;
};
case 84: {
deal<84 & 1>(nums[0], c, ans);
deal<84 & 2>(nums[1], c, ans);
deal<84 & 4>(nums[2], c, ans);
deal<84 & 8>(nums[3], c, ans);
deal<84 & 16>(nums[4], c, ans);
deal<84 & 32>(nums[5], c, ans);
deal<84 & 64>(nums[6], c, ans);
deal<84 & 128>(nums[7], c, ans);
break;
};
case 85: {
deal<85 & 1>(nums[0], c, ans);
deal<85 & 2>(nums[1], c, ans);
deal<85 & 4>(nums[2], c, ans);
deal<85 & 8>(nums[3], c, ans);
deal<85 & 16>(nums[4], c, ans);
deal<85 & 32>(nums[5], c, ans);
deal<85 & 64>(nums[6], c, ans);
deal<85 & 128>(nums[7], c, ans);
break;
};
case 86: {
deal<86 & 1>(nums[0], c, ans);
deal<86 & 2>(nums[1], c, ans);
deal<86 & 4>(nums[2], c, ans);
deal<86 & 8>(nums[3], c, ans);
deal<86 & 16>(nums[4], c, ans);
deal<86 & 32>(nums[5], c, ans);
deal<86 & 64>(nums[6], c, ans);
deal<86 & 128>(nums[7], c, ans);
break;
};
case 87: {
deal<87 & 1>(nums[0], c, ans);
deal<87 & 2>(nums[1], c, ans);
deal<87 & 4>(nums[2], c, ans);
deal<87 & 8>(nums[3], c, ans);
deal<87 & 16>(nums[4], c, ans);
deal<87 & 32>(nums[5], c, ans);
deal<87 & 64>(nums[6], c, ans);
deal<87 & 128>(nums[7], c, ans);
break;
};
case 88: {
deal<88 & 1>(nums[0], c, ans);
deal<88 & 2>(nums[1], c, ans);
deal<88 & 4>(nums[2], c, ans);
deal<88 & 8>(nums[3], c, ans);
deal<88 & 16>(nums[4], c, ans);
deal<88 & 32>(nums[5], c, ans);
deal<88 & 64>(nums[6], c, ans);
deal<88 & 128>(nums[7], c, ans);
break;
};
case 89: {
deal<89 & 1>(nums[0], c, ans);
deal<89 & 2>(nums[1], c, ans);
deal<89 & 4>(nums[2], c, ans);
deal<89 & 8>(nums[3], c, ans);
deal<89 & 16>(nums[4], c, ans);
deal<89 & 32>(nums[5], c, ans);
deal<89 & 64>(nums[6], c, ans);
deal<89 & 128>(nums[7], c, ans);
break;
};
case 90: {
deal<90 & 1>(nums[0], c, ans);
deal<90 & 2>(nums[1], c, ans);
deal<90 & 4>(nums[2], c, ans);
deal<90 & 8>(nums[3], c, ans);
deal<90 & 16>(nums[4], c, ans);
deal<90 & 32>(nums[5], c, ans);
deal<90 & 64>(nums[6], c, ans);
deal<90 & 128>(nums[7], c, ans);
break;
};
case 91: {
deal<91 & 1>(nums[0], c, ans);
deal<91 & 2>(nums[1], c, ans);
deal<91 & 4>(nums[2], c, ans);
deal<91 & 8>(nums[3], c, ans);
deal<91 & 16>(nums[4], c, ans);
deal<91 & 32>(nums[5], c, ans);
deal<91 & 64>(nums[6], c, ans);
deal<91 & 128>(nums[7], c, ans);
break;
};
case 92: {
deal<92 & 1>(nums[0], c, ans);
deal<92 & 2>(nums[1], c, ans);
deal<92 & 4>(nums[2], c, ans);
deal<92 & 8>(nums[3], c, ans);
deal<92 & 16>(nums[4], c, ans);
deal<92 & 32>(nums[5], c, ans);
deal<92 & 64>(nums[6], c, ans);
deal<92 & 128>(nums[7], c, ans);
break;
};
case 93: {
deal<93 & 1>(nums[0], c, ans);
deal<93 & 2>(nums[1], c, ans);
deal<93 & 4>(nums[2], c, ans);
deal<93 & 8>(nums[3], c, ans);
deal<93 & 16>(nums[4], c, ans);
deal<93 & 32>(nums[5], c, ans);
deal<93 & 64>(nums[6], c, ans);
deal<93 & 128>(nums[7], c, ans);
break;
};
case 94: {
deal<94 & 1>(nums[0], c, ans);
deal<94 & 2>(nums[1], c, ans);
deal<94 & 4>(nums[2], c, ans);
deal<94 & 8>(nums[3], c, ans);
deal<94 & 16>(nums[4], c, ans);
deal<94 & 32>(nums[5], c, ans);
deal<94 & 64>(nums[6], c, ans);
deal<94 & 128>(nums[7], c, ans);
break;
};
case 95: {
deal<95 & 1>(nums[0], c, ans);
deal<95 & 2>(nums[1], c, ans);
deal<95 & 4>(nums[2], c, ans);
deal<95 & 8>(nums[3], c, ans);
deal<95 & 16>(nums[4], c, ans);
deal<95 & 32>(nums[5], c, ans);
deal<95 & 64>(nums[6], c, ans);
deal<95 & 128>(nums[7], c, ans);
break;
};
case 96: {
deal<96 & 1>(nums[0], c, ans);
deal<96 & 2>(nums[1], c, ans);
deal<96 & 4>(nums[2], c, ans);
deal<96 & 8>(nums[3], c, ans);
deal<96 & 16>(nums[4], c, ans);
deal<96 & 32>(nums[5], c, ans);
deal<96 & 64>(nums[6], c, ans);
deal<96 & 128>(nums[7], c, ans);
break;
};
case 97: {
deal<97 & 1>(nums[0], c, ans);
deal<97 & 2>(nums[1], c, ans);
deal<97 & 4>(nums[2], c, ans);
deal<97 & 8>(nums[3], c, ans);
deal<97 & 16>(nums[4], c, ans);
deal<97 & 32>(nums[5], c, ans);
deal<97 & 64>(nums[6], c, ans);
deal<97 & 128>(nums[7], c, ans);
break;
};
case 98: {
deal<98 & 1>(nums[0], c, ans);
deal<98 & 2>(nums[1], c, ans);
deal<98 & 4>(nums[2], c, ans);
deal<98 & 8>(nums[3], c, ans);
deal<98 & 16>(nums[4], c, ans);
deal<98 & 32>(nums[5], c, ans);
deal<98 & 64>(nums[6], c, ans);
deal<98 & 128>(nums[7], c, ans);
break;
};
case 99: {
deal<99 & 1>(nums[0], c, ans);
deal<99 & 2>(nums[1], c, ans);
deal<99 & 4>(nums[2], c, ans);
deal<99 & 8>(nums[3], c, ans);
deal<99 & 16>(nums[4], c, ans);
deal<99 & 32>(nums[5], c, ans);
deal<99 & 64>(nums[6], c, ans);
deal<99 & 128>(nums[7], c, ans);
break;
};
case 100: {
deal<100 & 1>(nums[0], c, ans);
deal<100 & 2>(nums[1], c, ans);
deal<100 & 4>(nums[2], c, ans);
deal<100 & 8>(nums[3], c, ans);
deal<100 & 16>(nums[4], c, ans);
deal<100 & 32>(nums[5], c, ans);
deal<100 & 64>(nums[6], c, ans);
deal<100 & 128>(nums[7], c, ans);
break;
};
case 101: {
deal<101 & 1>(nums[0], c, ans);
deal<101 & 2>(nums[1], c, ans);
deal<101 & 4>(nums[2], c, ans);
deal<101 & 8>(nums[3], c, ans);
deal<101 & 16>(nums[4], c, ans);
deal<101 & 32>(nums[5], c, ans);
deal<101 & 64>(nums[6], c, ans);
deal<101 & 128>(nums[7], c, ans);
break;
};
case 102: {
deal<102 & 1>(nums[0], c, ans);
deal<102 & 2>(nums[1], c, ans);
deal<102 & 4>(nums[2], c, ans);
deal<102 & 8>(nums[3], c, ans);
deal<102 & 16>(nums[4], c, ans);
deal<102 & 32>(nums[5], c, ans);
deal<102 & 64>(nums[6], c, ans);
deal<102 & 128>(nums[7], c, ans);
break;
};
case 103: {
deal<103 & 1>(nums[0], c, ans);
deal<103 & 2>(nums[1], c, ans);
deal<103 & 4>(nums[2], c, ans);
deal<103 & 8>(nums[3], c, ans);
deal<103 & 16>(nums[4], c, ans);
deal<103 & 32>(nums[5], c, ans);
deal<103 & 64>(nums[6], c, ans);
deal<103 & 128>(nums[7], c, ans);
break;
};
case 104: {
deal<104 & 1>(nums[0], c, ans);
deal<104 & 2>(nums[1], c, ans);
deal<104 & 4>(nums[2], c, ans);
deal<104 & 8>(nums[3], c, ans);
deal<104 & 16>(nums[4], c, ans);
deal<104 & 32>(nums[5], c, ans);
deal<104 & 64>(nums[6], c, ans);
deal<104 & 128>(nums[7], c, ans);
break;
};
case 105: {
deal<105 & 1>(nums[0], c, ans);
deal<105 & 2>(nums[1], c, ans);
deal<105 & 4>(nums[2], c, ans);
deal<105 & 8>(nums[3], c, ans);
deal<105 & 16>(nums[4], c, ans);
deal<105 & 32>(nums[5], c, ans);
deal<105 & 64>(nums[6], c, ans);
deal<105 & 128>(nums[7], c, ans);
break;
};
case 106: {
deal<106 & 1>(nums[0], c, ans);
deal<106 & 2>(nums[1], c, ans);
deal<106 & 4>(nums[2], c, ans);
deal<106 & 8>(nums[3], c, ans);
deal<106 & 16>(nums[4], c, ans);
deal<106 & 32>(nums[5], c, ans);
deal<106 & 64>(nums[6], c, ans);
deal<106 & 128>(nums[7], c, ans);
break;
};
case 107: {
deal<107 & 1>(nums[0], c, ans);
deal<107 & 2>(nums[1], c, ans);
deal<107 & 4>(nums[2], c, ans);
deal<107 & 8>(nums[3], c, ans);
deal<107 & 16>(nums[4], c, ans);
deal<107 & 32>(nums[5], c, ans);
deal<107 & 64>(nums[6], c, ans);
deal<107 & 128>(nums[7], c, ans);
break;
};
case 108: {
deal<108 & 1>(nums[0], c, ans);
deal<108 & 2>(nums[1], c, ans);
deal<108 & 4>(nums[2], c, ans);
deal<108 & 8>(nums[3], c, ans);
deal<108 & 16>(nums[4], c, ans);
deal<108 & 32>(nums[5], c, ans);
deal<108 & 64>(nums[6], c, ans);
deal<108 & 128>(nums[7], c, ans);
break;
};
case 109: {
deal<109 & 1>(nums[0], c, ans);
deal<109 & 2>(nums[1], c, ans);
deal<109 & 4>(nums[2], c, ans);
deal<109 & 8>(nums[3], c, ans);
deal<109 & 16>(nums[4], c, ans);
deal<109 & 32>(nums[5], c, ans);
deal<109 & 64>(nums[6], c, ans);
deal<109 & 128>(nums[7], c, ans);
break;
};
case 110: {
deal<110 & 1>(nums[0], c, ans);
deal<110 & 2>(nums[1], c, ans);
deal<110 & 4>(nums[2], c, ans);
deal<110 & 8>(nums[3], c, ans);
deal<110 & 16>(nums[4], c, ans);
deal<110 & 32>(nums[5], c, ans);
deal<110 & 64>(nums[6], c, ans);
deal<110 & 128>(nums[7], c, ans);
break;
};
case 111: {
deal<111 & 1>(nums[0], c, ans);
deal<111 & 2>(nums[1], c, ans);
deal<111 & 4>(nums[2], c, ans);
deal<111 & 8>(nums[3], c, ans);
deal<111 & 16>(nums[4], c, ans);
deal<111 & 32>(nums[5], c, ans);
deal<111 & 64>(nums[6], c, ans);
deal<111 & 128>(nums[7], c, ans);
break;
};
case 112: {
deal<112 & 1>(nums[0], c, ans);
deal<112 & 2>(nums[1], c, ans);
deal<112 & 4>(nums[2], c, ans);
deal<112 & 8>(nums[3], c, ans);
deal<112 & 16>(nums[4], c, ans);
deal<112 & 32>(nums[5], c, ans);
deal<112 & 64>(nums[6], c, ans);
deal<112 & 128>(nums[7], c, ans);
break;
};
case 113: {
deal<113 & 1>(nums[0], c, ans);
deal<113 & 2>(nums[1], c, ans);
deal<113 & 4>(nums[2], c, ans);
deal<113 & 8>(nums[3], c, ans);
deal<113 & 16>(nums[4], c, ans);
deal<113 & 32>(nums[5], c, ans);
deal<113 & 64>(nums[6], c, ans);
deal<113 & 128>(nums[7], c, ans);
break;
};
case 114: {
deal<114 & 1>(nums[0], c, ans);
deal<114 & 2>(nums[1], c, ans);
deal<114 & 4>(nums[2], c, ans);
deal<114 & 8>(nums[3], c, ans);
deal<114 & 16>(nums[4], c, ans);
deal<114 & 32>(nums[5], c, ans);
deal<114 & 64>(nums[6], c, ans);
deal<114 & 128>(nums[7], c, ans);
break;
};
case 115: {
deal<115 & 1>(nums[0], c, ans);
deal<115 & 2>(nums[1], c, ans);
deal<115 & 4>(nums[2], c, ans);
deal<115 & 8>(nums[3], c, ans);
deal<115 & 16>(nums[4], c, ans);
deal<115 & 32>(nums[5], c, ans);
deal<115 & 64>(nums[6], c, ans);
deal<115 & 128>(nums[7], c, ans);
break;
};
case 116: {
deal<116 & 1>(nums[0], c, ans);
deal<116 & 2>(nums[1], c, ans);
deal<116 & 4>(nums[2], c, ans);
deal<116 & 8>(nums[3], c, ans);
deal<116 & 16>(nums[4], c, ans);
deal<116 & 32>(nums[5], c, ans);
deal<116 & 64>(nums[6], c, ans);
deal<116 & 128>(nums[7], c, ans);
break;
};
case 117: {
deal<117 & 1>(nums[0], c, ans);
deal<117 & 2>(nums[1], c, ans);
deal<117 & 4>(nums[2], c, ans);
deal<117 & 8>(nums[3], c, ans);
deal<117 & 16>(nums[4], c, ans);
deal<117 & 32>(nums[5], c, ans);
deal<117 & 64>(nums[6], c, ans);
deal<117 & 128>(nums[7], c, ans);
break;
};
case 118: {
deal<118 & 1>(nums[0], c, ans);
deal<118 & 2>(nums[1], c, ans);
deal<118 & 4>(nums[2], c, ans);
deal<118 & 8>(nums[3], c, ans);
deal<118 & 16>(nums[4], c, ans);
deal<118 & 32>(nums[5], c, ans);
deal<118 & 64>(nums[6], c, ans);
deal<118 & 128>(nums[7], c, ans);
break;
};
case 119: {
deal<119 & 1>(nums[0], c, ans);
deal<119 & 2>(nums[1], c, ans);
deal<119 & 4>(nums[2], c, ans);
deal<119 & 8>(nums[3], c, ans);
deal<119 & 16>(nums[4], c, ans);
deal<119 & 32>(nums[5], c, ans);
deal<119 & 64>(nums[6], c, ans);
deal<119 & 128>(nums[7], c, ans);
break;
};
case 120: {
deal<120 & 1>(nums[0], c, ans);
deal<120 & 2>(nums[1], c, ans);
deal<120 & 4>(nums[2], c, ans);
deal<120 & 8>(nums[3], c, ans);
deal<120 & 16>(nums[4], c, ans);
deal<120 & 32>(nums[5], c, ans);
deal<120 & 64>(nums[6], c, ans);
deal<120 & 128>(nums[7], c, ans);
break;
};
case 121: {
deal<121 & 1>(nums[0], c, ans);
deal<121 & 2>(nums[1], c, ans);
deal<121 & 4>(nums[2], c, ans);
deal<121 & 8>(nums[3], c, ans);
deal<121 & 16>(nums[4], c, ans);
deal<121 & 32>(nums[5], c, ans);
deal<121 & 64>(nums[6], c, ans);
deal<121 & 128>(nums[7], c, ans);
break;
};
case 122: {
deal<122 & 1>(nums[0], c, ans);
deal<122 & 2>(nums[1], c, ans);
deal<122 & 4>(nums[2], c, ans);
deal<122 & 8>(nums[3], c, ans);
deal<122 & 16>(nums[4], c, ans);
deal<122 & 32>(nums[5], c, ans);
deal<122 & 64>(nums[6], c, ans);
deal<122 & 128>(nums[7], c, ans);
break;
};
case 123: {
deal<123 & 1>(nums[0], c, ans);
deal<123 & 2>(nums[1], c, ans);
deal<123 & 4>(nums[2], c, ans);
deal<123 & 8>(nums[3], c, ans);
deal<123 & 16>(nums[4], c, ans);
deal<123 & 32>(nums[5], c, ans);
deal<123 & 64>(nums[6], c, ans);
deal<123 & 128>(nums[7], c, ans);
break;
};
case 124: {
deal<124 & 1>(nums[0], c, ans);
deal<124 & 2>(nums[1], c, ans);
deal<124 & 4>(nums[2], c, ans);
deal<124 & 8>(nums[3], c, ans);
deal<124 & 16>(nums[4], c, ans);
deal<124 & 32>(nums[5], c, ans);
deal<124 & 64>(nums[6], c, ans);
deal<124 & 128>(nums[7], c, ans);
break;
};
case 125: {
deal<125 & 1>(nums[0], c, ans);
deal<125 & 2>(nums[1], c, ans);
deal<125 & 4>(nums[2], c, ans);
deal<125 & 8>(nums[3], c, ans);
deal<125 & 16>(nums[4], c, ans);
deal<125 & 32>(nums[5], c, ans);
deal<125 & 64>(nums[6], c, ans);
deal<125 & 128>(nums[7], c, ans);
break;
};
case 126: {
deal<126 & 1>(nums[0], c, ans);
deal<126 & 2>(nums[1], c, ans);
deal<126 & 4>(nums[2], c, ans);
deal<126 & 8>(nums[3], c, ans);
deal<126 & 16>(nums[4], c, ans);
deal<126 & 32>(nums[5], c, ans);
deal<126 & 64>(nums[6], c, ans);
deal<126 & 128>(nums[7], c, ans);
break;
};
case 127: {
deal<127 & 1>(nums[0], c, ans);
deal<127 & 2>(nums[1], c, ans);
deal<127 & 4>(nums[2], c, ans);
deal<127 & 8>(nums[3], c, ans);
deal<127 & 16>(nums[4], c, ans);
deal<127 & 32>(nums[5], c, ans);
deal<127 & 64>(nums[6], c, ans);
deal<127 & 128>(nums[7], c, ans);
break;
};
case 128: {
deal<128 & 1>(nums[0], c, ans);
deal<128 & 2>(nums[1], c, ans);
deal<128 & 4>(nums[2], c, ans);
deal<128 & 8>(nums[3], c, ans);
deal<128 & 16>(nums[4], c, ans);
deal<128 & 32>(nums[5], c, ans);
deal<128 & 64>(nums[6], c, ans);
deal<128 & 128>(nums[7], c, ans);
break;
};
case 129: {
deal<129 & 1>(nums[0], c, ans);
deal<129 & 2>(nums[1], c, ans);
deal<129 & 4>(nums[2], c, ans);
deal<129 & 8>(nums[3], c, ans);
deal<129 & 16>(nums[4], c, ans);
deal<129 & 32>(nums[5], c, ans);
deal<129 & 64>(nums[6], c, ans);
deal<129 & 128>(nums[7], c, ans);
break;
};
case 130: {
deal<130 & 1>(nums[0], c, ans);
deal<130 & 2>(nums[1], c, ans);
deal<130 & 4>(nums[2], c, ans);
deal<130 & 8>(nums[3], c, ans);
deal<130 & 16>(nums[4], c, ans);
deal<130 & 32>(nums[5], c, ans);
deal<130 & 64>(nums[6], c, ans);
deal<130 & 128>(nums[7], c, ans);
break;
};
case 131: {
deal<131 & 1>(nums[0], c, ans);
deal<131 & 2>(nums[1], c, ans);
deal<131 & 4>(nums[2], c, ans);
deal<131 & 8>(nums[3], c, ans);
deal<131 & 16>(nums[4], c, ans);
deal<131 & 32>(nums[5], c, ans);
deal<131 & 64>(nums[6], c, ans);
deal<131 & 128>(nums[7], c, ans);
break;
};
case 132: {
deal<132 & 1>(nums[0], c, ans);
deal<132 & 2>(nums[1], c, ans);
deal<132 & 4>(nums[2], c, ans);
deal<132 & 8>(nums[3], c, ans);
deal<132 & 16>(nums[4], c, ans);
deal<132 & 32>(nums[5], c, ans);
deal<132 & 64>(nums[6], c, ans);
deal<132 & 128>(nums[7], c, ans);
break;
};
case 133: {
deal<133 & 1>(nums[0], c, ans);
deal<133 & 2>(nums[1], c, ans);
deal<133 & 4>(nums[2], c, ans);
deal<133 & 8>(nums[3], c, ans);
deal<133 & 16>(nums[4], c, ans);
deal<133 & 32>(nums[5], c, ans);
deal<133 & 64>(nums[6], c, ans);
deal<133 & 128>(nums[7], c, ans);
break;
};
case 134: {
deal<134 & 1>(nums[0], c, ans);
deal<134 & 2>(nums[1], c, ans);
deal<134 & 4>(nums[2], c, ans);
deal<134 & 8>(nums[3], c, ans);
deal<134 & 16>(nums[4], c, ans);
deal<134 & 32>(nums[5], c, ans);
deal<134 & 64>(nums[6], c, ans);
deal<134 & 128>(nums[7], c, ans);
break;
};
case 135: {
deal<135 & 1>(nums[0], c, ans);
deal<135 & 2>(nums[1], c, ans);
deal<135 & 4>(nums[2], c, ans);
deal<135 & 8>(nums[3], c, ans);
deal<135 & 16>(nums[4], c, ans);
deal<135 & 32>(nums[5], c, ans);
deal<135 & 64>(nums[6], c, ans);
deal<135 & 128>(nums[7], c, ans);
break;
};
case 136: {
deal<136 & 1>(nums[0], c, ans);
deal<136 & 2>(nums[1], c, ans);
deal<136 & 4>(nums[2], c, ans);
deal<136 & 8>(nums[3], c, ans);
deal<136 & 16>(nums[4], c, ans);
deal<136 & 32>(nums[5], c, ans);
deal<136 & 64>(nums[6], c, ans);
deal<136 & 128>(nums[7], c, ans);
break;
};
case 137: {
deal<137 & 1>(nums[0], c, ans);
deal<137 & 2>(nums[1], c, ans);
deal<137 & 4>(nums[2], c, ans);
deal<137 & 8>(nums[3], c, ans);
deal<137 & 16>(nums[4], c, ans);
deal<137 & 32>(nums[5], c, ans);
deal<137 & 64>(nums[6], c, ans);
deal<137 & 128>(nums[7], c, ans);
break;
};
case 138: {
deal<138 & 1>(nums[0], c, ans);
deal<138 & 2>(nums[1], c, ans);
deal<138 & 4>(nums[2], c, ans);
deal<138 & 8>(nums[3], c, ans);
deal<138 & 16>(nums[4], c, ans);
deal<138 & 32>(nums[5], c, ans);
deal<138 & 64>(nums[6], c, ans);
deal<138 & 128>(nums[7], c, ans);
break;
};
case 139: {
deal<139 & 1>(nums[0], c, ans);
deal<139 & 2>(nums[1], c, ans);
deal<139 & 4>(nums[2], c, ans);
deal<139 & 8>(nums[3], c, ans);
deal<139 & 16>(nums[4], c, ans);
deal<139 & 32>(nums[5], c, ans);
deal<139 & 64>(nums[6], c, ans);
deal<139 & 128>(nums[7], c, ans);
break;
};
case 140: {
deal<140 & 1>(nums[0], c, ans);
deal<140 & 2>(nums[1], c, ans);
deal<140 & 4>(nums[2], c, ans);
deal<140 & 8>(nums[3], c, ans);
deal<140 & 16>(nums[4], c, ans);
deal<140 & 32>(nums[5], c, ans);
deal<140 & 64>(nums[6], c, ans);
deal<140 & 128>(nums[7], c, ans);
break;
};
case 141: {
deal<141 & 1>(nums[0], c, ans);
deal<141 & 2>(nums[1], c, ans);
deal<141 & 4>(nums[2], c, ans);
deal<141 & 8>(nums[3], c, ans);
deal<141 & 16>(nums[4], c, ans);
deal<141 & 32>(nums[5], c, ans);
deal<141 & 64>(nums[6], c, ans);
deal<141 & 128>(nums[7], c, ans);
break;
};
case 142: {
deal<142 & 1>(nums[0], c, ans);
deal<142 & 2>(nums[1], c, ans);
deal<142 & 4>(nums[2], c, ans);
deal<142 & 8>(nums[3], c, ans);
deal<142 & 16>(nums[4], c, ans);
deal<142 & 32>(nums[5], c, ans);
deal<142 & 64>(nums[6], c, ans);
deal<142 & 128>(nums[7], c, ans);
break;
};
case 143: {
deal<143 & 1>(nums[0], c, ans);
deal<143 & 2>(nums[1], c, ans);
deal<143 & 4>(nums[2], c, ans);
deal<143 & 8>(nums[3], c, ans);
deal<143 & 16>(nums[4], c, ans);
deal<143 & 32>(nums[5], c, ans);
deal<143 & 64>(nums[6], c, ans);
deal<143 & 128>(nums[7], c, ans);
break;
};
case 144: {
deal<144 & 1>(nums[0], c, ans);
deal<144 & 2>(nums[1], c, ans);
deal<144 & 4>(nums[2], c, ans);
deal<144 & 8>(nums[3], c, ans);
deal<144 & 16>(nums[4], c, ans);
deal<144 & 32>(nums[5], c, ans);
deal<144 & 64>(nums[6], c, ans);
deal<144 & 128>(nums[7], c, ans);
break;
};
case 145: {
deal<145 & 1>(nums[0], c, ans);
deal<145 & 2>(nums[1], c, ans);
deal<145 & 4>(nums[2], c, ans);
deal<145 & 8>(nums[3], c, ans);
deal<145 & 16>(nums[4], c, ans);
deal<145 & 32>(nums[5], c, ans);
deal<145 & 64>(nums[6], c, ans);
deal<145 & 128>(nums[7], c, ans);
break;
};
case 146: {
deal<146 & 1>(nums[0], c, ans);
deal<146 & 2>(nums[1], c, ans);
deal<146 & 4>(nums[2], c, ans);
deal<146 & 8>(nums[3], c, ans);
deal<146 & 16>(nums[4], c, ans);
deal<146 & 32>(nums[5], c, ans);
deal<146 & 64>(nums[6], c, ans);
deal<146 & 128>(nums[7], c, ans);
break;
};
case 147: {
deal<147 & 1>(nums[0], c, ans);
deal<147 & 2>(nums[1], c, ans);
deal<147 & 4>(nums[2], c, ans);
deal<147 & 8>(nums[3], c, ans);
deal<147 & 16>(nums[4], c, ans);
deal<147 & 32>(nums[5], c, ans);
deal<147 & 64>(nums[6], c, ans);
deal<147 & 128>(nums[7], c, ans);
break;
};
case 148: {
deal<148 & 1>(nums[0], c, ans);
deal<148 & 2>(nums[1], c, ans);
deal<148 & 4>(nums[2], c, ans);
deal<148 & 8>(nums[3], c, ans);
deal<148 & 16>(nums[4], c, ans);
deal<148 & 32>(nums[5], c, ans);
deal<148 & 64>(nums[6], c, ans);
deal<148 & 128>(nums[7], c, ans);
break;
};
case 149: {
deal<149 & 1>(nums[0], c, ans);
deal<149 & 2>(nums[1], c, ans);
deal<149 & 4>(nums[2], c, ans);
deal<149 & 8>(nums[3], c, ans);
deal<149 & 16>(nums[4], c, ans);
deal<149 & 32>(nums[5], c, ans);
deal<149 & 64>(nums[6], c, ans);
deal<149 & 128>(nums[7], c, ans);
break;
};
case 150: {
deal<150 & 1>(nums[0], c, ans);
deal<150 & 2>(nums[1], c, ans);
deal<150 & 4>(nums[2], c, ans);
deal<150 & 8>(nums[3], c, ans);
deal<150 & 16>(nums[4], c, ans);
deal<150 & 32>(nums[5], c, ans);
deal<150 & 64>(nums[6], c, ans);
deal<150 & 128>(nums[7], c, ans);
break;
};
case 151: {
deal<151 & 1>(nums[0], c, ans);
deal<151 & 2>(nums[1], c, ans);
deal<151 & 4>(nums[2], c, ans);
deal<151 & 8>(nums[3], c, ans);
deal<151 & 16>(nums[4], c, ans);
deal<151 & 32>(nums[5], c, ans);
deal<151 & 64>(nums[6], c, ans);
deal<151 & 128>(nums[7], c, ans);
break;
};
case 152: {
deal<152 & 1>(nums[0], c, ans);
deal<152 & 2>(nums[1], c, ans);
deal<152 & 4>(nums[2], c, ans);
deal<152 & 8>(nums[3], c, ans);
deal<152 & 16>(nums[4], c, ans);
deal<152 & 32>(nums[5], c, ans);
deal<152 & 64>(nums[6], c, ans);
deal<152 & 128>(nums[7], c, ans);
break;
};
case 153: {
deal<153 & 1>(nums[0], c, ans);
deal<153 & 2>(nums[1], c, ans);
deal<153 & 4>(nums[2], c, ans);
deal<153 & 8>(nums[3], c, ans);
deal<153 & 16>(nums[4], c, ans);
deal<153 & 32>(nums[5], c, ans);
deal<153 & 64>(nums[6], c, ans);
deal<153 & 128>(nums[7], c, ans);
break;
};
case 154: {
deal<154 & 1>(nums[0], c, ans);
deal<154 & 2>(nums[1], c, ans);
deal<154 & 4>(nums[2], c, ans);
deal<154 & 8>(nums[3], c, ans);
deal<154 & 16>(nums[4], c, ans);
deal<154 & 32>(nums[5], c, ans);
deal<154 & 64>(nums[6], c, ans);
deal<154 & 128>(nums[7], c, ans);
break;
};
case 155: {
deal<155 & 1>(nums[0], c, ans);
deal<155 & 2>(nums[1], c, ans);
deal<155 & 4>(nums[2], c, ans);
deal<155 & 8>(nums[3], c, ans);
deal<155 & 16>(nums[4], c, ans);
deal<155 & 32>(nums[5], c, ans);
deal<155 & 64>(nums[6], c, ans);
deal<155 & 128>(nums[7], c, ans);
break;
};
case 156: {
deal<156 & 1>(nums[0], c, ans);
deal<156 & 2>(nums[1], c, ans);
deal<156 & 4>(nums[2], c, ans);
deal<156 & 8>(nums[3], c, ans);
deal<156 & 16>(nums[4], c, ans);
deal<156 & 32>(nums[5], c, ans);
deal<156 & 64>(nums[6], c, ans);
deal<156 & 128>(nums[7], c, ans);
break;
};
case 157: {
deal<157 & 1>(nums[0], c, ans);
deal<157 & 2>(nums[1], c, ans);
deal<157 & 4>(nums[2], c, ans);
deal<157 & 8>(nums[3], c, ans);
deal<157 & 16>(nums[4], c, ans);
deal<157 & 32>(nums[5], c, ans);
deal<157 & 64>(nums[6], c, ans);
deal<157 & 128>(nums[7], c, ans);
break;
};
case 158: {
deal<158 & 1>(nums[0], c, ans);
deal<158 & 2>(nums[1], c, ans);
deal<158 & 4>(nums[2], c, ans);
deal<158 & 8>(nums[3], c, ans);
deal<158 & 16>(nums[4], c, ans);
deal<158 & 32>(nums[5], c, ans);
deal<158 & 64>(nums[6], c, ans);
deal<158 & 128>(nums[7], c, ans);
break;
};
case 159: {
deal<159 & 1>(nums[0], c, ans);
deal<159 & 2>(nums[1], c, ans);
deal<159 & 4>(nums[2], c, ans);
deal<159 & 8>(nums[3], c, ans);
deal<159 & 16>(nums[4], c, ans);
deal<159 & 32>(nums[5], c, ans);
deal<159 & 64>(nums[6], c, ans);
deal<159 & 128>(nums[7], c, ans);
break;
};
case 160: {
deal<160 & 1>(nums[0], c, ans);
deal<160 & 2>(nums[1], c, ans);
deal<160 & 4>(nums[2], c, ans);
deal<160 & 8>(nums[3], c, ans);
deal<160 & 16>(nums[4], c, ans);
deal<160 & 32>(nums[5], c, ans);
deal<160 & 64>(nums[6], c, ans);
deal<160 & 128>(nums[7], c, ans);
break;
};
case 161: {
deal<161 & 1>(nums[0], c, ans);
deal<161 & 2>(nums[1], c, ans);
deal<161 & 4>(nums[2], c, ans);
deal<161 & 8>(nums[3], c, ans);
deal<161 & 16>(nums[4], c, ans);
deal<161 & 32>(nums[5], c, ans);
deal<161 & 64>(nums[6], c, ans);
deal<161 & 128>(nums[7], c, ans);
break;
};
case 162: {
deal<162 & 1>(nums[0], c, ans);
deal<162 & 2>(nums[1], c, ans);
deal<162 & 4>(nums[2], c, ans);
deal<162 & 8>(nums[3], c, ans);
deal<162 & 16>(nums[4], c, ans);
deal<162 & 32>(nums[5], c, ans);
deal<162 & 64>(nums[6], c, ans);
deal<162 & 128>(nums[7], c, ans);
break;
};
case 163: {
deal<163 & 1>(nums[0], c, ans);
deal<163 & 2>(nums[1], c, ans);
deal<163 & 4>(nums[2], c, ans);
deal<163 & 8>(nums[3], c, ans);
deal<163 & 16>(nums[4], c, ans);
deal<163 & 32>(nums[5], c, ans);
deal<163 & 64>(nums[6], c, ans);
deal<163 & 128>(nums[7], c, ans);
break;
};
case 164: {
deal<164 & 1>(nums[0], c, ans);
deal<164 & 2>(nums[1], c, ans);
deal<164 & 4>(nums[2], c, ans);
deal<164 & 8>(nums[3], c, ans);
deal<164 & 16>(nums[4], c, ans);
deal<164 & 32>(nums[5], c, ans);
deal<164 & 64>(nums[6], c, ans);
deal<164 & 128>(nums[7], c, ans);
break;
};
case 165: {
deal<165 & 1>(nums[0], c, ans);
deal<165 & 2>(nums[1], c, ans);
deal<165 & 4>(nums[2], c, ans);
deal<165 & 8>(nums[3], c, ans);
deal<165 & 16>(nums[4], c, ans);
deal<165 & 32>(nums[5], c, ans);
deal<165 & 64>(nums[6], c, ans);
deal<165 & 128>(nums[7], c, ans);
break;
};
case 166: {
deal<166 & 1>(nums[0], c, ans);
deal<166 & 2>(nums[1], c, ans);
deal<166 & 4>(nums[2], c, ans);
deal<166 & 8>(nums[3], c, ans);
deal<166 & 16>(nums[4], c, ans);
deal<166 & 32>(nums[5], c, ans);
deal<166 & 64>(nums[6], c, ans);
deal<166 & 128>(nums[7], c, ans);
break;
};
case 167: {
deal<167 & 1>(nums[0], c, ans);
deal<167 & 2>(nums[1], c, ans);
deal<167 & 4>(nums[2], c, ans);
deal<167 & 8>(nums[3], c, ans);
deal<167 & 16>(nums[4], c, ans);
deal<167 & 32>(nums[5], c, ans);
deal<167 & 64>(nums[6], c, ans);
deal<167 & 128>(nums[7], c, ans);
break;
};
case 168: {
deal<168 & 1>(nums[0], c, ans);
deal<168 & 2>(nums[1], c, ans);
deal<168 & 4>(nums[2], c, ans);
deal<168 & 8>(nums[3], c, ans);
deal<168 & 16>(nums[4], c, ans);
deal<168 & 32>(nums[5], c, ans);
deal<168 & 64>(nums[6], c, ans);
deal<168 & 128>(nums[7], c, ans);
break;
};
case 169: {
deal<169 & 1>(nums[0], c, ans);
deal<169 & 2>(nums[1], c, ans);
deal<169 & 4>(nums[2], c, ans);
deal<169 & 8>(nums[3], c, ans);
deal<169 & 16>(nums[4], c, ans);
deal<169 & 32>(nums[5], c, ans);
deal<169 & 64>(nums[6], c, ans);
deal<169 & 128>(nums[7], c, ans);
break;
};
case 170: {
deal<170 & 1>(nums[0], c, ans);
deal<170 & 2>(nums[1], c, ans);
deal<170 & 4>(nums[2], c, ans);
deal<170 & 8>(nums[3], c, ans);
deal<170 & 16>(nums[4], c, ans);
deal<170 & 32>(nums[5], c, ans);
deal<170 & 64>(nums[6], c, ans);
deal<170 & 128>(nums[7], c, ans);
break;
};
case 171: {
deal<171 & 1>(nums[0], c, ans);
deal<171 & 2>(nums[1], c, ans);
deal<171 & 4>(nums[2], c, ans);
deal<171 & 8>(nums[3], c, ans);
deal<171 & 16>(nums[4], c, ans);
deal<171 & 32>(nums[5], c, ans);
deal<171 & 64>(nums[6], c, ans);
deal<171 & 128>(nums[7], c, ans);
break;
};
case 172: {
deal<172 & 1>(nums[0], c, ans);
deal<172 & 2>(nums[1], c, ans);
deal<172 & 4>(nums[2], c, ans);
deal<172 & 8>(nums[3], c, ans);
deal<172 & 16>(nums[4], c, ans);
deal<172 & 32>(nums[5], c, ans);
deal<172 & 64>(nums[6], c, ans);
deal<172 & 128>(nums[7], c, ans);
break;
};
case 173: {
deal<173 & 1>(nums[0], c, ans);
deal<173 & 2>(nums[1], c, ans);
deal<173 & 4>(nums[2], c, ans);
deal<173 & 8>(nums[3], c, ans);
deal<173 & 16>(nums[4], c, ans);
deal<173 & 32>(nums[5], c, ans);
deal<173 & 64>(nums[6], c, ans);
deal<173 & 128>(nums[7], c, ans);
break;
};
case 174: {
deal<174 & 1>(nums[0], c, ans);
deal<174 & 2>(nums[1], c, ans);
deal<174 & 4>(nums[2], c, ans);
deal<174 & 8>(nums[3], c, ans);
deal<174 & 16>(nums[4], c, ans);
deal<174 & 32>(nums[5], c, ans);
deal<174 & 64>(nums[6], c, ans);
deal<174 & 128>(nums[7], c, ans);
break;
};
case 175: {
deal<175 & 1>(nums[0], c, ans);
deal<175 & 2>(nums[1], c, ans);
deal<175 & 4>(nums[2], c, ans);
deal<175 & 8>(nums[3], c, ans);
deal<175 & 16>(nums[4], c, ans);
deal<175 & 32>(nums[5], c, ans);
deal<175 & 64>(nums[6], c, ans);
deal<175 & 128>(nums[7], c, ans);
break;
};
case 176: {
deal<176 & 1>(nums[0], c, ans);
deal<176 & 2>(nums[1], c, ans);
deal<176 & 4>(nums[2], c, ans);
deal<176 & 8>(nums[3], c, ans);
deal<176 & 16>(nums[4], c, ans);
deal<176 & 32>(nums[5], c, ans);
deal<176 & 64>(nums[6], c, ans);
deal<176 & 128>(nums[7], c, ans);
break;
};
case 177: {
deal<177 & 1>(nums[0], c, ans);
deal<177 & 2>(nums[1], c, ans);
deal<177 & 4>(nums[2], c, ans);
deal<177 & 8>(nums[3], c, ans);
deal<177 & 16>(nums[4], c, ans);
deal<177 & 32>(nums[5], c, ans);
deal<177 & 64>(nums[6], c, ans);
deal<177 & 128>(nums[7], c, ans);
break;
};
case 178: {
deal<178 & 1>(nums[0], c, ans);
deal<178 & 2>(nums[1], c, ans);
deal<178 & 4>(nums[2], c, ans);
deal<178 & 8>(nums[3], c, ans);
deal<178 & 16>(nums[4], c, ans);
deal<178 & 32>(nums[5], c, ans);
deal<178 & 64>(nums[6], c, ans);
deal<178 & 128>(nums[7], c, ans);
break;
};
case 179: {
deal<179 & 1>(nums[0], c, ans);
deal<179 & 2>(nums[1], c, ans);
deal<179 & 4>(nums[2], c, ans);
deal<179 & 8>(nums[3], c, ans);
deal<179 & 16>(nums[4], c, ans);
deal<179 & 32>(nums[5], c, ans);
deal<179 & 64>(nums[6], c, ans);
deal<179 & 128>(nums[7], c, ans);
break;
};
case 180: {
deal<180 & 1>(nums[0], c, ans);
deal<180 & 2>(nums[1], c, ans);
deal<180 & 4>(nums[2], c, ans);
deal<180 & 8>(nums[3], c, ans);
deal<180 & 16>(nums[4], c, ans);
deal<180 & 32>(nums[5], c, ans);
deal<180 & 64>(nums[6], c, ans);
deal<180 & 128>(nums[7], c, ans);
break;
};
case 181: {
deal<181 & 1>(nums[0], c, ans);
deal<181 & 2>(nums[1], c, ans);
deal<181 & 4>(nums[2], c, ans);
deal<181 & 8>(nums[3], c, ans);
deal<181 & 16>(nums[4], c, ans);
deal<181 & 32>(nums[5], c, ans);
deal<181 & 64>(nums[6], c, ans);
deal<181 & 128>(nums[7], c, ans);
break;
};
case 182: {
deal<182 & 1>(nums[0], c, ans);
deal<182 & 2>(nums[1], c, ans);
deal<182 & 4>(nums[2], c, ans);
deal<182 & 8>(nums[3], c, ans);
deal<182 & 16>(nums[4], c, ans);
deal<182 & 32>(nums[5], c, ans);
deal<182 & 64>(nums[6], c, ans);
deal<182 & 128>(nums[7], c, ans);
break;
};
case 183: {
deal<183 & 1>(nums[0], c, ans);
deal<183 & 2>(nums[1], c, ans);
deal<183 & 4>(nums[2], c, ans);
deal<183 & 8>(nums[3], c, ans);
deal<183 & 16>(nums[4], c, ans);
deal<183 & 32>(nums[5], c, ans);
deal<183 & 64>(nums[6], c, ans);
deal<183 & 128>(nums[7], c, ans);
break;
};
case 184: {
deal<184 & 1>(nums[0], c, ans);
deal<184 & 2>(nums[1], c, ans);
deal<184 & 4>(nums[2], c, ans);
deal<184 & 8>(nums[3], c, ans);
deal<184 & 16>(nums[4], c, ans);
deal<184 & 32>(nums[5], c, ans);
deal<184 & 64>(nums[6], c, ans);
deal<184 & 128>(nums[7], c, ans);
break;
};
case 185: {
deal<185 & 1>(nums[0], c, ans);
deal<185 & 2>(nums[1], c, ans);
deal<185 & 4>(nums[2], c, ans);
deal<185 & 8>(nums[3], c, ans);
deal<185 & 16>(nums[4], c, ans);
deal<185 & 32>(nums[5], c, ans);
deal<185 & 64>(nums[6], c, ans);
deal<185 & 128>(nums[7], c, ans);
break;
};
case 186: {
deal<186 & 1>(nums[0], c, ans);
deal<186 & 2>(nums[1], c, ans);
deal<186 & 4>(nums[2], c, ans);
deal<186 & 8>(nums[3], c, ans);
deal<186 & 16>(nums[4], c, ans);
deal<186 & 32>(nums[5], c, ans);
deal<186 & 64>(nums[6], c, ans);
deal<186 & 128>(nums[7], c, ans);
break;
};
case 187: {
deal<187 & 1>(nums[0], c, ans);
deal<187 & 2>(nums[1], c, ans);
deal<187 & 4>(nums[2], c, ans);
deal<187 & 8>(nums[3], c, ans);
deal<187 & 16>(nums[4], c, ans);
deal<187 & 32>(nums[5], c, ans);
deal<187 & 64>(nums[6], c, ans);
deal<187 & 128>(nums[7], c, ans);
break;
};
case 188: {
deal<188 & 1>(nums[0], c, ans);
deal<188 & 2>(nums[1], c, ans);
deal<188 & 4>(nums[2], c, ans);
deal<188 & 8>(nums[3], c, ans);
deal<188 & 16>(nums[4], c, ans);
deal<188 & 32>(nums[5], c, ans);
deal<188 & 64>(nums[6], c, ans);
deal<188 & 128>(nums[7], c, ans);
break;
};
case 189: {
deal<189 & 1>(nums[0], c, ans);
deal<189 & 2>(nums[1], c, ans);
deal<189 & 4>(nums[2], c, ans);
deal<189 & 8>(nums[3], c, ans);
deal<189 & 16>(nums[4], c, ans);
deal<189 & 32>(nums[5], c, ans);
deal<189 & 64>(nums[6], c, ans);
deal<189 & 128>(nums[7], c, ans);
break;
};
case 190: {
deal<190 & 1>(nums[0], c, ans);
deal<190 & 2>(nums[1], c, ans);
deal<190 & 4>(nums[2], c, ans);
deal<190 & 8>(nums[3], c, ans);
deal<190 & 16>(nums[4], c, ans);
deal<190 & 32>(nums[5], c, ans);
deal<190 & 64>(nums[6], c, ans);
deal<190 & 128>(nums[7], c, ans);
break;
};
case 191: {
deal<191 & 1>(nums[0], c, ans);
deal<191 & 2>(nums[1], c, ans);
deal<191 & 4>(nums[2], c, ans);
deal<191 & 8>(nums[3], c, ans);
deal<191 & 16>(nums[4], c, ans);
deal<191 & 32>(nums[5], c, ans);
deal<191 & 64>(nums[6], c, ans);
deal<191 & 128>(nums[7], c, ans);
break;
};
case 192: {
deal<192 & 1>(nums[0], c, ans);
deal<192 & 2>(nums[1], c, ans);
deal<192 & 4>(nums[2], c, ans);
deal<192 & 8>(nums[3], c, ans);
deal<192 & 16>(nums[4], c, ans);
deal<192 & 32>(nums[5], c, ans);
deal<192 & 64>(nums[6], c, ans);
deal<192 & 128>(nums[7], c, ans);
break;
};
case 193: {
deal<193 & 1>(nums[0], c, ans);
deal<193 & 2>(nums[1], c, ans);
deal<193 & 4>(nums[2], c, ans);
deal<193 & 8>(nums[3], c, ans);
deal<193 & 16>(nums[4], c, ans);
deal<193 & 32>(nums[5], c, ans);
deal<193 & 64>(nums[6], c, ans);
deal<193 & 128>(nums[7], c, ans);
break;
};
case 194: {
deal<194 & 1>(nums[0], c, ans);
deal<194 & 2>(nums[1], c, ans);
deal<194 & 4>(nums[2], c, ans);
deal<194 & 8>(nums[3], c, ans);
deal<194 & 16>(nums[4], c, ans);
deal<194 & 32>(nums[5], c, ans);
deal<194 & 64>(nums[6], c, ans);
deal<194 & 128>(nums[7], c, ans);
break;
};
case 195: {
deal<195 & 1>(nums[0], c, ans);
deal<195 & 2>(nums[1], c, ans);
deal<195 & 4>(nums[2], c, ans);
deal<195 & 8>(nums[3], c, ans);
deal<195 & 16>(nums[4], c, ans);
deal<195 & 32>(nums[5], c, ans);
deal<195 & 64>(nums[6], c, ans);
deal<195 & 128>(nums[7], c, ans);
break;
};
case 196: {
deal<196 & 1>(nums[0], c, ans);
deal<196 & 2>(nums[1], c, ans);
deal<196 & 4>(nums[2], c, ans);
deal<196 & 8>(nums[3], c, ans);
deal<196 & 16>(nums[4], c, ans);
deal<196 & 32>(nums[5], c, ans);
deal<196 & 64>(nums[6], c, ans);
deal<196 & 128>(nums[7], c, ans);
break;
};
case 197: {
deal<197 & 1>(nums[0], c, ans);
deal<197 & 2>(nums[1], c, ans);
deal<197 & 4>(nums[2], c, ans);
deal<197 & 8>(nums[3], c, ans);
deal<197 & 16>(nums[4], c, ans);
deal<197 & 32>(nums[5], c, ans);
deal<197 & 64>(nums[6], c, ans);
deal<197 & 128>(nums[7], c, ans);
break;
};
case 198: {
deal<198 & 1>(nums[0], c, ans);
deal<198 & 2>(nums[1], c, ans);
deal<198 & 4>(nums[2], c, ans);
deal<198 & 8>(nums[3], c, ans);
deal<198 & 16>(nums[4], c, ans);
deal<198 & 32>(nums[5], c, ans);
deal<198 & 64>(nums[6], c, ans);
deal<198 & 128>(nums[7], c, ans);
break;
};
case 199: {
deal<199 & 1>(nums[0], c, ans);
deal<199 & 2>(nums[1], c, ans);
deal<199 & 4>(nums[2], c, ans);
deal<199 & 8>(nums[3], c, ans);
deal<199 & 16>(nums[4], c, ans);
deal<199 & 32>(nums[5], c, ans);
deal<199 & 64>(nums[6], c, ans);
deal<199 & 128>(nums[7], c, ans);
break;
};
case 200: {
deal<200 & 1>(nums[0], c, ans);
deal<200 & 2>(nums[1], c, ans);
deal<200 & 4>(nums[2], c, ans);
deal<200 & 8>(nums[3], c, ans);
deal<200 & 16>(nums[4], c, ans);
deal<200 & 32>(nums[5], c, ans);
deal<200 & 64>(nums[6], c, ans);
deal<200 & 128>(nums[7], c, ans);
break;
};
case 201: {
deal<201 & 1>(nums[0], c, ans);
deal<201 & 2>(nums[1], c, ans);
deal<201 & 4>(nums[2], c, ans);
deal<201 & 8>(nums[3], c, ans);
deal<201 & 16>(nums[4], c, ans);
deal<201 & 32>(nums[5], c, ans);
deal<201 & 64>(nums[6], c, ans);
deal<201 & 128>(nums[7], c, ans);
break;
};
case 202: {
deal<202 & 1>(nums[0], c, ans);
deal<202 & 2>(nums[1], c, ans);
deal<202 & 4>(nums[2], c, ans);
deal<202 & 8>(nums[3], c, ans);
deal<202 & 16>(nums[4], c, ans);
deal<202 & 32>(nums[5], c, ans);
deal<202 & 64>(nums[6], c, ans);
deal<202 & 128>(nums[7], c, ans);
break;
};
case 203: {
deal<203 & 1>(nums[0], c, ans);
deal<203 & 2>(nums[1], c, ans);
deal<203 & 4>(nums[2], c, ans);
deal<203 & 8>(nums[3], c, ans);
deal<203 & 16>(nums[4], c, ans);
deal<203 & 32>(nums[5], c, ans);
deal<203 & 64>(nums[6], c, ans);
deal<203 & 128>(nums[7], c, ans);
break;
};
case 204: {
deal<204 & 1>(nums[0], c, ans);
deal<204 & 2>(nums[1], c, ans);
deal<204 & 4>(nums[2], c, ans);
deal<204 & 8>(nums[3], c, ans);
deal<204 & 16>(nums[4], c, ans);
deal<204 & 32>(nums[5], c, ans);
deal<204 & 64>(nums[6], c, ans);
deal<204 & 128>(nums[7], c, ans);
break;
};
case 205: {
deal<205 & 1>(nums[0], c, ans);
deal<205 & 2>(nums[1], c, ans);
deal<205 & 4>(nums[2], c, ans);
deal<205 & 8>(nums[3], c, ans);
deal<205 & 16>(nums[4], c, ans);
deal<205 & 32>(nums[5], c, ans);
deal<205 & 64>(nums[6], c, ans);
deal<205 & 128>(nums[7], c, ans);
break;
};
case 206: {
deal<206 & 1>(nums[0], c, ans);
deal<206 & 2>(nums[1], c, ans);
deal<206 & 4>(nums[2], c, ans);
deal<206 & 8>(nums[3], c, ans);
deal<206 & 16>(nums[4], c, ans);
deal<206 & 32>(nums[5], c, ans);
deal<206 & 64>(nums[6], c, ans);
deal<206 & 128>(nums[7], c, ans);
break;
};
case 207: {
deal<207 & 1>(nums[0], c, ans);
deal<207 & 2>(nums[1], c, ans);
deal<207 & 4>(nums[2], c, ans);
deal<207 & 8>(nums[3], c, ans);
deal<207 & 16>(nums[4], c, ans);
deal<207 & 32>(nums[5], c, ans);
deal<207 & 64>(nums[6], c, ans);
deal<207 & 128>(nums[7], c, ans);
break;
};
case 208: {
deal<208 & 1>(nums[0], c, ans);
deal<208 & 2>(nums[1], c, ans);
deal<208 & 4>(nums[2], c, ans);
deal<208 & 8>(nums[3], c, ans);
deal<208 & 16>(nums[4], c, ans);
deal<208 & 32>(nums[5], c, ans);
deal<208 & 64>(nums[6], c, ans);
deal<208 & 128>(nums[7], c, ans);
break;
};
case 209: {
deal<209 & 1>(nums[0], c, ans);
deal<209 & 2>(nums[1], c, ans);
deal<209 & 4>(nums[2], c, ans);
deal<209 & 8>(nums[3], c, ans);
deal<209 & 16>(nums[4], c, ans);
deal<209 & 32>(nums[5], c, ans);
deal<209 & 64>(nums[6], c, ans);
deal<209 & 128>(nums[7], c, ans);
break;
};
case 210: {
deal<210 & 1>(nums[0], c, ans);
deal<210 & 2>(nums[1], c, ans);
deal<210 & 4>(nums[2], c, ans);
deal<210 & 8>(nums[3], c, ans);
deal<210 & 16>(nums[4], c, ans);
deal<210 & 32>(nums[5], c, ans);
deal<210 & 64>(nums[6], c, ans);
deal<210 & 128>(nums[7], c, ans);
break;
};
case 211: {
deal<211 & 1>(nums[0], c, ans);
deal<211 & 2>(nums[1], c, ans);
deal<211 & 4>(nums[2], c, ans);
deal<211 & 8>(nums[3], c, ans);
deal<211 & 16>(nums[4], c, ans);
deal<211 & 32>(nums[5], c, ans);
deal<211 & 64>(nums[6], c, ans);
deal<211 & 128>(nums[7], c, ans);
break;
};
case 212: {
deal<212 & 1>(nums[0], c, ans);
deal<212 & 2>(nums[1], c, ans);
deal<212 & 4>(nums[2], c, ans);
deal<212 & 8>(nums[3], c, ans);
deal<212 & 16>(nums[4], c, ans);
deal<212 & 32>(nums[5], c, ans);
deal<212 & 64>(nums[6], c, ans);
deal<212 & 128>(nums[7], c, ans);
break;
};
case 213: {
deal<213 & 1>(nums[0], c, ans);
deal<213 & 2>(nums[1], c, ans);
deal<213 & 4>(nums[2], c, ans);
deal<213 & 8>(nums[3], c, ans);
deal<213 & 16>(nums[4], c, ans);
deal<213 & 32>(nums[5], c, ans);
deal<213 & 64>(nums[6], c, ans);
deal<213 & 128>(nums[7], c, ans);
break;
};
case 214: {
deal<214 & 1>(nums[0], c, ans);
deal<214 & 2>(nums[1], c, ans);
deal<214 & 4>(nums[2], c, ans);
deal<214 & 8>(nums[3], c, ans);
deal<214 & 16>(nums[4], c, ans);
deal<214 & 32>(nums[5], c, ans);
deal<214 & 64>(nums[6], c, ans);
deal<214 & 128>(nums[7], c, ans);
break;
};
case 215: {
deal<215 & 1>(nums[0], c, ans);
deal<215 & 2>(nums[1], c, ans);
deal<215 & 4>(nums[2], c, ans);
deal<215 & 8>(nums[3], c, ans);
deal<215 & 16>(nums[4], c, ans);
deal<215 & 32>(nums[5], c, ans);
deal<215 & 64>(nums[6], c, ans);
deal<215 & 128>(nums[7], c, ans);
break;
};
case 216: {
deal<216 & 1>(nums[0], c, ans);
deal<216 & 2>(nums[1], c, ans);
deal<216 & 4>(nums[2], c, ans);
deal<216 & 8>(nums[3], c, ans);
deal<216 & 16>(nums[4], c, ans);
deal<216 & 32>(nums[5], c, ans);
deal<216 & 64>(nums[6], c, ans);
deal<216 & 128>(nums[7], c, ans);
break;
};
case 217: {
deal<217 & 1>(nums[0], c, ans);
deal<217 & 2>(nums[1], c, ans);
deal<217 & 4>(nums[2], c, ans);
deal<217 & 8>(nums[3], c, ans);
deal<217 & 16>(nums[4], c, ans);
deal<217 & 32>(nums[5], c, ans);
deal<217 & 64>(nums[6], c, ans);
deal<217 & 128>(nums[7], c, ans);
break;
};
case 218: {
deal<218 & 1>(nums[0], c, ans);
deal<218 & 2>(nums[1], c, ans);
deal<218 & 4>(nums[2], c, ans);
deal<218 & 8>(nums[3], c, ans);
deal<218 & 16>(nums[4], c, ans);
deal<218 & 32>(nums[5], c, ans);
deal<218 & 64>(nums[6], c, ans);
deal<218 & 128>(nums[7], c, ans);
break;
};
case 219: {
deal<219 & 1>(nums[0], c, ans);
deal<219 & 2>(nums[1], c, ans);
deal<219 & 4>(nums[2], c, ans);
deal<219 & 8>(nums[3], c, ans);
deal<219 & 16>(nums[4], c, ans);
deal<219 & 32>(nums[5], c, ans);
deal<219 & 64>(nums[6], c, ans);
deal<219 & 128>(nums[7], c, ans);
break;
};
case 220: {
deal<220 & 1>(nums[0], c, ans);
deal<220 & 2>(nums[1], c, ans);
deal<220 & 4>(nums[2], c, ans);
deal<220 & 8>(nums[3], c, ans);
deal<220 & 16>(nums[4], c, ans);
deal<220 & 32>(nums[5], c, ans);
deal<220 & 64>(nums[6], c, ans);
deal<220 & 128>(nums[7], c, ans);
break;
};
case 221: {
deal<221 & 1>(nums[0], c, ans);
deal<221 & 2>(nums[1], c, ans);
deal<221 & 4>(nums[2], c, ans);
deal<221 & 8>(nums[3], c, ans);
deal<221 & 16>(nums[4], c, ans);
deal<221 & 32>(nums[5], c, ans);
deal<221 & 64>(nums[6], c, ans);
deal<221 & 128>(nums[7], c, ans);
break;
};
case 222: {
deal<222 & 1>(nums[0], c, ans);
deal<222 & 2>(nums[1], c, ans);
deal<222 & 4>(nums[2], c, ans);
deal<222 & 8>(nums[3], c, ans);
deal<222 & 16>(nums[4], c, ans);
deal<222 & 32>(nums[5], c, ans);
deal<222 & 64>(nums[6], c, ans);
deal<222 & 128>(nums[7], c, ans);
break;
};
case 223: {
deal<223 & 1>(nums[0], c, ans);
deal<223 & 2>(nums[1], c, ans);
deal<223 & 4>(nums[2], c, ans);
deal<223 & 8>(nums[3], c, ans);
deal<223 & 16>(nums[4], c, ans);
deal<223 & 32>(nums[5], c, ans);
deal<223 & 64>(nums[6], c, ans);
deal<223 & 128>(nums[7], c, ans);
break;
};
case 224: {
deal<224 & 1>(nums[0], c, ans);
deal<224 & 2>(nums[1], c, ans);
deal<224 & 4>(nums[2], c, ans);
deal<224 & 8>(nums[3], c, ans);
deal<224 & 16>(nums[4], c, ans);
deal<224 & 32>(nums[5], c, ans);
deal<224 & 64>(nums[6], c, ans);
deal<224 & 128>(nums[7], c, ans);
break;
};
case 225: {
deal<225 & 1>(nums[0], c, ans);
deal<225 & 2>(nums[1], c, ans);
deal<225 & 4>(nums[2], c, ans);
deal<225 & 8>(nums[3], c, ans);
deal<225 & 16>(nums[4], c, ans);
deal<225 & 32>(nums[5], c, ans);
deal<225 & 64>(nums[6], c, ans);
deal<225 & 128>(nums[7], c, ans);
break;
};
case 226: {
deal<226 & 1>(nums[0], c, ans);
deal<226 & 2>(nums[1], c, ans);
deal<226 & 4>(nums[2], c, ans);
deal<226 & 8>(nums[3], c, ans);
deal<226 & 16>(nums[4], c, ans);
deal<226 & 32>(nums[5], c, ans);
deal<226 & 64>(nums[6], c, ans);
deal<226 & 128>(nums[7], c, ans);
break;
};
case 227: {
deal<227 & 1>(nums[0], c, ans);
deal<227 & 2>(nums[1], c, ans);
deal<227 & 4>(nums[2], c, ans);
deal<227 & 8>(nums[3], c, ans);
deal<227 & 16>(nums[4], c, ans);
deal<227 & 32>(nums[5], c, ans);
deal<227 & 64>(nums[6], c, ans);
deal<227 & 128>(nums[7], c, ans);
break;
};
case 228: {
deal<228 & 1>(nums[0], c, ans);
deal<228 & 2>(nums[1], c, ans);
deal<228 & 4>(nums[2], c, ans);
deal<228 & 8>(nums[3], c, ans);
deal<228 & 16>(nums[4], c, ans);
deal<228 & 32>(nums[5], c, ans);
deal<228 & 64>(nums[6], c, ans);
deal<228 & 128>(nums[7], c, ans);
break;
};
case 229: {
deal<229 & 1>(nums[0], c, ans);
deal<229 & 2>(nums[1], c, ans);
deal<229 & 4>(nums[2], c, ans);
deal<229 & 8>(nums[3], c, ans);
deal<229 & 16>(nums[4], c, ans);
deal<229 & 32>(nums[5], c, ans);
deal<229 & 64>(nums[6], c, ans);
deal<229 & 128>(nums[7], c, ans);
break;
};
case 230: {
deal<230 & 1>(nums[0], c, ans);
deal<230 & 2>(nums[1], c, ans);
deal<230 & 4>(nums[2], c, ans);
deal<230 & 8>(nums[3], c, ans);
deal<230 & 16>(nums[4], c, ans);
deal<230 & 32>(nums[5], c, ans);
deal<230 & 64>(nums[6], c, ans);
deal<230 & 128>(nums[7], c, ans);
break;
};
case 231: {
deal<231 & 1>(nums[0], c, ans);
deal<231 & 2>(nums[1], c, ans);
deal<231 & 4>(nums[2], c, ans);
deal<231 & 8>(nums[3], c, ans);
deal<231 & 16>(nums[4], c, ans);
deal<231 & 32>(nums[5], c, ans);
deal<231 & 64>(nums[6], c, ans);
deal<231 & 128>(nums[7], c, ans);
break;
};
case 232: {
deal<232 & 1>(nums[0], c, ans);
deal<232 & 2>(nums[1], c, ans);
deal<232 & 4>(nums[2], c, ans);
deal<232 & 8>(nums[3], c, ans);
deal<232 & 16>(nums[4], c, ans);
deal<232 & 32>(nums[5], c, ans);
deal<232 & 64>(nums[6], c, ans);
deal<232 & 128>(nums[7], c, ans);
break;
};
case 233: {
deal<233 & 1>(nums[0], c, ans);
deal<233 & 2>(nums[1], c, ans);
deal<233 & 4>(nums[2], c, ans);
deal<233 & 8>(nums[3], c, ans);
deal<233 & 16>(nums[4], c, ans);
deal<233 & 32>(nums[5], c, ans);
deal<233 & 64>(nums[6], c, ans);
deal<233 & 128>(nums[7], c, ans);
break;
};
case 234: {
deal<234 & 1>(nums[0], c, ans);
deal<234 & 2>(nums[1], c, ans);
deal<234 & 4>(nums[2], c, ans);
deal<234 & 8>(nums[3], c, ans);
deal<234 & 16>(nums[4], c, ans);
deal<234 & 32>(nums[5], c, ans);
deal<234 & 64>(nums[6], c, ans);
deal<234 & 128>(nums[7], c, ans);
break;
};
case 235: {
deal<235 & 1>(nums[0], c, ans);
deal<235 & 2>(nums[1], c, ans);
deal<235 & 4>(nums[2], c, ans);
deal<235 & 8>(nums[3], c, ans);
deal<235 & 16>(nums[4], c, ans);
deal<235 & 32>(nums[5], c, ans);
deal<235 & 64>(nums[6], c, ans);
deal<235 & 128>(nums[7], c, ans);
break;
};
case 236: {
deal<236 & 1>(nums[0], c, ans);
deal<236 & 2>(nums[1], c, ans);
deal<236 & 4>(nums[2], c, ans);
deal<236 & 8>(nums[3], c, ans);
deal<236 & 16>(nums[4], c, ans);
deal<236 & 32>(nums[5], c, ans);
deal<236 & 64>(nums[6], c, ans);
deal<236 & 128>(nums[7], c, ans);
break;
};
case 237: {
deal<237 & 1>(nums[0], c, ans);
deal<237 & 2>(nums[1], c, ans);
deal<237 & 4>(nums[2], c, ans);
deal<237 & 8>(nums[3], c, ans);
deal<237 & 16>(nums[4], c, ans);
deal<237 & 32>(nums[5], c, ans);
deal<237 & 64>(nums[6], c, ans);
deal<237 & 128>(nums[7], c, ans);
break;
};
case 238: {
deal<238 & 1>(nums[0], c, ans);
deal<238 & 2>(nums[1], c, ans);
deal<238 & 4>(nums[2], c, ans);
deal<238 & 8>(nums[3], c, ans);
deal<238 & 16>(nums[4], c, ans);
deal<238 & 32>(nums[5], c, ans);
deal<238 & 64>(nums[6], c, ans);
deal<238 & 128>(nums[7], c, ans);
break;
};
case 239: {
deal<239 & 1>(nums[0], c, ans);
deal<239 & 2>(nums[1], c, ans);
deal<239 & 4>(nums[2], c, ans);
deal<239 & 8>(nums[3], c, ans);
deal<239 & 16>(nums[4], c, ans);
deal<239 & 32>(nums[5], c, ans);
deal<239 & 64>(nums[6], c, ans);
deal<239 & 128>(nums[7], c, ans);
break;
};
case 240: {
deal<240 & 1>(nums[0], c, ans);
deal<240 & 2>(nums[1], c, ans);
deal<240 & 4>(nums[2], c, ans);
deal<240 & 8>(nums[3], c, ans);
deal<240 & 16>(nums[4], c, ans);
deal<240 & 32>(nums[5], c, ans);
deal<240 & 64>(nums[6], c, ans);
deal<240 & 128>(nums[7], c, ans);
break;
};
case 241: {
deal<241 & 1>(nums[0], c, ans);
deal<241 & 2>(nums[1], c, ans);
deal<241 & 4>(nums[2], c, ans);
deal<241 & 8>(nums[3], c, ans);
deal<241 & 16>(nums[4], c, ans);
deal<241 & 32>(nums[5], c, ans);
deal<241 & 64>(nums[6], c, ans);
deal<241 & 128>(nums[7], c, ans);
break;
};
case 242: {
deal<242 & 1>(nums[0], c, ans);
deal<242 & 2>(nums[1], c, ans);
deal<242 & 4>(nums[2], c, ans);
deal<242 & 8>(nums[3], c, ans);
deal<242 & 16>(nums[4], c, ans);
deal<242 & 32>(nums[5], c, ans);
deal<242 & 64>(nums[6], c, ans);
deal<242 & 128>(nums[7], c, ans);
break;
};
case 243: {
deal<243 & 1>(nums[0], c, ans);
deal<243 & 2>(nums[1], c, ans);
deal<243 & 4>(nums[2], c, ans);
deal<243 & 8>(nums[3], c, ans);
deal<243 & 16>(nums[4], c, ans);
deal<243 & 32>(nums[5], c, ans);
deal<243 & 64>(nums[6], c, ans);
deal<243 & 128>(nums[7], c, ans);
break;
};
case 244: {
deal<244 & 1>(nums[0], c, ans);
deal<244 & 2>(nums[1], c, ans);
deal<244 & 4>(nums[2], c, ans);
deal<244 & 8>(nums[3], c, ans);
deal<244 & 16>(nums[4], c, ans);
deal<244 & 32>(nums[5], c, ans);
deal<244 & 64>(nums[6], c, ans);
deal<244 & 128>(nums[7], c, ans);
break;
};
case 245: {
deal<245 & 1>(nums[0], c, ans);
deal<245 & 2>(nums[1], c, ans);
deal<245 & 4>(nums[2], c, ans);
deal<245 & 8>(nums[3], c, ans);
deal<245 & 16>(nums[4], c, ans);
deal<245 & 32>(nums[5], c, ans);
deal<245 & 64>(nums[6], c, ans);
deal<245 & 128>(nums[7], c, ans);
break;
};
case 246: {
deal<246 & 1>(nums[0], c, ans);
deal<246 & 2>(nums[1], c, ans);
deal<246 & 4>(nums[2], c, ans);
deal<246 & 8>(nums[3], c, ans);
deal<246 & 16>(nums[4], c, ans);
deal<246 & 32>(nums[5], c, ans);
deal<246 & 64>(nums[6], c, ans);
deal<246 & 128>(nums[7], c, ans);
break;
};
case 247: {
deal<247 & 1>(nums[0], c, ans);
deal<247 & 2>(nums[1], c, ans);
deal<247 & 4>(nums[2], c, ans);
deal<247 & 8>(nums[3], c, ans);
deal<247 & 16>(nums[4], c, ans);
deal<247 & 32>(nums[5], c, ans);
deal<247 & 64>(nums[6], c, ans);
deal<247 & 128>(nums[7], c, ans);
break;
};
case 248: {
deal<248 & 1>(nums[0], c, ans);
deal<248 & 2>(nums[1], c, ans);
deal<248 & 4>(nums[2], c, ans);
deal<248 & 8>(nums[3], c, ans);
deal<248 & 16>(nums[4], c, ans);
deal<248 & 32>(nums[5], c, ans);
deal<248 & 64>(nums[6], c, ans);
deal<248 & 128>(nums[7], c, ans);
break;
};
case 249: {
deal<249 & 1>(nums[0], c, ans);
deal<249 & 2>(nums[1], c, ans);
deal<249 & 4>(nums[2], c, ans);
deal<249 & 8>(nums[3], c, ans);
deal<249 & 16>(nums[4], c, ans);
deal<249 & 32>(nums[5], c, ans);
deal<249 & 64>(nums[6], c, ans);
deal<249 & 128>(nums[7], c, ans);
break;
};
case 250: {
deal<250 & 1>(nums[0], c, ans);
deal<250 & 2>(nums[1], c, ans);
deal<250 & 4>(nums[2], c, ans);
deal<250 & 8>(nums[3], c, ans);
deal<250 & 16>(nums[4], c, ans);
deal<250 & 32>(nums[5], c, ans);
deal<250 & 64>(nums[6], c, ans);
deal<250 & 128>(nums[7], c, ans);
break;
};
case 251: {
deal<251 & 1>(nums[0], c, ans);
deal<251 & 2>(nums[1], c, ans);
deal<251 & 4>(nums[2], c, ans);
deal<251 & 8>(nums[3], c, ans);
deal<251 & 16>(nums[4], c, ans);
deal<251 & 32>(nums[5], c, ans);
deal<251 & 64>(nums[6], c, ans);
deal<251 & 128>(nums[7], c, ans);
break;
};
case 252: {
deal<252 & 1>(nums[0], c, ans);
deal<252 & 2>(nums[1], c, ans);
deal<252 & 4>(nums[2], c, ans);
deal<252 & 8>(nums[3], c, ans);
deal<252 & 16>(nums[4], c, ans);
deal<252 & 32>(nums[5], c, ans);
deal<252 & 64>(nums[6], c, ans);
deal<252 & 128>(nums[7], c, ans);
break;
};
case 253: {
deal<253 & 1>(nums[0], c, ans);
deal<253 & 2>(nums[1], c, ans);
deal<253 & 4>(nums[2], c, ans);
deal<253 & 8>(nums[3], c, ans);
deal<253 & 16>(nums[4], c, ans);
deal<253 & 32>(nums[5], c, ans);
deal<253 & 64>(nums[6], c, ans);
deal<253 & 128>(nums[7], c, ans);
break;
};
case 254: {
deal<254 & 1>(nums[0], c, ans);
deal<254 & 2>(nums[1], c, ans);
deal<254 & 4>(nums[2], c, ans);
deal<254 & 8>(nums[3], c, ans);
deal<254 & 16>(nums[4], c, ans);
deal<254 & 32>(nums[5], c, ans);
deal<254 & 64>(nums[6], c, ans);
deal<254 & 128>(nums[7], c, ans);
break;
};
case 255: {
deal<255 & 1>(nums[0], c, ans);
deal<255 & 2>(nums[1], c, ans);
deal<255 & 4>(nums[2], c, ans);
deal<255 & 8>(nums[3], c, ans);
deal<255 & 16>(nums[4], c, ans);
deal<255 & 32>(nums[5], c, ans);
deal<255 & 64>(nums[6], c, ans);
deal<255 & 128>(nums[7], c, ans);
break;
};
}
}
ans %= mod;
printf("%d\n", (int)(ans % mod));
}
fflush(stdout);
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbg = 2e18;
int mod;
struct matrix {
int a[2][3];
void init() { memset(a, 0, sizeof(a)); }
void init1() {
init();
a[0][0] = a[1][1] = 1;
}
matrix() { init(); }
matrix operator*(const matrix &t) const {
matrix ret;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 2; k++) {
ret.a[i][j] += 1ll * a[i][k] * t.a[k][j];
}
if (j == 2) ret.a[i][j] += a[i][2];
ret.a[i][j] %= mod;
}
}
return ret;
}
void out() {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) cout << a[i][j] << " ";
cout << endl;
}
cout << endl;
}
};
struct SGT {
matrix a[800111];
void init() {
for (int i = 0; i < 800111; i++) a[i].init1();
}
SGT() { init(); }
void change(int x, int v, int l, int r, int p = 1) {
if (x == l && x == r) {
a[p].init1();
if (v != -1) {
a[p].a[0][0] = 0;
a[p].a[1][0] = a[p].a[0][1] = 1;
a[p].a[1][2] = v;
}
return;
}
int m = l + r >> 1;
if (x <= m)
change(x, v, l, m, p << 1);
else
change(x, v, m + 1, r, p << 1 | 1);
a[p] = a[p << 1] * a[p << 1 | 1];
}
matrix query(int x, int y, int l, int r, int p = 1) {
if (x <= l && r <= y) return a[p];
int m = l + r >> 1;
if (x <= m && m < y)
return query(x, y, l, m, p << 1) * query(x, y, m + 1, r, p << 1 | 1);
else if (x <= m)
return query(x, y, l, m, p << 1);
else
return query(x, y, m + 1, r, p << 1 | 1);
}
matrix haru() { return a[1]; }
void out(int l, int r, int p = 1) {
cout << l << "," << r << ":" << endl;
a[p].out();
if (l == r) return;
int m = l + r >> 1;
out(l, m, p << 1);
out(m + 1, r, p << 1 | 1);
}
} sora;
const int B = 123;
int n, q, a[30011], id[30011];
vector<int> v;
struct query {
int l, r, id;
bool operator<(const query &t) const {
if (l / B != t.l / B)
return l < t.l;
else
return r < t.r;
}
} qr[30011];
int cnt[30011], ans[30011];
void add(int x) {
if (!(cnt[id[x]]++)) sora.change(id[x], a[x], 1, n);
}
void del(int x) {
if (!(--cnt[id[x]])) sora.change(id[x], -1, 1, n);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), v.push_back(a[i]);
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++)
id[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &qr[i].l, &qr[i].r);
qr[i].id = i;
}
sort(qr + 1, qr + q + 1);
int L = 1, R = 0;
for (int i = 1; i <= q; i++) {
int l = qr[i].l, r = qr[i].r;
while (R < r) add(++R);
while (R > r) del(R--);
while (L < l) del(L++);
while (L > l) add(--L);
matrix tmp = sora.haru();
ans[qr[i].id] = sora.haru().a[1][2];
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, k;
int a[200000], u[200000], c[200000], h[200000], val[200000];
int f[100000];
map<int, int> mp;
int main() {
cin >> n >> m;
f[0] = f[1] = 1;
f[0] %= m;
f[1] %= m;
for (i = 2; i < 100000; i++) {
f[i] = (f[i - 1] + f[i - 2]) % m;
}
for (i = 0; i < n; i++) {
cin >> a[i];
c[i] = a[i];
}
int nom = 1;
sort(c, c + n);
mp[c[0]] = 0;
val[0] = c[0] % m;
for (i = 1; i < n; i++) {
if (c[i] != c[i - 1]) {
val[nom] = c[i] % m;
mp[c[i]] = nom++;
}
}
for (i = 0; i < n; i++) {
h[i] = mp[a[i]];
}
int q;
cin >> q;
for (i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--, r--;
for (j = l; j <= r; j++) {
u[h[j]] = 1;
}
long long ans = 0;
int cur = 0;
for (j = 0; j < nom; j++) {
if (u[j]) {
ans += val[j] * f[cur++];
u[j] = 0;
}
}
ans %= m;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 3;
const int MAXN = 30005;
map<int, int> Mp;
int V[MAXN], Cnt, cnt[MAXN];
int N, M, A[MAXN], B[MAXN];
int Q, stq, L, R, Ans[MAXN];
struct Matr {
int a[MAXK][MAXK];
} I, It[MAXN];
Matr cheng(Matr A, Matr B) {
Matr rt;
memset(rt.a, 0, sizeof(rt.a));
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= 2; j++)
for (int k = 1; k <= 2; k++)
rt.a[i][j] = (rt.a[i][j] + A.a[i][k] * B.a[k][j]) % M;
return rt;
}
struct que {
int l, r, id;
} q[MAXN];
struct Node {
int l, r, cnt, siz, sum0, sum1;
} s[MAXN * 8];
bool cmp(que A, que B) {
return A.l / stq == B.l / stq ? A.r < B.r : A.l < B.l;
}
void Prepare() {
I.a[1][1] = 0;
I.a[1][2] = 1;
I.a[2][1] = 1;
I.a[2][2] = 1;
It[0].a[1][1] = 1;
It[0].a[1][2] = 0;
It[0].a[2][1] = 0;
It[0].a[2][2] = 1;
for (int i = 1; i <= N + 1; i++) It[i] = cheng(It[i - 1], I);
}
void Push_Up(int rt) {
s[rt].cnt = s[rt * 2].cnt + s[rt * 2 + 1].cnt;
s[rt].siz = s[rt * 2].siz + s[rt * 2 + 1].siz;
int u = s[rt * 2].cnt;
s[rt].sum0 = (s[rt * 2].sum0 + s[rt * 2 + 1].sum0 * It[u].a[1][1] +
s[rt * 2 + 1].sum1 * It[u].a[1][2]) %
M;
s[rt].sum1 = (s[rt * 2].sum1 + s[rt * 2 + 1].sum0 * It[u + 1].a[1][1] +
s[rt * 2 + 1].sum1 * It[u + 1].a[1][2]) %
M;
}
void Build(int rt, int l, int r) {
s[rt].l = l;
s[rt].r = r;
s[rt].cnt = s[rt].siz = 0;
s[rt].sum0 = s[rt].sum1 = 0;
if (l == r) return;
int mid = (l + r) / 2;
Build(rt * 2, l, mid);
Build(rt * 2 + 1, mid + 1, r);
}
void Insert(int rt, int p, int val) {
if (s[rt].r < p || s[rt].l > p) return;
if (s[rt].l == s[rt].r) {
if (s[rt].siz == 0) {
s[rt].cnt++;
s[rt].sum0 = V[p] % M;
s[rt].sum1 = V[p] % M;
}
s[rt].siz += val;
if (s[rt].siz == 0) {
s[rt].cnt--;
s[rt].sum0 = 0;
s[rt].sum1 = 0;
}
return;
}
Insert(rt * 2, p, val);
Insert(rt * 2 + 1, p, val);
Push_Up(rt);
}
void Add(int x) { Insert(1, Mp[A[x]], 1); }
void Remove(int x) { Insert(1, Mp[A[x]], -1); }
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]), B[i] = A[i];
sort(B + 1, B + N + 1);
Prepare();
for (int i = 1; i <= N; i++) {
if (!Mp[B[i]]) {
Mp[B[i]] = ++Cnt;
V[Cnt] = B[i];
}
}
scanf("%d", &Q);
stq = sqrt(Q);
for (int i = 1; i <= Q; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
Build(1, 1, Cnt);
sort(q + 1, q + Q + 1, cmp);
L = R = 1;
Add(1);
for (int i = 1; i <= Q; i++) {
while (L < q[i].l) Remove(L++);
while (L > q[i].l) Add(--L);
while (R < q[i].r) Add(++R);
while (R > q[i].r) Remove(R--);
Ans[q[i].id] = s[1].sum0;
}
for (int i = 1; i <= Q; i++) printf("%d\n", Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 11;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
;
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
for (int i = int(0); i < int(1 << K); ++i) {
mb[i] = K;
while (mb[i] >= 0 && !(i & (1 << mb[i]))) {
--mb[i];
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
};
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
};
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
if (i) {
v[w][q | (1 << i)][0] = v[w][q | (1 << (i - 1))][0];
v[w][q | (1 << i)][1] = v[w][q | (1 << (i - 1))][1];
bt[w][q | (1 << i)] = bt[w][q | (1 << (i - 1))];
} else {
v[w][q | (1 << i)][0] = v[w][q][0];
v[w][q | (1 << i)][1] = v[w][q][1];
bt[w][q | (1 << i)] = bt[w][q];
}
} else {
v[w][q | (1 << i)][0] =
(v[w][q][0] + f[bt[w][q]] * (a[p[t * K + i]] % mod)) % mod;
v[w][q | (1 << i)][1] =
(v[w][q][1] + f[bt[w][q] + 1] * (a[p[t * K + i]] % mod)) %
mod;
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
ans[i] = (ans[i] + v[ttt][mmm][0] * f[cnt[i] + 2] +
v[ttt][mmm][1] * f[cnt[i] + 3]) %
mod;
;
;
;
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
;
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = int;
using pii = tuple<lli, lli>;
using ppii = tuple<pii, pii>;
using piii = tuple<lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B>
ostream& operator<<(ostream& s, tuple<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B, class C>
ostream& operator<<(ostream& s, tuple<A, B, C> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << "," << get<2>(a) << ")";
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
lli n, m;
lli F[100000];
struct node {
node() {}
lli v = 0;
lli s1 = 0, s2 = 0;
lli shiftBy = 0;
};
struct tree {
lli n;
vector<node> A;
tree(lli n_) : n((lli)1 << (lli)(log2(n_) + 1)), A(2 * n) {}
void print_tree_(lli i, lli a, lli b, lli in) {
push(i, a, b);
lli c = (a + b) / 2;
if (i < n) print_tree_(2 * i, a, c, in + 1);
for (lli i = 0; i < (lli)(in); ++i) cout << " ";
cout << "| " << i << " " << A[i].v;
cout << endl;
if (i < n) print_tree_(2 * i + 1, c + 1, b, in + 1);
}
void print_tree() { print_tree_(1, 0, n - 1, 0); }
void push(lli i, lli a, lli b) {
if (i < n) {
lli c = (a + b) / 2;
if (A[i].shiftBy) {
shift__(2 * i, a, c, A[i].shiftBy);
shift__(2 * i + 1, c + 1, b, A[i].shiftBy);
A[i].shiftBy = 0;
}
}
}
void build() {
for (lli i = (n - 1); i >= (lli)(0); --i) update(i);
}
void update(lli i) {
A[i].s1 = (A[2 * i].s1 + A[2 * i + 1].s1) % m;
A[i].s2 = (A[2 * i].s2 + A[2 * i + 1].s2) % m;
}
void shift__(lli i, lli a, lli b, lli v) {
if (v) {
A[i].shiftBy += v;
A[i].v += v;
lli ns1 = F[49999 + v] * A[i].s1 + F[50000 + v] * A[i].s2;
lli ns2 = F[50000 + v] * A[i].s1 + F[50001 + v] * A[i].s2;
A[i].s1 = ns1 % m;
A[i].s2 = ns2 % m;
}
}
void shift_(lli i, lli a, lli b, lli l, lli r, lli v, lli x) {
if (l > b) return;
if (r < a) return;
if (l <= a && b <= r) {
if (l == a) insert_(i, a, b, l, x);
shift__(i, a, b, v);
return;
}
push(i, a, b);
lli c = (a + b) / 2;
shift_(2 * i, a, c, l, r, v, x);
shift_(2 * i + 1, c + 1, b, l, r, v, x);
update(i);
}
void shift(lli l, lli r, lli v, lli x) { shift_(1, 0, n - 1, l, r, v, x); }
void insert_(lli i, lli a, lli b, lli l, lli v) {
if (l > b) return;
if (l < a) return;
push(i, a, b);
if (l <= a && b <= l) {
A[i].s1 = (F[50000 + A[i].v] * v) % m;
A[i].s2 = (F[50001 + A[i].v] * v) % m;
return;
}
lli c = (a + b) / 2;
insert_(2 * i, a, c, l, v);
insert_(2 * i + 1, c + 1, b, l, v);
update(i);
}
lli query() { return A[1].s1 % m; }
};
int main(int, char**) {
srand(time(0));
ios::sync_with_stdio(false);
cin >> n >> m;
F[50000] = 0;
F[50001] = 1;
for (lli i = (50002); i <= (lli)(99999); ++i)
F[i] = (F[i - 2] + F[i - 1]) % m;
for (lli i = (49999); i >= (lli)(0); --i)
F[i] = (F[i + 2] - F[i + 1] + m + m) % m;
vi A(n);
for (lli i = 0; i < (lli)(n); ++i) cin >> A[i];
set<lli> AS;
for (lli i = 0; i < (lli)(n); ++i) AS.insert(A[i]);
lli ni = 0;
unordered_map<lli, lli> TOI;
for (auto x : AS) {
TOI[x] = ni;
ni += 1;
}
tree t(ni);
lli q;
cin >> q;
vii Q(q);
for (lli i = 0; i < (lli)(q); ++i) cin >> get<0>(Q[i]) >> get<1>(Q[i]);
for (lli i = 0; i < (lli)(q); ++i) get<0>(Q[i]) -= 1;
for (lli i = 0; i < (lli)(q); ++i) get<1>(Q[i]) -= 1;
lli bsize = 250;
vi I(q);
for (lli i = 0; i < (lli)(q); ++i) I[i] = i;
sort(begin(I), end(I), [&](lli a, lli b) {
return pii(get<0>(Q[a]) / bsize, get<1>(Q[a])) <
make_tuple(get<0>(Q[b]) / bsize, get<1>(Q[b]));
});
vi ANS(q);
unordered_map<lli, lli> M;
auto mo_add = [&](lli x) {
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, 1, x % m);
}
M[x] += 1;
};
auto mo_remove = [&](lli x) {
M[x] -= 1;
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, -1, 0);
}
};
lli cl = 0, cr = -1;
for (lli i = 0; i < (lli)(q); ++i) {
lli l = get<0>(Q[I[i]]), r = get<1>(Q[I[i]]);
while (cr < r) {
cr += 1;
mo_add(A[cr]);
}
while (cl > l) {
cl -= 1;
mo_add(A[cl]);
}
while (cr > r) {
mo_remove(A[cr]);
cr -= 1;
}
while (cl < l) {
mo_remove(A[cl]);
cl += 1;
}
ANS[I[i]] = t.query();
}
for (lli i = 0; i < (lli)(q); ++i) cout << ANS[i] << '\n';
cout << flush;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("-Ofast", "-funroll-all-loops", "-ffast-math")
#pragma GCC target("avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long Linf = 0x7f7f7f7f7f7f7f7f;
const int Inf = 0x3f3f3f3f;
const int MAXN = 2e5;
char buf[100000], *p1 = buf, *p2 = buf;
inline char nc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int w = 1, data = 0;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = nc();
if (ch == '-') w = -1, ch = nc();
while (ch >= '0' && ch <= '9') data = data * 10 + ch - '0', ch = nc();
return w * data;
}
int blLen, P, bas = 1e5;
struct Que {
int l, r, id;
bool operator<(const Que& oth) const {
return ((l / blLen) ^ (oth.l / blLen)) ? l / blLen < oth.l / blLen
: ((l / blLen) & 1) ? r < oth.r
: r > oth.r;
}
} que[MAXN];
int n, q, a[MAXN], b[MAXN], coN, fib[MAXN];
struct Node {
int lVal, Val, addv;
};
struct Segment_Tree {
Node v[MAXN << 2];
void PushUp(int rt) {
v[rt].lVal = (v[rt << 1].lVal + v[rt << 1 | 1].lVal) % P;
v[rt].Val = (v[rt << 1].Val + v[rt << 1 | 1].Val) % P;
}
void Add(int l, int r, int C, int rt) {
long long lVal = ((1ll * v[rt].lVal * fib[bas + C - 1]) +
(1ll * v[rt].Val * fib[bas + C])) %
P;
long long Val = ((1ll * v[rt].lVal * fib[bas + C]) +
(1ll * v[rt].Val * fib[bas + C + 1])) %
P;
v[rt].lVal = lVal;
v[rt].Val = Val;
v[rt].addv += C;
}
void PushDown(int l, int r, int rt) {
if (v[rt].addv) {
int mid = (l + r) >> 1;
Add(l, mid, v[rt].addv, rt << 1);
Add(mid + 1, r, v[rt].addv, rt << 1 | 1);
v[rt].addv = 0;
}
}
void UpdateAdd(int L, int C, int l, int r, int rt) {
if (l == r) {
v[rt].lVal = 1ll * b[l] % P * fib[bas + v[rt].addv] % P;
v[rt].Val = 1ll * b[l] % P * fib[bas + v[rt].addv + 1] % P;
return;
}
int mid = (l + r) >> 1;
PushDown(l, r, rt);
if (L <= mid)
UpdateAdd(L, C, l, mid, rt << 1), Add(mid + 1, r, C, rt << 1 | 1);
else
UpdateAdd(L, C, mid + 1, r, rt << 1 | 1);
PushUp(rt);
}
void UpdateRemove(int L, int C, int l, int r, int rt) {
if (l == r) {
v[rt].lVal = v[rt].Val = 0;
return;
}
int mid = (l + r) >> 1;
PushDown(l, r, rt);
if (L <= mid)
UpdateRemove(L, C, l, mid, rt << 1), Add(mid + 1, r, C, rt << 1 | 1);
else
UpdateRemove(L, C, mid + 1, r, rt << 1 | 1);
PushUp(rt);
}
} t;
int cnt[MAXN];
void add(int x) {
if (!cnt[x]) t.UpdateAdd(x, 1, 1, coN, 1);
cnt[x]++;
}
void remove(int x) {
--cnt[x];
if (!cnt[x]) t.UpdateRemove(x, -1, 1, coN, 1);
}
int ans[MAXN];
int32_t main() {
n = read();
P = read();
blLen = sqrt(n);
for (int i = 1; i <= n; i++) b[i] = a[i] = read();
q = read();
for (int i = 1; i <= q; i++) que[que[i].id = i].l = read(), que[i].r = read();
sort(que + 1, que + q + 1);
sort(b + 1, b + n + 1);
coN = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + coN + 1, a[i]) - b;
fib[bas] = 0;
fib[bas + 1] = 1;
for (int i = 2; bas + i < MAXN; i++)
fib[bas + i] = (1ll * fib[bas + i - 1] + fib[bas + i - 2]) % P;
for (int i = 1; bas - i >= 0; i++)
fib[bas - i] = (1ll * fib[bas - i + 2] - fib[bas - i + 1] + P) % P;
int l = 1, r = 0;
for (int i = 1; i <= q; i++) {
while (l < que[i].l) remove(a[l++]);
while (l > que[i].l) add(a[--l]);
while (r < que[i].r) add(a[++r]);
while (r > que[i].r) remove(a[r--]);
ans[que[i].id] = t.v[1].Val;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
pair<int, int> a[maxn];
int ans[maxn], step[maxn], f[maxn], l[maxn], r[maxn], last[maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first), a[i].second = i;
sort(a + 1, a + 1 + n);
f[0] = 1, f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l[i], &r[i]);
last[i] = -1;
}
for (int i = 1; i <= n; i++) {
int d = a[i].first % m;
for (int j = 1; j <= q; j++) {
if (a[i].second < l[j] || a[i].second > r[j]) continue;
if (a[i].first == last[j]) continue;
ans[j] = (ans[j] + f[step[j]++] * d) % m;
last[j] = a[i].first;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
struct T {
int A, id;
bool operator<(const T &B) const { return A < B.A; }
} I[30001];
int Fibs[30001];
int ANS[30001];
int Step[30001];
int Last[30001];
int L[30001], R[30001];
int main(void) {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; ++i) scanf("%d", &I[I[i].id = i].A);
sort(I + 1, I + n + 1);
scanf("%d", &q);
for (int i = 1; i <= q; ++i)
scanf("%d%d", &L[i], &R[i]), ANS[i] = Step[i] = Last[i] = 0;
;
Fibs[0] = 0;
Fibs[1] = 1;
for (int i = 2; i <= n; ++i) Fibs[i] = (Fibs[i - 1] + Fibs[i - 2]) % m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= q; ++j) {
if (I[i].id < L[j] || I[i].id > R[j] || I[i].A == Last[j]) continue;
ANS[j] = (ANS[j] + (Last[j] = I[i].A) % m * Fibs[++Step[j]]) % m;
}
}
for (int i = 1; i <= q; ++i) printf("%d\n", ANS[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) f = c == '-' ? 1 : 0;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return f ? -x : x;
}
const int N = 30005, B = 250;
int n, m, P, L, A[N], num[N], bl[N], ans[N], f[N], ct[N], sz[N * 4], s1[N * 4],
s2[N * 4];
struct na {
int l, r, id;
} e[N];
inline bool cmp(const na &a, const na &b) {
if (bl[a.l] != bl[b.l]) return a.l < b.l;
return (bl[a.l] & 1) ? (a.r < b.r) : (a.r > b.r);
}
inline void ins(int a) {
if (ct[a]++) return;
int o = 1, l = 1, r = L, mid;
while (l != r) {
if (a <= (mid = l + r >> 1))
o = (o << 1), r = mid;
else
o = (o << 1 | 1), l = mid + 1;
}
s1[o] = num[a], sz[o] = 1;
for (o >>= 1; o; o >>= 1) {
a = sz[(o << 1)], sz[o] = sz[(o << 1)] + sz[(o << 1 | 1)];
s1[o] =
(s1[(o << 1)] + f[a + 1] * s1[(o << 1 | 1)] + f[a] * s2[(o << 1 | 1)]) %
P;
s2[o] = (s2[(o << 1)] +
(a ? f[a] * s1[(o << 1 | 1)] + f[a - 1] * s2[(o << 1 | 1)]
: s2[(o << 1 | 1)])) %
P;
}
}
inline void del(int a) {
if (--ct[a]) return;
int o = 1, l = 1, r = L, mid;
while (l != r) {
if (a <= (mid = l + r >> 1))
o = (o << 1), r = mid;
else
o = (o << 1 | 1), l = mid + 1;
}
s1[o] = sz[o] = 0;
for (o >>= 1; o; o >>= 1) {
a = sz[(o << 1)], sz[o] = sz[(o << 1)] + sz[(o << 1 | 1)];
s1[o] =
(s1[(o << 1)] + f[a + 1] * s1[(o << 1 | 1)] + f[a] * s2[(o << 1 | 1)]) %
P;
s2[o] = (s2[(o << 1)] +
(a ? f[a] * s1[(o << 1 | 1)] + f[a - 1] * s2[(o << 1 | 1)]
: s2[(o << 1 | 1)])) %
P;
}
}
int main() {
n = read(), P = read();
for (int i = 1; i <= n; i++) A[i] = num[i] = read(), bl[i] = (i - 1) / B + 1;
for (int i = (f[1] = 1, 2); i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % P;
sort(num + 1, num + n + 1);
L = unique(num + 1, num + n + 1) - num - 1;
for (int i = 1; i <= n; i++)
A[i] = lower_bound(num + 1, num + L + 1, A[i]) - num;
m = read();
for (int i = 1; i <= m; i++) e[i].l = read(), e[i].r = read(), e[i].id = i;
sort(e + 1, e + m + 1, cmp);
for (int i = 1, l = 1, r = 0; i <= m; i++) {
while (e[i].l < l) ins(A[--l]);
while (r < e[i].r) ins(A[++r]);
while (l < e[i].l) del(A[l++]);
while (e[i].r < r) del(A[r--]);
ans[e[i].id] = s1[1];
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
const int N = 30005;
int n, m, Qi, f[N], l[N], r[N], h[N], ans[N], las[N];
std::pair<int, int> a[N];
int main() {
memset(las, -1, sizeof las);
scanf("%d%d", &n, &m);
f[1] = f[2] = 1;
for (int i = 3; i <= n; ++i) {
f[i] = (f[i - 2] + f[i - 1]) % m;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
}
std::sort(a + 1, a + 1 + n);
scanf("%d", &Qi);
for (int i = 1; i <= Qi; ++i) {
scanf("%d%d", &l[i], &r[i]);
}
for (int i = 1; i <= n; ++i) {
int t = a[i].first % m;
for (int j = 1; j <= Qi; ++j) {
if (l[j] <= a[i].second && a[i].second <= r[j] && a[i].first != las[j]) {
las[j] = a[i].first;
++h[j];
ans[j] = (ans[j] + f[h[j]] * t) % m;
}
}
}
for (int i = 1; i <= Qi; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, m, q, l, r;
cin >> n >> m;
vector<pair<int, int> > a(n);
for (int i = 0; i < (n); ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
vector<int> s(n), bt(n);
int idx = 0, uniq = 0, last = -1;
while (idx < n) {
if (last != a[idx].first) ++uniq;
last = a[idx].first;
bt[a[idx].second] = uniq - 1;
s[uniq - 1] = a[idx].first % m;
++idx;
}
vector<long long> fib(uniq);
fib[0] = 1;
if (uniq > 1) fib[1] = 1;
for (int i = 2; i < (uniq); ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
cin >> q;
vector<int> inc(uniq);
for (int qq = 0; qq < (q); ++qq) {
cin >> l >> r;
fill(inc.begin(), inc.end(), 0);
for (int i = l - 1; i < (r); ++i) inc[bt[i]] = 1;
long long sum = 0;
int idxf = 0;
for (int i = 0; i < (uniq); ++i) {
sum += inc[i] * s[i] * fib[idxf];
idxf += inc[i];
}
cout << sum % m << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
struct node {
int x, y;
bool operator<(const node& t) const { return x < t.x; }
} a[30003];
int f[30003];
signed main() {
int n = read(), p = read();
for (int i = 1; i <= n; ++i) a[i].x = read(), a[i].y = i;
sort(a + 1, a + n + 1);
f[1] = 1, f[2] = 1;
for (int i = 3; i <= n; ++i) f[i] = (f[i - 1] + f[i - 2]) % p;
long long ans;
for (int m = read(), l, r, c, qwq; m--;) {
l = read(), r = read(), ans = 0, qwq = 0, c = 0;
for (int i = 1; i <= n; ++i)
(a[i].y >= l && a[i].y <= r && a[i].x != qwq) &&
(ans += 1ll * a[i].x * f[++c], qwq = a[i].x);
printf("%lld\n", ans % p);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[30005];
int h[30005];
int st[30005];
int t[30005];
int f[30005];
int main() {
int n, m, p, i, le, mn, mx, l, r, cnt, T;
long long s;
scanf("%d%d", &n, &p);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), h[i] = st[i] = a[i];
sort(st + 1, st + 1 + n);
le = unique(st + 1, st + 1 + n) - st;
for (i = 1; i <= n; i++) h[i] = lower_bound(st + 1, st + le, h[i]) - st;
scanf("%d", &m);
f[1] = f[2] = 1;
for (i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % p;
for (T = 1; T <= m; T++) {
scanf("%d%d", &l, &r);
mn = 2e9, mx = -2e9;
for (i = l; i <= r; i++)
t[h[i]] = T, mn = h[i] < mn ? h[i] : mn, mx = h[i] > mx ? h[i] : mx;
s = cnt = 0;
for (i = mn; i <= mx; i++)
if (t[i] == T) s += 1ll * f[++cnt] * st[i];
printf("%d\n", s % p);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using namespace std::placeholders;
int max_fib = 2;
uint16_t fib_memo[30000];
uint16_t mod;
vector<int> range;
bool comp_idx(int i, int j) { return range[i] < range[j]; }
int max_bit(int a) {
int count = 0;
while (a & 1) {
a >>= 1;
count++;
}
return count;
}
void fill_fib(int n) {
for (int i = max_fib; i < (n + 1); ++i) {
fib_memo[i] = (uint16_t)(fib_memo[i - 2] + fib_memo[i - 1]);
fib_memo[i] = fib_memo[i] % mod;
}
max_fib = max(max_fib, n + 1);
return;
}
int main() {
fib_memo[0] = 1;
fib_memo[1] = 1;
int amount;
cin >> amount >> mod;
fill_fib(29999);
range.reserve(amount);
vector<int> idx;
idx.reserve(amount);
for (int i = 0; i < (amount); ++i) {
int a;
cin >> a;
idx.push_back(i);
range.push_back(a);
}
sort(idx.begin(), idx.end(), comp_idx);
vector<int> range_unmodded;
vector<uint16_t> range_modded;
range_modded.reserve(amount);
range_unmodded.reserve(amount);
for (int i = 0; i < (amount); ++i) {
range_unmodded.push_back(range[idx[i]]);
range_modded.push_back((uint16_t)(range[idx[i]] % (uint32_t)mod));
}
int queries;
cin >> queries;
for (int i = 0; i < (queries); ++i) {
int start, end;
cin >> start >> end;
start--;
end--;
int last_item = -1;
int fib_counter = 0;
uint64_t sum = 0;
for (int j = 0; j < (amount); ++j) {
if (((uint32_t)idx[j] - start <= (uint32_t)(end - start)) &&
(last_item != range_unmodded[j])) {
last_item = range_unmodded[j];
uint32_t product = range_modded[j] * fib_memo[fib_counter++];
sum += product;
}
}
cout << sum % mod << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30011;
int mod;
int a[N], b[N];
int fib[N];
struct SegTree {
int l[N << 2], r[N << 2];
int sz[N << 2];
int v0[N << 2];
int v1[N << 2];
void init(int left, int right, int x = 1) {
l[x] = left;
r[x] = right;
sz[x] = v0[x] = v1[x] = 0;
if (left + 1 != right) {
int mid = (left + right) / 2;
init(left, mid, 2 * x);
init(mid, right, 2 * x + 1);
}
}
void change(int pos, int c, int x = 1) {
if (l[x] + 1 == r[x]) {
sz[x] = c;
v1[x] = (c ? b[pos] : 0) % mod;
} else {
int mid = (l[x] + r[x]) / 2;
if (pos < mid)
change(pos, c, 2 * x);
else
change(pos, c, 2 * x + 1);
sz[x] = sz[2 * x] + sz[2 * x + 1];
if (sz[2 * x]) {
v0[x] = v0[2 * x] + fib[sz[2 * x]] * v1[2 * x + 1] +
fib[sz[2 * x] - 1] * v0[2 * x + 1];
v1[x] = v1[2 * x] + fib[sz[2 * x] + 1] * v1[2 * x + 1] +
fib[sz[2 * x]] * v0[2 * x + 1];
} else {
v0[x] = v0[2 * x + 1];
v1[x] = v1[2 * x + 1];
}
v0[x] %= mod;
v1[x] %= mod;
}
}
int query() { return v1[1]; }
} st;
int Sqrt = 160;
struct Query {
int l, r;
int id;
Query() {}
Query(int l, int r, int id) : l(l), r(r), id(id) {}
bool operator<(const Query &rhs) const {
if (l / Sqrt == rhs.l / Sqrt) {
if (l / Sqrt % 2) return r < rhs.r;
return r > rhs.r;
}
return l < rhs.l;
}
} query[N];
int ans[N];
map<int, int> disc;
map<int, int> all;
void add(int pos) {
all[a[pos]]++;
if (all[a[pos]] == 1) st.change(disc[a[pos]], 1);
}
void del(int pos) {
all[a[pos]]--;
if (all[a[pos]] == 0) st.change(disc[a[pos]], 0);
}
int main() {
ios ::sync_with_stdio(false);
int n;
cin >> n >> mod;
Sqrt = (int)sqrt(n);
fib[1] = fib[2] = 1;
for (int i = 3; i < N; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 1; i <= n; i++) {
cin >> a[i];
disc[a[i]] = 0;
}
int cnt = 0;
for (auto it = disc.begin(); it != disc.end(); it++) {
b[cnt] = it->first;
it->second = cnt++;
}
st.init(0, cnt);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> query[i].l >> query[i].r;
query[i].id = i;
}
sort(query, query + m);
int l = 1, r = 0;
for (int i = 0; i < m; i++) {
Query &q = query[i];
while (l > q.l) add(--l);
while (r < q.r) add(++r);
while (l < q.l) del(l++);
while (r > q.r) del(r--);
ans[q.id] = st.query();
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
const double pi = 3.141592653589793238462643383279;
namespace MyMinMax {
template <typename T>
inline T mn(const T x, const T y) {
return x < y ? x : y;
}
template <typename T>
inline T mx(const T x, const T y) {
return x > y ? x : y;
}
template <typename T>
inline bool chmin(T &x, const T y) {
return (x > y) && ((x = y), 1);
}
template <typename T>
inline bool chmax(T &x, const T y) {
return (x < y) && ((x = y), 1);
}
template <typename T, typename... Args>
inline T mx(const T x, const Args... args) {
return mx(x, mx(args...));
}
template <typename T, typename... Args>
inline T mn(const T x, const Args... args) {
return mn(x, mn(args...));
}
} // namespace MyMinMax
using namespace MyMinMax;
namespace IO {
const int DPAIRSIZ = 1 << 18;
char BB[DPAIRSIZ], *SS = BB, *TT = BB;
inline char getcha() {
return SS == TT && (TT = (SS = BB) + fread(BB, 1, DPAIRSIZ, stdin), SS == TT)
? EOF
: *SS++;
}
template <typename T = int>
inline T read() {
T x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
return x;
}
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
}
template <typename T>
inline void read(T *bg, T *ed) {
while (bg != ed) read(*bg++);
}
inline void read(char &ch) {
ch = getcha();
while (ch <= 32) ch = getcha();
}
inline void read(char *s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void sread(char *s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void pread(char *&s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void spread(char *&s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
char out[DPAIRSIZ], *Out = out;
inline void putcha(char x) {
*Out++ = x;
if (Out - out >= (DPAIRSIZ)) fwrite(out, 1, Out - out, stdout), Out = out;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putcha(45), x = -x;
if (x > 9) fprint(x / 10);
putcha(x % 10 + 48);
}
inline void print() { putcha(10); }
template <typename T>
inline void print(T x) {
fprint(x);
putcha(10);
}
inline void print(char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
inline void print(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
template <typename T, typename... Args>
inline void print(T x, Args... args) {
fprint(x);
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename T, typename... Args>
inline void printl(T x, Args... args) {
fprint(x);
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename T>
inline void sprint(T x) {
fprint(x);
putcha(32);
}
template <typename T, typename... Args>
inline void sprint(T x, Args... args) {
fprint(x);
putcha(32);
sprint(args...);
}
template <typename T>
inline void sprint(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
}
template <typename T>
inline void print(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
putcha(10);
}
template <typename T>
inline void printl(T *bg, T *ed) {
while (bg != ed) print(*bg++);
}
class AutoFlush {
public:
~AutoFlush() { fwrite(out, 1, Out - out, stdout); }
} __AutoFlush;
} // namespace IO
using namespace IO;
const int INF = 0x3f3f3f3f;
const long long INFll = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 3e4 + 5;
int f[MAXN], m, a[MAXN], n, q;
inline void init() {
f[0] = f[1] = 1;
for (int i = (2); i <= (n); ++i)
((f[i] = f[i - 1] + f[i - 2]) >= m) && (f[i] -= m);
}
int b[MAXN];
namespace DPair {
int cnt1[256], cnt2[256], cnt3[256], cnt4[256], A[MAXN];
inline void RadixSort(int *a, const int N) {
for (int i = 0; i < N - 3; i += 4) {
const int x[4] = {a[i], a[i + 1], a[i + 2], a[i + 3]};
++cnt1[x[0] & 255];
++cnt1[x[1] & 255];
++cnt1[x[2] & 255];
++cnt1[x[3] & 255];
++cnt2[x[0] >> 8 & 255];
++cnt2[x[1] >> 8 & 255];
++cnt2[x[2] >> 8 & 255];
++cnt2[x[3] >> 8 & 255];
++cnt3[x[0] >> 16 & 255];
++cnt3[x[1] >> 16 & 255];
++cnt3[x[2] >> 16 & 255];
++cnt3[x[3] >> 16 & 255];
++cnt4[x[0] >> 24 & 255];
++cnt4[x[1] >> 24 & 255];
++cnt4[x[2] >> 24 & 255];
++cnt4[x[3] >> 24 & 255];
}
for (int i = (1); i < (256); ++i) {
cnt1[i] += cnt1[i - 1];
cnt2[i] += cnt2[i - 1];
cnt3[i] += cnt3[i - 1];
cnt4[i] += cnt4[i - 1];
}
for (int i = N - 1; i >= 3; i -= 4) {
const int x[4] = {a[i], a[i - 1], a[i - 2], a[i - 3]};
A[--cnt1[x[0] & 255]] = x[0];
A[--cnt1[x[1] & 255]] = x[1];
A[--cnt1[x[2] & 255]] = x[2];
A[--cnt1[x[3] & 255]] = x[3];
}
for (int i = N - 1; i >= 3; i -= 4) {
const int x[4] = {A[i], A[i - 1], A[i - 2], A[i - 3]};
a[--cnt2[x[0] >> 8 & 255]] = x[0];
a[--cnt2[x[1] >> 8 & 255]] = x[1];
a[--cnt2[x[2] >> 8 & 255]] = x[2];
a[--cnt2[x[3] >> 8 & 255]] = x[3];
}
for (int i = N - 1; i >= 3; i -= 4) {
const int x[4] = {a[i], a[i - 1], a[i - 2], a[i - 3]};
A[--cnt3[x[0] >> 16 & 255]] = x[0];
A[--cnt3[x[1] >> 16 & 255]] = x[1];
A[--cnt3[x[2] >> 16 & 255]] = x[2];
A[--cnt3[x[3] >> 16 & 255]] = x[3];
}
for (int i = N - 1; i >= 3; i -= 4) {
const int x[4] = {A[i], A[i - 1], A[i - 2], A[i - 3]};
a[--cnt4[x[0] >> 24 & 255]] = x[0];
a[--cnt4[x[1] >> 24 & 255]] = x[1];
a[--cnt4[x[2] >> 24 & 255]] = x[2];
a[--cnt4[x[3] >> 24 & 255]] = x[3];
}
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
memset(cnt3, 0, sizeof(cnt3));
memset(cnt4, 0, sizeof(cnt4));
}
inline void RadixSort(int *a, int *_a) {
int N = _a - a;
while (N & 3) a[N++] = INF;
RadixSort(a, N);
}
} // namespace DPair
signed main() {
read(n, m);
read(a + 1, a + n + 1);
init();
read(q);
while (q--) {
int l, r;
read(l, r);
const int len = (r - l + 1);
memcpy(b, a + l, len * sizeof(int));
DPair ::RadixSort(b, b + len);
const int p = std ::unique(b, b + len) - b;
int ans[4] = {0, 0, 0, 0};
for (int i = 0; i < p - 3; i += 4) {
ans[0] = (1ll * b[i] * f[i] + ans[0]) % m;
ans[1] = (1ll * b[i + 1] * f[i + 1] + ans[1]) % m;
ans[2] = (1ll * b[i + 2] * f[i + 2] + ans[2]) % m;
ans[3] = (1ll * b[i + 3] * f[i + 3] + ans[3]) % m;
}
switch (p & 3) {
case 3:
ans[0] = (1ll * b[p - 3] * f[p - 3] + ans[0]) % m;
case 2:
ans[0] = (1ll * b[p - 2] * f[p - 2] + ans[0]) % m;
case 1:
ans[0] = (1ll * b[p - 1] * f[p - 1] + ans[0]) % m;
}
print((ans[0] + ans[1] + ans[2] + ans[3]) % m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 10;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
struct node {
int v, id;
bool operator<(const node& rhs) const { return v < rhs.v; }
} arr[maxn];
int f[maxn];
int n, m, q;
int l[maxn], r[maxn];
int lastv[maxn], lastd[maxn], ans[maxn];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
arr[i].v = read();
arr[i].id = i;
}
sort(arr + 1, arr + 1 + n);
q = read();
for (int i = 1; i <= q; i++) {
l[i] = read();
r[i] = read();
}
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
for (int i = 1; i <= q; i++) lastv[i] = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= q; j++) {
if (l[j] <= arr[i].id && arr[i].id <= r[j] && lastv[j] < arr[i].v) {
++lastd[j];
ans[j] = (ans[j] + arr[i].v % m * f[lastd[j]]) % m;
lastv[j] = arr[i].v;
}
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
int a[maxn], pos[maxn], q, n, m, d[maxn];
int fib[maxn][2];
map<int, int> H;
vector<int> V;
long long Ans[maxn];
int cnt[maxn];
struct treenode {
int L, R;
int sum1, sum2, siz;
void update(int v) {
siz = v;
sum1 = sum2 = v * d[L] % m;
}
};
treenode tree[maxn * 4];
inline void push_down(int o) {}
inline void push_up(int o) {
tree[o].siz = tree[2 * o].siz + tree[2 * o + 1].siz;
tree[o].sum1 =
(tree[2 * o].sum1 + fib[tree[2 * o].siz][0] * tree[o * 2 + 1].sum1 +
fib[tree[2 * o].siz][1] * tree[o * 2 + 1].sum2) %
m;
tree[o].sum2 =
(tree[2 * o].sum2 + fib[tree[2 * o].siz + 1][0] * tree[o * 2 + 1].sum1 +
fib[tree[2 * o].siz + 1][1] * tree[o * 2 + 1].sum2) %
m;
}
inline void build_tree(int L, int R, int o) {
tree[o].L = L, tree[o].R = R, tree[o].sum1 = tree[o].sum2 = tree[o].siz = 0;
if (R > L) {
int mid = (L + R) >> 1;
build_tree(L, mid, o * 2);
build_tree(mid + 1, R, o * 2 + 1);
}
}
inline void update(int QL, int QR, int v, int o) {
int L = tree[o].L, R = tree[o].R;
if (QL <= L && R <= QR)
tree[o].update(v);
else {
push_down(o);
int mid = (L + R) >> 1;
if (QL <= mid) update(QL, QR, v, o * 2);
if (QR > mid) update(QL, QR, v, o * 2 + 1);
push_up(o);
}
}
struct query {
int l, r, id;
} Q[maxn];
bool cmp(query a, query b) {
if (pos[a.l] == pos[b.l]) return a.r < b.r;
return pos[a.l] < pos[b.l];
}
void Updata(int x) {
int p = H[a[x]];
cnt[p]++;
if (cnt[p] == 1) update(p, p, 1, 1);
}
void Delete(int x) {
int p = H[a[x]];
cnt[p]--;
if (cnt[p] == 0) update(p, p, 0, 1);
}
int main() {
scanf("%d%d", &n, &m);
int sz = ceil(sqrt(1.0 * n));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
V.push_back(a[i]);
pos[i] = (i - 1) / sz;
}
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
for (int i = 0; i < V.size(); i++) {
H[V[i]] = i + 1;
d[i + 1] = V[i] % m;
}
fib[0][0] = 1 % m, fib[1][1] = 1 % m;
for (int i = 2; i <= n; i++) {
fib[i][0] = (fib[i - 1][0] + fib[i - 2][0]) % m;
fib[i][1] = (fib[i - 1][1] + fib[i - 2][1]) % m;
}
build_tree(1, n, 1);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q + 1, Q + 1 + q, cmp);
int l = 1, r = 0;
int ans = 0;
for (int i = 1; i <= q; i++) {
int id = Q[i].id;
while (r < Q[i].r) {
r++;
Updata(r);
}
while (l > Q[i].l) {
l--;
Updata(l);
}
while (r > Q[i].r) {
Delete(r);
r--;
}
while (l < Q[i].l) {
Delete(l);
l++;
}
Ans[id] = tree[1].sum1;
}
for (int i = 1; i <= q; i++) printf("%lld\n", Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c;
int w = 1;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') w = -1;
int ans = c - '0';
while ((c = getchar()) >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + c - '0';
return ans * w;
}
int n, m, blk, ynt, mod;
int a[30005], f[30005], ys[30005], bel[30005], num[30005], pre[30005 << 2],
now[30005 << 2], siz[30005 << 2];
int res[30005];
struct node {
int l, r, id;
} q[30005];
bool cmp(node tx, node ty) {
if (bel[tx.l] == bel[ty.l]) return tx.r < ty.r;
return tx.l < ty.l;
}
void pushup(int v) {
int x = siz[v * 2];
siz[v] = siz[v * 2] + siz[v * 2 + 1];
pre[v] = (pre[v * 2] + 1ll * pre[v * 2 + 1] * (x ? f[x - 1] : 1) +
1ll * now[v * 2 + 1] * f[x]) %
mod;
now[v] = (now[v * 2] + 1ll * pre[v * 2 + 1] * f[x] +
1ll * now[v * 2 + 1] * f[x + 1]) %
mod;
}
void upd(int v, int l, int r, int pos, int op) {
if (l == r) {
now[v] = (now[v] + ys[pos] * op) % mod;
siz[v] += op;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
upd(v * 2, l, mid, pos, op);
else
upd(v * 2 + 1, mid + 1, r, pos, op);
pushup(v);
}
void add(int x) {
if (++num[a[x]] == 1) upd(1, 1, ynt, a[x], 1);
}
void del(int x) {
if (--num[a[x]] == 0) upd(1, 1, ynt, a[x], -1);
}
int main() {
n = read(), mod = read(), blk = sqrt(n);
for (int i = 1; i <= n; i++)
a[i] = read(), ys[i] = a[i], bel[i] = (i - 1) / blk + 1;
sort(ys + 1, ys + n + 1);
ynt = unique(ys + 1, ys + n + 1) - ys - 1;
for (int i = 1; i <= n; i++)
a[i] = lower_bound(ys + 1, ys + ynt + 1, a[i]) - ys;
m = read();
f[1] = f[2] = 1;
for (int i = 3; i <= ynt; i++) f[i] = (f[i - 1] + f[i - 2]) % mod;
for (int i = 1; i <= m; i++) q[i].l = read(), q[i].r = read(), q[i].id = i;
sort(q + 1, q + m + 1, cmp);
int l = 1, r = 0, tl, tr;
for (int i = 1; i <= m; i++) {
tl = q[i].l, tr = q[i].r;
while (r < tr) add(++r);
while (l > tl) add(--l);
while (r > tr) del(r--);
while (l < tl) del(l++);
res[q[i].id] = now[1];
}
for (int i = 1; i <= m; i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fread {
const int SIZE = 1 << 26;
char buf[SIZE], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T) return '\n';
}
return *S++;
}
} // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 26;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c) {
*S++ = c;
if (S == T) flush();
}
struct NTR {
~NTR() { flush(); }
} ztr;
} // namespace Fwrite
namespace Fastio {
struct Reader {
template <typename T>
Reader& operator>>(T& x) {
char c = Fread ::getchar();
T f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = Fread ::getchar();
}
x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = Fread ::getchar();
}
x *= f;
return *this;
}
Reader& operator>>(char& c) {
c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
return *this;
}
Reader& operator>>(char* str) {
int len = 0;
char c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
while (c != '\n' && c != ' ') {
str[len++] = c;
c = Fread ::getchar();
}
str[len] = '\0';
return *this;
}
Reader() {}
} cin;
const char endl = '\n';
struct Writer {
template <typename T>
Writer& operator<<(T x) {
if (x == 0) {
Fwrite ::putchar('0');
return *this;
}
if (x < 0) {
Fwrite ::putchar('-');
x = -x;
}
static int sta[45];
int top = 0;
while (x) {
sta[++top] = x % 10;
x /= 10;
}
while (top) {
Fwrite ::putchar(sta[top] + '0');
--top;
}
return *this;
}
Writer& operator<<(char c) {
Fwrite ::putchar(c);
return *this;
}
Writer& operator<<(char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer& operator<<(const char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer() {}
} cout;
} // namespace Fastio
int n, p, m;
pair<int, int> a[30010];
int f[30010];
int l[30010], r[30010], mx[30010];
int ans[30010], now[30010];
signed main() {
Fastio ::cin >> n >> p;
for (int i = 1; i <= n; i++) Fastio ::cin >> a[i].first, a[i].second = i;
sort(a + 1, a + n + 1);
f[1] = 1, f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % p;
Fastio ::cin >> m;
for (int i = 1; i <= m; i++) Fastio ::cin >> l[i] >> r[i], mx[i] = -1;
for (int i = 1; i <= n; i++) {
int x = a[i].first % p;
for (int j = 1; j <= m; j++)
if (a[i].second >= l[j] && a[i].second <= r[j] && a[i].first != mx[j]) {
mx[j] = a[i].first;
ans[j] = (ans[j] + f[++now[j]] * x) % p;
}
}
for (int i = 1; i <= m; i++) Fastio ::cout << ans[i] << Fastio ::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int maxn = 3e4 + 1000;
const int inf = 0x3f3f3f3f;
const double PI = acos(-1.0);
int n, m;
pair<int, int> a[maxn];
int l[maxn], r[maxn];
int f[maxn];
int ans[maxn];
int last[maxn];
int step[maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + 1 + n);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l[i], &r[i]);
last[i] = -1;
}
f[0] = f[1] = 1;
for (int i = 2; i < maxn; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
for (int i = 1; i <= n; i++) {
int x = a[i].first % m;
int p = a[i].second;
for (int j = 1; j <= q; j++) {
if (p < l[j] || p > r[j]) continue;
if (last[j] == a[i].first) continue;
ans[j] = (ans[j] + f[step[j]++] * x) % m;
last[j] = a[i].first;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int BLOCK = 250;
int m;
int from[N], to[N], res[N];
pair<int, int> ev[N];
int REAL[N], a[N];
int id[N];
inline bool cmp(int x, int y) {
int u = from[x] / BLOCK;
int v = from[y] / BLOCK;
if (u != v) {
return u < v;
}
return to[x] < to[y];
}
int a11[N], a12[N], a13[N];
int a21[N], a22[N], a23[N];
void build(int x, int l, int r) {
a11[x] = 1;
a12[x] = 0;
a13[x] = 0;
a21[x] = 0;
a22[x] = 1;
a23[x] = 0;
if (l < r) {
int y = (l + r) >> 1;
build(x + x, l, y);
build(x + x + 1, y + 1, r);
}
}
void modify(int x, int l, int r, int pos, int action) {
if (l == r) {
if (action == 1) {
a11[x] = 1;
a12[x] = 1;
a13[x] = REAL[pos];
a21[x] = 1;
a22[x] = 0;
a23[x] = 0;
} else {
a11[x] = 1;
a12[x] = 0;
a13[x] = 0;
a21[x] = 0;
a22[x] = 1;
a23[x] = 0;
}
return;
}
int y = (l + r) >> 1;
if (pos <= y) {
modify(x + x, l, y, pos, action);
} else {
modify(x + x + 1, y + 1, r, pos, action);
}
a11[x] = (a11[x + x] * a11[x + x + 1] + a12[x + x] * a21[x + x + 1]) % m;
a12[x] = (a11[x + x] * a12[x + x + 1] + a12[x + x] * a22[x + x + 1]) % m;
a21[x] = (a21[x + x] * a11[x + x + 1] + a22[x + x] * a21[x + x + 1]) % m;
a22[x] = (a21[x + x] * a12[x + x + 1] + a22[x + x] * a22[x + x + 1]) % m;
a13[x] =
(a11[x + x] * a13[x + x + 1] + a12[x + x] * a23[x + x + 1] + a13[x + x]) %
m;
a23[x] =
(a21[x + x] * a13[x + x + 1] + a22[x + x] * a23[x + x + 1] + a23[x + x]) %
m;
}
int t;
int have[N];
int OPS;
void add(int what) {
if (have[what] == 0) {
OPS++;
modify(1, 0, t - 1, what, 1);
}
have[what]++;
}
void del(int what) {
have[what]--;
if (have[what] == 0) {
OPS++;
modify(1, 0, t - 1, what, 0);
}
}
int main() {
int n;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &ev[i].first);
ev[i].second = i;
}
sort(ev, ev + n);
t = -1;
for (int i = 0; i < n; i++) {
if (i == 0 || ev[i].first != ev[i - 1].first) {
t++;
REAL[t] = ev[i].first % m;
}
a[ev[i].second] = t;
}
t++;
for (int i = 0; i < t; i++) {
have[i] = 0;
}
build(1, 0, t - 1);
int tt;
scanf("%d", &tt);
for (int qq = 0; qq < tt; qq++) {
scanf("%d %d", from + qq, to + qq);
from[qq]--;
to[qq]--;
res[qq] = 0;
id[qq] = qq;
}
sort(id, id + tt, cmp);
int ll = from[0], rr = from[0] - 1;
OPS = 0;
for (int qq = 0; qq < tt; qq++) {
while (rr > to[id[qq]]) {
del(a[rr]);
rr--;
}
while (ll < from[id[qq]]) {
del(a[ll]);
ll++;
}
while (rr < to[id[qq]]) {
rr++;
add(a[rr]);
}
while (ll > from[id[qq]]) {
ll--;
add(a[ll]);
}
res[id[qq]] = a13[1];
}
for (int qq = 0; qq < tt; qq++) {
printf("%d\n", (res[qq] % m + m) % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, mod, q, N, p;
int val[30005], rak[30005], ans[30005], fib[60005];
int s[120005], v[120005], vp[120005];
struct Question {
int l, r, id;
bool operator<(const Question &b) const {
return l / p < b.l / p || (l / p == b.l / p && r < b.r);
}
} Q[30005];
void get_rank() {
memcpy(rak, val, sizeof(rak));
sort(val + 1, val + n + 1);
int tmp = 1;
for (int i = 2; i <= n; i++) {
if (val[i] != val[i - 1]) val[++tmp] = val[i];
}
N = tmp;
for (int i = 1; i <= n; i++)
rak[i] = lower_bound(val + 1, val + N + 1, rak[i]) - val;
}
void get_fibs() {
fib[N] = 0, fib[N + 1] = 1;
for (int i = 2; i <= N; i++)
fib[N + i] = (fib[N + i - 1] + fib[N + i - 2]) % mod;
for (int i = 1; i <= N; i++)
fib[N - i] = (fib[N - i + 2] - fib[N - i + 1] + mod) % mod;
}
void pushup(int o) {
v[o] = (v[o << 1] + v[o << 1 | 1]) % mod;
vp[o] = (vp[o << 1] + vp[o << 1 | 1]) % mod;
}
void shift(int o, int k) {
int x, y;
x = (vp[o] * fib[N + k] + v[o] * fib[N + k + 1]) % mod;
y = (vp[o] * fib[N + k - 1] + v[o] * fib[N + k]) % mod;
v[o] = x, vp[o] = y;
}
void pushdown(int o) {
if (s[o]) {
s[o << 1] += s[o];
s[o << 1 | 1] += s[o];
shift(o << 1, s[o]);
shift(o << 1 | 1, s[o]);
s[o] = 0;
}
}
void insert(int o, int l, int r, int x) {
if (r - l == 1) {
vp[o] = val[l] % mod * fib[N + s[o]] % mod;
v[o] = val[l] % mod * fib[N + 1 + s[o]] % mod;
} else {
int mid = l + r >> 1;
pushdown(o);
if (x < mid) {
insert(o << 1, l, mid, x);
s[o << 1 | 1]++;
shift(o << 1 | 1, 1);
} else
insert(o << 1 | 1, mid, r, x);
pushup(o);
}
}
void remove(int o, int l, int r, int x) {
if (r - l == 1)
v[o] = vp[o] = 0;
else {
int mid = l + r >> 1;
pushdown(o);
if (x < mid) {
remove(o << 1, l, mid, x);
s[o << 1 | 1]--;
shift(o << 1 | 1, -1);
} else
remove(o << 1 | 1, mid, r, x);
pushup(o);
}
}
int cnt[30005];
void insert(int k) {
if (!cnt[k]++) insert(1, 1, N + 1, k);
}
void remove(int k) {
if (!--cnt[k]) remove(1, 1, N + 1, k);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; i++) scanf("%d", val + i);
get_rank();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
p = sqrt(n);
sort(Q + 1, Q + q + 1);
get_fibs();
int L = 1, R = 0;
for (int i = 1; i <= q; i++) {
while (R > Q[i].r) remove(rak[R--]);
while (R < Q[i].r) insert(rak[++R]);
while (L < Q[i].l) remove(rak[L++]);
while (L > Q[i].l) insert(rak[--L]);
ans[Q[i].id] = v[1];
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
int a[int(30000 + 1000)], b[int(30000 + 1000)], t = 0;
map<int, int> Hash;
int wall[int(30000 + 1000)] = {0};
vector<int> vec[int(30000 + 1000)];
int fib[int(30000 + 1000)], ans[int(30000 + 1000)] = {0}, l[int(30000 + 1000)],
r[int(30000 + 1000)];
int main() {
int n, m, Q;
scanf("%d", &n);
;
scanf("%d", &m);
;
for (int i = int(1); i <= (int)n; i++) {
scanf("%d", &a[i]);
;
b[i] = a[i];
}
scanf("%d", &Q);
;
for (int i = int(1); i <= (int)Q; i++) {
scanf("%d", &l[i]);
;
scanf("%d", &r[i]);
;
vec[r[i]].push_back(i);
}
fib[1] = fib[2] = 1;
for (int i = 3; i <= n; ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
sort(b + 1, b + n + 1);
t = 1;
for (int i = 2; i <= n; ++i)
if (b[i] != b[i - 1]) b[++t] = b[i];
for (int i = int(1); i <= (int)t; i++) Hash[b[i]] = i;
for (int i = int(1); i <= (int)n; i++) a[i] = Hash[a[i]];
for (int i = int(1); i <= (int)t; i++) b[i] %= m;
int qid, cnt, idx, A, szz;
for (int i = 1; i <= n; ++i) {
wall[a[i]] = i;
szz = vec[i].size();
for (int j = 0; j < szz; ++j) {
cnt = 0;
qid = vec[i][j];
A = 0;
for (int k = 1; k <= t; ++k) {
if (wall[k] >= l[qid]) {
cnt++;
A = (A + fib[cnt] * b[k]) % m;
}
}
ans[qid] = A;
}
}
for (int i = int(1); i <= (int)Q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
const int maxn = 300001;
struct node {
int sz, in0, in1;
};
node tree[maxn];
int n, mod, x, y, a[maxn], b[maxn];
int ret[maxn];
int fibo[maxn];
int cnt, cnts[maxn];
pair<pair<int, int>, pair<int, int> > q[maxn];
int B;
int m;
inline void update(int k) {
int L = k << 1;
int R = k << 1 | 1;
tree[k].sz = tree[L].sz + tree[R].sz;
tree[k].in0 = (tree[L].in0 + fibo[tree[L].sz + 1] * tree[R].in1 +
fibo[tree[L].sz] * tree[R].in0) %
mod;
tree[k].in1 = (tree[L].in1 + fibo[tree[L].sz + 2] * tree[R].in1 +
fibo[tree[L].sz + 1] * tree[R].in0) %
mod;
}
void insert(int k, int l, int r, int x, int p) {
if (l == r) {
tree[k].sz = p;
tree[k].in0 = 0;
tree[k].in1 = (p == 0) ? 0 : (b[x] % mod);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
insert(k << 1, l, mid, x, p);
else
insert(k << 1 | 1, mid + 1, r, x, p);
update(k);
}
inline void add(int p) {
if (++cnts[a[p]] == 1) insert(1, 0, cnt - 1, a[p], 1);
}
inline void del(int p) {
if (--cnts[a[p]] == 0) insert(1, 0, cnt - 1, a[p], 0);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i - 1] = a[i];
}
fibo[0] = 1;
fibo[2] = 1;
for (int i = 3; i <= n + 20; i++) fibo[i] = (fibo[i - 2] + fibo[i - 1]) % mod;
sort(b, b + n);
B = sqrt(n);
cnt = unique(b, b + n) - b;
for (int i = 1; i <= n; i++) a[i] = lower_bound(b, b + cnt, a[i]) - b;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
q[i] = pair<pair<int, int>, pair<int, int> >(pair<int, int>(x, y),
pair<int, int>(x / B, i));
}
sort(q + 1, q + 1 + m,
[](pair<pair<int, int>, pair<int, int> > &x,
pair<pair<int, int>, pair<int, int> > &y) {
if (x.second.first != y.second.first)
return x.second.first < y.second.first;
return x.first.second < y.first.second;
});
int l = 1;
int r = 0;
for (int i = 1; i <= m; i++) {
while (r < q[i].first.second) add(++r);
while (r > q[i].first.second) del(r--);
while (l > q[i].first.first) add(--l);
while (l < q[i].first.first) del(l++);
ret[q[i].second.second] = tree[1].in1 % mod;
}
for (int i = 1; i <= m; i++) printf("%d\n", ret[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int F[300005], num[300005], max_val[300005], ans[300005];
struct node {
int val;
int num;
} a[300005];
struct question {
int l, r;
} ques[300005];
bool cmp(const node x, const node y) { return x.val < y.val; }
bool cmp2(const question k, const question t) {
if (k.r != t.r) return k.r < t.r;
return k.l < t.l;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].val);
a[i].num = i;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &ques[i].l, &ques[i].r);
max_val[i] = -1;
num[i] = 0;
}
sort(a + 1, a + n + 1, cmp);
F[1] = F[2] = 1;
for (int i = 3; i <= n; i++) F[i] = (F[i - 1] + F[i - 2]) % m;
for (int i = 1; i <= n; i++) {
int j = 1;
int x = a[i].val % m;
for (int j = 1; j <= q; j++) {
if (max_val[j] == a[i].val) continue;
if (a[i].num < ques[j].l || a[i].num > ques[j].r) continue;
num[j]++;
ans[j] += x * F[num[j]];
ans[j] %= m;
max_val[j] = a[i].val;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void EnableFileIO(const string &fileName) {
if (fileName.empty()) return;
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
return;
}
const int INF = (1 << 30) - 1;
const long long LINF = (1LL << 61) - 1;
const double EPS = 1e-10, PI = acos(-1);
const int N = 3e4 + 100, MAGIC = 200;
int n, P, m;
pair<int, int> a[N], q[N];
int cnt[N], maxi[N];
long long f[N], ans[N];
int main() {
srand((int)time(0));
EnableFileIO("");
scanf("%d%d", &n, &P);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
f[0] = 1, f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % P;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &q[i].first, &q[i].second);
--q[i].first, --q[i].second;
}
memset(maxi, -1, sizeof maxi);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (q[j].first <= a[i].second && a[i].second <= q[j].second &&
a[i].first > maxi[j]) {
ans[j] += a[i].first * f[cnt[j]++];
maxi[j] = a[i].first;
}
}
}
for (int i = 0; i < m; i++) {
printf("%lld\n", ans[i] % P);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
inline bool upmin(T& a, const S& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T& a, const S& b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
inline void gn(double& x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double& x) {
double t;
scanf("%lf", &t);
x = t;
}
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
int inf = 0x3f3f3f3f;
double eps = 1e-6;
int mo = 1000000007;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
int first[33333];
int seq[33333];
const int SEG_MAXN = 100000 + 5;
int seg[SEG_MAXN * 4], seg1[SEG_MAXN * 4];
int num[SEG_MAXN * 4];
inline void segpu(int x) {
num[x] = num[x << 1] + num[x << 1 | 1];
if (num[x << 1]) {
seg[x] = (seg[x << 1] + 1ll * first[num[x << 1] - 1] * seg[x << 1 | 1] +
1ll * first[num[x << 1]] * seg1[x << 1 | 1]) %
mo;
seg1[x] = (seg1[x << 1] + 1ll * first[num[x << 1]] * seg[x << 1 | 1] +
1ll * first[num[x << 1] + 1] * seg1[x << 1 | 1]) %
mo;
} else {
seg[x] = seg[x << 1 | 1];
seg1[x] = seg1[x << 1 | 1];
}
}
void seginit_in(int l, int r, int x) {
if (l == r) {
seg[x] = seg1[x] = 0;
num[x] = 0;
} else {
int mid = l + r >> 1;
seginit_in(l, mid, x << 1);
seginit_in(mid + 1, r, x << 1 | 1);
segpu(x);
}
}
int l1, r1, I;
int sans;
bool ans_bo;
int stag;
void segupd_in(int l, int r, int x) {
if (l == r) {
seg[x] = 0, seg1[x] = stag * seq[l];
num[x] = stag;
} else {
int mid = l + r >> 1;
if (I <= mid)
segupd_in(l, mid, x << 1);
else
segupd_in(mid + 1, r, x << 1 | 1);
segpu(x);
}
}
int segn;
void segupd(int i, int v) {
stag = v, I = i;
segupd_in(1, segn, 1);
}
void seginit(int n) {
segn = n;
seginit_in(1, segn, 1);
}
int n;
int ai[33333];
map<int, int> ma;
struct Q {
int l, r, id;
} que[33333];
int q;
int tot = 0;
int SZ = 200;
int cmp(const Q& a, const Q& b) {
if (a.l / SZ == b.l / SZ)
return a.r < b.r;
else
return a.l < b.l;
}
int cl, cr;
int cnt[33333];
int out[33333];
void upd(int id, int del) {
if (cnt[id] == 0 && del == 1) {
segupd(id, 1);
} else if (cnt[id] == 1 && del == -1) {
segupd(id, 0);
}
cnt[id] += del;
}
void gaol(int l) {
while (cl > l) {
cl--;
upd(ai[cl], 1);
}
while (cl < l) {
upd(ai[cl], -1);
cl++;
}
}
void gaor(int r) {
while (cr < r) {
cr++;
upd(ai[cr], 1);
}
while (cr > r) {
upd(ai[cr], -1);
cr--;
}
}
int main() {
gn(n);
gn(mo);
first[0] = 0;
first[1] = 1 % mo;
for (int i = (2), _ed = (30010); i < _ed; i++)
first[i] = (first[i - 1] + first[i - 2]) % mo;
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
gn(ai[i]);
ma[ai[i]];
}
for (__typeof((ma).begin()) i = (ma).begin(); i != (ma).end(); i++)
seq[i->second = ++tot] = (i->first) % mo;
for (int i = (1), _ed = (n + 1); i < _ed; i++) ai[i] = ma[ai[i]];
gn(q);
for (int i = (1), _ed = (q + 1); i < _ed; i++)
gn(que[i].l), gn(que[i].r), que[i].id = i;
sort(que + 1, que + 1 + q, cmp);
seginit(tot);
cl = 1, cr = 0;
for (int i = (1), _ed = (q + 1); i < _ed; i++) {
if (cl > que[i].r)
gaol(que[i].l), gaor(que[i].r);
else
gaor(que[i].r), gaol(que[i].l);
out[que[i].id] = seg1[1];
}
for (int i = (1), _ed = (q + 1); i < _ed; i++) printf("%d\n", out[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 30010;
long long n, mod, Q;
long long f[MAXN], maxc[MAXN], p[MAXN], ans[MAXN];
struct node {
long long x, t;
} a[MAXN];
pair<long long, long long> q[MAXN];
bool cmp(node a, node b) { return a.x < b.x; }
signed main() {
scanf("%I64d%I64d", &n, &mod);
for (register long long i = 1; i <= n; ++i) {
scanf("%lld", &a[i].x);
a[i].t = i;
}
f[1] = f[2] = 1;
for (register long long i = 3; i <= n; ++i)
f[i] = (f[i - 1] + f[i - 2]) % mod;
sort(a + 1, a + n + 1, cmp);
scanf("%I64d", &Q);
for (register long long i = 1; i <= Q; ++i)
scanf("%I64d%I64d", &q[i].first, &q[i].second);
for (register long long i = 1; i <= n; ++i) {
long long pos = a[i].t, x = a[i].x % mod;
for (register long long j = 1; j <= Q; ++j)
if (q[j].first <= pos && pos <= q[j].second && maxc[j] != a[i].x) {
ans[j] += f[++p[j]] * x;
maxc[j] = a[i].x;
}
}
for (long long i = 1; i <= Q; ++i) printf("%I64d\n", ans[i] % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret;
}
const int MAXN = 30000;
int A[MAXN + 10], at;
int getloc(int x) {
int l = 1, r = at;
while (l <= r) {
int mid = (l + r) >> 1;
if (A[mid] < x)
l = mid + 1;
else if (A[mid] == x)
return mid;
else
r = mid - 1;
}
return -1;
}
int m, F[MAXN + 10];
const int MAXT = (MAXN << 3) + (MAXN << 1);
struct SegTree {
int sum[MAXT + 10], sum1[MAXT + 10], sz[MAXT + 10];
void update(int x) {
sz[x] = sz[x << 1] + sz[x << 1 | 1];
if (!sz[x << 1]) {
sum[x] = sum[x << 1 | 1];
sum1[x] = sum1[x << 1 | 1];
} else {
int s = sz[x << 1];
sum[x] =
(sum[x << 1 | 1] * F[s - 1] + sum1[x << 1 | 1] * F[s] + sum[x << 1]) %
m;
sum1[x] = (sum[x << 1 | 1] * F[s] + sum1[x << 1 | 1] * F[s + 1] +
sum1[x << 1]) %
m;
}
return;
}
void modify(int x, int l, int r, int k) {
while (l < r) {
int mid = (l + r) >> 1;
if (k <= mid) {
x <<= 1;
r = mid;
} else {
x <<= 1;
x |= 1;
l = mid + 1;
}
}
sz[x] ^= 1;
sum[x] = sum1[x] = sz[x] * A[l] % m;
while (x >> 1) update(x >>= 1);
return;
}
} seg;
int n;
int a[MAXN + 10];
int cnt[MAXN + 10];
void work(int id, int k) {
bool l = (cnt[id] > 0);
cnt[id] += k;
if (l ^ (cnt[id] > 0)) seg.modify(1, 1, at, id);
return;
}
int L[MAXN + 10], R[MAXN + 10], bel[MAXN + 10];
bool cmp(int l, int r) {
return bel[L[l]] < bel[L[r]] || (bel[L[l]] == bel[L[r]] && R[l] < R[r]);
}
int id[MAXN + 10];
int ans[MAXN + 10];
void init() {
n = read();
m = read();
for (int i = 1; i <= n; i++) A[i] = a[i] = read();
sort(A + 1, A + n + 1);
for (int i = 1, j = i; i <= n; i = j + 1) {
A[++at] = A[i];
j = i;
while (j < n && A[j + 1] == A[at]) j++;
}
F[1] = F[2] = 1;
for (int i = 3; i <= at + 1; i++) F[i] = (F[i - 1] + F[i - 2]) % m;
int Q = read();
for (int i = 1; i <= Q; i++) {
L[i] = read();
R[i] = read();
id[i] = i;
}
int S = (int)(sqrt(Q)), ll = 1, lt = 0;
while (ll <= n) {
for (int j = 1; j <= S && ll <= n; j++) bel[ll++] = lt;
++lt;
}
sort(id + 1, id + Q + 1, cmp);
int ln = 1, rn = 0;
for (int i = 1; i <= Q; i++) {
while (ln < L[id[i]]) work(getloc(a[ln++]), -1);
while (ln > L[id[i]]) work(getloc(a[--ln]), 1);
while (rn < R[id[i]]) work(getloc(a[++rn]), 1);
while (rn > R[id[i]]) work(getloc(a[rn--]), -1);
ans[id[i]] = seg.sum[1];
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return;
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 10;
int a[maxn], b[maxn], c[maxn];
int n, m, fib[maxn];
int sum[2][maxn << 2], sz[maxn << 2];
void gather(int p) {
sz[p] = sz[p << 1] + sz[p << 1 | 1];
sum[0][p] = (sum[0][p << 1] + fib[sz[p << 1] + 1] * sum[0][p << 1 | 1] +
fib[sz[p << 1]] * sum[1][p << 1 | 1]) %
m;
if (sz[p << 1])
sum[1][p] = (sum[1][p << 1] + fib[sz[p << 1]] * sum[0][p << 1 | 1] +
fib[sz[p << 1] - 1] * sum[1][p << 1 | 1]) %
m;
else
sum[1][p] = sum[1][p << 1 | 1];
}
void modify(int p, int tl, int tr, int x, int v) {
if (tr < x || x < tl) return;
if (tl == tr) {
sz[p] = v;
sum[0][p] = v ? b[tl] % m : 0;
return;
}
int mid = (tl + tr) >> 1;
modify(p << 1, tl, mid, x, v);
modify(p << 1 | 1, mid + 1, tr, x, v);
gather(p);
}
int ans[maxn];
int block, cnt[maxn];
struct query {
int id, l, r;
} Q[maxn];
bool cmp(query A, query B) {
if (A.l / block != B.l / block) return A.l / block < B.l / block;
return A.r < B.r;
}
int main(void) {
scanf("%d %d", &n, &m);
fib[1] = fib[2] = 1 % m;
for (int i = 3; i <= n; i++) fib[i] = (fib[i - 2] + fib[i - 1]) % m;
for (int i = 1; i <= n; i++) scanf("%d", a + i), b[i] = a[i];
sort(b + 1, b + 1 + n);
int tot = unique(b + 1, b + 1 + n) - b - 1;
for (int i = 1; i <= n; i++) c[i] = lower_bound(b + 1, b + 1 + tot, a[i]) - b;
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) scanf("%d %d", &Q[i].l, &Q[i].r), Q[i].id = i;
block = sqrt(n), sort(Q, Q + q, cmp);
int l = 1, r = 0;
for (int i = 0; i < q; i++) {
while (r < Q[i].r) {
r++, cnt[c[r]]++;
if (cnt[c[r]] == 1) modify(1, 1, n, c[r], 1);
}
while (r > Q[i].r) {
cnt[c[r]]--;
if (!cnt[c[r]]) modify(1, 1, n, c[r], 0);
r--;
}
while (l < Q[i].l) {
cnt[c[l]]--;
if (!cnt[c[l]]) modify(1, 1, n, c[l], 0);
l++;
}
while (l > Q[i].l) {
l--, cnt[c[l]]++;
if (cnt[c[l]] == 1) modify(1, 1, n, c[l], 1);
}
ans[Q[i].id] = sum[0][1];
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
int a[30000], n, a2[30000], n2, fib[30000];
bool seen[30000];
int main() {
scanf("%d%d", &n, &mod);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
a2[i] = a[i];
}
fib[0] = fib[1] = 1;
for (int i = 2; i < n; ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
sort(a2, a2 + n);
n2 = unique(a2, a2 + n) - a2;
for (int i = 0; i < n; ++i) a[i] = lower_bound(a2, a2 + n2, a[i]) - a2;
for (int i = 0; i < n2; ++i) a2[i] %= mod;
int nQueries, L, R;
scanf("%d", &nQueries);
while (nQueries--) {
scanf("%d%d", &L, &R);
L--;
R--;
for (int i = L; i <= R; ++i) seen[a[i]] = 1;
int ans = 0, cur = 0;
for (int i = 0; i < n; ++i)
if (seen[i]) ans = (ans + a2[i] * fib[cur++]) % mod;
for (int i = L; i <= R; ++i) seen[a[i]] = 0;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, mod;
long long f[30005] = {0, 1, 1}, Max[30005], Ans[30005], Now[30005];
struct node {
long long value, Index;
bool operator<(const node &p) const { return value < p.value; }
} a[30005];
pair<long long, long long> operation[30005];
void read(long long &x) {
x = 0;
char c = getchar();
long long f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= f;
return;
}
void write(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
signed main() {
read(n), read(mod);
for (register long long i = 1; i <= n; ++i) {
read(a[i].value), a[i].Index = i;
f[i] = (i >= 3 ? f[i - 1] + f[i - 2] : f[i]) % mod;
}
sort(a + 1, a + n + 1);
read(m);
for (register long long i = 1; i <= m; ++i) {
Max[i] = -1;
read(operation[i].first), read(operation[i].second);
}
for (register long long i = 1; i <= n; ++i) {
long long x = a[i].value % mod;
for (register long long j = 1; j <= m; ++j)
if (a[i].Index >= operation[j].first &&
a[i].Index <= operation[j].second && a[i].value != Max[j]) {
Max[j] = a[i].value;
Ans[j] += x * f[++Now[j]];
}
}
for (register long long i = 1; i <= m; ++i)
write(Ans[i] % mod), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int flag = 1;
x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') flag = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= flag;
}
using namespace std;
struct node {
int val, num;
friend bool operator<(const node &x, const node &y) { return x.val < y.val; }
} a[100050];
int n, m, q, t, fib[100050], l[100050], r[100050], maxn[100050], st[100050];
long long ans[100050];
int main() {
int i, j;
read(n);
read(m);
for (i = 1; i <= n; ++i) read(a[i].val), a[i].num = i;
sort(a + 1, a + n + 1);
fib[1] = fib[2] = 1;
for (i = 3; i <= n; ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
read(q);
for (i = 1; i <= q; ++i) read(l[i]), read(r[i]), maxn[i] = -1;
for (i = 1; i <= n; ++i) {
t = a[i].val % m;
for (j = 1; j <= q; ++j)
if (a[i].num >= l[j] && a[i].num <= r[j] && a[i].val ^ maxn[j]) {
maxn[j] = a[i].val;
ans[j] += fib[++st[j]] * t;
}
}
for (i = 1; i <= q; ++i) printf("%lld\n", ans[i] % m);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
int n, m, f[30010], q;
pair<int, int> a[30010];
struct ask {
int x, y;
} Q[30010];
int main() {
scanf("%d%d", &n, &m);
f[1] = f[2] = 1;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].first), a[i].second = i;
sort(a + 1, a + 1 + n);
for (int i = 3; i <= n; ++i) f[i] = (f[i - 1] + f[i - 2]) % m;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].x, &Q[i].y);
int t = 0, ans = 0;
for (int j = 1; j <= n; j++)
if (Q[i].x <= a[j].second && a[j].second <= Q[i].y) {
ans = (ans + f[++t] * (a[j].first % m)) % m;
int now = a[j].first;
while (a[j].first == now && j <= n) j++;
j--;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 30000 + 10;
const int INF = ~0U >> 1;
pair<int, int> a[MAX_N];
int n, m, fib[MAX_N], b[MAX_N];
int main() {
scanf("%d%d", &n, &m);
fib[1] = fib[2] = 1 % m;
for (int i = 3; i < MAX_N; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = make_pair(x, i);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) b[i] = a[i].first % m;
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
long long ans = 0;
int pre = -INF, cur = 1;
for (int i = 1; i <= n; i++)
if (l <= a[i].second && a[i].second <= r && a[i].first > pre) {
ans += 1LL * b[i] * fib[cur++];
pre = a[i].first;
}
printf("%I64d\n", ans % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int mod;
struct mat {
int a[2][2];
mat() { memset(a, 0, sizeof a); }
void init() {
a[0][0] = a[1][1] = 1;
a[0][1] = a[1][0] = 0;
}
int *operator[](int x) { return a[x]; }
};
mat f[100010];
mat operator*(const mat &a, const mat &b) {
mat c;
c.a[0][0] = (a.a[0][0] * b.a[0][0] + a.a[0][1] * b.a[1][0]) % mod;
c.a[0][1] = (a.a[0][0] * b.a[0][1] + a.a[0][1] * b.a[1][1]) % mod;
return c;
}
mat cha(const mat &a, const mat &b) {
mat c;
c.a[0][0] = (a.a[0][0] * b.a[0][0] + a.a[0][1] * b.a[1][0]) % mod;
c.a[0][1] = (a.a[0][0] * b.a[0][1] + a.a[0][1] * b.a[1][1]) % mod;
c.a[1][0] = (a.a[1][0] * b.a[0][0] + a.a[1][1] * b.a[1][0]) % mod;
c.a[1][1] = (a.a[1][0] * b.a[0][1] + a.a[1][1] * b.a[1][1]) % mod;
return c;
}
mat operator+(const mat &a, const mat &b) {
mat c;
c.a[0][0] = (a.a[0][0] + b.a[0][0]) % mod;
c.a[0][1] = (a.a[0][1] + b.a[0][1]) % mod;
return c;
}
struct tree {
struct pp {
int l, r, ls, rs, sz;
mat s;
pp() { l = r = ls = rs = sz = 0; }
};
pp a[100010];
int n, rt;
tree() { n = rt = 0; }
void build(int &p, int l, int r) {
p = ++n;
a[p].l = l;
a[p].r = r;
if (l != r) {
int mid = (l + r) >> 1;
build(a[p].ls, l, mid);
build(a[p].rs, mid + 1, r);
}
}
void change1(int p, int x, const mat &v) {
if (a[p].l == a[p].r) {
a[p].sz = 0;
a[p].s = v;
return;
}
int mid = (a[p].l + a[p].r) >> 1;
if (x <= mid)
change1(a[p].ls, x, v);
else
change1(a[p].rs, x, v);
a[p].sz = a[a[p].ls].sz + a[a[p].rs].sz;
a[p].s = a[a[p].ls].s + a[a[p].rs].s * f[a[a[p].ls].sz];
}
void change2(int p, int x, const mat &v) {
if (a[p].l == a[p].r) {
a[p].sz = 1;
a[p].s = v;
return;
}
int mid = (a[p].l + a[p].r) >> 1;
if (x <= mid)
change2(a[p].ls, x, v);
else
change2(a[p].rs, x, v);
a[p].sz = a[a[p].ls].sz + a[a[p].rs].sz;
a[p].s = a[a[p].ls].s + a[a[p].rs].s * f[a[a[p].ls].sz];
}
};
tree tr;
struct p {
int l, r, id;
};
int size;
int cmp(p a, p b) {
return a.l / size != b.l / size ? a.l / size < b.l / size : a.r < b.r;
}
p b[100010];
int d[100010];
int a[100010];
int num[100010];
int m, q;
int ans[100010];
mat a1, a2, a3;
void add(int x) {
if (!num[x]) {
a3.a[0][0] = a3.a[0][1] = d[x] % mod;
a3.a[1][0] = a3.a[1][1] = 0;
tr.change2(tr.rt, x, a3);
}
num[x]++;
}
void del(int x) {
num[x]--;
if (!num[x]) {
a3.a[0][0] = a3.a[0][1] = a3.a[1][0] = a3.a[1][1] = 0;
tr.change1(tr.rt, x, a3);
}
}
int main() {
scanf("%d%d", &n, &mod);
a1.a[0][1] = a1.a[1][0] = a1.a[1][1] = 1;
a1.a[0][0] = 0;
size = sqrt(n) + 0.5;
int i;
f[0][0][0] = f[0][1][1] = 1;
for (i = 1; i <= n; i++) f[i] = cha(f[i - 1], a1);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
d[i] = a[i];
}
sort(d + 1, d + n + 1);
m = unique(d + 1, d + n + 1) - d - 1;
for (i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
scanf("%d", &q);
for (i = 1; i <= q; i++) {
scanf("%d%d", &b[i].l, &b[i].r);
b[i].id = i;
}
sort(b + 1, b + q + 1, cmp);
tr.build(tr.rt, 1, m);
memset(num, 0, sizeof num);
int l = 1, r = 0;
for (i = 1; i <= q; i++) {
while (r < b[i].r) add(a[++r]);
while (l > b[i].l) add(a[--l]);
while (r > b[i].r) del(a[r--]);
while (l < b[i].l) del(a[l++]);
ans[b[i].id] = tr.a[1].s.a[0][0];
}
for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
int N, M;
cin >> N >> M;
vector<int> fib(30001);
fib[0] = fib[1] = 1;
for (int i = 2; i < 30001; ++i) {
fib[i] = (fib[i - 1] + fib[i - 2]) % M;
}
vector<pair<int, int> > nums(N);
for (int i = 0; i < N; ++i) {
cin >> nums[i].first;
nums[i].second = i;
}
int Q;
cin >> Q;
vector<pair<int, int> > intervals(Q);
for (int i = 0; i < Q; ++i) {
cin >> intervals[i].first >> intervals[i].second;
intervals[i].first--;
intervals[i].second--;
}
sort(nums.begin(), nums.end());
vector<int> next(N, N);
int nextN = N, last = -1, cur = nums.back().first;
for (int i = N - 1; i >= 0; --i) {
if (nums[i].first != cur) {
cur = nums[i].first;
last = nums[i + 1].first;
nextN = i + 1;
}
next[i] = nextN - 1;
}
for (int i = 0; i < N; i++) {
nums[i].first = nums[i].first % M;
}
for (int i = 0; i < Q; ++i) {
long long sum = 0;
int LB = intervals[i].first, UB = intervals[i].second, k = 0;
for (int j = 0; j < N; ++j) {
if (nums[j].second >= LB & nums[j].second <= UB) {
sum += nums[j].first * fib[k];
j = next[j];
++k;
}
}
cout << sum % M << '\n';
}
cout << flush;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
using lli = int;
using pii = tuple<lli, lli>;
using ppii = tuple<pii, pii>;
using piii = tuple<lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B>
ostream& operator<<(ostream& s, tuple<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B, class C>
ostream& operator<<(ostream& s, tuple<A, B, C> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << "," << get<2>(a) << ")";
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
lli n, m;
lli F[100000];
struct node {
node() {}
lli v = 0;
lli s1 = 0, s2 = 0;
lli shiftBy = 0;
};
struct tree {
lli n;
vector<node> A;
tree(lli n_) : n((lli)1 << (lli)(log2(n_) + 1)), A(2 * n) {}
void print_tree_(lli i, lli a, lli b, lli in) {
push(i, a, b);
lli c = (a + b) / 2;
if (i < n) print_tree_(2 * i, a, c, in + 1);
for (lli i = 0; i < (lli)(in); ++i) cout << " ";
cout << "| " << i << " " << A[i].v;
cout << endl;
if (i < n) print_tree_(2 * i + 1, c + 1, b, in + 1);
}
void print_tree() { print_tree_(1, 0, n - 1, 0); }
void push(lli i, lli a, lli b) {
if (i < n) {
lli c = (a + b) / 2;
if (A[i].shiftBy) {
shift__(2 * i, a, c, A[i].shiftBy);
shift__(2 * i + 1, c + 1, b, A[i].shiftBy);
A[i].shiftBy = 0;
}
}
}
void build() {
for (lli i = (n - 1); i >= (lli)(0); --i) update(i);
}
void update(lli i) {
A[i].s1 = (A[2 * i].s1 + A[2 * i + 1].s1) % m;
A[i].s2 = (A[2 * i].s2 + A[2 * i + 1].s2) % m;
}
void shift__(lli i, lli a, lli b, lli v) {
if (v) {
A[i].shiftBy += v;
A[i].v += v;
lli ns1 = F[49999 + v] * A[i].s1 + F[50000 + v] * A[i].s2;
lli ns2 = F[50000 + v] * A[i].s1 + F[50001 + v] * A[i].s2;
A[i].s1 = ns1 % m;
A[i].s2 = ns2 % m;
}
}
void shift_(lli i, lli a, lli b, lli l, lli r, lli v, lli x) {
if (l > b) return;
if (r < a) return;
if (l <= a && b <= r) {
if (l == a) insert_(i, a, b, l, x);
shift__(i, a, b, v);
return;
}
push(i, a, b);
lli c = (a + b) / 2;
shift_(2 * i, a, c, l, r, v, x);
shift_(2 * i + 1, c + 1, b, l, r, v, x);
update(i);
}
void shift(lli l, lli r, lli v, lli x) { shift_(1, 0, n - 1, l, r, v, x); }
void insert_(lli i, lli a, lli b, lli l, lli v) {
if (l > b) return;
if (l < a) return;
push(i, a, b);
if (l <= a && b <= l) {
A[i].s1 = (F[50000 + A[i].v] * v) % m;
A[i].s2 = (F[50001 + A[i].v] * v) % m;
return;
}
lli c = (a + b) / 2;
insert_(2 * i, a, c, l, v);
insert_(2 * i + 1, c + 1, b, l, v);
update(i);
}
lli query() { return A[1].s1 % m; }
};
int main(int, char**) {
srand(time(0));
ios::sync_with_stdio(false);
scanf("%d%d", &n, &m);
F[50000] = 0;
F[50001] = 1;
for (lli i = (50002); i <= (lli)(99999); ++i)
F[i] = (F[i - 2] + F[i - 1]) % m;
for (lli i = (49999); i >= (lli)(0); --i)
F[i] = (F[i + 2] - F[i + 1] + m + m) % m;
vi A(n);
for (lli i = 0; i < (lli)(n); ++i) scanf("%d", &A[i]);
set<lli> AS;
for (lli i = 0; i < (lli)(n); ++i) AS.insert(A[i]);
lli ni = 0;
unordered_map<lli, lli> TOI;
for (auto x : AS) {
TOI[x] = ni;
ni += 1;
}
tree t(ni);
lli q;
scanf("%d", &q);
vii Q(q);
for (lli i = 0; i < (lli)(q); ++i)
scanf("%d%d", &get<0>(Q[i]), &get<1>(Q[i]));
for (lli i = 0; i < (lli)(q); ++i) get<0>(Q[i]) -= 1;
for (lli i = 0; i < (lli)(q); ++i) get<1>(Q[i]) -= 1;
lli bsize = 250;
vi I(q);
for (lli i = 0; i < (lli)(q); ++i) I[i] = i;
sort(begin(I), end(I), [&](lli a, lli b) {
return pii(get<0>(Q[a]) / bsize, get<1>(Q[a])) <
make_tuple(get<0>(Q[b]) / bsize, get<1>(Q[b]));
});
vi ANS(q);
unordered_map<lli, lli> M;
auto mo_add = [&](lli x) {
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, 1, x % m);
}
M[x] += 1;
};
auto mo_remove = [&](lli x) {
M[x] -= 1;
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, -1, 0);
}
};
lli cl = 0, cr = -1;
for (lli i = 0; i < (lli)(q); ++i) {
lli l = get<0>(Q[I[i]]), r = get<1>(Q[I[i]]);
while (cr < r) {
cr += 1;
mo_add(A[cr]);
}
while (cl > l) {
cl -= 1;
mo_add(A[cl]);
}
while (cr > r) {
mo_remove(A[cr]);
cr -= 1;
}
while (cl < l) {
mo_remove(A[cl]);
cl += 1;
}
ANS[I[i]] = t.query();
}
for (lli i = 0; i < (lli)(q); ++i) cout << ANS[i] << '\n';
cout << flush;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e10;
const int P = 1e9 + 7;
const int N = 100005;
inline int IN() {
int x = 0;
int ch = 0, f = 0;
for (ch = getchar(); ch != -1 && (ch < 48 || ch > 57); ch = getchar())
f = (ch == '-');
for (; ch >= 48 && ch <= 57; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? (-x) : x;
}
int Pow(int x, int y, int p) {
int a = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) a = (long long)a * x % p;
return a;
}
int n, m, a[N], tq, S = 200, b[N];
struct node {
int l, r, id;
} q[N];
inline int cmp(const node &a, const node &b) {
if (a.l / S != b.l / S) return a.l < b.l;
if ((a.l / S) & 1)
return a.r > b.r;
else
return a.r < b.r;
}
struct mat {
int a11, a12, a21, a22;
} tmp, power[N], base, t[N * 4];
mat operator*(const mat &a, const mat &b) {
tmp.a11 = (a.a11 * b.a11 + a.a12 * b.a21) % m;
tmp.a12 = (a.a11 * b.a12 + a.a12 * b.a22) % m;
tmp.a21 = (a.a21 * b.a11 + a.a22 * b.a21) % m;
tmp.a22 = (a.a21 * b.a12 + a.a22 * b.a22) % m;
return tmp;
}
mat operator+(const mat &a, const mat &b) {
tmp.a11 = (a.a11 + b.a11);
if (tmp.a11 >= m) tmp.a11 -= m;
tmp.a12 = (a.a12 + b.a12);
if (tmp.a12 >= m) tmp.a12 -= m;
tmp.a21 = (a.a21 + b.a21);
if (tmp.a21 >= m) tmp.a21 -= m;
tmp.a22 = (a.a22 + b.a22);
if (tmp.a22 >= m) tmp.a22 -= m;
return tmp;
}
int siz[N * 4], res, has[N * 4];
void M(int x, int L, int R, int v, int p) {
if (L == R) {
siz[x] += p;
if (siz[x] > 0) {
has[x] = 1;
t[x] = (mat){b[L], b[L], b[L], 0};
} else {
has[x] = 0;
t[x] = (mat){0, 0, 0, 0};
}
return;
}
int md = (L + R) >> 1;
if (v <= md)
M(x * 2, L, md, v, p);
else
M(x * 2 + 1, md + 1, R, v, p);
has[x] = has[x * 2] + has[x * 2 + 1];
t[x] = t[x * 2] + (t[x * 2 + 1] * power[has[x * 2]]);
}
int ans[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) {
scanf("%d", a + i);
b[++*b] = a[i];
}
sort(b + 1, b + *b + 1);
*b = unique(b + 1, b + *b + 1) - (b + 1);
for (int i = (int)(1); i <= (int)(n); i++)
a[i] = lower_bound(b + 1, b + *b + 1, a[i]) - b;
for (int i = (int)(1); i <= (int)(*b); i++) b[i] %= m;
scanf("%d", &tq);
for (int i = (int)(1); i <= (int)(tq); i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + tq + 1, cmp);
int tl = q[1].l, tr = q[1].r;
power[0].a11 = power[0].a22 = 1;
base.a11 = base.a12 = base.a21 = 1;
for (int i = (int)(1); i <= (int)(n); i++) power[i] = power[i - 1] * base;
for (int i = (int)(tl); i <= (int)(tr); i++) M(1, 1, *b, a[i], 1);
for (int i = (int)(1); i <= (int)(tq); i++) {
ans[q[i].id] = t[1].a12;
if (i == tq) break;
int ql = q[i + 1].l, qr = q[i + 1].r;
while (tl > ql) {
--tl;
M(1, 1, *b, a[tl], 1);
}
while (tl < ql) {
M(1, 1, *b, a[tl], -1);
++tl;
}
while (tr > qr) {
M(1, 1, *b, a[tr], -1);
--tr;
}
while (tr < qr) {
++tr;
M(1, 1, *b, a[tr], 1);
}
}
for (int i = (int)(1); i <= (int)(tq); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int first[33333];
pair<int, int> a[33333];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
first[0] = first[1] = 1 % m;
for (int i = 2; i <= n; i++) {
first[i] = first[i - 1] + first[i - 2];
if (first[i] >= m) {
first[i] -= m;
}
}
int l, r, q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
--l, --r;
long long sum = 0, color = -1, i = 0;
for (int j = 0; j < n; j++) {
if (color == a[j].first) continue;
if (l <= a[j].second && a[j].second <= r) {
color = a[j].first;
sum += ((long long)first[i++]) * a[j].first;
}
}
printf("%d\n", int(sum % m));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, k;
} a[30030];
int n, m, q, f[30030], l[30030], r[30030], k[30030], maxx[30030];
long long ans[30030] = {};
bool cmp(node aa, node bb) { return aa.x < bb.x; }
int main() {
scanf("%d%d", &n, &m);
f[1] = 1;
f[2] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].k = i;
if (i >= 3) f[i] = (f[i - 1] + f[i - 2]) % m;
}
sort(a + 1, a + n + 1, cmp);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", &l[i], &r[i]);
memset(maxx, -1, sizeof(maxx));
for (int i = 1; i <= n; i++) {
int x = a[i].x % m;
for (int j = 1; j <= q; j++) {
if (l[j] <= a[i].k && a[i].k <= r[j] && a[i].x != maxx[j]) {
maxx[j] = a[i].x;
ans[j] += x * f[++k[j]];
}
}
}
for (int i = 1; i <= q; i++) {
printf("%lld\n", ans[i] % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 32768;
const int BLK = 350;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> operator%(pair<int, int> a, int b) {
return {a.first % b, a.second % b};
}
int N, M, Q;
int arr[MAXN];
int _fib[MAXN], _mfib[MAXN];
int ql[MAXN], qr[MAXN];
int ans[MAXN];
int V;
vector<int> vec;
vector<int> qgrp[MAXN];
int BIT[MAXN];
int cnt[MAXN];
pair<int, int> seg[MAXN * 2];
int tag[MAXN * 2];
int fib(int x) { return x < 0 ? _mfib[-x] : _fib[x]; }
void addBIT(int pos, int val) {
pos++;
while (pos < MAXN) {
BIT[pos] += val;
pos += pos & (-pos);
}
}
int qryBIT(int pos) {
int a = 0;
pos++;
while (pos) {
a += BIT[pos];
pos -= pos & (-pos);
}
return a;
}
void set_tag(int s, int val) {
tag[s] += val;
int ff = (seg[s].first * fib(val + 1) + seg[s].second * fib(val)) % M;
int ss = (seg[s].first * fib(val) + seg[s].second * fib(val - 1)) % M;
seg[s] = {ff, ss};
}
void clear_tag(int s, int lb, int rb) {
if (!tag[s]) return;
if (rb - lb > 1) {
set_tag(2 * s, tag[s]);
set_tag(2 * s + 1, tag[s]);
}
tag[s] = 0;
}
void add_seg(int s, int lb, int rb, int pos, pair<int, int> val) {
if (pos < lb || pos >= rb) return;
clear_tag(s, lb, rb);
if (rb - lb == 1) {
seg[s] = (seg[s] + val) % M;
} else {
int mb = (lb + rb) >> 1;
add_seg(2 * s, lb, mb, pos, val);
add_seg(2 * s + 1, mb, rb, pos, val);
seg[s] = (seg[2 * s] + seg[2 * s + 1]) % M;
}
}
void update_seg(int s, int lb, int rb, int l, int r, int val) {
if (rb <= l || r <= lb) return;
if (l <= lb && rb <= r) {
set_tag(s, val);
} else {
clear_tag(s, lb, rb);
int mb = (lb + rb) >> 1;
update_seg(2 * s, lb, mb, l, r, val);
update_seg(2 * s + 1, mb, rb, l, r, val);
seg[s] = (seg[2 * s] + seg[2 * s + 1]) % M;
}
}
int qry_seg() { return seg[1].first; }
void add_num(int v) {
int n = arr[v];
if (cnt[n] == 0) {
int ord = qryBIT(n);
pair<int, int> pr;
pr.first = (fib(ord + 1) * vec[n]) % M;
pr.second = (fib(ord) * vec[n]) % M;
add_seg(1, 0, N, n, pr);
update_seg(1, 0, N, n + 1, N, 1);
addBIT(n, 1);
}
cnt[n]++;
}
void del_num(int v) {
int n = arr[v];
cnt[n]--;
if (cnt[n] == 0) {
addBIT(n, -1);
int ord = qryBIT(n);
pair<int, int> pr;
pr.first = (M - ((fib(ord + 1) * vec[n]) % M)) % M;
pr.second = (M - ((fib(ord) * vec[n]) % M)) % M;
add_seg(1, 0, N, n, pr);
update_seg(1, 0, N, n + 1, N, -1);
}
}
int qry_ans() { return qry_seg(); }
void make_fib() {
_fib[0] = 0;
_fib[1] = 1 % M;
for (int i = 2; i < MAXN; i++) _fib[i] = (_fib[i - 2] + _fib[i - 1]) % M;
for (int i = 0; i < MAXN; i++)
_mfib[i] = (i % 2 ? _fib[i] : (M - _fib[i]) % M);
}
void make() {
for (int i = 0; i < N; i++) vec.push_back(arr[i]);
sort(begin(vec), end(vec));
V = unique(begin(vec), end(vec)) - vec.begin();
vec.resize(V);
for (int i = 0; i < N; i++)
arr[i] = lower_bound(begin(vec), end(vec), arr[i]) - vec.begin();
for (int i = 0; i < V; i++) vec[i] %= M;
for (int i = 0; i < Q; i++) qgrp[ql[i] / BLK].push_back(i);
for (int i = 0; i < MAXN; i++)
sort(begin(qgrp[i]), end(qgrp[i]),
[](int a, int b) { return qr[a] < qr[b]; });
}
void calc() {
int lb = 0;
int rb = 0;
for (int g = 0; g < MAXN; g++) {
if (qgrp[g].empty()) continue;
if (g % 2 == 1) reverse(begin(qgrp[g]), end(qgrp[g]));
for (auto i : qgrp[g]) {
while (lb > ql[i]) add_num(--lb);
while (rb < qr[i]) add_num(rb++);
while (rb > qr[i]) del_num(--rb);
while (lb < ql[i]) del_num(lb++);
ans[i] = qry_ans();
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
make_fib();
for (int i = 0; i < N; i++) cin >> arr[i];
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> ql[i] >> qr[i];
ql[i]--;
}
make();
calc();
for (int i = 0; i < Q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char nchar() {
static const int bufl = 1 << 20;
static char buf[bufl], *a, *b;
return a == b && (b = (a = buf) + fread(buf, 1, bufl, stdin), a == b) ? EOF
: *a++;
}
inline int read() {
int x = 0, f = 1;
char c = nchar();
for (; !isdigit(c); c = nchar())
if (c == '-') f = -1;
for (; isdigit(c); c = nchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(int x) {
if (!x)
puts("0");
else {
static char s[12];
int tot = 0;
for (; x; x /= 10) s[++tot] = x % 10 + '0';
while (tot) putchar(s[tot--]);
puts("");
}
}
const int maxn = 3e4 + 1;
int n, m, q, block[maxn], size, a[maxn], dc[maxn], u, dq[maxn];
int fib[maxn], ans[maxn];
inline int Plus(int x, int y) { return (x + y) % q; }
inline int Multi(int x, int y) { return x * y % q; }
inline int Sub(int x, int y) { return Plus(x, q - y); }
struct query {
int l, r, id;
inline bool operator<(const query& b) const {
return block[l] != block[b.l] ? block[l] < block[b.l] : r < b.r;
}
} b[maxn];
struct Mat {
int a[2][2];
Mat() { memset(a, 0, sizeof a); }
Mat(int b, int c, int d, int e) {
a[0][0] = b, a[0][1] = c, a[1][0] = d, a[1][1] = e;
}
inline int* operator[](int x) { return a[x]; }
inline void eye() { a[0][0] = a[1][1] = 1; }
} nxt[maxn];
inline Mat operator*(Mat a, Mat b) {
Mat ret;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
ret.a[i][j] = Plus(ret.a[i][j], Multi(a.a[i][k], b.a[k][j]));
return ret;
}
struct lie {
int a[2];
lie(int x = 0, int y = 0) { a[0] = x, a[1] = y; }
inline int& operator[](int x) { return a[x]; }
};
inline lie operator*(Mat a, lie b) {
int c[2] = {0, 0};
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) c[i] = Plus(c[i], Multi(a[i][j], b[j]));
return lie(c[0], c[1]);
}
inline lie operator+(lie a, lie b) {
return lie(Plus(a.a[0], b.a[0]), Plus(a.a[1], b.a[1]));
}
namespace sgt {
lie t[maxn << 1];
int how[maxn << 1], what[maxn << 1];
inline int ID(int l, int r) { return l + r | l != r; }
void mpoint(int l, int r, int p, int d) {
int x = ID(l, r);
if (l == r) {
what[x] = (bool)(how[x] += d);
if (!how[x])
t[x] = (lie){0, 0};
else if (how[x] == 1 && d == 1)
t[x] = (lie){dq[l], 0};
return;
}
int mid = (l + r) >> 1, lc = ID(l, mid), rc = ID(mid + 1, r);
p <= mid ? mpoint(l, mid, p, d) : mpoint(mid + 1, r, p, d);
int ls = what[lc];
what[x] = what[lc] + what[rc];
t[x] = t[lc] + nxt[ls] * t[rc];
}
inline int getans() { return t[ID(1, u)][0]; }
void mpoint(int x, int d) { mpoint(1, u, x, d); }
} // namespace sgt
inline void inc(int p) {
int x = a[p];
sgt::mpoint(x, 1);
}
inline void dec(int p) {
int x = a[p];
sgt::mpoint(x, -1);
}
int main() {
size = max(1, (int)sqrt(n = read())), q = read();
nxt[0].eye(), nxt[1] = Mat(1, 1, 1, 0);
for (int i = 2; i <= n; ++i) nxt[i] = nxt[i - 1] * nxt[1];
fib[1] = fib[2] = 1;
for (int i = 3; i <= n; ++i) fib[i] = Plus(fib[i - 1], fib[i - 2]);
for (int i = 1; i <= n; ++i) block[i] = (i - 1) / size + 1;
for (int i = 1; i <= n; ++i) a[i] = dc[i] = read();
sort(dc + 1, dc + n + 1), u = unique(dc + 1, dc + n + 1) - dc - 1;
for (int i = 1; i <= n; ++i) dq[i] = dc[i] % q;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(dc + 1, dc + u + 1, a[i]) - dc;
m = read();
for (int i = 1; i <= m; ++i) {
int l = read(), r = read();
b[i] = (query){l, r, i};
}
sort(b + 1, b + m + 1);
int l = 1, r = 0;
for (int i = 1; i <= m; ++i) {
int &ql = b[i].l, &qr = b[i].r, &id = b[i].id;
while (r < qr) inc(++r);
while (l > ql) inc(--l);
while (r > qr) dec(r--);
while (l < ql) dec(l++);
ans[id] = sgt::getans();
}
for_each(ans + 1, ans + m + 1, write);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int n, Q, mo, L[N], R[N];
int cnt[N], f[N];
pair<int, int> a[N];
long long ans[N];
int main() {
scanf("%d%d", &n, &mo);
for (int i = (int)(1); i <= (int)(n); i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
scanf("%d", &Q);
for (int i = (int)(1); i <= (int)(Q); i++) scanf("%d%d", &L[i], &R[i]);
for (int i = (int)(1); i <= (int)(n); i++)
f[i] = (i == 1 ? 1 : f[i - 1] + f[i - 2]) % mo;
for (int i = (int)(1); i <= (int)(n); i++) {
int v = a[i].first % mo, pp = a[i].second;
int p = (i == 1 || a[i].first != a[i - 1].first ? -1 : a[i - 1].second);
for (int j = (int)(1); j <= (int)(Q); j++)
if (p < L[j] && L[j] <= pp && pp <= R[j]) ans[j] += v * f[++cnt[j]];
}
for (int i = (int)(1); i <= (int)(Q); i++) printf("%lld\n", ans[i] % mo);
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
const int INF = 2000000005;
const int block = 200;
int mod, *fib, pool[MAXN];
int rmove(int sum, int sum1, int k) {
return (fib[k + 1] * sum + fib[k] * sum1) % mod;
}
struct tree {
int l;
int r;
int sum;
int sum1;
int shift;
tree *lson;
tree *rson;
tree() {
l = r = sum = sum1 = shift = 0;
lson = rson = NULL;
}
void right_move(int k) {
int t = (fib[k + 1] * sum + fib[k] * sum1) % mod;
int t1 = (fib[k] * sum + fib[k - 1] * sum1) % mod;
sum = t;
sum1 = t1;
shift += k;
}
void fixup() {
sum = (lson->sum + rson->sum) % mod;
sum1 = (lson->sum1 + rson->sum1) % mod;
int t = rmove(sum, sum1, shift);
int t1 = rmove(sum, sum1, shift - 1);
sum = t;
sum1 = t1;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int W, int S, int rs) {
if (l == r) {
sum = W * fib[S] % mod;
sum1 = W * fib[S - 1] % mod;
return;
}
int mid = (l + r) / 2;
if (id <= mid) {
rson->right_move(rs);
lson->modify(id, W, S - shift, rs);
} else
rson->modify(id, W, S - shift, rs);
fixup();
}
void move(int L, int R, int k) {
if (l >= L && r <= R) {
right_move(k);
return;
}
int mid = (l + r) / 2;
if (L <= mid) lson->move(L, R, k);
if (R > mid) rson->move(L, R, k);
fixup();
}
};
struct Ftree {
int bit[MAXN];
Ftree() { memset(bit, 0, sizeof(bit)); }
void add(int pos, int k) {
for (int i = pos; i < MAXN; i += ((i) & -(i))) bit[i] += k;
}
int sum(int pos) {
int ret = 0;
for (int i = pos; i; i -= ((i) & -(i))) ret += bit[i];
return ret;
}
int query(int l, int r) { return sum(r) - sum(l - 1); }
};
struct data {
int id;
int w;
bool operator<(data t) const { return w < t.w; }
};
struct QUERY {
int id;
int l;
int r;
bool operator<(QUERY t) const {
if (l / block != t.l / block) return l < t.l;
return r < t.r;
}
};
int N, Q;
int a[MAXN], rank[MAXN];
QUERY q[MAXN];
int L, R, cnt[MAXN];
tree T;
Ftree FT;
void Rr_move() {
R++;
cnt[rank[R]]++;
if (cnt[rank[R]] == 1) {
FT.add(rank[R], 1);
int s = FT.sum(rank[R]);
T.modify(rank[R], a[R], s, 1);
}
}
void Rl_move() {
cnt[rank[R]]--;
if (cnt[rank[R]] == 0) {
FT.add(rank[R], -1);
T.modify(rank[R], 0, 0, -1);
}
R--;
}
void Ll_move() {
L--;
cnt[rank[L]]++;
if (cnt[rank[L]] == 1) {
FT.add(rank[L], 1);
int s = FT.sum(rank[L]);
T.modify(rank[L], a[L], s, 1);
}
}
void Lr_move() {
cnt[rank[L]]--;
if (cnt[rank[L]] == 0) {
FT.add(rank[L], -1);
T.modify(rank[L], 0, 0, -1);
}
L++;
}
data tmp[MAXN];
void init() {
scanf("%d %d", &N, &mod);
fib = pool + MAXN / 2;
fib[1] = fib[2] = 1;
for (int i = 3; i < 40000; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 0; i > -40000; i--) fib[i] = (fib[i + 2] - fib[i + 1]) % mod;
for (int i = 1; i <= N; i++) {
scanf("%d", a + i);
tmp[i].id = i;
tmp[i].w = a[i];
}
std::sort(tmp + 1, tmp + N + 1);
int cur = 0;
for (int i = 1; i <= N; i++) {
if (i == 1 || tmp[i].w != tmp[i - 1].w) cur++;
rank[tmp[i].id] = cur;
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].id = i;
}
std::sort(q + 1, q + Q + 1);
T.build(1, N);
L = R = 1;
T.modify(rank[1], a[1], 1, 1);
cnt[rank[1]] = 1;
FT.add(rank[1], 1);
}
void solve() {
static int ans[MAXN];
for (int i = 1; i <= Q; i++) {
int l = q[i].l, r = q[i].r;
while (R < r) Rr_move();
while (L < l) Lr_move();
while (L > l) Ll_move();
while (R > r) Rl_move();
ans[q[i].id] = (T.sum % mod + mod) % mod;
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 30010, MaxT = 1 << 16, Block = 300;
int n, mod, q;
int a[MaxN], val[MaxN], vtot;
int inc(int x, int v) {
x += v;
return x >= mod ? x - mod : x;
}
struct query {
int l, r, id;
bool operator<(const query &a) const {
if (l / Block == a.l / Block) return r < a.r;
return l < a.l;
}
} Q[MaxN];
struct Matrix {
int c[2][2];
Matrix operator*=(const Matrix &a) {
int ret[2][2];
ret[0][0] = (c[0][0] * a.c[0][0] + c[0][1] * a.c[1][0]) % mod;
ret[0][1] = (c[0][0] * a.c[0][1] + c[0][1] * a.c[1][1]) % mod;
ret[1][0] = (c[1][0] * a.c[0][0] + c[1][1] * a.c[1][0]) % mod;
ret[1][1] = (c[1][0] * a.c[0][1] + c[1][1] * a.c[1][1]) % mod;
memcpy(c, ret, sizeof(ret));
return *this;
}
Matrix operator*(const Matrix &a) const {
Matrix ret;
ret.c[0][0] = (c[0][0] * a.c[0][0] + c[0][1] * a.c[1][0]) % mod;
ret.c[0][1] = (c[0][0] * a.c[0][1] + c[0][1] * a.c[1][1]) % mod;
ret.c[1][0] = (c[1][0] * a.c[0][0] + c[1][1] * a.c[1][0]) % mod;
ret.c[1][1] = (c[1][0] * a.c[0][1] + c[1][1] * a.c[1][1]) % mod;
return ret;
}
} I, F, pow_F[MaxN * 2], invF, *power;
struct Vector {
int c[2];
Vector() {}
Vector(int x, int y) { c[0] = x, c[1] = y; }
Vector operator*=(const Matrix &a) {
int ret[2];
ret[0] = (a.c[0][0] * c[0] + a.c[0][1] * c[1]) % mod;
ret[1] = (a.c[1][0] * c[0] + a.c[1][1] * c[1]) % mod;
memcpy(c, ret, sizeof(ret));
return *this;
}
Vector operator+(const Vector &a) const {
return Vector(inc(c[0], a.c[0]), inc(c[1], a.c[1]));
}
};
int ans[MaxN];
struct Tree_node {
int lazy;
Vector sum;
} T[MaxT];
void set_lazy(int now, int d) {
if (!d) return;
T[now].sum *= power[d];
T[now].lazy += d;
}
void push_down(int now) {
set_lazy(now << 1, T[now].lazy);
set_lazy(now << 1 | 1, T[now].lazy);
T[now].lazy = 0;
}
void update(int now) { T[now].sum = T[now << 1].sum + T[now << 1 | 1].sum; }
void modify_c(int l, int r, int x, int now, int d) {
if (l == r) {
T[now].sum.c[0] = power[T[now].lazy].c[0][0] * d % mod;
T[now].sum.c[1] = power[T[now].lazy].c[1][0] * d % mod;
return;
}
int mid = (l + r) >> 1;
push_down(now);
if (x <= mid)
modify_c(l, mid, x, now << 1, d);
else
modify_c(mid + 1, r, x, now << 1 | 1, d);
update(now);
}
void modify_mul(int l, int r, int x, int now, int d) {
if (r < x) return;
if (x <= l) return set_lazy(now, d);
int mid = (l + r) >> 1;
push_down(now);
modify_mul(l, mid, x, now << 1, d);
modify_mul(mid + 1, r, x, now << 1 | 1, d);
update(now);
}
void init() {
I.c[0][0] = I.c[1][1] = 1;
F.c[0][0] = F.c[0][1] = F.c[1][0] = 1;
invF.c[0][1] = invF.c[1][0] = 1;
invF.c[1][1] = mod - 1;
power = pow_F + MaxN;
power[0] = I;
for (int i = 1; i <= n; ++i) power[i] = power[i - 1] * F;
for (int i = 1; i <= n; ++i) power[-i] = power[-i + 1] * invF;
}
int cnt[MaxN];
bool inside[MaxN];
void do_reverse(int pos) {
int u = a[pos];
if (inside[pos]) {
if (--cnt[u] == 0) {
modify_c(1, vtot, u, 1, 0);
modify_mul(1, vtot, u + 1, 1, -1);
}
} else {
if (cnt[u]++ == 0) {
modify_c(1, vtot, u, 1, val[u] % mod);
modify_mul(1, vtot, u + 1, 1, 1);
}
}
inside[pos] ^= 1;
}
void move(int &last, int to) {
while (last < to) do_reverse(++last);
while (last > to) do_reverse(last--);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
val[i] = a[i];
}
sort(val + 1, val + n + 1);
vtot = unique(val + 1, val + n + 1) - val - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(val + 1, val + vtot + 1, a[i]) - val;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q + 1, Q + q + 1);
init();
int l = 0, r = 0;
for (int i = 1; i <= q; ++i) {
move(l, Q[i].l - 1);
move(r, Q[i].r);
ans[Q[i].id] = T[1].sum.c[0];
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
using lli = int;
using pii = tuple<lli, lli>;
using ppii = tuple<pii, pii>;
using piii = tuple<lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B>
ostream& operator<<(ostream& s, tuple<A, B> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << ")";
}
template <class A, class B, class C>
ostream& operator<<(ostream& s, tuple<A, B, C> const& a) {
return s << "(" << get<0>(a) << "," << get<1>(a) << "," << get<2>(a) << ")";
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
lli n, m;
lli F[100000];
struct node {
node() {}
lli v = 0;
lli s1 = 0, s2 = 0;
lli shiftBy = 0;
};
struct tree {
lli n;
vector<node> A;
tree(lli n_) : n((lli)1 << (lli)(log2(n_) + 1)), A(2 * n) {}
void print_tree_(lli i, lli a, lli b, lli in) {
push(i, a, b);
lli c = (a + b) / 2;
if (i < n) print_tree_(2 * i, a, c, in + 1);
for (lli i = 0; i < (lli)(in); ++i) cout << " ";
cout << "| " << i << " " << A[i].v;
cout << endl;
if (i < n) print_tree_(2 * i + 1, c + 1, b, in + 1);
}
void print_tree() { print_tree_(1, 0, n - 1, 0); }
void push(lli i, lli a, lli b) {
if (i < n) {
lli c = (a + b) / 2;
if (A[i].shiftBy) {
shift__(2 * i, a, c, A[i].shiftBy);
shift__(2 * i + 1, c + 1, b, A[i].shiftBy);
A[i].shiftBy = 0;
}
}
}
void build() {
for (lli i = (n - 1); i >= (lli)(0); --i) update(i);
}
void update(lli i) {
A[i].s1 = (A[2 * i].s1 + A[2 * i + 1].s1) % m;
A[i].s2 = (A[2 * i].s2 + A[2 * i + 1].s2) % m;
}
void shift__(lli i, lli a, lli b, lli v) {
if (v) {
A[i].shiftBy += v;
A[i].v += v;
lli ns1 = F[49999 + v] * A[i].s1 + F[50000 + v] * A[i].s2;
lli ns2 = F[50000 + v] * A[i].s1 + F[50001 + v] * A[i].s2;
A[i].s1 = ns1 % m;
A[i].s2 = ns2 % m;
}
}
void shift_(lli i, lli a, lli b, lli l, lli r, lli v, lli x) {
if (l > b) return;
if (r < a) return;
if (l <= a && b <= r) {
if (l == a) insert_(i, a, b, l, x);
shift__(i, a, b, v);
return;
}
push(i, a, b);
lli c = (a + b) / 2;
shift_(2 * i, a, c, l, r, v, x);
shift_(2 * i + 1, c + 1, b, l, r, v, x);
update(i);
}
void shift(lli l, lli r, lli v, lli x) { shift_(1, 0, n - 1, l, r, v, x); }
void insert_(lli i, lli a, lli b, lli l, lli v) {
if (l > b) return;
if (l < a) return;
push(i, a, b);
if (l <= a && b <= l) {
A[i].s1 = (F[50000 + A[i].v] * v) % m;
A[i].s2 = (F[50001 + A[i].v] * v) % m;
return;
}
lli c = (a + b) / 2;
insert_(2 * i, a, c, l, v);
insert_(2 * i + 1, c + 1, b, l, v);
update(i);
}
lli query() { return A[1].s1 % m; }
};
int main(int, char**) {
srand(time(0));
ios::sync_with_stdio(false);
cin >> n >> m;
F[50000] = 0;
F[50001] = 1;
for (lli i = (50002); i <= (lli)(99999); ++i)
F[i] = (F[i - 2] + F[i - 1]) % m;
for (lli i = (49999); i >= (lli)(0); --i)
F[i] = (F[i + 2] - F[i + 1] + m + m) % m;
vi A(n);
for (lli i = 0; i < (lli)(n); ++i) cin >> A[i];
set<lli> AS;
for (lli i = 0; i < (lli)(n); ++i) AS.insert(A[i]);
lli ni = 0;
unordered_map<lli, lli> TOI;
for (auto x : AS) {
TOI[x] = ni;
ni += 1;
}
tree t(ni);
lli q;
cin >> q;
vii Q(q);
for (lli i = 0; i < (lli)(q); ++i) cin >> get<0>(Q[i]) >> get<1>(Q[i]);
for (lli i = 0; i < (lli)(q); ++i) get<0>(Q[i]) -= 1;
for (lli i = 0; i < (lli)(q); ++i) get<1>(Q[i]) -= 1;
lli bsize = 250;
vi I(q);
for (lli i = 0; i < (lli)(q); ++i) I[i] = i;
sort(begin(I), end(I), [&](lli a, lli b) {
return pii(get<0>(Q[a]) / bsize, get<1>(Q[a])) <
make_tuple(get<0>(Q[b]) / bsize, get<1>(Q[b]));
});
vi ANS(q);
unordered_map<lli, lli> M;
auto mo_add = [&](lli x) {
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, 1, x % m);
}
M[x] += 1;
};
auto mo_remove = [&](lli x) {
M[x] -= 1;
if (M[x] == 0) {
t.shift(TOI[x], ni - 1, -1, 0);
}
};
lli cl = 0, cr = -1;
for (lli i = 0; i < (lli)(q); ++i) {
lli l = get<0>(Q[I[i]]), r = get<1>(Q[I[i]]);
while (cr < r) {
cr += 1;
mo_add(A[cr]);
}
while (cl > l) {
cl -= 1;
mo_add(A[cl]);
}
while (cr > r) {
mo_remove(A[cr]);
cr -= 1;
}
while (cl < l) {
mo_remove(A[cl]);
cl += 1;
}
ANS[I[i]] = t.query();
}
for (lli i = 0; i < (lli)(q); ++i) cout << ANS[i] << '\n';
cout << flush;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(3e4) + 111;
int n, moder, m;
int a[maxn], b[maxn], tot = 0;
int block, belong[maxn];
int fb[maxn];
map<int, int> v;
void init() {
fb[-1] = 1;
fb[1] = fb[2] = 1;
for (int i = 3; i <= n; i++) fb[i] = (fb[i - 1] + fb[i - 2]) % moder;
return;
}
struct query {
int l, r, id;
bool operator<(const query& b) const {
if (belong[l] != belong[b.l])
return belong[l] < belong[b.l];
else
return r < b.r;
}
void read(int _id) {
scanf("%d%d", &l, &r);
id = _id;
return;
}
} q[maxn];
int ans[maxn];
struct Node {
int cnt, l, r;
Node() {}
Node(int c, int lans, int rans) : cnt(c), l(lans), r(rans) {}
} node[maxn * 8];
int seg_merge(int pos, int a, int b, int c) {
return (a + fb[pos - 1] * b + fb[pos] * c) % moder;
}
void update(int k) {
node[k].cnt = node[(k << 1)].cnt + node[((k << 1) ^ 1)].cnt;
node[k].l = seg_merge(node[(k << 1)].cnt, node[(k << 1)].l,
node[((k << 1) ^ 1)].l, node[((k << 1) ^ 1)].r);
node[k].r = seg_merge(node[(k << 1)].cnt + 1, node[(k << 1)].r,
node[((k << 1) ^ 1)].l, node[((k << 1) ^ 1)].r);
return;
}
void seg_modify(int k, int l, int r, int pos, int val) {
if (l == r) {
node[k] = Node(val, (b[pos] * val % moder), (b[pos] * val % moder));
return;
}
if (pos <= ((l + r) >> 1)) seg_modify((k << 1), l, ((l + r) >> 1), pos, val);
if (pos > ((l + r) >> 1))
seg_modify(((k << 1) ^ 1), ((l + r) >> 1) + 1, r, pos, val);
update(k);
return;
}
int c[maxn];
void blo_ins(int id) {
c[id]++;
if (c[id] == 1)
seg_modify(1, 1, tot, id, 1);
else
return;
}
void blo_del(int id) {
c[id]--;
if (c[id] == 0)
seg_modify(1, 1, tot, id, 0);
else
return;
}
int main() {
scanf("%d%d", &n, &moder);
block = (int)sqrt(1.0 * n);
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
belong[i] = (i - 1) / block;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) q[i].read(i);
sort(b + 1, b + 1 + n);
tot = unique(b + 1, b + 1 + n) - (b + 1);
for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + 1 + tot, a[i]) - b;
sort(q + 1, q + 1 + m);
int l = 1, r = 0;
for (int i = 1; i <= m; i++) {
int ql = q[i].l, qr = q[i].r;
while (r < qr) blo_ins(a[++r]);
while (l > ql) blo_ins(a[--l]);
while (r > qr) blo_del(a[r--]);
while (l < ql) blo_del(a[l++]);
ans[q[i].id] = node[1].l;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 15;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
;
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
for (int i = int(0); i < int(1 << K); ++i) {
mb[i] = K;
while (mb[i] >= 0 && !(i & (1 << mb[i]))) {
--mb[i];
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
};
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
};
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
if (i) {
v[w][q | (1 << i)][0] = v[w][q | (1 << (i - 1))][0];
v[w][q | (1 << i)][1] = v[w][q | (1 << (i - 1))][1];
bt[w][q | (1 << i)] = bt[w][q | (1 << (i - 1))];
} else {
v[w][q | (1 << i)][0] = v[w][q][0];
v[w][q | (1 << i)][1] = v[w][q][1];
bt[w][q | (1 << i)] = bt[w][q];
}
} else {
v[w][q | (1 << i)][0] =
(v[w][q][0] + f[bt[w][q]] * (a[p[t * K + i]] % mod)) % mod;
v[w][q | (1 << i)][1] =
(v[w][q][1] + f[bt[w][q] + 1] * (a[p[t * K + i]] % mod)) %
mod;
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
ans[i] = (ans[i] + v[ttt][mmm][0] * f[cnt[i] + 2] +
v[ttt][mmm][1] * f[cnt[i] + 3]) %
mod;
;
;
;
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
;
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Q, len, l, r, pos, step, stepp;
int a[30010], b[30010], F[30010], Fr[30010], num[30010];
class que {
public:
int l, r, t, ans, order;
} q[30010];
class rec {
public:
int s1, s2, mark, num;
} seg[300010];
bool cmpq(const que &a, const que &b) {
return (a.t < b.t) || (a.t == b.t && a.r < b.r);
}
bool cmpord(const que &a, const que &b) { return (a.order < b.order); }
void move_right(int x, int delta) {
int t1 = (seg[x].s1 * F[delta + 1] + seg[x].s2 * F[delta]) % M;
int t2 = (seg[x].s1 * F[delta] + seg[x].s2 * F[delta - 1]) % M;
seg[x].s1 = t1;
seg[x].s2 = t2;
seg[x].mark += delta;
}
void move_left(int x, int delta) {
int t1 = (seg[x].s1 * Fr[delta - 1] + seg[x].s2 * Fr[delta]) % M;
int t2 = (seg[x].s1 * Fr[delta] + seg[x].s2 * Fr[delta + 1]) % M;
seg[x].s1 = t1;
seg[x].s2 = t2;
seg[x].mark -= delta;
}
void mark_down(int x, int l, int r) {
if (l < r) {
if (seg[x].mark > 0) {
move_right(x << 1, seg[x].mark);
move_right((x << 1) + 1, seg[x].mark);
}
if (seg[x].mark < 0) {
move_left(x << 1, -seg[x].mark);
move_left((x << 1) + 1, -seg[x].mark);
}
}
seg[x].mark = 0;
}
void move(int x, int l, int r, int ll, int rr, int delta) {
if (l == ll && r == rr) {
if (delta > 0) move_right(x, delta);
if (delta < 0) move_left(x, -delta);
return;
}
if (seg[x].mark) mark_down(x, l, r);
int mid = (l + r) >> 1;
if (rr <= mid)
move(x << 1, l, mid, ll, rr, delta);
else if (ll > mid)
move((x << 1) + 1, mid + 1, r, ll, rr, delta);
else
move(x << 1, l, mid, ll, mid, delta),
move((x << 1) + 1, mid + 1, r, mid + 1, rr, delta);
}
void Init(int x, int l, int r, int t, int delta) {
mark_down(x, l, r);
seg[x].num += delta;
if (l == r) {
pos += seg[x].num;
if (delta > 0) {
if (t < len) move(1, 1, len, t + 1, len, 1);
seg[x].s1 = F[pos] * b[t] % M;
seg[x].s2 = F[pos - 1] * b[t] % M;
}
if (delta < 0) {
seg[x].s1 = seg[x].s2 = 0;
if (t < len) move(1, 1, len, t + 1, len, -1);
}
return;
}
int mid = (l + r) >> 1;
if (t <= mid)
Init(x << 1, l, mid, t, delta);
else
pos += seg[x << 1].num, Init((x << 1) + 1, mid + 1, r, t, delta);
seg[x].s1 = seg[x << 1].s1 + seg[(x << 1) + 1].s1;
seg[x].s2 = seg[x << 1].s2 + seg[(x << 1) + 1].s2;
if (seg[x].s1 >= M) seg[x].s1 -= M;
if (seg[x].s2 >= M) seg[x].s2 -= M;
}
int main() {
scanf("%d%d", &N, &M);
F[0] = 0;
F[1] = 1;
for (int i = 2; i <= N; i++) F[i] = (F[i - 1] + F[i - 2]) % M;
Fr[0] = 0;
Fr[1] = 1;
for (int i = 2; i <= N; i++) Fr[i] = (Fr[i - 2] - Fr[i - 1] + M) % M;
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
memcpy(b, a, sizeof(b));
sort(b + 1, b + N + 1);
len = unique(b + 1, b + N + 1) - b - 1;
for (int i = 1; i <= N; i++) a[i] = lower_bound(b + 1, b + len + 1, a[i]) - b;
for (int i = 1; i <= len; i++) b[i] = b[i] % M;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
scanf("%d%d", &q[i].l, &q[i].r), q[i].t = (q[i].l - 1) / sqrt(N),
q[i].order = i;
sort(q + 1, q + Q + 1, cmpq);
l = 1;
r = 0;
for (int i = 1; i <= Q; i++) {
pos = 0;
while (r < q[i].r) {
num[a[++r]]++;
if (num[a[r]] == 1) pos = 0, Init(1, 1, len, a[r], 1);
}
while (l > q[i].l) {
num[a[--l]]++;
if (num[a[l]] == 1) pos = 0, Init(1, 1, len, a[l], 1);
}
while (r > q[i].r) {
num[a[r]]--;
if (num[a[r]] == 0) pos = 0, Init(1, 1, len, a[r], -1);
r--;
}
while (l < q[i].l) {
num[a[l]]--;
if (num[a[l]] == 0) pos = 0, Init(1, 1, len, a[l], -1);
l++;
}
q[i].ans = seg[1].s1;
if (q[i].ans < 0) q[i].ans += M;
}
sort(q + 1, q + Q + 1, cmpord);
for (int i = 1; i <= Q; i++) printf("%d\n", q[i].ans);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops, no-stack-protector")
#pragma GCC target("avx,avx2,fma")
using namespace std;
constexpr int N = 30001;
pair<int, short> a[N];
short f[N];
struct query {
int last = -1;
short l, r, c = 0, ans = 0;
} Q[N];
short n, m, q;
int32_t main() {
cin >> n >> m;
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = ((int)f[i - 1] + f[i - 2]) % m;
for (int i = 0; i < (n); i++) cin >> a[i].first, a[i].second = i + 1;
sort(a, a + n);
cin >> q;
for (int i = 0; i < (q); i++) cin >> Q[i].l >> Q[i].r;
for (int i = 0; i < (n); i++) {
const short t = a[i].first % m;
#pragma GCC ivdep
for (int j = 0; j < (q); j++) {
if (a[i].second >= Q[j].l && a[i].second <= Q[j].r &&
a[i].first != Q[j].last)
Q[j].last = a[i].first,
Q[j].ans = ((int)Q[j].ans + (int)f[++Q[j].c] * t) % m;
}
}
for (int i = 0; i < (q); i++) cout << Q[i].ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int seg[2000001][2], lzy[2000001], fib[200001], M;
void update(int idx, int s, int e) {
if (s == e) {
lzy[idx] = 0;
return;
}
int v1 = (seg[idx * 2 + 1][0] * fib[lzy[idx] - 1] +
seg[idx * 2 + 1][1] * fib[lzy[idx]]) %
M;
int v2 = (seg[idx * 2 + 1][0] * fib[lzy[idx]] +
seg[idx * 2 + 1][1] * fib[lzy[idx] + 1]) %
M;
seg[idx * 2 + 1][0] = v1;
seg[idx * 2 + 1][1] = v2;
lzy[idx * 2 + 1] += lzy[idx];
v1 = (seg[idx * 2 + 2][0] * fib[lzy[idx] - 1] +
seg[idx * 2 + 2][1] * fib[lzy[idx]]) %
M;
v2 = (seg[idx * 2 + 2][0] * fib[lzy[idx]] +
seg[idx * 2 + 2][1] * fib[lzy[idx] + 1]) %
M;
seg[idx * 2 + 2][0] = v1;
seg[idx * 2 + 2][1] = v2;
lzy[idx * 2 + 2] += lzy[idx];
lzy[idx] = 0;
}
void insert1(int idx, int s, int e, int p, int v1, int v2) {
if (lzy[idx]) {
update(idx, s, e);
}
if (s == e) {
seg[idx][0] = v1;
seg[idx][1] = v2;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert1(idx * 2 + 1, s, mid, p, v1, v2);
else
insert1(idx * 2 + 2, mid + 1, e, p, v1, v2);
for (int i = (0); i < (2); ++i)
seg[idx][i] = (seg[idx * 2 + 1][i] + seg[idx * 2 + 2][i]) % M;
}
void insert2(int idx, int s, int e, int st, int ed) {
if (st > ed) return;
if (lzy[idx]) {
update(idx, s, e);
}
if (s == st && e == ed) {
int v = (seg[idx][0] + seg[idx][1]) % M;
seg[idx][0] = seg[idx][1];
seg[idx][1] = v;
lzy[idx]++;
return;
}
int mid = (s + e) / 2;
if (ed <= mid)
insert2(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
insert2(idx * 2 + 2, mid + 1, e, st, ed);
else {
insert2(idx * 2 + 1, s, mid, st, mid);
insert2(idx * 2 + 2, mid + 1, e, mid + 1, ed);
}
for (int i = (0); i < (2); ++i)
seg[idx][i] = (seg[idx * 2 + 1][i] + seg[idx * 2 + 2][i]) % M;
}
pair<int, int> query1(int idx, int s, int e, int st, int ed) {
if (lzy[idx]) {
update(idx, s, e);
}
if (st > ed) return make_pair(0, 0);
if (s == st && e == ed) return make_pair(seg[idx][0], seg[idx][1]);
int mid = (s + e) / 2;
if (ed <= mid)
return query1(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
return query1(idx * 2 + 2, mid + 1, e, st, ed);
else {
pair<int, int> pl = query1(idx * 2 + 1, s, mid, st, mid);
pair<int, int> pr = query1(idx * 2 + 2, mid + 1, e, mid + 1, ed);
return make_pair((pl.first + pr.first) % M, (pl.second + pr.second) % M);
}
}
int seg2[2000001];
void insert(int idx, int s, int e, int p) {
if (s == e) {
seg2[idx]++;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert(idx * 2 + 1, s, mid, p);
else
insert(idx * 2 + 2, mid + 1, e, p);
seg2[idx]++;
}
int query(int idx, int s, int e, int st, int ed) {
if (st > ed) return 0;
if (s == st && e == ed) return seg2[idx];
int mid = (s + e) / 2;
if (ed <= mid)
return query(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
return query(idx * 2 + 2, mid + 1, e, st, ed);
else {
return query(idx * 2 + 1, s, mid, st, mid) +
query(idx * 2 + 2, mid + 1, e, mid + 1, ed);
}
}
pair<int, int> pp[300001];
vector<pair<int, int> > vc[300001];
int res[300001];
map<int, int> mm;
int ar[300001], val[300001];
int on[300001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> M;
for (int i = (0); i < (n); ++i) {
cin >> ar[i];
mm[ar[i]] = 1;
}
int cnt = 0;
for (auto &v : mm) {
v.second = ++cnt;
val[v.second] = v.first % M;
}
for (int i = (0); i < (n); ++i) {
ar[i] = mm[ar[i]];
}
fib[0] = 0;
fib[1] = 1 % M;
for (int i = 2; i <= 200000; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % M;
int SZ = 250;
int q;
cin >> q;
for (int i = (0); i < (q); ++i) {
int l, r;
cin >> l >> r;
l--;
r--;
pp[i] = make_pair(l, r);
if ((l / SZ) == (r / SZ)) {
set<int> S;
for (int j = l; j <= r; j++) S.insert(ar[j]);
int cc = 0;
for (auto &v : S) {
res[i] = (res[i] + val[v] * fib[++cc]) % M;
}
continue;
}
vc[r].push_back(make_pair(l, i));
}
for (int i = 0; i < n; i += SZ) {
memset(on, 0, sizeof on);
memset(seg, 0, sizeof seg);
memset(seg2, 0, sizeof seg2);
for (int j = i + SZ; j < n; j++) {
if (on[ar[j]] == 0) {
on[ar[j]] = 1;
int pre = query(0, 1, cnt, 1, ar[j] - 1) + 1;
insert(0, 1, cnt, ar[j]);
insert1(0, 1, cnt, ar[j], (val[ar[j]] * fib[pre - 1]) % M,
(val[ar[j]] * fib[pre]) % M);
insert2(0, 1, cnt, ar[j] + 1, cnt);
}
for (int k = (0); k < (vc[j].size()); ++k) {
if (vc[j][k].first < i || vc[j][k].first >= i + SZ) continue;
set<int> S;
for (int l = i + SZ - 1; l >= vc[j][k].first; l--) {
if (on[ar[l]] || S.count(ar[l])) continue;
S.insert(ar[l]);
}
int cc = 0, pre = 0, tot = 0;
for (auto &v : S) {
pair<int, int> p = query1(0, 1, cnt, pre + 1, v);
int pcnt = query(0, 1, cnt, pre + 1, v);
int vv = (p.first * fib[cc] + p.second * fib[cc + 1]) % M;
pre = v;
tot += pcnt + 1;
cc++;
vv = (vv + val[v] * fib[tot]) % M;
res[vc[j][k].second] = (res[vc[j][k].second] + vv) % M;
}
pair<int, int> p = query1(0, 1, cnt, pre + 1, cnt);
int vv = (p.first * fib[cc] + p.second * fib[cc + 1]) % M;
res[vc[j][k].second] = (res[vc[j][k].second] + vv) % M;
}
}
}
for (int i = (0); i < (q); ++i) cout << res[i] << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
const double pi = 3.141592653589793238462643383279;
namespace MyMinMax {
template <typename T>
inline T mn(const T x, const T y) {
return x < y ? x : y;
}
template <typename T>
inline T mx(const T x, const T y) {
return x > y ? x : y;
}
template <typename T>
inline bool chmin(T &x, const T y) {
return (x > y) && ((x = y), 1);
}
template <typename T>
inline bool chmax(T &x, const T y) {
return (x < y) && ((x = y), 1);
}
template <typename T, typename... Args>
inline T mx(const T x, const Args... args) {
return mx(x, mx(args...));
}
template <typename T, typename... Args>
inline T mn(const T x, const Args... args) {
return mn(x, mn(args...));
}
} // namespace MyMinMax
using namespace MyMinMax;
namespace IO {
const int DPAIRSIZ = 1 << 18;
char BB[DPAIRSIZ], *SS = BB, *TT = BB;
inline char getcha() {
return SS == TT && (TT = (SS = BB) + fread(BB, 1, DPAIRSIZ, stdin), SS == TT)
? EOF
: *SS++;
}
template <typename T = int>
inline T read() {
T x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
return x;
}
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
}
template <typename T>
inline void read(T *bg, T *ed) {
while (bg != ed) read(*bg++);
}
inline void read(char &ch) {
ch = getcha();
while (ch <= 32) ch = getcha();
}
inline void read(char *s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void sread(char *s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void pread(char *&s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void spread(char *&s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
char out[DPAIRSIZ], *Out = out;
inline void putcha(char x) {
*Out++ = x;
if (Out - out >= (DPAIRSIZ)) fwrite(out, 1, Out - out, stdout), Out = out;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putcha(45), x = -x;
if (x > 9) fprint(x / 10);
putcha(x % 10 + 48);
}
inline void print() { putcha(10); }
template <typename T>
inline void print(T x) {
fprint(x);
putcha(10);
}
inline void print(char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
inline void print(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
template <typename T, typename... Args>
inline void print(T x, Args... args) {
fprint(x);
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename T, typename... Args>
inline void printl(T x, Args... args) {
fprint(x);
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename T>
inline void sprint(T x) {
fprint(x);
putcha(32);
}
template <typename T, typename... Args>
inline void sprint(T x, Args... args) {
fprint(x);
putcha(32);
sprint(args...);
}
template <typename T>
inline void sprint(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
}
template <typename T>
inline void print(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
putcha(10);
}
template <typename T>
inline void printl(T *bg, T *ed) {
while (bg != ed) print(*bg++);
}
class AutoFlush {
public:
~AutoFlush() { fwrite(out, 1, Out - out, stdout); }
} __AutoFlush;
} // namespace IO
using namespace IO;
const int INF = 0x3f3f3f3f;
const long long INFll = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 3e4 + 5;
int f[MAXN], m, a[MAXN], n, q;
inline void init() {
f[0] = f[1] = 1;
for (int i = (2); i <= (n); ++i)
((f[i] = f[i - 1] + f[i - 2]) >= m) && (f[i] -= m);
}
int b[MAXN];
namespace DPair {
int cnt1[256], cnt2[256], cnt3[256], cnt4[256], A[MAXN];
inline void RadixSort(int *a, const int N) {
for (int i = (0); i < (N); ++i) {
++cnt1[a[i] & 255];
++cnt2[a[i] >> 8 & 255];
++cnt3[a[i] >> 16 & 255];
++cnt4[a[i] >> 24 & 255];
}
for (int i = (1); i < (256); ++i) {
cnt1[i] += cnt1[i - 1];
cnt2[i] += cnt2[i - 1];
cnt3[i] += cnt3[i - 1];
cnt4[i] += cnt4[i - 1];
}
for (int i = (N - 1); i >= (0); --i) A[--cnt1[a[i] & 255]] = a[i];
for (int i = (N - 1); i >= (0); --i) a[--cnt2[A[i] >> 8 & 255]] = A[i];
for (int i = (N - 1); i >= (0); --i) A[--cnt3[a[i] >> 16 & 255]] = a[i];
for (int i = (N - 1); i >= (0); --i) a[--cnt4[A[i] >> 24 & 255]] = A[i];
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
memset(cnt3, 0, sizeof(cnt3));
memset(cnt4, 0, sizeof(cnt4));
}
inline void RadixSort(int *a, int *_a) {
int N = _a - a, lim = 256;
while (N & 3) a[N++] = INF;
N > lim ? RadixSort(a, N) : std ::sort(a, _a);
}
} // namespace DPair
signed main() {
read(n, m);
read(a + 1, a + n + 1);
init();
read(q);
while (q--) {
int l, r;
read(l, r);
const int len = (r - l + 1);
memcpy(b, a + l, len * sizeof(int));
DPair ::RadixSort(b, b + len);
const int p = std ::unique(b, b + len) - b;
int ans[4] = {0, 0, 0, 0};
for (int i = 0; i < p - 3; i += 4) {
ans[0] = (1ll * b[i] * f[i] + ans[0]) % m;
ans[1] = (1ll * b[i + 1] * f[i + 1] + ans[1]) % m;
ans[2] = (1ll * b[i + 2] * f[i + 2] + ans[2]) % m;
ans[3] = (1ll * b[i + 3] * f[i + 3] + ans[3]) % m;
}
switch (p & 3) {
case 3:
ans[0] = (1ll * b[p - 3] * f[p - 3] + ans[0]) % m;
case 2:
ans[0] = (1ll * b[p - 2] * f[p - 2] + ans[0]) % m;
case 1:
ans[0] = (1ll * b[p - 1] * f[p - 1] + ans[0]) % m;
}
print((ans[0] + ans[1] + ans[2] + ans[3]) % m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned int n, m, q, sq;
unsigned int *a, *fib;
struct query {
unsigned int l, r, ind;
} * queries;
struct node {
unsigned int key, prior, mdkey, val, prevVal, size;
node *l, *r;
node(){};
node(unsigned int key, unsigned int prior, unsigned int mdkey)
: key(key),
prior(prior),
mdkey(mdkey),
prevVal(0),
val(mdkey),
size(1),
l(NULL),
r(NULL){};
};
unsigned int calcVal(node* t) {
if (t == NULL) return 0;
return t->val;
}
unsigned int calcPrevVal(node* t) {
if (t == NULL) return 0;
return t->prevVal;
}
unsigned int calcSize(node* t) {
if (t == NULL)
return 0;
else
return t->size;
}
void mergeT(node*& t, node* l, node* r) {
if (l == NULL)
t = r;
else if (r == NULL)
t = l;
else if (l->prior > r->prior)
mergeT(l->r, l->r, r), t = l;
else
mergeT(r->l, l, r->l), t = r;
if (t == NULL) return;
unsigned int ind = calcSize(t->l) + 1;
t->size = ind + calcSize(t->r);
unsigned int temp = calcVal(t->r);
unsigned int tempPrev = calcPrevVal(t->r);
t->val = (calcVal(t->l) + t->mdkey * fib[ind] + tempPrev * fib[ind] +
temp * fib[ind + 1]) %
m;
t->prevVal = (calcPrevVal(t->l) + t->mdkey * fib[ind - 1] +
tempPrev * fib[ind - 1] + temp * fib[ind]) %
m;
}
void split(node* t, unsigned int key, node*& l, node*& r) {
if (t == NULL)
return void(l = r = NULL);
else if (t->key > key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
unsigned int ind = calcSize(t->l) + 1;
t->size = ind + calcSize(t->r);
unsigned int temp = calcVal(t->r);
unsigned int tempPrev = calcPrevVal(t->r);
t->val = (calcVal(t->l) + t->mdkey * fib[ind] + tempPrev * fib[ind] +
temp * fib[ind + 1]) %
m;
t->prevVal = (calcPrevVal(t->l) + t->mdkey * fib[ind - 1] +
tempPrev * fib[ind - 1] + temp * fib[ind]) %
m;
}
bool compare1(query q1, query q2) {
return (q1.l / sq == q2.l / sq ? q1.r < q2.r : q1.l < q2.l);
}
void Solve() {
scanf("%d%d", &n, &m);
mt19937 rnd(123);
a = new unsigned int[n];
fib = new unsigned int[n + 1];
node** atree = new node*[n];
unordered_map<unsigned int, unsigned int> z;
for (unsigned int i = 0; i < (n); ++i) {
scanf("%d", &a[i]);
atree[i] = new node(a[i], rnd(), a[i] % m);
z.insert(make_pair(a[i], 0));
}
fib[0] = 0, fib[1] = 1;
for (unsigned int i = 2; i <= n; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
scanf("%d", &q);
sq = (unsigned int)sqrt(3.0 * n);
queries = new query[q];
unsigned int* answers = new unsigned int[q];
for (unsigned int i = 0; i < (q); ++i)
scanf("%d%d", &queries[i].l, &queries[i].r), queries[i].l--, queries[i].r--,
queries[i].ind = i;
sort(queries, queries + q, compare1);
unsigned int l = queries[0].l, r = l;
node* t = atree[l];
z[a[l]]++;
for (unsigned int i = 0; i < (q); ++i) {
while (queries[i].l < l) {
l--;
auto itz = z.find(a[l]);
if (itz->second == 0) {
node *tl, *tr, *it = atree[l];
split(t, a[l], tl, tr);
mergeT(t, tl, it);
mergeT(t, t, tr);
}
itz->second++;
}
while (queries[i].r > r) {
r++;
auto itz = z.find(a[r]);
if (itz->second == 0) {
node *tl, *tr, *it = atree[r];
split(t, a[r], tl, tr);
mergeT(t, tl, it);
mergeT(t, t, tr);
}
itz->second++;
}
while (queries[i].l > l) {
auto itz = z.find(a[l]);
itz->second--;
if (itz->second == 0) {
node *tl, *tr, *it;
split(t, a[l], tl, tr);
split(tl, a[l] - 1, tl, it);
mergeT(t, tl, tr);
}
l++;
}
while (queries[i].r < r) {
auto itz = z.find(a[r]);
itz->second--;
if (itz->second == 0) {
node *tl, *tr, *it;
split(t, a[r], tl, tr);
split(tl, a[r] - 1, tl, it);
mergeT(t, tl, tr);
}
r--;
}
answers[queries[i].ind] = calcVal(t);
}
for (unsigned int i = 0; i < (q); ++i) printf("%d\n", answers[i]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &a) {
a = 0;
int c = getchar(), b = 1;
while (c > '9' || c < '0') {
if (c == '-') b = -1;
c = getchar();
}
while (c >= '0' && c <= '9') a = (a << 3) + (a << 1) + c - 48, c = getchar();
a *= b;
}
inline int Rem() {
int a = 0, c = getchar(), b = 1;
while (c > '9' || c < '0') {
if (c == '-') b = -1;
c = getchar();
}
while (c >= '0' && c <= '9') a = (a << 3) + (a << 1) + c - 48, c = getchar();
return a *= b;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
inline void W(int x) {
if (x < 0) {
putchar('-'), x = -x;
}
write(x);
}
const int N = 3e4 + 5;
int n, m, p, rec[N], f[N], pos[N], l[N], r[N];
long long ans[N];
struct node {
int num, id;
bool operator<(const node &b) const { return num < b.num; }
} a[N];
int main() {
read(n);
read(p);
for (int i = 1; i <= n; i++) read(a[i].num), a[i].id = i;
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % p;
sort(a + 1, a + 1 + n);
read(m);
for (int i = 1; i <= m; i++) {
read(l[i]);
read(r[i]);
rec[i] = -1;
}
for (int i = 1, x; i <= n; i++) {
x = a[i].num % p;
for (int j = 1; j <= m; j++) {
if (l[j] <= a[i].id && a[i].id <= r[j] && a[i].num != rec[j]) {
rec[j] = a[i].num;
ans[j] += f[++pos[j]] * x;
}
}
}
for (int i = 1; i <= m; i++) cout << ans[i] % p << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
const int INF = 2000000005;
const int block = 200;
int mod, *fib, pool[MAXN];
int rmove(int sum, int sum1, int k) {
return (fib[k + 1] * sum + fib[k] * sum1) % mod;
}
struct tree {
int l;
int r;
int sum;
int sum1;
int shift;
tree *lson;
tree *rson;
tree() {
l = r = sum = sum1 = shift = 0;
lson = rson = NULL;
}
void right_move(int k) {
int t = (fib[k + 1] * sum + fib[k] * sum1) % mod;
int t1 = (fib[k] * sum + fib[k - 1] * sum1) % mod;
sum = t;
sum1 = t1;
shift += k;
}
void fixup() {
sum = (lson->sum + rson->sum) % mod;
sum1 = (lson->sum1 + rson->sum1) % mod;
int t = rmove(sum, sum1, shift);
int t1 = rmove(sum, sum1, shift - 1);
sum = t;
sum1 = t1;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int W, int S, int rs) {
if (l == r) {
sum = W * fib[S] % mod;
sum1 = W * fib[S - 1] % mod;
return;
}
int mid = (l + r) / 2;
if (id <= mid) {
rson->right_move(rs);
lson->modify(id, W, S - shift, rs);
} else
rson->modify(id, W, S - shift, rs);
fixup();
}
void move(int L, int R, int k) {
if (l >= L && r <= R) {
right_move(k);
return;
}
int mid = (l + r) / 2;
if (L <= mid) lson->move(L, R, k);
if (R > mid) rson->move(L, R, k);
fixup();
}
void print() {
if (lson) lson->print();
printf("seg_tree l %d r %d sum %d sum1 %d\n", l, r, sum, sum1);
if (rson) rson->print();
}
};
struct Ftree {
int bit[MAXN];
Ftree() { memset(bit, 0, sizeof(bit)); }
void add(int pos, int k) {
for (int i = pos; i < MAXN; i += ((i) & -(i))) bit[i] += k;
}
int sum(int pos) {
int ret = 0;
for (int i = pos; i; i -= ((i) & -(i))) ret += bit[i];
return ret;
}
int query(int l, int r) { return sum(r) - sum(l - 1); }
};
struct data {
int id;
int w;
bool operator<(data t) const { return w < t.w; }
};
struct QUERY {
int id;
int l;
int r;
bool operator<(QUERY t) const {
if (l / block != t.l / block) return l < t.l;
return r < t.r;
}
};
int N, Q;
int a[MAXN], rank[MAXN];
QUERY q[MAXN];
int L, R, cnt[MAXN];
tree T;
Ftree FT;
void Rr_move() {
R++;
cnt[rank[R]]++;
if (cnt[rank[R]] == 1) {
FT.add(rank[R], 1);
int s = FT.sum(rank[R]);
T.modify(rank[R], a[R], s, 1);
}
}
void Rl_move() {
cnt[rank[R]]--;
if (cnt[rank[R]] == 0) {
FT.add(rank[R], -1);
T.modify(rank[R], 0, 0, -1);
}
R--;
}
void Ll_move() {
L--;
cnt[rank[L]]++;
if (cnt[rank[L]] == 1) {
FT.add(rank[L], 1);
int s = FT.sum(rank[L]);
T.modify(rank[L], a[L], s, 1);
}
}
void Lr_move() {
cnt[rank[L]]--;
if (cnt[rank[L]] == 0) {
FT.add(rank[L], -1);
T.modify(rank[L], 0, 0, -1);
}
L++;
}
data tmp[MAXN];
void init() {
scanf("%d %d", &N, &mod);
fib = pool + MAXN / 2;
fib[1] = fib[2] = 1;
for (int i = 3; i < 40000; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 0; i > -40000; i--) fib[i] = (fib[i + 2] - fib[i + 1]) % mod;
for (int i = 1; i <= N; i++) {
scanf("%d", a + i);
tmp[i].id = i;
tmp[i].w = a[i];
}
std::sort(tmp + 1, tmp + N + 1);
int cur = 0;
for (int i = 1; i <= N; i++) {
if (i == 1 || tmp[i].w != tmp[i - 1].w) cur++;
rank[tmp[i].id] = cur;
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].id = i;
}
std::sort(q + 1, q + Q + 1);
T.build(1, N);
L = R = 1;
T.modify(rank[1], a[1], 1, 1);
cnt[rank[1]] = 1;
FT.add(rank[1], 1);
}
void solve() {
static int ans[MAXN];
for (int i = 1; i <= Q; i++) {
int l = q[i].l, r = q[i].r;
while (R < r) Rr_move();
while (L < l) Lr_move();
while (L > l) Ll_move();
while (R > r) Rl_move();
ans[q[i].id] = (T.sum % mod + mod) % mod;
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ql[300007], qr[300007], f[300007], pos[300007], ans[300007],
mx[300007];
long long n, q, mod;
inline long long read() {
long long res = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
res = res * 10 + ch - 48;
ch = getchar();
}
return res * flag;
}
struct node {
long long id, val;
} a[300007];
bool cmp(node x, node y) { return x.val < y.val; }
inline long long fastmod(long long x) { return x >= mod ? x - mod : x; }
signed main() {
n = read(), mod = read();
f[1] = f[2] = 1;
for (long long i = 3; i <= n; ++i) {
f[i] = fastmod(f[i - 1] + f[i - 2]);
}
for (long long i = 1; i <= n; ++i) {
a[i].id = i;
a[i].val = read();
}
sort(a + 1, a + 1 + n, cmp);
q = read();
for (long long i = 1; i <= q; ++i) {
ql[i] = read(), qr[i] = read();
}
for (long long i = 1; i <= n; ++i) {
long long res = a[i].val % mod;
for (long long j = 1; j <= q; ++j) {
if (a[i].id >= ql[j] && a[i].id <= qr[j] && a[i].val != mx[j]) {
ans[j] += f[++pos[j]] * res;
mx[j] = a[i].val;
}
}
}
for (long long i = 1; i <= q; ++i) {
printf("%lld\n", ans[i] % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30010;
int p;
int fi[maxn];
inline int f(int x) {
if (x >= 0)
return fi[x];
else
return ((-x) & 1) ? fi[-x] : p - fi[-x];
}
struct Segment_Tree {
int sum1[maxn << 2], sum2[maxn << 2];
int size[maxn << 2];
int tag_k[maxn << 2];
int n;
void Update(int o) {
sum1[o] = (sum1[(o << 1)] + sum1[(o << 1 | 1)]) % p;
sum2[o] = (sum2[(o << 1)] + sum2[(o << 1 | 1)]) % p;
size[o] = size[(o << 1)] + size[(o << 1 | 1)];
}
void Mark(int o, int k) {
if (k == 1) {
int x1 = sum1[o];
sum1[o] += sum2[o], sum2[o] = x1;
if (sum1[o] > p) sum1[o] -= p;
tag_k[o]++;
return;
}
int x1 = (sum1[o] * f(k + 1) + sum2[o] * f(k)) % p,
x2 = (sum1[o] * f(k) + sum2[o] * f(k - 1)) % p;
sum1[o] = x1;
sum2[o] = x2;
tag_k[o] += k;
}
void Push_Down(int o) {
if (tag_k[o]) {
Mark((o << 1), tag_k[o]);
Mark((o << 1 | 1), tag_k[o]);
tag_k[o] = 0;
}
}
void Change(int o, int l, int r, int x, int v, int w, int c) {
if (l == r) {
if (c == -1)
size[o] = sum1[o] = sum2[o] = 0;
else
size[o] = 1, sum1[o] = v * f(w + 1) % p, sum2[o] = v * f(w) % p;
return;
}
Push_Down(o);
if (x <= ((l + r) >> 1))
Change((o << 1), l, ((l + r) >> 1), x, v, w, c), Mark((o << 1 | 1), c);
else
Change((o << 1 | 1), ((l + r) >> 1) + 1, r, x, v, w + size[(o << 1)], c);
Update(o);
}
void Change(int x, int v, int c) { Change(1, 1, n, x, v, 0, c); }
int Result() { return sum1[1]; }
} T;
int a[maxn], temp[maxn];
int cnt[maxn];
int ans[maxn];
int n, q, blocksize, ts;
struct Query {
int l, r, block, id;
bool operator<(const Query &b) const {
return block < b.block || block == b.block && r < b.r;
}
} Q[maxn];
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memcpy(temp, a, sizeof(temp));
sort(temp + 1, temp + 1 + n);
ts = unique(temp + 1, temp + 1 + n) - (temp + 1);
for (int i = 1; i <= n; i++)
a[i] = lower_bound(temp + 1, temp + 1 + ts, a[i]) - temp;
for (int i = 1; i <= ts; i++) temp[i] %= p;
T.n = ts;
fi[1] = 1;
fi[2] = 1;
for (int i = 3; i <= ts + 2; i++) fi[i] = (fi[i - 1] + fi[i - 2]) % p;
blocksize = sqrt(n);
scanf("%d", &q);
for (int i = 1; i <= q; i++)
scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].block = Q[i].l / blocksize,
Q[i].id = i;
sort(Q + 1, Q + 1 + q);
for (int i = 1, l = 1, r = 0; i <= q; i++) {
while (r < Q[i].r) {
r++;
cnt[a[r]]++;
if (cnt[a[r]] == 1) T.Change(a[r], temp[a[r]], 1);
}
while (r > Q[i].r) {
cnt[a[r]]--;
if (cnt[a[r]] == 0) T.Change(a[r], temp[a[r]], -1);
r--;
}
while (l > Q[i].l) {
l--;
cnt[a[l]]++;
if (cnt[a[l]] == 1) T.Change(a[l], temp[a[l]], 1);
}
while (l < Q[i].l) {
cnt[a[l]]--;
if (cnt[a[l]] == 0) T.Change(a[l], temp[a[l]], -1);
l++;
}
ans[Q[i].id] = T.Result();
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int primero = 1 << 15;
const int tope = 1 << 16;
int cuantos[tope];
int f0[tope];
int f1[tope];
int ocurrencias[tope];
int fibo[tope];
int n, modulo;
int a[tope];
int norden = 0;
int orden[tope];
int valormod[tope];
int buscapos(int x) {
int inf = 0;
int sup = norden;
while (inf + 1 < sup) {
int med = (inf + sup) / 2;
if (orden[med] <= x)
inf = med;
else
sup = med;
}
return inf;
}
void anyade(int x, int val) {
int pos = buscapos(x);
pos += primero;
ocurrencias[pos] += val;
cuantos[pos] = ocurrencias[pos] > 0;
f0[pos] = 0;
f1[pos] = valormod[pos - primero] * cuantos[pos];
while (pos > 1) {
pos /= 2;
cuantos[pos] = cuantos[2 * pos] + cuantos[2 * pos + 1];
if (cuantos[2 * pos] == 0) {
f0[pos] = f0[2 * pos + 1];
f1[pos] = f1[2 * pos + 1];
} else {
int c = cuantos[2 * pos];
f0[pos] = (f0[2 * pos] + fibo[c] * f1[2 * pos + 1] +
fibo[c - 1] * f0[2 * pos + 1]) %
modulo;
f1[pos] = (f1[2 * pos] + fibo[c + 1] * f1[2 * pos + 1] +
fibo[c] * f0[2 * pos + 1]) %
modulo;
}
}
}
const int base = 175;
struct elem {
int iq, l, r;
};
bool operator<(elem e1, elem e2) {
int b1 = e1.l / base;
int b2 = e2.l / base;
return b1 < b2 or (b1 == b2 and e1.r < e2.r);
}
int nq;
int sol[tope];
int main() {
ios::sync_with_stdio(false);
set<int> s;
cin >> n >> modulo;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s.insert(a[i]);
}
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
orden[norden++] = *it;
sort(orden, orden + norden);
for (int i = 0; i < norden; i++) valormod[i] = orden[i] % modulo;
fibo[1] = 1;
for (int i = 2; i <= n; i++) fibo[i] = (fibo[i - 2] + fibo[i - 1]) % modulo;
cin >> nq;
vector<elem> v;
for (int i = 0; i < nq; i++) {
elem e;
e.iq = i;
cin >> e.l >> e.r;
v.push_back(e);
}
sort(v.begin(), v.end());
int l = 1;
int r = 0;
for (int i = 0; i < int(v.size()); i++) {
elem &e = v[i];
while (r < e.r) {
r++;
anyade(a[r], 1);
}
while (e.l < l) {
l--;
anyade(a[l], 1);
}
while (e.r < r) {
anyade(a[r], -1);
r--;
}
while (l < e.l) {
anyade(a[l], -1);
l++;
}
sol[e.iq] = f1[1];
}
for (int i = 0; i < nq; i++)
cout << ((sol[i] % modulo + modulo) % modulo) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
int mod, n, m, a[maxn], b[maxn], c[maxn], used[maxn], block, ans[maxn];
bool vis[maxn];
struct query {
int l, r, id;
bool operator<(const query &a) const {
if (l / block != a.l / block) return l / block < a.l / block;
return r != a.r ? r < a.r : l < a.l;
}
} Q[maxn];
struct segtree {
int node[maxn << 2][2][3];
void build(int rt, int l, int r) {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
}
void update(int rt, int l, int r, int x, int k) {
if (l == r) {
if (k) {
node[rt][0][0] = node[rt][0][1] = node[rt][1][0] = 1;
node[rt][1][1] = 0;
node[rt][0][2] = node[rt][1][2] = c[x];
} else {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
}
return;
}
int mid = (l + r) >> 1;
x <= mid ? update(rt << 1, l, mid, x, k)
: update(rt << 1 | 1, mid + 1, r, x, k);
node[rt][0][0] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][0][1] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][0][2] =
(node[rt << 1][0][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][2] + node[rt << 1][0][2]) %
mod;
node[rt][1][0] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][1][1] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][1][2] =
(node[rt << 1][1][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][2] + node[rt << 1][1][2]) %
mod;
}
} tree;
void add(int x) {
if (++used[x] == 1) tree.update(1, 1, m, x, 1);
}
void del(int x) {
if (--used[x] == 0) tree.update(1, 1, m, x, 0);
}
void work(int x) {
if (vis[x]) {
vis[x] = false;
del(a[x]);
} else {
vis[x] = true;
add(a[x]);
}
}
int main() {
while (~scanf("%d%d", &n, &mod)) {
block = sqrt(n + 0.5);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= m; ++i) c[i] = b[i] % mod;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
tree.build(1, 1, m);
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q, Q + q);
memset(vis, 0, sizeof(vis));
memset(used, 0, sizeof(used));
int l = Q[0].l, r = Q[0].r;
for (int i = l; i <= r; ++i) work(i);
ans[Q[0].id] = tree.node[1][1][2];
for (int i = 1; i < q; ++i) {
while (l < Q[i].l) work(l++);
while (l > Q[i].l) work(--l);
while (r < Q[i].r) work(++r);
while (r > Q[i].r) work(r--);
ans[Q[i].id] = tree.node[1][1][2];
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30005;
int n, mod, fib[MAXN], a[MAXN], p[MAXN];
int wcnt[33005];
int main() {
int Q, l, r;
scanf("%d%d", &n, &mod);
fib[1] = fib[2] = 1;
for (int i = 3; i <= n; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[i] = a[i];
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++) a[i] = lower_bound(p + 1, p + n + 1, a[i]) - p;
for (int i = 1; i <= n; i++) p[i] %= mod;
long long ans;
int cur;
scanf("%d", &Q);
for (int kase = 1; kase <= Q; kase++) {
ans = cur = 0;
scanf("%d%d", &l, &r);
for (register int i = l; i <= r; ++i) wcnt[a[i]] = kase;
for (register int i = 1; i <= n; ++i)
if (wcnt[i] == kase) ans += p[i] * fib[++cur];
printf("%d\n", (int)(ans % mod));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int f[30013];
pair<int, int> a[30013];
int b[30013];
int main() {
scanf("%d%d", &n, &m);
f[1] = f[2] = 1 % m;
for (int i = 3; i < 30013; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i + 1;
}
sort(a, a + n);
for (int i = 0; i < n; i++) b[i] = a[i].first % m;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int on = 1;
long long ans = 0;
int prev = -1;
for (int i = 0; i < n; i++) {
if (l <= a[i].second && a[i].second <= r) {
if (a[i].first > prev) {
ans = ans + b[i] * f[on++];
prev = a[i].first;
}
}
}
printf("%lld\n", ans % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, id;
friend bool operator<(node a, node b) {
if (a.x == b.x) return a.id < b.id;
return a.x < b.x;
}
} a[51000];
int n, m, q, f[51000] = {0}, l[51000] = {0}, r[51000] = {0}, ans[51000] = {0},
last[51000] = {0}, lng[51000] = {0};
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].id = i;
if (i <= 2)
f[i] = 1;
else
f[i] = (f[i - 1] + f[i - 2]) % m;
}
sort(a + 1, a + n + 1);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", l + i, r + i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= q; j++)
if (l[j] <= a[i].id && a[i].id <= r[j] && last[j] != a[i].x) {
lng[j]++;
last[j] = a[i].x;
ans[j] = (ans[j] + f[lng[j]] * (a[i].x % m)) % m;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3;
const int MAX_N = 30030;
int BLOCK = 250;
int MOD;
struct Matrix {
unsigned int a[N][N];
Matrix() { memset(a, 0, sizeof(a)); }
void make_identity() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
a[i][j] = (i == j);
}
}
}
void print() const {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cerr << a[i][j] << " ";
}
cerr << "\n";
}
cerr << "\n";
}
};
struct Query {
int l;
int r;
int id;
};
bool cmp_queries(const Query &a, const Query &b) {
return make_pair((a.l - 1) / BLOCK, a.r) < make_pair((b.l - 1) / BLOCK, b.r);
}
void multiply(const Matrix &a, const Matrix &b, Matrix &c) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
unsigned int value = 0ul;
for (int k = 0; k < N; k++) {
value += a.a[i][k] * b.a[k][j];
}
c.a[i][j] = value % MOD;
}
}
}
int a[MAX_N];
int real_a[MAX_N];
pair<int, int> buffer[MAX_N];
int compress_a(int n, int a[], int real_a[]) {
for (int i = 1; i <= n; i++) {
buffer[i] = make_pair(a[i], i);
}
sort(buffer + 1, buffer + n + 1);
int h = 1;
real_a[1] = buffer[1].first;
a[buffer[1].second] = 1;
for (int i = 2; i <= n; i++) {
if (real_a[h] < buffer[i].first) {
real_a[h + 1] = buffer[i].first;
h += 1;
}
a[buffer[i].second] = h;
}
return h;
}
Matrix tree[4 * MAX_N];
int counters[MAX_N];
int h;
void build_tree(int v, int l, int r) {
tree[v].make_identity();
if (l == r) {
return;
}
int x = (l + r) / 2;
build_tree(v + v, l, x);
build_tree(v + v + 1, x + 1, r);
}
void switch_on(int pos) {
int v = 1;
int l = 1;
int r = h;
while (l < r) {
int x = (l + r) / 2;
if (pos <= x) {
v = v + v;
r = x;
} else {
v = v + v + 1;
l = x + 1;
}
}
tree[v].a[0][0] = 0;
tree[v].a[0][1] = 1;
tree[v].a[0][2] = 0;
tree[v].a[1][0] = 1;
tree[v].a[1][1] = 1;
tree[v].a[1][2] = 0;
tree[v].a[2][0] = 0;
tree[v].a[2][1] = real_a[pos] % MOD;
tree[v].a[2][2] = 1;
v >>= 1;
while (v) {
tree[v].a[0][0] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[0][1] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[0][2] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[1][0] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[1][1] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[1][2] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[2][0] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[2][1] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[2][2] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][2]) %
MOD;
v >>= 1;
}
}
void switch_off(int pos) {
int v = 1;
int l = 1;
int r = h;
while (l < r) {
int x = (l + r) / 2;
if (pos <= x) {
v = v + v;
r = x;
} else {
v = v + v + 1;
l = x + 1;
}
}
tree[v].make_identity();
v >>= 1;
while (v) {
tree[v].a[0][0] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[0][1] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[0][2] = (tree[v + v + 1].a[0][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[0][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[0][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[1][0] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[1][1] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[1][2] = (tree[v + v + 1].a[1][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[1][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[1][2] * tree[v + v].a[2][2]) %
MOD;
tree[v].a[2][0] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][0] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][0] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][0]) %
MOD;
tree[v].a[2][1] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][1] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][1] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][1]) %
MOD;
tree[v].a[2][2] = (tree[v + v + 1].a[2][0] * tree[v + v].a[0][2] +
tree[v + v + 1].a[2][1] * tree[v + v].a[1][2] +
tree[v + v + 1].a[2][2] * tree[v + v].a[2][2]) %
MOD;
v >>= 1;
}
}
void add_value(int x) {
if (counters[x] == 0) {
switch_on(x);
}
counters[x] += 1;
}
void delete_value(int x) {
if (counters[x] == 1) {
switch_off(x);
}
counters[x] -= 1;
}
int get_answer() { return (int)tree[1].a[2][1]; }
Query queries[MAX_N];
int answer[MAX_N];
void solve() {
int n;
scanf("%d%d", &n, &MOD);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
h = compress_a(n, a, real_a);
build_tree(1, 1, h);
int q;
scanf("%d", &q);
for (int it = 0; it < q; it++) {
int l, r;
scanf("%d%d", &l, &r);
queries[it].l = l;
queries[it].r = r;
queries[it].id = it;
}
sort(queries, queries + q, cmp_queries);
int l = queries[0].l;
int r = queries[0].r;
for (int i = l; i <= r; i++) {
add_value(a[i]);
}
answer[queries[0].id] = get_answer();
for (int i = 1; i < q; i++) {
while (r < queries[i].r) {
r += 1;
add_value(a[r]);
}
while (queries[i].l < l) {
l -= 1;
add_value(a[l]);
}
while (r > queries[i].r) {
delete_value(a[r]);
r -= 1;
}
while (queries[i].l > l) {
delete_value(a[l]);
l += 1;
}
answer[queries[i].id] = get_answer();
}
for (int i = 0; i < q; i++) {
printf("%d\n", answer[i]);
}
}
int main() {
int cases;
cases = 1;
for (int i = 0; i < cases; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[30005];
int h[30005];
int st[30005];
int t[30005];
int f[30005];
int read() {
int s = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s;
}
int main() {
int n, m, p, i, le, mn, mx, l, r, cnt, T;
long long s;
n = read(), p = read();
for (i = 1; i <= n; i++) h[i] = st[i] = a[i] = read();
sort(st + 1, st + 1 + n);
le = unique(st + 1, st + 1 + n) - st;
for (i = 1; i <= n; i++) h[i] = lower_bound(st + 1, st + le, h[i]) - st;
m = read();
f[1] = f[2] = 1;
for (i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % p;
for (T = 1; T <= m; T++) {
l = read(), r = read();
mn = 2e9, mx = -2e9;
for (i = l; i <= r; i++)
t[h[i]] = T, mn = h[i] < mn ? h[i] : mn, mx = h[i] > mx ? h[i] : mx;
s = cnt = 0;
for (i = mn; i <= mx; i++)
if (t[i] == T) s += 1ll * f[++cnt] * st[i];
printf("%d\n", s % p);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30006;
int IN[MAXN];
int ile[MAXN];
vector<int> R;
int BAS, mod;
int FIB[MAXN];
const int PIER = 200;
struct node {
int w, ws, ile;
node() { w = ws = ile = 0; }
} D[1 << 16];
int fib(int a) { return FIB[max(a, 0)]; }
void update(int k) {
while (k) {
int le = D[2 * k].ile;
D[k].w = (D[2 * k].w + 1LL * fib(le + 1) * D[2 * k + 1].w +
1LL * fib(le) * D[2 * k + 1].ws) %
mod;
D[k].ws = (D[2 * k].ws + 1LL * fib(le + 1) * D[2 * k + 1].ws +
1LL * fib(le) * (D[2 * k + 1].w + mod - D[2 * k + 1].ws)) %
mod;
D[k].ile = D[2 * k].ile + D[2 * k + 1].ile;
;
k /= 2;
}
}
inline void dodaj(int i) {
int w = IN[i];
;
ile[w]++;
if (ile[w] > 1) return;
w += BAS;
D[w].w = R[IN[i]] % mod;
D[w].ile = 1;
;
update(w / 2);
;
}
inline void usun(int i) {
int w = IN[i];
ile[w]--;
if (ile[w] >= 1) return;
w += BAS;
D[w].w = D[w].ile = 0;
update(w / 2);
}
inline int wynik() { return D[1].w; }
inline bool cmp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
int p1 = a.first.first / PIER, p2 = b.first.first / PIER;
if (p1 != p2) return p1 < p2;
if (p1 & 1) return b.first.second < a.first.second;
return a.first.second < b.first.second;
}
vector<int> sqrt_decom(vector<pair<int, int> > Z) {
int d = Z.size();
vector<pair<pair<int, int>, int> > Q(d);
for (int i = 0; i < (d); ++i) Q[i] = pair<pair<int, int>, int>(Z[i], i);
vector<int> ans(d);
sort(Q.begin(), Q.end(), cmp);
int p = 1, k = 0;
for (auto it = (Q).begin(); it != (Q).end(); ++it) {
while (p > it->first.first) dodaj(--p);
while (k < it->first.second) dodaj(++k);
while (p < it->first.first) usun(p++);
while (k > it->first.second) usun(k--);
ans[it->second] = wynik();
}
return ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &mod);
FIB[0] = 0;
FIB[1] = 1 % mod;
for (int i = 0; i < (MAXN - 2); ++i) FIB[i + 2] = (FIB[i] + FIB[i + 1]) % mod;
for (int i = 0; i < (n); ++i) scanf("%d", &IN[i]);
for (int i = 0; i < (n); ++i) R.push_back(IN[i]);
sort((R).begin(), (R).end());
R.resize(unique((R).begin(), (R).end()) - R.begin());
for (int i = 0; i < (n); ++i)
IN[i] = lower_bound((R).begin(), (R).end(), IN[i]) - R.begin();
BAS = 1;
while (BAS < R.size()) BAS *= 2;
vector<pair<int, int> > Z;
scanf("%d", &q);
for (int i = 0; i < (q); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
Z.push_back(pair<int, int>(a, b));
}
vector<int> ans = sqrt_decom(Z);
for (auto it = (ans).begin(); it != (ans).end(); ++it) printf("%d\n", *it);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
int fib[100000];
int rfib[100000];
class BIT {
public:
int bit[32768 + 1];
void add(int a, int b) {
a++;
for (;;) {
bit[a] += b;
a += a & -a;
if (a > 32768) return;
}
}
int get(int a) {
a++;
int ret = 0;
for (;;) {
ret += bit[a];
a -= a & -a;
if (a == 0) return ret;
}
}
};
class segtree {
public:
int seg[32768 * 2];
int pl[32768 * 2];
int flag[32768 * 2];
void update(int beg, int end, int node, int lb, int ub, int n) {
if (ub < beg || end < lb) return;
if (beg <= lb && ub <= end) {
if (n == 1) {
int t = pl[node];
pl[node] = seg[node];
seg[node] = (seg[node] + t) % mod;
flag[node]++;
} else {
int t = seg[node];
seg[node] = pl[node];
pl[node] = (t + mod - pl[node]) % mod;
flag[node]--;
}
return;
}
if (flag[node]) {
if (flag[node] > 0) {
int a = seg[node * 2], b = pl[node * 2];
seg[node * 2] = (a * fib[flag[node] + 1] + b * fib[flag[node]]) % mod;
pl[node * 2] = (a * fib[flag[node]] + b * fib[flag[node] - 1]) % mod;
a = seg[node * 2 + 1], b = pl[node * 2 + 1];
seg[node * 2 + 1] =
(a * fib[flag[node] + 1] + b * fib[flag[node]]) % mod;
pl[node * 2 + 1] =
(a * fib[flag[node]] + b * fib[flag[node] - 1]) % mod;
} else {
int a = seg[node * 2], b = pl[node * 2];
seg[node * 2] =
(a * rfib[-flag[node] - 1] + b * rfib[-flag[node]]) % mod;
pl[node * 2] =
(a * rfib[-flag[node]] + b * rfib[-flag[node] + 1]) % mod;
a = seg[node * 2 + 1], b = pl[node * 2 + 1];
seg[node * 2 + 1] =
(a * rfib[-flag[node] - 1] + b * rfib[-flag[node]]) % mod;
pl[node * 2 + 1] =
(a * rfib[-flag[node]] + b * rfib[-flag[node] + 1]) % mod;
}
flag[node * 2] += flag[node];
flag[node * 2 + 1] += flag[node];
flag[node] = 0;
}
update(beg, end, node * 2, lb, (lb + ub) / 2, n);
update(beg, end, node * 2 + 1, (lb + ub) / 2 + 1, ub, n);
seg[node] = (seg[node * 2] + seg[node * 2 + 1]) % mod;
pl[node] = (pl[node * 2] + pl[node * 2 + 1]) % mod;
}
void add(int p, int node, int lb, int ub, int t1, int t2) {
if (ub < p || p < lb) return;
if (lb == ub) {
seg[node] += t1;
pl[node] += t2;
seg[node] %= mod;
pl[node] %= mod;
return;
}
if (flag[node]) {
if (flag[node] > 0) {
int a = seg[node * 2], b = pl[node * 2];
seg[node * 2] = (a * fib[flag[node] + 1] + b * fib[flag[node]]) % mod;
pl[node * 2] = (a * fib[flag[node]] + b * fib[flag[node] - 1]) % mod;
a = seg[node * 2 + 1], b = pl[node * 2 + 1];
seg[node * 2 + 1] =
(a * fib[flag[node] + 1] + b * fib[flag[node]]) % mod;
pl[node * 2 + 1] =
(a * fib[flag[node]] + b * fib[flag[node] - 1]) % mod;
} else {
int a = seg[node * 2], b = pl[node * 2];
seg[node * 2] =
(a * rfib[-flag[node] - 1] + b * rfib[-flag[node]]) % mod;
pl[node * 2] =
(a * rfib[-flag[node]] + b * rfib[-flag[node] + 1]) % mod;
a = seg[node * 2 + 1], b = pl[node * 2 + 1];
seg[node * 2 + 1] =
(a * rfib[-flag[node] - 1] + b * rfib[-flag[node]]) % mod;
pl[node * 2 + 1] =
(a * rfib[-flag[node]] + b * rfib[-flag[node] + 1]) % mod;
}
flag[node * 2] += flag[node];
flag[node * 2 + 1] += flag[node];
flag[node] = 0;
}
add(p, node * 2, lb, (lb + ub) / 2, t1, t2);
add(p, node * 2 + 1, (lb + ub) / 2 + 1, ub, t1, t2);
seg[node] = (seg[node * 2] + seg[node * 2 + 1]) % mod;
pl[node] = (pl[node * 2] + pl[node * 2 + 1]) % mod;
}
};
segtree tree;
BIT bi;
int ans[30000];
int cnt[30000];
int main() {
int num;
scanf("%d%d", &num, &mod);
vector<int> vec;
vector<int> zat;
for (int i = 0; i < num; i++) {
int z;
scanf("%d", &z);
vec.push_back(z);
zat.push_back(z);
}
sort(zat.begin(), zat.end());
int query;
scanf("%d", &query);
vector<pair<pair<int, int>, pair<int, int> > > dat;
for (int i = 0; i < query; i++) {
int za, zb;
scanf("%d%d", &za, &zb);
za--;
zb--;
dat.push_back(make_pair(make_pair(zb / 300, za), make_pair(zb, i)));
}
fib[1] = rfib[1] = 1;
for (int i = 2; i < 50000; i++) {
fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
rfib[i] = (rfib[i - 2] + mod - rfib[i - 1]) % mod;
}
sort(dat.begin(), dat.end());
int nl = 0, nr = -1;
for (int i = 0; i < query; i++) {
int beg = dat[i].first.second, end = dat[i].second.first,
idx = dat[i].second.second;
for (int p = 0;; p++) {
if (nl > beg) {
nl--;
int low = lower_bound(zat.begin(), zat.end(), vec[nl]) - zat.begin();
if (cnt[low] == 0) {
int t = bi.get(low);
tree.add(low, 1, 0, 32768 - 1, vec[nl] % mod * fib[t + 1] % mod,
vec[nl] % mod * fib[t] % mod);
tree.update(low + 1, 32768 - 1, 1, 0, 32768 - 1, 1);
bi.add(low, 1);
}
cnt[low]++;
} else if (nr < end) {
nr++;
int low = lower_bound(zat.begin(), zat.end(), vec[nr]) - zat.begin();
if (cnt[low] == 0) {
int t = bi.get(low);
tree.add(low, 1, 0, 32768 - 1, vec[nr] % mod * fib[t + 1] % mod,
vec[nr] % mod * fib[t] % mod);
tree.update(low + 1, 32768 - 1, 1, 0, 32768 - 1, 1);
bi.add(low, 1);
}
cnt[low]++;
} else if (nl < beg) {
int low = lower_bound(zat.begin(), zat.end(), vec[nl]) - zat.begin();
if (cnt[low] == 1) {
int t = bi.get(low - 1);
tree.add(low, 1, 0, 32768 - 1,
(mod - vec[nl] % mod * fib[t + 1] % mod) % mod,
(mod - vec[nl] % mod * fib[t] % mod) % mod);
tree.update(low + 1, 32768 - 1, 1, 0, 32768 - 1, -1);
bi.add(low, -1);
}
nl++;
cnt[low]--;
} else if (nr > end) {
int low = lower_bound(zat.begin(), zat.end(), vec[nr]) - zat.begin();
if (cnt[low] == 1) {
int t = bi.get(low - 1);
tree.add(low, 1, 0, 32768 - 1,
(mod - vec[nr] % mod * fib[t + 1] % mod) % mod,
(mod - vec[nr] % mod * fib[t] % mod) % mod);
tree.update(low + 1, 32768 - 1, 1, 0, 32768 - 1, -1);
bi.add(low, -1);
}
nr--;
cnt[low]--;
} else
break;
}
ans[idx] = tree.seg[1];
}
for (int i = 0; i < query; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int first[33333];
pair<int, int> a[33333];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
first[0] = first[1] = 1 % m;
for (int i = 2; i <= n; i++) {
first[i] = first[i - 1] + first[i - 2];
if (first[i] >= m) {
first[i] -= m;
}
}
int l, r, q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
--l, --r;
long long sum = 0, color = -1, i = 0;
for (int j = 0; j < n; j++) {
if (color == a[j].first) continue;
if (l <= a[j].second && a[j].second <= r) {
color = a[j].first;
sum += ((long long)first[i++]) * a[j].first;
}
}
printf("%d\n", int(sum % m));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 32768;
const int sq = 180;
int n, m, q;
int a[maxn];
pair<pair<int, int>, int> qu[maxn];
int l, r;
int x[maxn], b[maxn], N;
int cnt[maxn];
int Az[maxn], Bz[maxn];
int A[maxn * 2], B[maxn * 2], s[maxn * 2];
int ans[maxn];
inline bool cmp(const pair<pair<int, int>, int> &A,
const pair<pair<int, int>, int> &B) {
return (A.first.second < B.first.second or
(A.first.second == B.first.second and A.first.first < B.first.first));
}
inline void update(int seg) {
A[seg] = (A[(seg * 2 + 1)] + (A[(seg * 2 + 2)] * Az[s[(seg * 2 + 1)]]) +
(B[(seg * 2 + 2)] * Az[s[(seg * 2 + 1)] + 1])) %
m;
B[seg] = (B[(seg * 2 + 1)] + (A[(seg * 2 + 2)] * Bz[s[(seg * 2 + 1)]]) +
(B[(seg * 2 + 2)] * Bz[s[(seg * 2 + 1)] + 1])) %
m;
s[seg] = s[(seg * 2 + 1)] + s[(seg * 2 + 2)];
}
void add(int seg, int ls, int rs, int ind, int c) {
if (ind + 1 <= ls or rs <= ind) return;
if (ls == rs - 1) {
s[seg] += c;
(A[seg] += c * x[ind]) %= m;
return;
}
int mid = (ls + rs) >> 1;
add((seg * 2 + 1), ls, mid, ind, c);
add((seg * 2 + 2), mid, rs, ind, c);
update(seg);
}
inline void add(int x, int c) {
cnt[x] += c;
if ((c == +1 and cnt[x] == 1) or (c == -1 and !cnt[x])) add(0, 0, n, x, c);
}
inline void go_to(int ind) {
for (; l != qu[ind].first.first;
l < qu[ind].first.first ? add(b[l++], -1) : add(b[--l], 1))
;
for (; r != qu[ind].first.second;
r > qu[ind].first.second ? add(b[r--], -1) : add(b[++r], 1))
;
ans[qu[ind].second] = (A[0] + B[0]) % m;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", a + i);
scanf("%d", &q);
for (int i = 0; i < q; i++)
scanf("%d%d", &qu[i].first.first, &qu[i].first.second);
for (int i = 0; i < n; i++) x[i] = a[i];
sort(x, x + n);
N = unique(x, x + n) - x;
for (int i = 0; i < n; i++) b[i] = lower_bound(x, x + N, a[i]) - x;
for (int i = 0; i < q; i++) {
qu[i].first.first--;
qu[i].first.second--;
qu[i].second = i;
}
sort(qu, qu + q);
for (int i = 0; i < q; i += sq) sort(qu + i, qu + min(i + sq, q), cmp);
Az[0] = 1;
Bz[1] = 1;
for (int i = 2; i < maxn; i++) {
Az[i] = (Az[i - 1] + Az[i - 2]) % m;
Bz[i] = (Bz[i - 1] + Bz[i - 2]) % m;
}
add(b[0], +1);
for (int i = 0; i < q; i++) go_to(i);
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int Q, B, bel[N];
struct query {
int l, r, id;
bool operator<(const query &R) const {
if (bel[l] != bel[R.l]) return bel[l] < bel[R.l];
if (bel[l] & 1)
return r < R.r;
else
return R.r < r;
}
} q[N];
int n, m, a[N], d[N], D;
int cnt[N], res[N];
int fib[N][2];
struct stree {
int a0, a1;
int s;
} t[N << 1];
inline int id(int l, int r) { return l + r | l != r; }
void pushup(int p, int l, int mid, int r) {
int L = id(l, mid), R = id(mid + 1, r);
t[p].s = t[L].s + t[R].s;
t[p].a0 = (t[L].a0 + fib[t[L].s][0] * t[R].a0 + fib[t[L].s][1] * t[R].a1) % Q;
t[p].a1 =
(t[L].a1 + fib[t[L].s + 1][0] * t[R].a0 + fib[t[L].s + 1][1] * t[R].a1) %
Q;
}
void modify(int l, int r, int x, int w) {
int p = id(l, r);
if (l == r) {
t[p].s = w;
t[p].a0 = t[p].a1 = w * d[x] % Q;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, x, w);
else
modify(mid + 1, r, x, w);
pushup(p, l, mid, r);
}
void add(int i) {
int x = a[i];
if (++cnt[x] == 1) {
modify(0, D, x, 1);
}
}
void del(int i) {
int x = a[i];
if (--cnt[x] == 0) {
modify(0, D, x, 0);
}
}
int main() {
scanf("%d%d", &n, &Q);
B = sqrt(n);
fib[0][0] = 1, fib[1][1] = 1;
for (int i = 2; i <= n; ++i) {
fib[i][0] = (fib[i - 2][0] + fib[i - 1][0]) % Q;
fib[i][1] = (fib[i - 2][1] + fib[i - 1][1]) % Q;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
d[D++] = a[i];
bel[i] = i / B;
}
sort(d, d + D);
D = unique(d, d + D) - d;
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d, d + D, a[i]) - d;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = (query){--x, --y, i};
}
sort(q, q + m);
int l = 0, r = -1;
for (int i = 0; i < m; ++i) {
while (r < q[i].r) {
add(++r);
}
while (l > q[i].l) {
add(--l);
}
while (r > q[i].r) {
del(r--);
}
while (l < q[i].l) {
del(l++);
}
res[q[i].id] = t[id(0, D)].a0 % Q;
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int neg = 1, num = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') neg = -1;
for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
return neg * num;
}
struct node {
int id, val;
} a[30100];
int n, m, l[30100], r[30100], Max[30100], f[30100], now[30100];
long long ans[30100];
inline bool cmp(node x, node y) { return x.val < y.val; }
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i].val = read(), a[i].id = i;
sort(a + 1, a + n + 1, cmp);
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
int q = read();
for (int i = 1; i <= q; i++) {
l[i] = read();
r[i] = read();
Max[i] = -1;
}
for (int i = 1; i <= n; i++) {
int x = a[i].val % m;
for (int j = 1; j <= q; j++) {
if (a[i].id >= l[j] && a[i].id <= r[j] && a[i].val != Max[j]) {
Max[j] = a[i].val;
ans[j] += f[++now[j]] * x;
}
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i] % m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int Q, B;
struct query {
int l, r, id;
bool operator<(const query &R) const {
int i = l / B, j = R.l / B;
if (i != j) return i < j;
if (i & 1)
return r < R.r;
else
return R.r < r;
}
} q[N];
int n, m, a[N], d[N], D;
int cnt[N], res[N];
int fib[N][2];
struct stree {
int a0, a1;
int s;
} t[N << 1];
inline int id(int l, int r) { return l + r | l != r; }
void pushup(int p, int l, int mid, int r) {
int L = id(l, mid), R = id(mid + 1, r);
t[p].s = t[L].s + t[R].s;
t[p].a0 = (t[L].a0 + fib[t[L].s][0] * t[R].a0 + fib[t[L].s][1] * t[R].a1) % Q;
t[p].a1 =
(t[L].a1 + fib[t[L].s + 1][0] * t[R].a0 + fib[t[L].s + 1][1] * t[R].a1) %
Q;
}
void modify(int l, int r, int x, int w) {
int p = id(l, r);
if (l == r) {
t[p].s = w;
t[p].a0 = t[p].a1 = w * d[x] % Q;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, x, w);
else
modify(mid + 1, r, x, w);
pushup(p, l, mid, r);
}
void add(int i) {
int x = a[i];
if (++cnt[x] == 1) {
modify(0, D, x, 1);
}
}
void del(int i) {
int x = a[i];
if (--cnt[x] == 0) {
modify(0, D, x, 0);
}
}
int main() {
scanf("%d%d", &n, &Q);
B = sqrt(n);
fib[0][0] = 1, fib[1][1] = 1;
for (int i = 2; i <= n; ++i) {
fib[i][0] = (fib[i - 2][0] + fib[i - 1][0]) % Q;
fib[i][1] = (fib[i - 2][1] + fib[i - 1][1]) % Q;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
d[D++] = a[i];
}
sort(d, d + D);
D = unique(d, d + D) - d;
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d, d + D, a[i]) - d;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = (query){--x, --y, i};
}
sort(q, q + m);
int l = 0, r = -1;
for (int i = 0; i < m; ++i) {
while (r < q[i].r) {
add(++r);
}
while (l > q[i].l) {
add(--l);
}
while (r > q[i].r) {
del(r--);
}
while (l < q[i].l) {
del(l++);
}
res[q[i].id] = t[id(0, D)].a0 % Q;
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
int gcd(int x, int y) {
while (y) {
int t = x % y;
x = y;
y = t;
}
return x;
}
int ans[30010], fib[30010], blo[30010];
struct query {
int l, r, id;
query() {}
query(int l, int r, int id) : l(l), r(r), id(id) {}
friend bool operator<(const query &a, const query &b) {
return blo[a.l] == blo[b.l] ? (blo[a.l] & 1 ? a.r > b.r : a.r < b.r)
: a.l < b.l;
}
};
query q[30010];
int s1[30010 << 2], s0[30010 << 2], sz[30010 << 2], cnt[30010];
vector<int> v;
int n, m, Q, a[30010];
void push_up(int rt) {
sz[rt] = sz[(rt << 1)], s1[rt] = s1[(rt << 1)], s0[rt] = s0[(rt << 1)];
(s0[rt] += s0[((rt << 1) | 1)] * fib[sz[(rt << 1)] + 1] +
s1[((rt << 1) | 1)] * fib[sz[(rt << 1)]]) %= m;
if (sz[(rt << 1)])
(s1[rt] += s0[((rt << 1) | 1)] * fib[sz[(rt << 1)]] +
s1[((rt << 1) | 1)] * fib[sz[(rt << 1)] - 1]) %= m;
else
s1[rt] = s1[((rt << 1) | 1)];
sz[rt] += sz[((rt << 1) | 1)];
}
void update(int x, int val, int ll, int rr, int rt) {
if (ll == rr) {
(s1[rt] += val * v[x - 1]) %= m;
(s0[rt] += val * v[x - 1]) %= m;
sz[rt] += val;
return;
}
if (x <= ((ll + rr) / 2))
update(x, val, ll, ((ll + rr) / 2), (rt << 1));
else
update(x, val, ((ll + rr) / 2) + 1, rr, ((rt << 1) | 1));
push_up(rt);
}
void add(int x) {
if (!cnt[a[x]]++) update(a[x], 1, 1, n, 1);
}
void del(int x) {
if (!--cnt[a[x]]) update(a[x], -1, 1, n, 1);
}
int main() {
scanf("%d%d", &n, &m);
fib[0] = 0, fib[1] = 1;
for (int i = 2; i <= n; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
for (int i = 0; i <= n; i++) blo[i] = i / 200;
v.clear();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), v.push_back(a[i]);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 1; i <= n; i++)
a[i] = 1 + lower_bound(v.begin(), v.end(), a[i]) - v.begin();
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int l, r;
scanf("%d%d", &l, &r);
q[i] = query(l, r, i);
}
sort(q, q + Q);
int l = 1, r = 1;
add(1);
for (int i = 0; i < Q; i++) {
while (r < q[i].r) add(++r);
while (l > q[i].l) add(--l);
while (r > q[i].r) del(r--);
while (l < q[i].l) del(l++);
ans[q[i].id] = s1[1];
}
for (int i = 0; i < Q; i++) printf("%d\n", (ans[i] + m) % m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 15;
const int SQRT = 185;
int M;
int gmod(int x) { return x % M; }
int add(int x, int y) { return (gmod(x) + gmod(y)) % M; }
int mult(int x, int y) { return gmod(x) * gmod(y) % M; }
int N, A[MAXN];
vector<int> vals;
int ind[MAXN];
int Q;
vector<pair<pair<int, int>, int>> qu[SQRT];
int ans[MAXN];
int F[2 * MAXN];
int gfib(int a, int b, int k) {
return add(mult(a, F[abs(k - 1)]), mult(b, F[k]));
}
struct node {
int size;
int sum0, sum1;
node() { size = sum0 = sum1 = 0; }
node(int su0, int su1, int sz) {
size = sz;
sum0 = su0;
sum1 = su1;
}
};
node operator+(node n1, node n2) {
return node(add(n1.sum0, gfib(n2.sum0, n2.sum1, n1.size)),
add(n1.sum1, gfib(n2.sum0, n2.sum1, n1.size + 1)),
n1.size + n2.size);
}
struct segtree {
node tree[2 * MAXN];
void update(int x) {
int v = gmod(vals[x]);
x += MAXN;
tree[x].sum1 = (tree[x].size ^= 1) * v;
while (x /= 2) {
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
} seg;
int nocc[MAXN];
void add(int x) {
if ((nocc[ind[x]]++) == 0) {
seg.update(ind[x]);
}
}
void rem(int x) {
if ((--nocc[ind[x]]) == 0) {
seg.update(ind[x]);
}
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
vals.push_back(A[i]);
}
sort((vals).begin(), (vals).end());
vals.resize(unique((vals).begin(), (vals).end()) - vals.begin());
for (int i = 0; i < N; i++) {
ind[i] = lower_bound((vals).begin(), (vals).end(), A[i]) - vals.begin();
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int lt, rt;
scanf("%d %d", <, &rt);
lt--;
qu[lt / SQRT].push_back(make_pair(pair<int, int>(rt, lt), i));
}
F[1] = 1;
for (int i = 2; i < 2 * MAXN; i++) {
F[i] = add(F[i - 1], F[i - 2]);
}
for (int i = 0; i < SQRT; i++) {
auto &vq = qu[i];
if (vq.empty()) {
continue;
}
fill_n(nocc, vals.size(), 0);
memset((seg.tree), (0), sizeof(seg.tree));
int lt = i * SQRT, rt = lt;
sort((vq).begin(), (vq).end());
for (auto p : vq) {
while (rt < p.first.first) {
add(rt++);
}
while (lt > p.first.second) {
add(--lt);
}
while (lt < p.first.second) {
rem(lt++);
}
ans[p.second] = seg.tree[1].sum1;
}
}
for (int i = 0; i < Q; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30005;
const int inf = 0x3f3f3f3f;
int mod;
int a[maxn], w[maxn], ans[maxn];
int cnt[maxn], tot;
int fib[maxn];
struct qNode {
int l, r, id, part;
bool operator<(const qNode &x) const {
if (part == x.part) return r < x.r;
return part < x.part;
}
} q[maxn];
struct TNode {
long long pre;
long long now;
int sz;
} tree[maxn * 4];
void pushup(int p) {
int ls = p * 2, rs = p * 2 + 1;
int k = tree[ls].sz;
tree[p].sz = tree[ls].sz + tree[rs].sz;
tree[p].pre = tree[ls].pre + tree[rs].pre * (k > 0 ? fib[k - 1] : 1) +
tree[rs].now * fib[k];
tree[p].pre %= mod;
tree[p].now =
tree[ls].now + tree[rs].pre * fib[k] + tree[rs].now * fib[k + 1];
tree[p].now %= mod;
}
void build(int p, int l, int r) {
if (l == r)
tree[p] = TNode{0, 0, 0};
else {
int mid = (l + r) >> 1;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
tree[p] = TNode{0, 0, 0};
}
}
void update(int p, int l, int r, int id, int v) {
if (l == r) {
tree[p].now += v * w[id];
tree[p].sz += v;
return;
}
int mid = (l + r) >> 1;
if (id <= mid) update(p * 2, l, mid, id, v);
if (id > mid) update(p * 2 + 1, mid + 1, r, id, v);
pushup(p);
}
void modify(int idx, int v) {
int x = a[idx];
cnt[x] += v;
if (cnt[x] == 1 && v == 1) {
update(1, 1, tot, x, 1);
}
if (cnt[x] == 0) {
update(1, 1, tot, x, -1);
}
}
int main() {
int n;
scanf("%d%d", &n, &mod);
map<int, int> rak;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
rak[a[i]] = 1;
}
tot = 0;
for (auto it : rak) {
rak[it.first] = ++tot;
w[tot] = it.first;
}
for (int i = 1; i <= n; i++) {
a[i] = rak[a[i]];
}
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i <= tot + 1; i++) {
fib[i] = (fib[i - 2] + fib[i - 1]) % mod;
}
int qCase;
scanf("%d", &qCase);
int block = sqrt(n);
for (int i = 1; i <= qCase; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
q[i].part = (q[i].l - 1) / block + 1;
}
sort(q + 1, q + 1 + qCase);
int l = 1, r = 0;
build(1, 1, tot);
for (int i = 1; i <= qCase; i++) {
while (l > q[i].l) modify(--l, 1);
while (r < q[i].r) modify(++r, 1);
while (l < q[i].l) modify(l++, -1);
while (r > q[i].r) modify(r--, -1);
ans[q[i].id] = tree[1].now;
}
for (int i = 1; i <= qCase; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30005;
const int MAXSQRT = 175;
const int MAXSEG = 1 << 16;
int N, M, Q, sz = 0;
int A[MAXN];
map<int, int> mp;
int B[MAXN];
pair<pair<int, int>, int> q[MAXN];
int seg[MAXSEG][2];
int lazy[MAXSEG];
int ans[MAXN];
int F[MAXN];
int occ[MAXN];
int BIT[MAXN];
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first / MAXSQRT == b.first.first / MAXSQRT)
return a.first.second < b.first.second;
return a.first.first / MAXSQRT < b.first.first / MAXSQRT;
}
inline void add(int idx, int val) {
for (; idx <= sz; idx += idx & -idx) BIT[idx] += val;
}
inline int get(int idx) {
int ret = 0;
for (; idx > 0; idx -= idx & -idx) ret += BIT[idx];
return ret;
}
inline void shift_up(int node, int n) {
int x = seg[node][0], y = seg[node][1];
seg[node][0] = (F[n + 1] * x + F[n] * y) % M;
seg[node][1] = (F[n] * x + F[n - 1] * y) % M;
}
inline void shift_down(int node, int n) {
int x = seg[node][0], y = seg[node][1];
int s = (n % 2 == 0) ? 1 : -1;
seg[node][0] = (s * F[n - 1] * x - s * F[n] * y) % M;
seg[node][1] = (-s * F[n] * x + s * F[n + 1] * y) % M;
}
inline void down(int node) {
if (lazy[node] > 0) {
shift_up(2 * node, lazy[node]);
shift_up(2 * node + 1, lazy[node]);
lazy[2 * node] += lazy[node];
lazy[2 * node + 1] += lazy[node];
lazy[node] = 0;
} else if (lazy[node] < 0) {
shift_down(2 * node, -lazy[node]);
shift_down(2 * node + 1, -lazy[node]);
lazy[2 * node] += lazy[node];
lazy[2 * node + 1] += lazy[node];
lazy[node] = 0;
}
}
void update(int node, int left, int right, int ql, int qr, bool go_up) {
if (ql <= left && right <= qr) {
if (go_up) {
shift_up(node, 1);
lazy[node]++;
} else {
shift_down(node, 1);
lazy[node]--;
}
return;
}
down(node);
int mid = (left + right) / 2;
if (ql <= mid) update(2 * node, left, mid, ql, qr, go_up);
if (mid + 1 <= qr) update(2 * node + 1, mid + 1, right, ql, qr, go_up);
seg[node][0] = (seg[2 * node][0] + seg[2 * node + 1][0]) % M;
seg[node][1] = (seg[2 * node][1] + seg[2 * node + 1][1]) % M;
}
void point_update(int node, int left, int right, int idx, int val0, int val1) {
if (left == idx && idx == right) {
seg[node][0] = val0;
seg[node][1] = val1;
return;
}
down(node);
int mid = (left + right) / 2;
if (idx <= mid)
point_update(2 * node, left, mid, idx, val0, val1);
else
point_update(2 * node + 1, mid + 1, right, idx, val0, val1);
seg[node][0] = (seg[2 * node][0] + seg[2 * node + 1][0]) % M;
seg[node][1] = (seg[2 * node][1] + seg[2 * node + 1][1]) % M;
}
inline void go(int idx, int sign) {
occ[B[idx]] += sign;
if (sign == 1 && occ[B[idx]] == 1) {
if (B[idx] != sz) update(1, 1, sz, B[idx] + 1, sz, true);
int order = get(B[idx]) + 1;
point_update(1, 1, sz, B[idx], 1LL * F[order] * A[idx] % M,
1LL * F[order - 1] * A[idx] % M);
add(B[idx], 1);
} else if (sign == -1 && occ[B[idx]] == 0) {
if (B[idx] != sz) update(1, 1, sz, B[idx] + 1, sz, false);
point_update(1, 1, sz, B[idx], 0, 0);
add(B[idx], -1);
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
mp[A[i]] = 1;
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
scanf("%d %d", &q[i].first.first, &q[i].first.second);
q[i].second = i;
}
sort(q, q + Q, cmp);
F[1] = F[2] = 1 % M;
for (int i = 3; i < MAXN; i++) F[i] = (F[i - 1] + F[i - 2]) % M;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)
it->second = ++sz;
for (int i = 1; i <= N; i++) B[i] = mp[A[i]];
int curl = q[0].first.first, curr = q[0].first.first - 1;
for (int i = 0; i < Q; i++) {
int ql = q[i].first.first, qr = q[i].first.second;
while (curl < ql) go(curl++, -1);
while (curl > ql) go(--curl, 1);
while (curr < qr) go(++curr, 1);
while (curr > qr) go(curr--, -1);
ans[q[i].second] = seg[1][0];
}
for (int i = 0; i < Q; i++) {
if (ans[i] < 0) ans[i] += M;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int T = 30033;
int N, q, mod;
vector<bitset<T> > v(2 * T);
bitset<T> get(int l, int r) {
bitset<T> ret;
for (l += N, r += N; l < r; l /= 2, r /= 2) {
if (l & 1) ret |= v[l++];
if (r & 1) ret |= v[--r];
}
return ret;
}
int num[T], fib[T];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d", &N, &mod);
map<int, vector<int> > mp;
for (int i = (0); i < (N); i++) {
int k;
scanf("%d", &k);
mp[k].push_back(i);
}
int a = 0, mx = mp.size();
for (auto it = mp.begin(); it != mp.end(); it++) {
for (int i : it->second) v[N + i][a] = 1;
num[a++] = (it->first) % mod;
}
for (int i = N; i-- > 0;) v[i] = v[2 * i] | v[(2 * i) ^ 1];
fib[0] = fib[1] = 1;
for (int i = (2); i < (T); i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
scanf("%d", &q);
vector<pair<int, int> > que(q);
vector<int> Ans(q);
for (int i = (0); i < (q); i++) {
scanf("%d%d", &(que[i].first), &(que[i].second));
que[i].first--;
}
for (int i = (0); i < (q); i++) {
bitset<T> b = get(que[i].first, que[i].second);
int c = 0;
uint64_t ans = 0;
for (int j = 0; j < mx;) {
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
ans += b[j] * fib[c] * num[j];
c += b[j++];
}
Ans[i] = ans % mod;
}
for (int i = (0); i < (q); i++) printf("%d\n", Ans[i]);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.