text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100020;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int pow(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = ((res) * (x));
res %= N;
y = y >> 1;
x = ((x) * (x));
}
return res;
}
int powm(int x, int y, int p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int power(long long int a, long long int b) {
if (b == 1) return a;
if (b == 0) return 1;
long long int m1 = power(a, b / 2);
if (b % 2) return m1 * m1 * a;
return m1 * m1;
}
void codeit() {
long long x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
long double d1, d2, d3;
d1 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
d2 = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
d3 = sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));
if ((long long)(x2 - x1) * (y3 - y1) == (long long)(y2 - y1) * (x3 - x1)) {
cout << "No";
return;
}
if (d1 == d2) {
cout << "Yes" << '\n';
return;
} else {
cout << "No" << '\n';
return;
}
return;
}
int main() {
long long int tt;
tt = 1;
for (int i = 0; i < tt; i++) codeit();
}
|
#include <bits/stdc++.h>
using namespace std;
double ax, ay, bx, by, cx, cy;
int main() {
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (bx == (ax + cx) / 2 && by == (ay + cy) / 2) {
cout << "No" << endl;
return 0;
}
double d_ab, d_cb;
d_ab = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
d_cb = (cx - bx) * (cx - bx) + (cy - by) * (cy - by);
if (d_ab == d_cb)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a1, b1, a2, b2, a3, b3;
cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3;
if ((b2 - b1) * (a3 - a2) == (b3 - b2) * (a2 - a1))
cout << "NO";
else {
if (((a2 - a1) * (a2 - a1) + (b2 - b1) * (b2 - b1)) ==
((a3 - a2) * (a3 - a2) + (b3 - b2) * (b3 - b2)))
cout << "YES";
else
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((pow(ax - bx, 2) + pow(ay - by, 2)) ==
(pow(cx - bx, 2) + pow(cy - by, 2))) {
double k1, k2;
if (ay == by) {
k2 = (cy - by) * 1.0 / (cx - bx);
if (k2 != 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else if (by == cy) {
k1 = (by - ay) * 1.0 / (bx - ax);
if (k1 != 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else if (ay != by && by != cy) {
k1 = (by - ay) * 1.0 / (bx - ax);
k2 = (cy - by) * 1.0 / (cx - bx);
if (k1 == k2) {
cout << "No" << endl;
} else
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
;
long double x1, x2, x3, y1, y2, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
long double x = (y2 - y1) / (x2 - x1);
long double y = (y3 - y2) / (x3 - x2);
long double d1 = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
long double d2 = sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2));
if (d1 != d2 || x == y) {
return cout << "NO", 0;
}
cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
int num[1000005];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
long long int ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
long long int aa = abs(ax - bx) * abs(ax - bx) + abs(ay - by) * abs(ay - by);
long long int bb = abs(cx - bx) * abs(cx - bx) + abs(cy - by) * abs(cy - by);
if (aa == bb) {
if (ax != bx && bx != cx) {
double ma = double(ay - by) / double(ax - bx);
double mb = double(by - cy) / double(bx - cx);
if (ma == mb)
cout << "NO\n";
else
cout << "YES\n";
} else {
if (ax == bx && bx == cx)
cout << "NO\n";
else
cout << "YES\n";
}
} else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long xa, xb, ya, yb, za, zb;
int main() {
ios_base::sync_with_stdio(false);
cin >> xa >> xb >> ya >> yb >> za >> zb;
long long x1 = (xa - ya) * (xa - ya) + (xb - yb) * (xb - yb);
long long x2 = (ya - za) * (ya - za) + (yb - zb) * (yb - zb);
long long y2 = (xa - za) * (xa - za) + (xb - zb) * (xb - zb);
;
if (x1 == x2 && (za - ya != ya - xa || zb - yb != yb - xb))
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f;
int main() {
cin >> a >> b >> c >> d >> e >> f;
if ((f - d) * (c - a) == (d - b) * (e - c)) {
cout << "NO" << endl;
return 0;
}
if ((d - b) * (d - b) + (c - a) * (c - a) ==
(f - d) * (f - d) + (e - c) * (e - c)) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 1000020;
double m(double ax, double ay, double bx, double by) {
if (ax - bx == 0) return 1.0;
return (by - ay) / (bx - ax);
}
double d(long long ax, long long ay, long long bx, long long by) {
return (ax - bx) * (ax - bx) + (by - ay) * (by - ay);
}
double const EPS = 1e-12;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (fabs(m(ax, ay, bx, by) - m(bx, by, cx, cy)) > EPS and
d(ax, ay, bx, by) == d(bx, by, cx, cy))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
long long ax, ay, bx, by, cx, cy;
std::cin >> ax >> ay >> bx >> by >> cx >> cy;
long long a = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
long long c = (cx - bx) * (cx - bx) + (cy - by) * (cy - by);
double k0 = (double)(ay - by) / (ax - bx);
double k1 = (double)(ay - cy) / (ax - cx);
if (a == c && k0 != k1)
std::cout << "Yes" << std::endl;
else
std::cout << "No" << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
long long readin() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
using namespace std;
int main() {
long long i, j;
long long n;
long long a1 = readin(), a2 = readin(), b1 = readin(), b2 = readin(),
c1 = readin(), c2 = readin();
long long guapi1, guapi2, guapi3, guapi4;
guapi1 = b1 - a1;
guapi2 = b2 - a2;
guapi3 = c1 - b1;
guapi4 = c2 - b2;
if (guapi2 == guapi4 && guapi1 == guapi3) {
cout << "NO";
return 0;
}
if ((guapi1 * guapi1 + guapi2 * guapi2) ==
(guapi3 * guapi3 + guapi4 * guapi4)) {
cout << "YES";
} else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double a, b, x, y, v, res, mi = 0.0000000001, t1, t2, c, d, vpr;
long double xb, yb, xc, yc;
int n, i, j, k, p = 0;
cin >> c >> d >> a >> b >> x >> y;
t1 = sqrt((x - a) * (x - a) + (y - b) * (y - b));
t2 = sqrt((c - a) * (c - a) + (d - b) * (d - b));
xb = a - c;
yb = b - d;
xc = x - c;
yc = y - d;
vpr = xb * yc - yb * xc;
if (abs(t1 - t2) <= mi && abs(vpr) > mi)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MAXN = 1e6;
const long long POLTOS = 50;
const long long SOTKA = 100;
const long long P = 1e9 + 7;
const long double pi = 3.141592653589793238462643383279;
const long double eps = 1e-7;
const long double base = 1e9 + 7;
struct point {
long long x, y;
};
struct vect {
long long x, y;
};
struct line {
long long a, b, c;
};
line get_line(point, point);
long double dot_product(vect, vect);
long double vec_len(vect);
vect get_vector(point, point);
long double angle(vect, vect);
long double cross_product(vect, vect);
long double dpline(point, line);
long double is_point_in_sector(point, point, point);
long double area_of_sector(long long, point[]);
long double vec_point_len(long double, long double, long double, long double);
bool is_point_in_line(point, line);
void w_arr(vector<long long>);
void w_matrix(vector<vector<long long> >);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
point a, b, c;
cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
vect x = get_vector(a, b), y = get_vector(b, c);
line n = get_line(a, c);
cout << (vec_point_len(a.x, a.y, b.x, b.y) !=
vec_point_len(b.x, b.y, c.x, c.y) ||
((c.x - b.x) * (b.y - a.y) == (c.y - b.y) * (b.x - a.x))
? "NO"
: "YES");
return 0;
}
bool is_point_in_line(point a, line n) {
return n.a * a.x + n.b * a.y + n.c == 0;
}
long double area_tr(long double a, long double b, long double c) {
long double p = (a + b + c) / 2;
return sqrt(abs(p) * abs(p - a) * abs(p - b) * abs(p - c));
}
long double vec_point_len(long double a, long double a1, long double b,
long double b1) {
return sqrt((a - b) * (a - b) + (a1 - b1) * (a1 - b1));
}
long double area_of_sector(long long n, point a[]) {
long double sum = 0;
for (long long i = 0; i < n; i++)
sum += (a[i].y + a[i + 1].y) * (a[i + 1].x - a[i].x);
return sum / 2;
}
line get_line(point a, point b) {
line k;
k.a = b.y - a.y;
k.b = a.x - b.x;
k.c = -k.a * a.x - k.b * a.y;
return k;
}
long double dot_product(vect a, vect b) { return a.x * b.x + a.y * b.y; }
long double vec_len(vect v) { return sqrt(v.x * v.x + v.y * v.y); }
vect get_vector(point a, point b) {
vect q;
q.x = b.x - a.x;
q.y = b.y - a.y;
return q;
}
long double angle(vect v, vect vi) {
return atan2(cross_product(v, vi), dot_product(v, vi));
}
long double cross_product(vect a, vect b) { return a.x * b.y - b.x * a.y; }
long double dpline(point p, line n) { return abs(n.a * p.x + n.b * p.y + n.c); }
long double is_point_in_sector(point p, point p1, point p2) {
vect v, v1, v2, v3;
line n = get_line(p1, p2);
v = get_vector(p1, p);
v1 = get_vector(p2, p);
v2 = get_vector(p, p2);
v3 = get_vector(p2, p1);
if (dot_product(v, v2) >= 0 && dot_product(v1, v3) >= 0)
return dpline(p, n);
else if (dot_product(v1, v3) < 0)
return vec_len(v1);
else if (dot_product(v, v2))
return vec_len(v);
}
void w_arr(vector<long long> f) {
for (long long i = 0; i < f.size(); i++) cout << f[i] << ' ';
cout << endl;
return;
}
void w_matrix(vector<vector<long long> > f) {
for (long long i = 0; i < f.size(); i++) {
for (long long j = 0; j < f[i].size(); j++) cout << f[i][j] << ' ';
cout << endl;
}
return;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(long long a) { return a * a; }
int main() {
long long ax, ay, bx, by, cx, cy;
scanf("%I64d%I64d%I64d%I64d%I64d%I64d", &ax, &ay, &bx, &by, &cx, &cy);
bool hasAns = false;
if (pow(ax - bx) + pow(ay - by) == pow(bx - cx) + pow(by - cy)) hasAns = true;
long long x1 = ax - bx, y1 = ay - by;
long long x2 = bx - cx, y2 = by - cy;
if (x2 * y1 == x1 * y2) hasAns = false;
if (hasAns)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ax, ay, bx, by, cx, cy;
int main() {
cin >> ax >> ay >> bx >> by >> cx >> cy;
long long ff1 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
long long ff2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy);
if ((bx - ax) * (cy - by) == (cx - bx) * (by - ay))
printf("NO\n");
else if (ff1 == ff2)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
long long a = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
long long b = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
long long c = (x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2);
bool p = 0;
if ((x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3) != 0) {
if (a == c) p = 1;
}
if (p)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (((ax - bx) * (ax - bx) + (ay - by) * (ay - by)) ==
((cx - bx) * (cx - bx) + (cy - by) * (cy - by)) &&
(ay - by) * (cx - bx) != (cy - by) * (ax - bx))
cout << "Yes" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ax, ay, bx, by, cx, cy, d1, d2;
cin >> ax >> ay >> bx >> by >> cx >> cy;
float s1, s2;
if ((by - ay) * (cx - bx) == (cy - by) * (bx - ax)) {
cout << "No";
} else {
d1 = (((bx - ax) * (bx - ax)) + ((by - ay) * (by - ay)));
d2 = (((cx - bx) * (cx - bx)) + ((cy - by) * (cy - by)));
if (d1 == d2)
cout << "Yes";
else
cout << "No";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long mod = 1e6 + 7;
const long eps = 1e-10;
const long long oo = 1e9;
const long maxn = 2500;
const long maxm = 20000;
const double pi = atan(1) * 4;
inline long gcd(long a, long b) {
long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long lcm(long a, long b) { return a / gcd(a, b) * b; }
inline void swap(long long &a, long long &b) {
long long tmp = a;
a = b;
b = tmp;
}
long long ax, ay, bx, by, cx, cy;
void fileio() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> ax >> ay >> bx >> by >> cx >> cy;
double sideAB = sqrt(pow(bx - ax, 2) + pow(by - ay, 2));
double sideCB = sqrt(pow(bx - cx, 2) + pow(by - cy, 2));
double sideAC = sqrt(pow(cx - ax, 2) + pow(cy - ay, 2));
if (sideAB + sideAC > sideCB and sideAB + sideCB > sideAC and
sideAC + sideCB > sideAB) {
if (fabs(sideAB - sideCB) <= eps)
cout << "Yes";
else
cout << "No";
return 0;
}
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000000 + 7;
const double eps = 1e-9;
const int inf = 0x3f3f3f3f;
const long long infl = 10000000000000000;
const int maxn = 100000 + 10;
const int maxm = 200000 + 10;
int in(int &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return -1;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
long long dis(int x1, int y1, int x2, int y2) {
long long x = 1.0 * x1 - x2;
long long y = 1.0 * y1 - y2;
return x * x + y * y;
}
int main() {
int x1, y1, x2, y2, x3, y3;
scanf("%d%d", &x1, &y1);
scanf("%d%d", &x2, &y2);
scanf("%d%d", &x3, &y3);
long long disa = dis(x1, y1, x2, y2);
long long disb = dis(x2, y2, x3, y3);
bool ok = 1;
if (disa != disb) ok = 0;
double k = 1.0 * (y1 - y2) / (x1 - x2);
double ny = 1.0 * y1 + (x3 - x1) * k;
if (x1 != x2) {
if (fabs(ny - 1.0 * y3) < eps) ok = 0;
} else {
if (x1 == x2 && x2 == x3) ok = 0;
}
puts(ok ? "Yes" : "No");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b > 0) {
int k = b;
b = a % b;
a = k;
}
return a;
}
int main() {
double ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (((ay - by) / (ax - bx)) == ((by - cy) / (bx - cx))) {
cout << "No";
} else {
if ((pow(ax - bx, 2) + pow(ay - by, 2)) ==
(pow(cx - bx, 2) + pow(cy - by, 2))) {
cout << "Yes";
} else
cout << "No";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dis(int x1, int x2, int y1, int y2) {
return (long long)(x1 - x2) * (x1 - x2) + (long long)(y1 - y2) * (y1 - y2);
}
int main() {
int ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((long long)(by - ay) * (cx - bx) == (long long)(bx - ax) * (cy - by))
cout << "NO" << endl;
else {
long long d1 = dis(ax, bx, ay, by);
long long d2 = dis(bx, cx, by, cy);
if (abs(d1 - d2) < 1e-9)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 5e3 + 5;
long long power(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
if (ret >= MOD) ret %= MOD;
if (a >= MOD) a %= MOD;
b >>= 1;
}
return ret;
}
long long invmod(long long x) { return power(x, MOD - 2); }
int32_t main() {
long long a[4], b[4];
for (long long i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
}
double x = (double)sqrt((a[1] - a[0]) * (a[1] - a[0]) +
(b[1] - b[0]) * (b[1] - b[0]));
double y = (double)sqrt((a[1] - a[2]) * (a[1] - a[2]) +
(b[1] - b[2]) * (b[1] - b[2]));
double z = (double)sqrt((a[2] - a[0]) * (a[2] - a[0]) +
(b[2] - b[0]) * (b[2] - b[0]));
if (x + y > z && y + z > x && x + z > y && x == y) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long xa, xb, xc, ya, yb, yc;
int main() {
cin >> xa >> ya >> xb >> yb >> xc >> yc;
if (xc + xa == 2 * xb && ya + yc == 2 * yb)
cout << "No";
else if ((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb) ==
(xc - xb) * (xc - xb) + (yc - yb) * (yc - yb))
cout << "Yes";
else
cout << "No";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long double ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((by - ay) / (bx - ax) != (cy - by) / (cx - bx) &&
(by - ay) * (by - ay) + (bx - ax) * (bx - ax) ==
(cy - by) * (cy - by) + (cx - bx) * (cx - bx)) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int orientation(long long ax, long long ay, long long bx, long long by,
long long cx, long long cy) {
long long val = (by - ay) * (cx - bx) - (bx - ax) * (cy - by);
if (val == 0) return 0;
return (val > 0) ? 1 : 2;
}
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (orientation(ax, ay, bx, by, cx, cy) == 0) {
printf("No\n");
return 0;
}
unsigned long long dab = (unsigned long long)((ax - bx) * (ax - bx)) +
(unsigned long long)((ay - by) * (ay - by));
unsigned long long dac = (unsigned long long)((ax - cx) * (ax - cx)) +
(unsigned long long)((ay - cy) * (ay - cy));
unsigned long long dbc = (unsigned long long)((cx - bx) * (cx - bx)) +
(unsigned long long)((cy - by) * (cy - by));
if (dab == dbc) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int main(int argc, char const *argv[]) {
long long a1, a2, b1, b2, c1, c2;
std::cin >> a1 >> a2 >> b1 >> b2 >> c1 >> c2;
long long d1 = (a1 - b1) * (a1 - b1) + (a2 - b2) * (a2 - b2);
long long d2 = (c1 - b1) * (c1 - b1) + (c2 - b2) * (c2 - b2);
long long s11 = (a1 - b1);
long long s12 = (a2 - b2);
long long s21 = (c1 - b1);
long long s22 = (c2 - b2);
if (d1 == d2 && s11 * s22 != s12 * s21)
std::cout << "Yes" << std::endl;
else
std::cout << "No" << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7FFFFFFF;
struct prioritycom {
bool operator()(const int& l, const int& r) { return l < r; }
};
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T bigmod(T n, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T t = bigmod(n, p / 2, m);
return (t * t) % m;
}
return (bigmod(n, p - 1, m) * n) % m;
}
template <class string>
long long int strton(string s) {
long long int won;
stringstream ss;
ss << s;
ss >> won;
return won;
}
template <class T>
string ntostr(T n) {
stringstream ss;
ss << n;
return ss.str();
}
template <class T>
inline T mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
bool isprime(T n) {
if (n % 2 == 0) {
if (n == 2)
return true;
else
return false;
}
T m = sqrt(n);
for (T i = 3; i <= m; i += 2) {
if (n % i == 0) return false;
}
return true;
}
bool isvowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isconsonant(char ch) {
if (isalpha(ch) && !isvowel(ch)) return true;
return false;
}
struct {
long long int x, y;
} pts[5];
bool sameline(long long int p, long long int q, long long int r) {
return (pts[p].y - pts[q].y) * (pts[q].x - pts[r].x) ==
(pts[q].y - pts[r].y) * (pts[p].x - pts[q].x);
}
int main() {
scanf("%lld%lld%lld%lld%lld%lld", &pts[1].x, &pts[1].y, &pts[2].x, &pts[2].y,
&pts[3].x, &pts[3].y);
if (sameline(1, 2, 3))
printf("No\n");
else {
if ((((pts[1].x - pts[2].x) * (pts[1].x - pts[2].x)) +
((pts[1].y - pts[2].y) * (pts[1].y - pts[2].y))) ==
(((pts[2].x - pts[3].x) * (pts[2].x - pts[3].x)) +
((pts[2].y - pts[3].y) * (pts[2].y - pts[3].y))))
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double pi = acos(-1.0);
const int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
long long ax, ay, bx, by, cx, cy;
long long GetDist(long long x, long long y, long long a, long long b) {
return ((x - a) * (x - a) + (y - b) * (y - b));
}
int main() {
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (GetDist(ax, ay, bx, by) == GetDist(bx, by, cx, cy)) {
if (ax == bx && bx == cx)
cout << "No";
else if (ay == by && by == cy)
cout << "No";
else if (ax - bx == bx - cx && ay - by == by - cy)
cout << "No";
else
cout << "Yes";
} else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int lowbit(int x) { return x & (-x); }
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
template <typename A, typename B, typename C>
inline A fpow(A x, B p, C lyd) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % lyd)
if (p & 1) ans = 1LL * x * ans % lyd;
return ans;
}
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T>
inline T max(T x, T y, T z) {
return max(max(x, y), z);
}
template <typename T>
inline T min(T x, T y, T z) {
return min(min(x, y), z);
}
const double pi = acos(-1.0);
const double eps = 1e-8;
const int maxn = 1e6 + 10;
const int maxp = 1010;
const long long INF = 0x3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
inline double sqr(double x) { return x * x; }
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) {
x = _x;
y = _y;
}
void input() { scanf("%lf%lf", &x, &y); }
void output() { printf("%.2f %.2f\n", x, y); }
bool operator==(Point b) const {
return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
}
bool operator<(Point b) const {
return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x;
}
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
double operator^(const Point &b) const { return x * b.y - y * b.x; }
double operator*(const Point &b) const { return x * b.x + y * b.y; }
double len() { return hypot(x, y); }
double len2() { return x * x + y * y; }
double distance(Point p) { return hypot(x - p.x, y - p.y); }
Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
Point operator*(const double &k) const { return Point(x * k, y * k); }
Point operator/(const double &k) const { return Point(x / k, y / k); }
double rad(Point a, Point b) {
Point p = *this;
return fabs(atan2(fabs((a - p) ^ (b - p)), (a - p) * (b - p)));
}
Point trunc(double r) {
double l = len();
if (!sgn(l)) return *this;
r /= l;
return Point(x * r, y * r);
}
Point rotleft() { return Point(-y, x); }
Point rotright() { return Point(y, -x); }
Point rotate(Point p, double angle) {
Point v = (*this) - p;
double c = cos(angle), s = sin(angle);
return Point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
}
};
struct Line {
Point s, e;
Line() {}
Line(Point _s, Point _e) {
s = _s;
e = _e;
}
bool operator==(Line v) { return (s == v.s) && (e == v.e); }
Line(Point p, double angle) {
s = p;
if (sgn(angle - pi / 2) == 0) {
e = (s + Point(0, 1));
} else {
e = (s + Point(1, tan(angle)));
}
}
Line(double a, double b, double c) {
if (sgn(a) == 0) {
s = Point(0, -c / b);
e = Point(1, -c / b);
} else if (sgn(b) == 0) {
s = Point(-c / a, 0);
e = Point(-c / a, 1);
} else {
s = Point(0, -c / b);
e = Point(1, (-c - a) / b);
}
}
void input() {
s.input();
e.input();
}
void adjust() {
if (e < s) swap(s, e);
}
double length() { return s.distance(e); }
double angle() {
double k = atan2(e.y - s.y, e.x - s.x);
if (sgn(k) < 0) k += pi;
if (sgn(k - pi) == 0) k -= pi;
return k;
}
int relation(Point p) {
int c = sgn((p - s) ^ (e - s));
if (c < 0)
return 1;
else if (c > 0)
return 2;
else
return 3;
}
bool pointonseg(Point p) {
return sgn((p - s) ^ (e - s)) == 0 && sgn((p - s) * (p - e)) <= 0;
}
bool parallel(Line v) { return sgn((e - s) ^ (v.e - v.s)) == 0; }
int segcrossseg(Line v) {
int d1 = sgn((e - s) ^ (v.s - s));
int d2 = sgn((e - s) ^ (v.e - s));
int d3 = sgn((v.e - v.s) ^ (s - v.s));
int d4 = sgn((v.e - v.s) ^ (e - v.s));
if ((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
return (d1 == 0 && sgn((v.s - s) * (v.s - e)) <= 0) ||
(d2 == 0 && sgn((v.e - s) * (v.e - e)) <= 0) ||
(d3 == 0 && sgn((s - v.s) * (s - v.e)) <= 0) ||
(d4 == 0 && sgn((e - v.s) * (e - v.e)) <= 0);
}
int linecrossseg(Line v) {
int d1 = sgn((e - s) ^ (v.s - s));
int d2 = sgn((e - s) ^ (v.e - s));
if ((d1 ^ d2) == -2) return 2;
return (d1 == 0 || d2 == 0);
}
int linecrossline(Line v) {
if ((*this).parallel(v)) return v.relation(s) == 3;
return 2;
}
Point crosspoint(Line v) {
double a1 = (v.e - v.s) ^ (s - v.s);
double a2 = (v.e - v.s) ^ (e - v.s);
return Point((s.x * a2 - e.x * a1) / (a2 - a1),
(s.y * a2 - e.y * a1) / (a2 - a1));
}
double dispointtoline(Point p) { return fabs((p - s) ^ (e - s)) / length(); }
double dispointtoseg(Point p) {
if (sgn((p - s) * (e - s)) < 0 || sgn((p - e) * (s - e)) < 0)
return min(p.distance(s), p.distance(e));
return dispointtoline(p);
}
double dissegtoseg(Line v) {
return min(min(dispointtoseg(v.s), dispointtoseg(v.e)),
min(v.dispointtoseg(s), v.dispointtoseg(e)));
}
Point lineprog(Point p) {
return s + (((e - s) * ((e - s) * (p - s))) / ((e - s).len2()));
}
Point symmetrypoint(Point p) {
Point q = lineprog(p);
return Point(2 * q.x - p.x, 2 * q.y - p.y);
}
};
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((bx - ax) * (bx - ax) + (by - ay) * (by - ay) !=
(bx - cx) * (bx - cx) + (by - cy) * (by - cy) ||
(by - ay) * (bx - cx) == (by - cy) * (bx - ax))
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d(long long ax, long long ay, long long bx, long long by) {
long long d = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
return d;
}
int main() {
long long ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
long long ab, ac, bc;
ab = d(ax, ay, bx, by);
bc = d(bx, by, cx, cy);
long double S = 0.5 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
if (0 == S) {
cout << "No" << endl;
} else {
if (ab == bc) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 5;
const int mod = 1e9 + 7;
double ax, ay, bx, by, cx, cy;
double dis(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
while (~scanf("%lf%lf%lf%lf%lf%lf", &ax, &ay, &bx, &by, &cx, &cy)) {
if ((by - ay) / (bx - ax) == (cy - by) / (cx - bx)) {
printf("No\n");
continue;
}
if (dis(ax, ay, bx, by) == dis(bx, by, cx, cy)) {
printf("Yes\n");
} else
printf("No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void inn(long long int &ix) { scanf("%lld", &ix); }
void inn(long long int &ix, long long int &iy) { scanf("%lld%lld", &ix, &iy); }
void inn(int &ix) { scanf("%d", &ix); }
void inn(int &ix, int &iy) { scanf("%d%d", &ix, &iy); }
void inn(long double &ix) { scanf("%Lf", &ix); }
void outt(long long int ix) { printf("%lld", ix); }
void outt(long long int ix, char cx) { printf("%lld%c", ix, cx); }
void outt(int ix) { printf("%d", ix); }
void outt(int ix, char cx) { printf("%d%c", ix, cx); }
void outt(long double ix, char cx) { printf("%.12Lf%c", ix, cx); }
void outt(long double ix) { printf("%.12Lf", ix); }
void outt(pair<long long int, long long int> x) {
cout << '{' << x.first << ',' << x.second << '}' << endl;
}
const int MM = 1200000;
long long int m, n, k, p1, p2, p3, p, f, a[MM];
string s, s1, s2;
long long int isL(long long int Ax, long long int Ay, long long int Bx,
long long int By, long long int Cx, long long int Cy) {
return (Ax * (By - Cy) + Bx * (Cy - Ay) + Cx * (Ay - By));
}
long double eps = 0.000001;
int main() {
long long int t;
long long int x1, x2, x3, y1, y2, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
p1 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
p2 = (x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2);
p = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
if (p1 == p2 && isL(x1, y1, x2, y2, x3, y3) != 0)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
if ((y2 - y1) * (x3 - x2) == (y3 - y2) * (x2 - x1)) {
cout << "No" << endl;
return 0;
}
if ((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) ==
(x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
stack<pair<long long, long long> > q;
long long n, a[N], go[N];
struct cell {
long long max_l, max_r, or_l, or_r;
};
bool d[N][35];
cell b[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
long long q = a[i], k = 1;
while (q != 0) {
d[i][k] = q % 2;
q /= 2;
k++;
}
}
q.push({0, 2e9});
for (long long i = 1; i <= n; i++) {
while (q.top().second <= a[i]) q.pop();
b[i].max_l = q.top().first;
q.push({i, a[i]});
}
while (!q.empty()) q.pop();
q.push({n + 1, 2e9});
for (long long i = n; i > 0; i--) {
while (q.top().second < a[i]) q.pop();
b[i].max_r = q.top().first;
q.push({i, a[i]});
}
while (!q.empty()) q.pop();
for (long long i = 1; i <= n; i++) {
long long k = 0;
for (long long j = 1; j < 35; j++)
if (d[i][j] == 0)
k = max(k, go[j]);
else
go[j] = i;
b[i].or_l = k;
}
for (long long i = 1; i < 35; i++) go[i] = n + 1;
for (long long i = n; i > 0; i--) {
long long k = n + 1;
for (long long j = 1; j < 35; j++)
if (d[i][j] == 0)
k = min(k, go[j]);
else
go[j] = i;
b[i].or_r = k;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (b[i].max_l >= b[i].or_l)
if (b[i].max_r <= b[i].or_r)
continue;
else
ans += (i - b[i].max_l) * (b[i].max_r - b[i].or_r);
else if (b[i].max_r <= b[i].or_r)
ans += (b[i].or_l - b[i].max_l) * (b[i].max_r - i);
else {
ans += (b[i].or_l - b[i].max_l) * (b[i].or_r - i);
ans += (b[i].max_r - b[i].or_r) * (i - b[i].or_l);
ans += (b[i].or_l - b[i].max_l) * (b[i].max_r - b[i].or_r);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> B;
int d[200000][100];
map<pair<int, int>, int> K;
void RMQ_init(const vector<int> &A) {
int n = A.size();
for (int i = 0; i < n; i++) d[i][0] = A[i];
for (int j = 1; (1 << j) <= n; j++)
for (int i = 0; i + (1 << j) - 1 < n; i++)
d[i][j] = max(d[i][j - 1], d[i + (1 << (j - 1))][j - 1]);
}
int RMQ(int L, int R) {
int k = 0;
while ((1 << (k + 1)) <= R - L + 1) k++;
return max(d[L][k], d[R - (1 << k) + 1][k]);
}
int checkst(int low, int high, vector<int> &A, int aim) {
while (low < high) {
int mid = (low + high) / 2 + 1;
if (A[mid] > aim) {
high = mid - 1;
} else {
low = mid;
}
}
return A[low];
}
int checked(int low, int high, vector<int> &A, int aim) {
while (low < high) {
int mid = (low + high) / 2;
if (A[mid] < aim) {
low = mid + 1;
} else {
high = mid;
}
}
return A[low];
}
int checkfrom(int st, int from, int ends) {
while (from < ends) {
int mid = (from + ends) / 2;
if (RMQ(mid, st) <= B[st]) {
ends = mid;
} else {
from = mid + 1;
}
}
return from;
}
int checkbehind(int st, int from, int ends) {
while (from < ends) {
int mid = (from + ends) / 2 + 1;
if (RMQ(st, mid) <= B[st]) {
from = mid;
} else {
ends = mid - 1;
}
}
return from;
}
int main() {
int n;
cin >> n;
vector<int> A[100];
int d;
K.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &d);
B.push_back(d);
}
RMQ_init(B);
for (int i = 0; i < n; i++) {
int c = B[i];
int n = 1;
while (c) {
int v = c % 2;
if (v) {
A[n].push_back(i);
}
n++;
c = c / 2;
}
}
vector<pair<int, int> > D;
for (int i = 0; i < n; i++) {
int from = checkfrom(i, 0, i);
int behind = checkbehind(i, i, n - 1);
D.push_back(make_pair(from, behind));
}
long long sum = 0;
int k = n;
for (int i = 0; i < n; i++) {
int G = B[i];
int n = 1;
int mins = -1;
int maxs = 20000000;
while (G) {
int v = G % 2;
if (v == 0) {
if (A[n].size() > 0) {
int f = checkst(0, A[n].size() - 1, A[n], i);
int e = k - 1;
e = checked(0, A[n].size() - 1, A[n], i);
if (e > i) {
maxs = min(maxs, e);
}
if (f < i) {
mins = max(mins, f);
}
}
}
n++;
G = G / 2;
}
int g = D[i].first;
if (K[make_pair(D[i].first, D[i].second)])
D[i].first = K[make_pair(D[i].first, D[i].second)];
if (maxs == 20000000) {
maxs = D[i].second + 1;
}
if (mins == -1) {
mins = D[i].first - 1;
}
long long fr = 0;
long long be = 0;
if (D[i].first <= mins)
fr = mins - D[i].first + 1;
else
fr = 0;
if (D[i].second >= maxs)
be = D[i].second - maxs + 1;
else
be = 0;
sum =
sum + be * (i - D[i].first + 1) + fr * (D[i].second - i + 1) - fr * be;
K[make_pair(g, D[i].second)] = i + 1;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
map<int, int> q;
int n, m, a[N], p[33], l[N], r[N];
int main() {
cin >> n;
for (int i = 1; i <= int(n); i++) scanf("%d", &a[i]);
for (int i = 0; i <= int(30); i++) p[i] = 0;
for (int i = 1; i <= int(n); i++) {
for (int j = 0; j <= int(30); j++)
if (a[i] >> j & 1)
p[j] = i;
else
l[i] = max(l[i], p[j]);
}
for (int i = 0; i <= int(30); i++) p[i] = n + 1;
for (int i = n; i >= int(1); i--) {
r[i] = n + 1;
for (int j = 0; j <= int(30); j++)
if (a[i] >> j & 1)
p[j] = i;
else
r[i] = min(r[i], p[j]);
if (q.count(a[i])) r[i] = min(q[a[i]], r[i]);
q[a[i]] = i;
}
long long ans = 1LL * n * (n + 1) / 2;
for (int i = 1; i <= int(n); i++) ans -= 1LL * (r[i] - i) * (i - l[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 200005;
long long n;
int a[maxN];
long long l[maxN], r[maxN];
int main(int argc, char** argv) {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
r[i] = n + 1;
}
vector<int> pre;
for (int i = 1; i <= n; i++) {
while (pre.size() && a[pre.back()] < a[i]) pre.pop_back();
if (pre.size()) l[i] = pre.back();
pre.push_back(i);
}
long long last;
for (int i = 0; i <= 30; i++) {
last = 0;
for (int j = 1; j <= n; j++) {
if ((a[j] >> i) & 1)
last = j;
else
l[j] = max(l[j], last);
}
last = n + 1;
for (int j = n; j; j--) {
if ((a[j] >> i) & 1)
last = j;
else
r[j] = min(r[j], last);
}
}
long long ans = n * (n + 1) / 2;
for (int i = 1; i <= n; i++) ans -= (i - l[i]) * (r[i] - i);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, inf = 1e9 + 100;
int tree[4 * N];
int a[N];
int n;
void build(int cn, int b, int e) {
if (b == e) {
tree[cn] = b;
return;
}
int lc = 2 * cn, rc = lc + 1, mid = (b + e) / 2;
build(lc, b, mid);
build(rc, mid + 1, e);
if (a[tree[lc]] > a[tree[rc]])
tree[cn] = tree[lc];
else
tree[cn] = tree[rc];
}
int query(int cn, int b, int e, int i, int j) {
if (b > j or e < i) return 0;
if (b >= i and e <= j) {
return tree[cn];
}
int lc = 2 * cn, rc = lc + 1, mid = (b + e) / 2;
int idx1 = query(lc, b, mid, i, j), idx2 = query(rc, mid + 1, e, i, j);
if (a[idx1] > a[idx2]) return idx1;
return idx2;
}
const int LOG = 20;
int rmq[N][LOG];
int lg[N];
void preprocess() {
for (int i = 1; i <= n; i++) rmq[i][0] = a[i];
for (int j = 1; j < LOG; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << j) - 1 <= n) {
rmq[i][j] = rmq[i][j - 1] | rmq[i + (1 << (j - 1))][j - 1];
} else
break;
}
}
for (int i = 2; i < N; i++) {
lg[i] = lg[i / 2] + 1;
}
}
int query(int i, int j) {
int k = lg[j - i + 1];
int ans = rmq[i][k] | rmq[j - (1 << k) + 1][k];
return ans;
}
long long ans;
void solve(int l, int r) {
if (l > r) return;
int mid = query(1, 1, n, l, r);
solve(l, mid - 1);
solve(mid + 1, r);
int lo = l, hi = mid;
while (hi > lo) {
int m = (lo + hi) / 2;
if (query(m, mid) == a[mid]) {
hi = m;
} else {
lo = m + 1;
}
}
int L = mid - lo + 1;
lo = mid, hi = r;
while (hi > lo) {
int m = (hi + lo + 1) / 2;
if (query(mid, m) == a[mid]) {
lo = m;
} else {
hi = m - 1;
}
}
int R = lo - mid + 1;
ans += 1ll * L * R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[0] = -inf;
preprocess();
build(1, 1, n);
solve(1, n);
ans = 1ll * n * (n + 1) / 2 - ans;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], l[200005], r[200005];
map<int, int> mp;
vector<int> vt[200005];
long long int an;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) l[i] = 1, r[i] = n;
for (int j = 0, lol; j <= 30; j++) {
lol = 0;
for (int i = 1; i <= n; i++) {
if (a[i] & (1 << j))
lol = i;
else
l[i] = max(l[i], lol + 1);
}
lol = n + 1;
for (int i = n; i >= 1; i--) {
if (a[i] & (1 << j))
lol = i;
else
r[i] = min(r[i], lol - 1);
}
}
for (int i = 1; i <= n; i++) vt[r[i]].push_back(a[i]);
an = n;
an = (an * (an - 1)) >> 1;
long long int lef, ri;
for (int i = 1; i <= n; i++) {
ri = r[i] - i + 1;
if (mp[a[i]])
lef = i - mp[a[i]] - 1;
else
lef = i - l[i];
an -= (lef * ri);
an -= (ri - 1);
mp[a[i]] = i;
for (int j = 0; j < vt[i].size(); j++) mp[vt[i][j]] = 0;
}
printf("%lld\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200009], pre[200009][33], suf[200009][33], lft[200009], rgt[200009];
stack<int> s1;
int main() {
int i, j, t1, t2, t3, t4, n, l, r;
long long int ans, buf1;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
for (j = 0; j < 31; j++) {
if ((1 << j) & a[i]) {
pre[i][j] = i;
} else {
pre[i][j] = pre[i - 1][j];
}
}
}
for (j = 0; j < 31; j++) {
suf[n + 1][j] = n + 1;
}
for (i = n; i >= 1; i--) {
for (j = 0; j < 31; j++) {
if ((1 << j) & a[i]) {
suf[i][j] = i;
} else {
suf[i][j] = suf[i + 1][j];
}
}
}
a[0] = a[n + 1] = 2e9;
s1.push(0);
for (i = 1; i <= n; i++) {
while (a[s1.top()] <= a[i]) {
s1.pop();
}
lft[i] = s1.top() + 1;
s1.push(i);
}
while (!s1.empty()) {
s1.pop();
}
s1.push(n + 1);
for (i = n; i >= 1; i--) {
while (a[s1.top()] < a[i]) {
s1.pop();
}
rgt[i] = s1.top() - 1;
s1.push(i);
}
ans = 1ll * n * (n + 1);
ans /= 2;
for (i = 1; i <= n; i++) {
l = 1;
r = n;
for (j = 0; j < 31; j++) {
if (!((1 << j) & a[i])) {
l = max(l, pre[i][j] + 1);
r = min(r, suf[i][j] - 1);
}
}
l = max(l, lft[i]);
r = min(r, rgt[i]);
buf1 = 1ll * (i - l + 1) * (r - i + 1);
ans -= buf1;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
ll a[200002];
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
for (ll i = 1; i <= n; ++i) cin >> a[i];
ll ans = (n * (n - 1)) / 2;
ll lhs = 0, rhs = 0;
a[0] = a[n + 1] = 1e12;
for (ll i = 1; i <= n; ++i) {
if (a[i] == a[i - 1]) {
lhs = 0;
--rhs;
} else {
lhs = 0;
rhs = 0;
for (ll j = i - 1; a[j] < a[i] && ((a[i] | a[j]) == a[i]); --j, lhs++)
;
for (ll j = i + 1; a[j] <= a[i] && ((a[i] | a[j]) == a[i]); ++j, rhs++)
;
}
ans -= (lhs + 1) * (rhs + 1);
++ans;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> b[31], q;
int n, a[200020], f[31];
long long ans;
int main() {
scanf("%d", &n);
ans = 1LL * n * (n + 1) / 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i; i--)
for (int j = 0; j < 31; j++)
if (a[i] & (1 << j)) b[j].push_back(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 31; j++)
if (!b[j].empty() && b[j].back() == i) b[j].pop_back();
int l = 0, r = n + 1;
while (!q.empty() && a[q.back()] < a[i]) q.pop_back();
if (!q.empty()) l = q.back();
q.push_back(i);
for (int j = 0; j < 31; j++)
if (!(a[i] & (1 << j))) {
l = max(f[j], l);
if (!b[j].empty()) r = min(r, b[j].back());
}
ans -= 1LL * (i - l) * (r - i);
for (int j = 0; j < 31; j++)
if (a[i] & (1 << j)) f[j] = i;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[202020], fr[202020], be[202002], qian[202020], hou[202020], q[222200],
f[101];
int main() {
int n, i, h, left, right, tmp, j;
long long ans;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
h = 0;
for (i = 1; i <= n; i++) {
if (i == 1) {
qian[i] = 1;
h++;
q[h] = 1;
} else {
while (h > 0 && a[i] > a[q[h]]) {
q[h] = 0;
h--;
}
if (h != 0)
qian[i] = q[h] + 1;
else
qian[i] = 1;
q[++h] = i;
}
tmp = 0;
for (j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) != (1 << j))
tmp = max(f[j], tmp);
else
f[j] = i;
}
fr[i] = tmp + 1;
}
memset(q, 0, sizeof(q));
h = 0;
for (i = 0; i <= 31; i++) f[i] = n + 1;
for (i = n; i >= 1; i--) {
if (i == n) {
hou[i] = n;
h++;
q[h] = n;
} else {
while (h > 0 && a[i] >= a[q[h]]) {
q[h] = 0;
h--;
}
if (h != 0)
hou[i] = q[h] - 1;
else
hou[i] = n;
q[++h] = i;
}
tmp = n + 1;
for (j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) != (1 << j))
tmp = min(f[j], tmp);
else
f[j] = i;
}
be[i] = tmp - 1;
}
ans = (long long)n * (n + 1) / 2;
for (i = 1; i <= n; i++) {
left = max(qian[i], fr[i]);
right = min(hou[i], be[i]);
ans = ans - (long long)(i - left + 1) * (right - i + 1);
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umin(T &a, T b) {
a = min(a, b);
}
template <class T>
inline void umax(T &a, T b) {
a = max(a, b);
}
const int INF = 0x3f3f3f3f;
long long mod = 1e9 + 7;
const int N = 200005;
int a[N], l[N], r[N];
int st[N];
int d[30];
int ll[N], rr[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int tp = -1;
a[0] = a[n + 1] = INF;
st[++tp] = 0;
for (int i = 1; i <= n; i++) {
while (a[st[tp]] < a[i]) {
tp--;
}
l[i] = st[tp];
st[++tp] = i;
}
tp = -1;
st[++tp] = n + 1;
for (int i = n; i >= 1; i--) {
while (a[st[tp]] <= a[i]) tp--;
r[i] = st[tp];
st[++tp] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 30; j++) {
if (a[i] >> j & 1) {
d[j] = i;
} else {
umax(ll[i], d[j]);
}
}
}
for (int i = 0; i < 30; i++) d[i] = n + 1;
for (int i = n; i >= 1; i--) {
rr[i] = n + 1;
for (int j = 0; j < 30; j++) {
if (a[i] >> j & 1) {
d[j] = i;
} else {
umin(rr[i], d[j]);
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)(i - l[i]) * (r[i] - i) -
(long long)(i - max(l[i], ll[i])) * (min(r[i], rr[i]) - i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long MAX_N = 2e5 + 100;
const long long MOD = 1e9 + 7;
using namespace std;
long long rm[MAX_N][20];
long long a[MAX_N];
map<int, int> last;
long long ans;
const long long c = (1ll << 50) - 1;
long long ask(long long l, long long r) {
long long len = r - l + 1;
int lg = (int)log2(len);
long long s = r - (1 << lg) + 1;
return (rm[l][lg] | rm[s][lg]);
}
bool check(long long i, long long j) {
j ^= c;
if (j & i) return true;
return false;
}
int main() {
long long n;
cin >> n;
ans = n * (n + 1) / 2;
for (int i = 1; i <= n; ++i) cin >> a[i], last[a[i]] = 0;
for (int i = 1; i <= n; ++i) rm[i][0] = a[i];
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= n - (1 << i) + 1; ++j) {
rm[j][i] = rm[j][i - 1] | rm[j + (1 << (i - 1))][i - 1];
}
}
for (int i = 1; i <= n; ++i) {
long long l1 = i;
long long r1 = last[a[i]] + 1;
long long l2 = i;
long long r2 = n;
if (!check(ask(r1, i), a[i]))
l1 = r1;
else {
while (l1 - r1 > 1) {
long long mid = (l1 + r1) / 2;
if (!check(ask(mid, i), a[i]))
l1 = mid;
else
r1 = mid;
}
}
if (!check(ask(i, n), a[i]))
l2 = n;
else {
while (r2 - l2 > 1) {
long long mid = (l2 + r2) / 2;
if (!check(ask(i, mid), a[i]))
l2 = mid;
else
r2 = mid;
}
}
ans -= (i - l1 + 1) * (l2 - i + 1);
last[a[i]] = i;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx,tune=native")
using namespace std;
template <typename T>
void in(T &x) {
T c = getchar();
while (((c < 48) || (c > 57)) && (c != '-')) c = getchar();
bool neg = false;
if (c == '-') neg = true;
x = 0;
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x * 10) + (c - 48);
if (neg) x = -x;
}
const int MAXN = 2e5 + 10;
const int BITS = 31;
int n;
int arr[MAXN];
int cmp[MAXN], sz;
int pp[MAXN];
vector<int> pos_bit[BITS];
vector<int> pos[MAXN];
int Press(int val) {
int idx = lower_bound(cmp, cmp + sz, val) - cmp;
if (idx == sz || cmp[idx] != val) return -1;
return idx;
}
pair<int, int> shit[BITS * 2];
int main() {
in(n);
for (int i = 1; i <= n; i++) {
in(arr[i]);
cmp[sz++] = arr[i];
}
sort(cmp, cmp + sz);
sz = unique(cmp, cmp + sz) - cmp;
for (int i = 1; i <= n; i++) {
pp[i] = Press(arr[i]);
pos[pp[i]].push_back(i);
for (int b = 0; b < BITS; b++) {
if ((1 << b) & arr[i]) {
pos_bit[b].push_back(i);
}
}
}
for (int i = 0; i < MAXN; i++) {
reverse(pos[i].begin(), pos[i].end());
}
for (int i = 0; i < BITS; i++) {
reverse(pos_bit[i].begin(), pos_bit[i].end());
}
long long ans = 0;
for (int l = 1; l <= n; l++) {
for (int b = 0; b < BITS; b++) {
if (pos_bit[b].size())
shit[b] = {pos_bit[b].back(), b};
else
shit[b] = {n + 1, b};
}
sort(shit, shit + BITS);
int bor = 0;
for (int i = 0; i < BITS; i++) {
if (shit[i].first == n + 1) break;
int st = i;
bor |= (1 << shit[st].second);
while (i + 1 < BITS && shit[i + 1].first == shit[i].first)
i++, bor |= 1 << (shit[i].second);
int p = Press(bor), rt = shit[i + 1].first;
if (p != -1 && pos[p].size() > 0) {
rt = min(rt, pos[p].back());
}
ans += (long long)rt - shit[st].first;
}
for (int b = 0; b < BITS; b++) {
if ((1 << b) & arr[l]) {
pos_bit[b].pop_back();
}
}
pos[pp[l]].pop_back();
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 2e5 + 5;
int n, a[N], msk[30], L[N], R[N], st[20][N], lg[N];
long long ans;
int rmq(int l, int r) {
int k = lg[r - l + 1];
return a[st[k][l]] > a[st[k][r - (1 << k) + 1]] ? st[k][l]
: st[k][r - (1 << k) + 1];
}
void solve(int l, int r) {
if (l > r) return;
int x = rmq(l, r);
ans += 1ll * (x - max(L[x], l) + 1) * (min(R[x], r) - x + 1);
solve(l, x - 1);
solve(x + 1, r);
}
int main() {
n = gi();
for (int i = 1; i <= n; ++i) a[i] = gi(), st[0][i] = i;
for (int i = 1; i <= n; ++i) {
L[i] = 1;
for (int j = 0; j < 30; ++j)
if (~(a[i] >> j) & 1) L[i] = max(L[i], msk[j] + 1);
for (int j = 0; j < 30; ++j)
if (a[i] >> j & 1) msk[j] = i;
}
for (int i = 0; i < 30; ++i) msk[i] = n + 1;
for (int i = n; i; --i) {
R[i] = n;
for (int j = 0; j < 30; ++j)
if (~(a[i] >> j) & 1) R[i] = min(R[i], msk[j] - 1);
for (int j = 0; j < 30; ++j)
if (a[i] >> j & 1) msk[j] = i;
}
for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
for (int j = 1; j <= lg[n]; ++j)
for (int i = 1; i + (1 << j) - 1 <= n; ++i)
st[j][i] = a[st[j - 1][i]] > a[st[j - 1][i + (1 << j - 1)]]
? st[j - 1][i]
: st[j - 1][i + (1 << j - 1)];
solve(1, n);
printf("%I64d\n", 1ll * n * (n + 1) / 2 - ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int maxn = 3e5 + 10;
int n, N;
int a[maxn], b1[maxn], b2[maxn];
int seg[maxn << 2];
void update(int i, int v, int l = 0, int r = N, int id = 0) {
if (r - l == 1) {
seg[id] = v;
return;
}
int mid = (l + r) >> 1;
if (i < mid)
update(i, v, l, mid, ((id << 1) + 1));
else
update(i, v, mid, r, ((id << 1) + 2));
seg[id] = seg[((id << 1) + 1)] | seg[((id << 1) + 2)];
}
int solve(int l1, int r1, int l = 0, int r = N, int id = 0) {
if (l >= r1 || r <= l1) return 0;
if (l >= l1 && r <= r1) return seg[id];
int mid = (l + r) >> 1;
return solve(l1, r1, l, mid, ((id << 1) + 1)) |
solve(l1, r1, mid, r, ((id << 1) + 2));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
int x = 1;
while (x <= n) x <<= 1;
N = x;
for (int i = 0; i < n; i++) cin >> a[i], update(i, a[i]);
vector<int> s;
s.push_back(-1);
for (int i = 0; i < n; i++) {
if (s.back() == -1) {
b1[i] = 0, s.push_back(i);
continue;
}
while (s.back() != -1 && a[i] > a[s.back()]) s.pop_back();
b1[i] = s.back() + 1;
s.push_back(i);
}
s.clear();
s.push_back(n);
for (int i = n - 1; i >= 0; i--) {
if (s.back() == n) {
b2[i] = n - 1, s.push_back(i);
continue;
}
while (s.back() != n && a[i] >= a[s.back()]) s.pop_back();
b2[i] = s.back() - 1;
s.push_back(i);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int l = b1[i] - 1, r = i;
while (r - l > 1) {
int mid = (l + r) >> 1;
int x = solve(mid, i + 1);
if ((x & a[i]) == x)
r = mid;
else
l = mid;
}
int pt1 = r;
l = i, r = b2[i] + 1;
while (r - l > 1) {
int mid = (l + r) >> 1;
int x = solve(i, mid + 1);
if ((x & a[i]) == x)
l = mid;
else
r = mid;
}
int pt2 = l;
long long L = i - pt1 + 1;
long long R = pt2 - i + 1;
long long res = L * R * 1LL;
L = i - b1[i] + 1;
R = b2[i] - i + 1;
res = ((L * R) - res) * 1LL;
ans += res;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long maxn = 2e5 + 1e2;
long long l[maxn], r[maxn];
long long a[maxn];
struct Node {
long long pos, val;
};
Node s[maxn];
long long n, m;
long long g[maxn][21];
long long f[maxn][21];
long long b[maxn];
long long ans;
long long top;
long long getor(long long l, long long r) {
long long k = log2(r - l + 1);
return f[l][k] | f[r - (1 << k) + 1][k];
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) f[i][0] = a[i];
for (long long i = 1; i <= n; i++) g[i][0] = a[i];
for (long long j = 1; j <= 20; j++)
for (long long i = 1; i <= n; i++) {
if (i + (1 << j) - 1 <= n) {
f[i][j] = f[i][j - 1] | f[i + (1 << j - 1)][j - 1];
}
}
l[1] = 1;
s[1].pos = 1;
s[1].val = a[1];
top = 1;
for (long long i = 2; i <= n; i++) {
while (top >= 1 && s[top].val < a[i]) top--;
if (!top)
l[i] = 1;
else
l[i] = s[top].pos + 1;
s[++top].pos = i;
s[top].val = a[i];
}
memset(s, 0, sizeof(s));
s[1].pos = n;
s[1].val = a[n];
r[n] = n;
top = 1;
for (long long i = n - 1; i >= 1; i--) {
while (top >= 1 && s[top].val <= a[i]) top--;
if (!top)
r[i] = n;
else
r[i] = s[top].pos - 1;
s[++top].pos = i;
s[top].val = a[i];
}
ans = n * (n - 1) / 2;
for (long long j = 1; j <= n; j++) {
long long x = j, y = r[j];
long long l1 = j, r1 = j;
while (x <= y) {
long long mid = (x + y) >> 1;
if (getor(j, mid) <= a[j])
r1 = mid, x = mid + 1;
else
y = mid - 1;
}
x = l[j], y = j;
while (x <= y) {
long long mid = (x + y) >> 1;
if (getor(mid, j) <= a[j])
l1 = mid, y = mid - 1;
else
x = mid + 1;
}
ans = ans - (r1 - j + 1) * (j - l1 + 1);
}
cout << ans + n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5 + 10;
int n;
int a[kN];
int id[kN];
set<int> s;
int le[30][kN], ri[30][kN];
int L[kN], R[kN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int j = 0; j < 30; j++) {
int cur = 0;
for (int i = 1; i <= n; i++) {
le[j][i] = cur;
if (a[i] & (1 << j)) cur = i;
}
cur = n + 1;
for (int i = n; i >= 1; i--) {
ri[j][i] = cur;
if (a[i] & (1 << j)) cur = i;
}
}
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j = 0; j < 30; j++)
if (!(a[i] & (1 << j))) v.push_back(j);
L[i] = 0;
for (int j : v) L[i] = max(L[i], le[j][i]);
}
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j = 0; j < 30; j++)
if (!(a[i] & (1 << j))) v.push_back(j);
R[i] = n + 1;
for (int j : v) R[i] = min(R[i], ri[j][i]);
}
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1,
[&](int i, int j) { return a[i] != a[j] ? a[i] > a[j] : i < j; });
s.insert(0);
s.insert(n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int ii = id[i];
auto it = s.lower_bound(ii);
int l = max(L[ii], *prev(it));
int r = min(R[ii], *it);
ans += 1LL * (ii - l) * (r - ii);
s.insert(ii);
}
ans = 1LL * n * (n + 1) / 2 - ans;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
inline void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
const int N = 2e5 + 5, M = 30;
int arr[N], nxt[N][M];
int n;
map<int, vector<int> > idxs;
int getNext(int val, int idx) {
if (!idxs.count(val)) return n + 1;
vector<int>& vec = idxs[val];
auto it = lower_bound(vec.begin(), vec.end(), idx);
if (it == vec.end()) return n + 1;
return *it;
}
int getNewBit(int val, int idx) {
int mn = n + 1;
for (int i = 0; i < M; ++i) {
if ((val >> i) & 1) continue;
mn = min(mn, nxt[idx][i]);
}
return mn;
}
inline void solve() {
read(n);
for (int i = 1; i <= n; ++i) {
read(arr[i]);
idxs[arr[i]].push_back(i);
}
for (int i = 0; i < M; ++i) {
nxt[n + 1][i] = n + 1;
}
for (int i = n; i > 0; --i) {
for (int j = 0; j < M; ++j) {
nxt[i][j] = nxt[i + 1][j];
if ((arr[i] >> j) & 1) {
nxt[i][j] = i;
}
}
}
long long ans = 0;
for (int st = 1; st <= n; ++st) {
long long cur = 0, idx = st, tmp = 0;
(st);
while (idx <= n) {
cur |= arr[idx];
int i1 = getNext(cur, idx);
int i2 = getNewBit(cur, idx);
if (i1 <= idx) {
idx = i2;
continue;
}
if (i1 < i2) {
ans += i1 - idx;
idx = i1;
continue;
}
tmp += i2 - idx;
idx = i2;
}
(st, tmp);
ans += tmp;
}
prn(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[210000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = n * (n + 1) / 2;
long long lidx[n];
long long ridx[n];
for (int i = 0; i < n; i++) {
lidx[i] = 0;
ridx[i] = n - 1;
}
map<long long, long long> nextval;
for (int i = 0; i < n; i++) {
if (nextval.find(a[i]) != nextval.end())
lidx[i] = max(lidx[i], nextval[a[i]] + 1);
nextval[a[i]] = i;
}
for (long long c = 0; c < 33; c++) {
long long d = (1LL << c);
long long last1 = -1;
for (int i = 0; i < n; i++) {
if (a[i] & d) {
last1 = i;
continue;
}
lidx[i] = max(lidx[i], last1 + 1);
}
}
for (long long c = 0; c < 33; c++) {
long long d = (1LL << c);
long long last1 = n;
for (int i = n - 1; i >= 0; i--) {
if (a[i] & d) {
last1 = i;
continue;
}
ridx[i] = min(ridx[i], last1 - 1);
}
}
for (long long i = 0; i < n; i++) {
ans -= (i - lidx[i] + 1) * (ridx[i] - i + 1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 3e5 + 10;
int a[mn];
int l[mn], r[mn], lb[mn], rb[mn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
stack<int> s;
a[0] = a[n + 1] = 0x3f3f3f3f;
s.push(0);
for (int i = 1; i <= n; i++) {
while (a[i] > a[s.top()]) s.pop();
l[i] = s.top();
s.push(i);
}
while (s.size()) s.pop();
s.push(n + 1);
for (int i = n; i >= 1; i--) {
while (a[i] >= a[s.top()]) s.pop();
r[i] = s.top();
s.push(i);
}
for (int i = 1; i <= n; i++) lb[i] = l[i], rb[i] = r[i];
for (int i = 0; i < 30; i++) {
int l1 = 0;
for (int j = 1; j <= n; j++) {
if (!((a[j] >> i) & 1))
lb[j] = max(lb[j], l1);
else
l1 = j;
}
l1 = n + 1;
for (int j = n; j >= 1; j--) {
if (!((a[j] >> i) & 1))
rb[j] = min(rb[j], l1);
else
l1 = j;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += 1LL * (i - l[i]) * (r[i] - i) - 1LL * (i - lb[i]) * (rb[i] - i);
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001 * 1001;
int a[MAXN];
long long ans;
void solve(int s, int e) {
if (e - s == 1) return;
int mid = (s + e) / 2;
solve(s, mid);
solve(mid, e);
vector<pair<int, int>> v1, v2;
vector<int> l, r;
int mx = 0, OR = 0;
int c1 = 0, c2 = 0;
for (int i = mid; i < e; i++) {
mx = max(mx, a[i]);
OR |= a[i];
if (OR == mx) {
c2++;
if (v2.size() && v2.back().first == mx)
v2.back().second++;
else
v2.push_back({mx, 1});
} else
r.push_back(OR);
}
mx = 0, OR = 0;
for (int i = mid - 1; i >= s; i--) {
mx = max(mx, a[i]);
OR |= a[i];
if (OR == mx) {
c1++;
if (v1.size() && v1.back().first == mx)
v1.back().second++;
else
v1.push_back({mx, 1});
} else
l.push_back(OR);
}
ans += 1ll * (e - mid - c2) * (mid - s - c1);
for (auto u : r)
for (auto v : v1)
if ((u | v.first) != v.first) ans += v.second;
for (auto u : l)
for (auto v : v2)
if ((u | v.first) != v.first) ans += v.second;
for (auto u : v1)
for (auto v : v2)
if ((v.first | u.first) != u.first && (v.first | u.first) != v.first)
ans += 1ll * v.second * u.second;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
solve(0, n);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int lef[N], rig[N], dig[N], n;
void solve(bool rig) {
stack<int> sta;
for (int i = (0); i < (n); i++) {
while (!sta.empty() && (dig[sta.top()] | dig[i]) == dig[i] &&
(rig == true || dig[sta.top()] != dig[i]))
sta.pop();
lef[i] = i - 1 - (!sta.empty() ? sta.top() : -1);
sta.push(i);
}
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%d", &dig[i]);
reverse(dig, dig + n);
solve(1);
for (int i = (0); i < (n); i++) rig[i] = lef[n - 1 - i];
reverse(dig, dig + n);
solve(0);
long long ans = 1ll * (n + 1) * n / 2;
for (int i = (0); i < (n); i++) ans -= 1ll * (lef[i] + 1) * (rig[i] + 1);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200300;
int n, m, a[N], v[N], sum[N];
long long ans;
map<int, int> rec;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = 10 * x + c - '0';
c = getchar();
}
x *= f;
}
struct ST {
int v[N][19], log2[N], n;
inline void init(int x) {
n = x;
log2[1] = 0;
for (int i = 2; i <= n; i++) {
log2[i] = log2[i - 1];
if ((1 << log2[i] + 1) <= i) log2[i]++;
}
for (int i = 1; i <= n; i++) v[i][0] = a[i];
for (int j = 1; j <= log2[n]; j++)
for (int i = 1; i <= n - (1 << j) + 1; i++)
v[i][j] = ((v[i][j - 1]) > (v[i + (1 << (j - 1))][j - 1])
? (v[i][j - 1])
: (v[i + (1 << (j - 1))][j - 1]));
}
inline int query(int l, int r) {
int k = log2[r - l + 1];
return ((v[l][k]) > (v[r - (1 << k) + 1][k]) ? (v[l][k])
: (v[r - (1 << k) + 1][k]));
}
} st;
struct ST1 {
int v[N][19], log2[N], n;
inline void init(int x) {
n = x;
log2[1] = 0;
for (int i = 2; i <= n; i++) {
log2[i] = log2[i - 1];
if ((1 << log2[i] + 1) <= i) log2[i]++;
}
for (int i = 1; i <= n; i++) v[i][0] = a[i];
for (int j = 1; j <= log2[n]; j++)
for (int i = 1; i <= n - (1 << j) + 1; i++)
v[i][j] = (v[i][j - 1] | v[i + (1 << (j - 1))][j - 1]);
}
inline int query(int l, int r) {
int k = log2[r - l + 1];
return (v[l][k] | v[r - (1 << k) + 1][k]);
}
} st1;
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
st.init(n);
st1.init(n);
for (int i = 1; i <= n; i++) {
int l = i, r = i;
int pre = rec[a[i]] + 1;
for (int j = 18; j >= 0; j--)
if (l - (1 << j) >= pre && st.query(l - (1 << j), l - 1) <= a[i]) {
int tmp = st1.query(l - (1 << j), l - 1);
if ((a[i] & tmp) == tmp) l -= (1 << j);
}
for (int j = 18; j >= 0; j--)
if (r + (1 << j) <= n && st.query(r + 1, r + (1 << j)) <= a[i]) {
int tmp = st1.query(r + 1, r + (1 << j));
if ((a[i] & tmp) == tmp) r += (1 << j);
}
ans += (long long)(r - i + 1) * (i - l + 1);
rec[a[i]] = i;
}
printf("%lld", (long long)n * (n + 1) / 2 - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_N = 2e5 + 10;
const int l_N = 20;
int st[l_N][max_N];
int lg[max_N];
int inp[max_N];
vector<int> bits[30];
int query_max(int i, int j);
int main() {
{
int j = 0;
for (int i = 0; i < max_N; ++i) {
while ((1 << j) <= i) {
++j;
}
lg[i] = j - 1;
}
}
int N;
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &inp[i]);
st[0][i] = inp[i];
}
for (int j = 1; j < l_N; ++j) {
for (int i = 1; i + (1 << j) - 1 <= N; ++i) {
st[j][i] = max(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < 30; ++j) {
if ((inp[i] >> j) & 1) {
bits[j].push_back(i);
}
}
}
long long ans = 0;
for (int i = 1; i <= N; ++i) {
vector<int> or_changes;
for (int j = 0; j < 30; ++j) {
auto it = lower_bound(bits[j].begin(), bits[j].end(), i);
if (it != bits[j].end()) {
or_changes.push_back(*it);
}
}
sort(or_changes.begin(), or_changes.end());
or_changes.push_back(N + 1);
int cid = *or_changes.begin();
int cor = inp[cid];
for (int j = 1; j < or_changes.size(); ++j) {
int L = cid, R = or_changes[j];
int low = L, high = R - 1, mid, best = R;
while (low <= high) {
mid = (low + high) >> 1;
if (query_max(L, mid) >= cor) {
best = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
ans += best - L;
cid = R;
cor |= inp[R];
}
}
cout << ans << endl;
}
int query_max(int i, int j) {
int d = lg[j - i + 1];
return max(st[d][i], st[d][j - (1 << d) + 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
const long long maxn = 5e5 + 10;
long long a[maxn], st[maxn][20], st2[maxn][20], lg[maxn], ans;
void build() {
for (long long j = 1; j <= lg[n]; ++j) {
for (long long i = 1; i <= n; ++i) {
st[i][j] = max(st[i][j - 1], st[min(i + (1 << (j - 1)), n)][j - 1]);
st2[i][j] = st2[i][j - 1] | st2[min(i + (1 << (j - 1)), n)][j - 1];
}
}
}
long long query1(long long l, long long r) {
long long len = lg[r - l + 1];
return max(st[l][len], st[r - (1 << len) + 1][len]);
}
long long query2(long long l, long long r) {
long long len = lg[r - l + 1];
return st2[l][len] | st2[r - (1 << len) + 1][len];
}
long long solve(long long x) {
long long l = 1, r = x - 1;
long long ans1 = x, ans2 = x;
while (l <= r) {
long long mid = (l + r) >> 1;
if (query1(mid, x - 1) < a[x] && query2(mid, x) <= a[x]) {
ans1 = mid;
r = mid - 1;
} else
l = mid + 1;
}
l = x + 1, r = n;
while (l <= r) {
long long mid = (l + r) >> 1;
if (query1(x + 1, mid) <= a[x] && query2(x, mid) <= a[x]) {
ans2 = mid;
l = mid + 1;
} else
r = mid - 1;
}
return (x - ans1 + 1) * (ans2 - x + 1);
}
signed main() {
n = read();
for (long long i = 1; i <= n; ++i) {
a[i] = read();
st[i][0] = st2[i][0] = a[i];
}
lg[0] = -1;
long long anss = n * (n + 1) / 2;
for (long long i = 1; i <= n; ++i) {
lg[i] = lg[i >> 1] + 1;
}
build();
for (long long i = 1; i <= n; ++i) {
anss -= solve(i);
}
cout << anss;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
int a[200105];
int nxt[33], af[200105];
map<int, int> mp;
long long ans;
void fmain(int ID) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int i = n; i; i--) {
int E = n + 1;
for (int(j) = 0; (j) < (int)(30); (j)++)
if (((a[i] >> j) & 1) == 0) {
if (nxt[j] != 0) E = min(E, nxt[j]);
}
af[i] = E;
for (int(j) = 0; (j) < (int)(30); (j)++)
if (((a[i] >> j) & 1) == 1) {
nxt[j] = i;
}
}
for (int(i) = 0; (i) < (int)(31); (i)++) nxt[i] = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
int B = 0;
for (int(j) = 0; (j) < (int)(30); (j)++)
if (((a[i] >> j) & 1) == 0) {
B = max(B, nxt[j]);
}
if (mp.find(a[i]) != mp.end()) B = max(B, mp[a[i]]);
ans += (long long)(i - B) * (af[i] - i) - 1;
mp[a[i]] = i;
for (int(j) = 0; (j) < (int)(30); (j)++)
if (((a[i] >> j) & 1) == 1) {
nxt[j] = i;
}
}
long long T = (long long)n * (n - 1) / 2;
printf("%lld\n", T - ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long maxn = 2e5 + 1e2;
long long l[maxn], r[maxn];
long long a[maxn];
struct Node {
long long pos, val;
};
Node s[maxn];
long long n, m;
long long g[maxn][21];
long long f[maxn][21];
long long b[maxn];
long long ans;
long long top;
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) b[i] = a[n - i + 1];
for (long long i = 1; i <= n; i++) f[i][0] = a[i];
for (long long i = 1; i <= n; i++) g[i][0] = a[i];
for (long long j = 1; j <= 20; j++)
for (long long i = 1; i <= n; i++) {
if (i + (1 << j) - 1 <= n) {
f[i][j] = f[i][j - 1] | f[i + (1 << j - 1)][j - 1];
}
}
for (long long j = 1; j <= 20; j++) {
for (long long i = 1; i <= n; i++) {
if (i - (1 << j) + 1 >= 1)
g[i][j] = g[i][j - 1] | g[i - (1 << j - 1)][j - 1];
}
}
l[1] = 1;
s[1].pos = 1;
s[1].val = a[1];
top = 1;
for (long long i = 2; i <= n; i++) {
while (top >= 1 && s[top].val < a[i]) top--;
if (!top)
l[i] = 1;
else
l[i] = s[top].pos + 1;
s[++top].pos = i;
s[top].val = a[i];
}
s[1].pos = n;
s[1].val = a[n];
r[n] = n;
top = 1;
for (long long i = n - 1; i >= 1; i--) {
while (top >= 1 && s[top].val <= a[i]) top--;
if (!top)
r[i] = n;
else
r[i] = s[top].pos - 1;
s[++top].pos = i;
s[top].val = a[i];
}
ans = n * (n - 1) / 2;
for (long long j = 1; j <= n; j++) {
long long ksj = j, lwk = j;
long long now = a[j];
long long pos = j;
for (long long i = 20; i >= 0; i--) {
if (pos + (1 << i) - 1 <= r[j] && ((now | f[pos][i]) <= a[j])) {
now |= f[pos][i];
pos = pos + (1 << i);
}
}
ksj = pos - 1;
pos = j;
now = a[j];
for (long long i = 20; i >= 0; i--) {
if (pos - (1 << i) + 1 >= l[j] && ((now | g[pos][i]) <= a[j])) {
now |= g[pos][i];
pos -= (1 << i);
}
}
lwk = pos + 1;
ans -= (ksj - j + 1) * (j - lwk + 1);
}
cout << ans + n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
long long l[maxn], r[maxn];
int n;
int arr[maxn];
int main() {
scanf("%d", &n);
long long ans = n;
ans *= (ans + 1);
ans /= 2ll;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
stack<int> sta;
sta.push(1);
for (int i = 2; i <= n; i++) {
while (sta.size()) {
int e = sta.top();
if ((arr[e] | arr[i]) != arr[e]) {
r[e] = i - 1;
sta.pop();
continue;
}
break;
}
sta.push(i);
}
while (!sta.empty()) {
int e = sta.top();
r[e] = n;
sta.pop();
}
sta.push(n);
for (int i = n - 1; i > 0; i--) {
while (sta.size()) {
int e = sta.top();
if ((arr[e] | arr[i]) != arr[e]) {
l[e] = i + 1;
sta.pop();
continue;
}
break;
}
while (sta.size() && arr[sta.top()] == arr[i]) {
l[sta.top()] = i + 1;
sta.pop();
}
sta.push(i);
}
while (!sta.empty()) {
int e = sta.top();
sta.pop();
l[e] = 1;
}
long long tol = 0;
for (int i = 1; i <= n; i++) {
l[i] = i - l[i] + 1;
r[i] = r[i] - i + 1;
ans -= (l[i]) * (r[i]);
}
tol /= 2;
ans -= tol;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, a[N], lstp[33], mxpos[N], mnpos[N], st[N][22], lg2[N];
long long ans;
int Qpos(int l, int r) {
int k = lg2[r - l + 1];
int x1 = st[l][k], x2 = st[r - (1 << k) + 1][k];
if (a[x1] > a[x2])
return x1;
else
return x2;
}
void solve(int l, int r) {
if (l > r) return;
if (l == r) {
ans++;
return;
}
int t = Qpos(l, r);
solve(l, t - 1);
solve(t + 1, r);
int L = mxpos[t] + 1, R = mnpos[t] - 1;
L = max(L, l), R = min(R, r);
ans += 1ll * (t - L + 1) * (R - t + 1);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) lg2[i] = lg2[i >> 1] + 1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), mnpos[i] = n + 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 30; j++) {
if (a[i] & (1 << j)) {
lstp[j] = i;
} else
mxpos[i] = max(mxpos[i], lstp[j]);
}
}
for (int j = 0; j <= 30; j++) lstp[j] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 30; j++) {
if (a[i] & (1 << j)) {
lstp[j] = i;
} else
mnpos[i] = min(mnpos[i], lstp[j]);
}
}
for (int i = 1; i <= n; i++) st[i][0] = i;
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int x1 = st[i][j - 1];
int x2 = st[i + (1 << (j - 1))][j - 1];
if (a[x1] > a[x2])
st[i][j] = x1;
else
st[i][j] = x2;
}
solve(1, n);
printf("%lld\n", 1ll * n * (n + 1) / 2 - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 200005;
int n, top, a[MAXN], L[MAXN], R[MAXN], sta[MAXN], pre[MAXN][31], nxt[MAXN][31];
long long ans;
inline void Solve(int x, int l, int r) {
for (int i = 0; i < 30; i++)
if (!(a[x] >> i & 1)) l = max(l, pre[x][i] + 1), r = min(r, nxt[x][i] - 1);
ans -= 1LL * (r - x + 1) * (x - l + 1);
}
int main() {
n = Read(), ans = 1LL * n * (n + 1) >> 1;
for (int i = 1; i <= n; i++) a[i] = Read();
for (int i = 1; i <= n; sta[++top] = i++)
while (top && a[i] > a[sta[top]]) R[sta[top--]] = i - 1;
while (top) R[sta[top--]] = n;
for (int i = n; i; sta[++top] = i--)
while (top && a[i] >= a[sta[top]]) L[sta[top--]] = i + 1;
while (top) L[sta[top--]] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 30; j++)
if (a[i - 1] >> j & 1)
pre[i][j] = i - 1;
else
pre[i][j] = pre[i - 1][j];
for (int j = 0; j < 30; j++) nxt[n + 1][j] = n + 1;
for (int i = n; i; i--)
for (int j = 0; j < 30; j++)
if (a[i + 1] >> j & 1)
nxt[i][j] = i + 1;
else
nxt[i][j] = nxt[i + 1][j];
for (int i = 1; i <= n; i++) Solve(i, L[i], R[i]);
return printf("%lld\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int LG = 30;
const int INF = (int)1e9 + 7;
struct Node {
int val, pos;
};
Node oper(Node a, Node b) {
if (a.val != b.val) {
return a.val > b.val ? a : b;
}
return a.pos < b.pos ? a : b;
}
struct STree {
vector<Node> st;
int n;
STree(int n) : st(4 * n + 5, ((Node){-INF, INF})), n(n) {}
void init(int k, int s, int e, int *a) {
if (s + 1 == e) {
st[k] = (Node){a[s], s};
return;
}
int m = (s + e) / 2;
init(2 * k, s, m, a);
init(2 * k + 1, m, e, a);
st[k] = oper(st[2 * k], st[2 * k + 1]);
}
Node query(int k, int s, int e, int a, int b) {
if (s >= b || e <= a) return ((Node){-INF, INF});
if (s >= a && e <= b) return st[k];
int m = (s + e) / 2;
return oper(query(2 * k, s, m, a, b), query(2 * k + 1, m, e, a, b));
}
void init(int *a) { init(1, 0, n, a); }
Node query(int a, int b) { return query(1, 0, n, a, b); }
};
int n, A[MAXN];
vector<int> P[LG];
int p[LG];
int main() {
while (scanf("%d", &n) >= 1) {
for (int i = (0); i < (int)(n); i++) scanf("%d", &A[i]);
STree S(n);
S.init(A);
for (int i = (0); i < (int)(LG); i++) {
for (int j = (0); j < (int)(n); j++) {
if (A[j] & (1 << i)) P[i].push_back(j);
}
p[i] = 0;
}
long long ans = 0;
for (int i = (0); i < (int)(n); i++) {
vector<int> r(1, n);
for (int j = (0); j < (int)(LG); j++) {
if (p[j] < ((int)P[j].size())) {
if (P[j][p[j]] == i) p[j]++;
if (p[j] < ((int)P[j].size())) {
if (A[i] & (1 << j))
;
else {
r.push_back(P[j][p[j]]);
}
}
}
}
sort(r.begin(), r.end());
r.resize(unique(r.begin(), r.end()) - r.begin());
int v = A[i];
for (int i = (0); i < (int)(((int)r.size()) - 1); i++) {
int a = r[i];
int b = r[i + 1];
Node g = S.query(a, b);
v |= A[a];
if (g.val != v) {
ans += b - a;
} else {
ans += g.pos - a;
}
}
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200030, LOG = 18;
int a[N];
int sp_max[N][LOG], sp_or[N][LOG];
int plen[N];
int get_max(int l, int r) {
if (l > r) return -1e9;
int len = plen[r - l + 1];
return max(sp_max[l][len], sp_max[r - (1 << len) + 1][len]);
}
int get_or(int l, int r) {
int len = plen[r - l + 1];
return sp_or[l][len] | sp_or[r - (1 << len) + 1][len];
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sp_max[i][0] = sp_or[i][0] = a[i];
}
for (int i = 2; i <= n; i++) {
plen[i] = plen[i / 2] + 1;
}
for (int lvl = 1; lvl < LOG; lvl++) {
for (int i = 0; i + (1 << lvl) - 1 < n; i++) {
sp_max[i][lvl] =
max(sp_max[i][lvl - 1], sp_max[i + (1 << (lvl - 1))][lvl - 1]);
sp_or[i][lvl] = sp_or[i][lvl - 1] | sp_or[i + (1 << (lvl - 1))][lvl - 1];
}
}
long long ans = n * 1LL * (n + 1) / 2;
for (int i = 0; i < n; i++) {
int l = 0, r = i, from_left = i;
while (l <= r) {
int m = (l + r) >> 1;
if (get_max(m, i - 1) < a[i])
r = m - 1, from_left = m;
else
l = m + 1;
}
l = from_left, r = i;
int myl = i;
while (l <= r) {
int m = (l + r) >> 1;
if (get_or(m, i) == a[i])
r = m - 1, myl = m;
else
l = m + 1;
}
l = i, r = n - 1;
int myr = i;
while (l <= r) {
int m = (l + r) >> 1;
if (get_or(i, m) == a[i])
l = m + 1, myr = m;
else
r = m - 1;
}
ans -= (myr - i + 1) * 1LL * (i - myl + 1);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int n, a[N], l[N], r[N], lor[N], ror[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
stack<int> st;
st.push(0);
a[0] = 2e9;
for (int i = 1; i <= n; ++i) {
while (a[i] >= a[st.top()]) st.pop();
l[i] = st.top();
st.push(i);
}
while (!st.empty()) st.pop();
st.push(0);
for (int i = 1; i <= n; ++i) {
while (a[i] >= (a[i] | a[st.top()])) st.pop();
lor[i] = st.top();
st.push(i);
}
while (!st.empty()) st.pop();
a[n + 1] = 2e9;
st.push(n + 1);
for (int i = n; i >= 1; --i) {
while (a[st.top()] < a[i]) st.pop();
r[i] = st.top();
st.push(i);
}
while (!st.empty()) st.pop();
st.push(n + 1);
for (int i = n; i >= 1; --i) {
while ((a[st.top()] | a[i]) <= a[i]) st.pop();
ror[i] = st.top();
st.push(i);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
lor[i] = max(lor[i], l[i]);
ror[i] = min(ror[i], r[i]);
ans += (i - l[i]) * 1ll * (r[i] - i);
ans -= (i - lor[i]) * 1ll * (ror[i] - i);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int rd() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f * x;
}
int n;
int l[1000005], r[1000005], l1[1000005], r1[1000005], t[35], a[1000005];
int Q[1000005], tp;
int main() {
n = rd();
for (int i = 1; i <= n; i++) a[i] = rd();
for (int i = 1; i <= n; i++) {
while (tp && a[i] > a[Q[tp]]) tp--;
if (tp) l[i] = Q[tp];
Q[++tp] = i;
}
tp = 0;
memset(Q, 0, sizeof(Q));
for (int i = n; i >= 1; i--) {
while (tp && a[i] >= a[Q[tp]]) tp--;
if (tp)
r[i] = Q[tp];
else
r[i] = n + 1;
Q[++tp] = i;
}
for (int i = 1; i <= n; i++) {
l1[i] = 0;
for (int j = 0; j <= 30; j++) {
if (a[i] & (1 << j))
t[j] = i;
else
l1[i] = max(l1[i], t[j]);
}
}
for (int i = 0; i <= 30; i++) t[i] = n + 1;
for (int i = n; i >= 1; i--) {
r1[i] = 0x3f3f3f3f;
for (int j = 0; j <= 30; j++) {
if (a[i] & (1 << j))
t[j] = i;
else
r1[i] = min(r1[i], t[j]);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (r[i] >= r1[i]) ans += 1ll * (i - l[i]) * (r[i] - r1[i]);
if (l1[i] >= l[i]) ans += 1ll * (r[i] - i) * (l1[i] - l[i]);
if (r[i] >= r1[i] && l1[i] >= l[i])
ans -= 1ll * (l1[i] - l[i]) * (r[i] - r1[i]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, a[200005], l[200005], r[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
a[0] = a[n + 1] = -1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
l[i] = i - 1;
while ((a[i] | a[l[i]]) == a[i]) {
l[i] = l[l[i]];
}
}
for (int i = n; i >= 1; i--) {
r[i] = i + 1;
while ((a[i] | a[r[i]]) == a[i] && a[r[i]] < a[i]) {
r[i] = r[r[i]];
}
}
long long ans = (1ll * n * (n + 1)) >> 1;
for (int i = 1; i <= n; i++) {
ans -= 1ll * (i - l[i]) * (r[i] - i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, nxt[200010], a[200010], sz[200010][31];
long long ans = 0;
map<int, int> mp;
inline char gc() {
static char *S, *T, buf[1 << 16];
if (T == S) {
T = (S = buf) + fread(buf, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char ch = gc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = gc();
}
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = gc();
return x * f;
}
inline int check(int l, int r) {
int res = 0;
for (int i = 0; i <= 30; ++i) res |= ((sz[r][i] - sz[l - 1][i]) > 0) << i;
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read(), nxt[i] = mp[a[i]], mp[a[i]] = i;
for (int j = 0; j <= 30; ++j) {
sz[i][j] = sz[i - 1][j];
if (a[i] & (1 << j)) sz[i][j]++;
}
}
for (int i = 1; i <= n; ++i) {
int l = max(nxt[i] + 1, 1), r = i, nowl = i;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid, i) == a[i])
nowl = mid, r = mid - 1;
else
l = mid + 1;
}
l = i, r = n;
int nowr = i;
while (l <= r) {
int mid = l + r >> 1;
if (check(i, mid) == a[i])
nowr = mid, l = mid + 1;
else
r = mid - 1;
}
ans += 1ll * (i - nowl + 1) * (nowr - i + 1);
}
printf("%I64d\n", 1ll * n * (n + 1) / 2 - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bitct(long long r) {
int c = 0;
for (; r; r &= r - 1) c++;
return c;
}
long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
long long choose(long long n, long long q) {
if (n == 0 || q == 0) return 1;
if (q == 1)
return n;
else
return (choose(n, q - 1) * (n - q + 1) / q);
}
template <typename T>
ostream& operator<<(ostream& o, vector<T> v) {
o << "[";
int i = 0, s = v.size();
for (; i + 1 < s; i++) o << v[i] << ", ";
if (s) o << v[i];
o << "]";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, unordered_map<K, V> m) {
o << "{";
for (auto i : m) o << i.first << " -> " << i.second << ", ";
o << "}";
return o;
}
template <typename K, typename V>
ostream& operator<<(ostream& o, map<K, V> m) {
o << "{";
for (auto i : m) o << i.first << " -> " << i.second << ", ";
o << "}";
return o;
}
template <typename K>
ostream& operator<<(ostream& o, set<K> m) {
o << "{";
for (auto i : m) o << i << ", ";
o << "}";
return o;
}
template <typename K>
ostream& operator<<(ostream& o, unordered_set<K> m) {
o << "{";
for (auto i : m) o << i << ", ";
o << "}";
return o;
}
template <typename T>
ostream& printv(vector<T> v) {
int i = 0, s = v.size();
for (; i + 1 < s; i++) cout << v[i] << " ";
if (s) cout << v[i];
return cout;
}
int main() {
ios_base::sync_with_stdio(false);
long long N;
cin >> N;
vector<long long> A;
vector<pair<long long, long long> > byh;
for (int i = 0; i < N; i++) {
long long x;
cin >> x;
A.push_back(x);
byh.push_back({-1 * x, i});
}
sort(byh.begin(), byh.end());
long long out = 0;
vector<vector<int> > rangesl(N, vector<int>(30, 0));
vector<vector<int> > rangesr(N, vector<int>(30, 0));
vector<int> prev(30, -1);
for (int i = 0; i < N; i++) {
rangesl[i] = prev;
for (int p = 0, k = A[i]; k > 0; p++, k = k >> 1) {
if (k % 2) prev[p] = i;
}
}
vector<int> next(30, N + 1);
for (int i = N; i-- > 0;) {
rangesr[i] = next;
for (int p = 0, k = A[i]; k > 0; p++, k = k >> 1) {
if (k % 2) next[p] = i;
}
}
set<int> used;
used.insert(-1);
used.insert(N);
for (long long topi = 0; topi < N; topi++) {
long long me = byh[topi].second;
auto f = used.lower_bound(me);
long long above = *f;
--f;
long long below = *f;
used.insert(me);
long long soonl = below, soonr = above;
for (int p = 0, k = A[me]; p < 30; p++, k = k >> 1) {
if (k % 2 == 0) {
soonl = max(soonl, (long long)rangesl[me][p]);
soonr = min(soonr, (long long)rangesr[me][p]);
}
}
out += (above - me) * (me - below) - 1 - ((soonr - me) * (me - soonl) - 1);
}
cout << out << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
inline void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
template <class T>
inline void hash_combine(size_t& seed, const T& v) {
std::hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename S, typename T>
struct hash<pair<S, T>> {
inline size_t operator()(const pair<S, T>& v) const {
size_t seed = 0;
::hash_combine(seed, v.first);
::hash_combine(seed, v.second);
return seed;
}
};
} // namespace std
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
unordered_map<long long, vector<int>, custom_hash> idxs;
const int N = 2e5 + 5, M = 30;
int arr[N], nxt[N][M];
int n;
int getNext(int val, int idx) {
if (!idxs.count(val)) return n + 1;
vector<int>& vec = idxs[val];
auto it = lower_bound(vec.begin(), vec.end(), idx);
if (it == vec.end()) return n + 1;
return *it;
}
int getNewBit(int val, int idx) {
int mn = n + 1;
for (int i = 0; i < M; ++i) {
if ((val >> i) & 1) continue;
mn = min(mn, nxt[idx][i]);
}
return mn;
}
inline void solve() {
read(n);
idxs.max_load_factor(.25);
idxs.reserve(n);
for (int i = 1; i <= n; ++i) {
read(arr[i]);
idxs[arr[i]].push_back(i);
}
for (int i = 0; i < M; ++i) {
nxt[n + 1][i] = n + 1;
}
for (int i = n; i > 0; --i) {
for (int j = 0; j < M; ++j) {
nxt[i][j] = nxt[i + 1][j];
if ((arr[i] >> j) & 1) {
nxt[i][j] = i;
}
}
}
long long ans = 0;
for (int st = 1; st <= n; ++st) {
long long cur = 0, idx = st, tmp = 0;
(st);
while (idx <= n) {
cur |= arr[idx];
int i1 = getNext(cur, idx);
int i2 = getNewBit(cur, idx);
if (i1 <= idx) {
idx = i2;
continue;
}
if (i1 < i2) {
ans += i1 - idx;
idx = i1;
continue;
}
tmp += i2 - idx;
idx = i2;
}
(st, tmp);
ans += tmp;
}
prn(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 1;
const int INF = 2e9 + 2;
const long long MOD = 1e9 + 7;
const int MAXBIT = 64;
struct pos {
int gl, gr;
int bl, br;
};
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> input;
for (int i = 0; i < n; ++i) {
int val;
cin >> val;
input.push_back(val);
}
vector<pos> v(n);
stack<pair<int, int> > st;
for (int i = 0; i < n; ++i) {
while (!st.empty() && st.top().first <= input[i]) {
v[st.top().second].gr = i;
st.pop();
}
st.push({input[i], i});
}
while (!st.empty()) {
v[st.top().second].gr = n;
st.pop();
}
for (int i = n - 1; i >= 0; --i) {
while (!st.empty() && st.top().first < input[i]) {
v[st.top().second].gl = i + 1;
st.pop();
}
st.push({input[i], i});
}
while (!st.empty()) {
v[st.top().second].gl = 0;
st.pop();
}
vector<int> go(MAXBIT, -1);
for (int i = 0; i < n; ++i) {
int temp = input[i];
int d = 0;
while (temp) {
if ((temp & 1)) go[d] = i;
d++;
temp >>= 1;
}
v[i].bl = -1;
for (int j = 0; j < MAXBIT; ++j)
if (go[j] != i) v[i].bl = max(v[i].bl, go[j]);
}
fill(go.begin(), go.end(), n + 1);
for (int i = n - 1; i >= 0; --i) {
int temp = input[i];
int d = 0;
while (temp) {
if ((temp & 1)) go[d] = i;
d++;
temp >>= 1;
}
v[i].br = n + 1;
for (int j = 0; j < MAXBIT; ++j)
if (go[j] != i) v[i].br = min(v[i].br, go[j] + 1);
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (v[i].bl >= v[i].gl)
ans += 1LL * (v[i].bl - v[i].gl + 1) * (v[i].gr - i);
if (v[i].br <= v[i].gr)
ans +=
1LL * (v[i].gr - v[i].br + 1) * (i - max(v[i].bl + 1, v[i].gl) + 1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXDEP = 18;
int N;
int h[200010];
int st[200010][MAXDEP + 1], ma[200010][MAXDEP + 1];
int lg[500010];
int nxt[200010][32];
int getmax(int L, int R) {
int len = R - L + 1, l = lg[len];
return max(ma[L][l], ma[R - (1 << l) + 1][l]);
}
pair<int, int> pos[33];
int main() {
for (int i = 0, j = 1; i <= MAXDEP; j *= 2, i++) lg[j] = i;
for (int i = 1; i <= 200000; i++) lg[i] = max(lg[i - 1], lg[i]);
scanf("%d", &N);
for (int i = 1; i <= N; i++)
scanf("%d", &h[i]), st[i][0] = h[i], ma[i][0] = h[i];
for (int d = 1; d <= MAXDEP; d++)
for (int i = 1; i <= N; i++)
if (i + (1 << (d - 1)) <= N) {
st[i][d] = st[i][d - 1] | st[i + (1 << (d - 1))][d - 1];
ma[i][d] = max(ma[i][d - 1], ma[i + (1 << (d - 1))][d - 1]);
} else {
st[i][d] = st[i][d - 1];
ma[i][d] = ma[i][d - 1];
}
for (int i = 0; i < 32; i++) nxt[N + 1][i] = N + 1;
for (int i = N; i >= 1; i--)
for (int j = 0; j < 32; j++)
if (h[i] & (1 << j))
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
pos[32].first = N + 1;
long long ans = 0;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < 32; j++) pos[j] = make_pair(nxt[i][j], j);
sort(pos, pos + 32);
int vv = 0;
int lastend = i - 1;
for (int j = 0; j < 32; j++) {
vv |= (1 << pos[j].second);
if (j == 31 || pos[j].first != pos[j + 1].first) {
if (pos[j].first == N + 1) break;
int L = pos[j].first, R = pos[j + 1].first - 1;
if (getmax(i, R) < vv) {
ans += R - L + 1;
continue;
}
if (getmax(i, L) >= vv) continue;
while (L < R - 1) {
int mid = (L + R) >> 1;
if (getmax(i, mid) < vv)
L = mid;
else
R = mid;
}
ans += L - pos[j].first + 1;
}
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 400010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
long long n, a[N], L[N], R[N], F[N], Ans;
map<long long, long long> Q;
signed main() {
n = read();
for (register long long i = 1; i <= n; i++) a[i] = read();
for (register long long i = 1; i <= n; i++) {
L[i] = Q[a[i]] + 1, Q[a[i]] = i;
for (register long long j = 0; j <= 30; j++) {
if ((a[i] >> j) & 1)
F[j] = i;
else
L[i] = max(L[i], F[j] + 1);
}
}
for (register long long i = 0; i <= 30; i++) F[i] = R[i] = n + 1;
for (register long long i = n; i; i--) {
R[i] = n + 1;
for (register long long j = 0; j <= 30; j++) {
if ((a[i] >> j) & 1)
F[j] = i;
else
R[i] = min(R[i], F[j] - 1);
}
}
for (register long long i = 1; i <= n; i++)
Ans += (R[i] - i + 1) * (i - L[i] + 1);
printf("%lld\n", max(n * (n + 1) / 2 - Ans, 0ll));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], v[200005];
struct rmq {
int db[200005][21];
void make() {
for (int i = 1; i <= n; i++) db[i][0] = a[i];
for (int j = 0; j < 20; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << j) > n)
db[i][j + 1] = db[i][j];
else
db[i][j + 1] = max(db[i][j], db[i + (1 << j)][j]);
}
}
}
int query(int a, int b, int k, int l, int r) {
if (a > b) return -1009;
int i = v[(b - a + 1)];
{ return max(db[a][i], db[b - (1 << i) + 1][i]); }
}
} R;
struct rmq2 {
int db[200005][21];
void make() {
for (int i = 1; i <= n; i++) db[i][0] = a[i];
for (int j = 0; j < 20; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << j) > n)
db[i][j + 1] = db[i][j];
else
db[i][j + 1] = (db[i][j] | db[i + (1 << j)][j]);
}
}
}
int query(int a, int b, int k, int l, int r) {
if (a > b) return 0;
int i = v[(b - a + 1)];
{ return (db[a][i] | db[b - (1 << i) + 1][i]); }
}
} O;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
O.make();
R.make();
for (int i = 1; i < 200005; i++) {
for (int j = 20; j >= 0; j--) {
if (i >= (1 << j)) {
v[i] = j;
break;
}
}
}
long long ans = 1LL * n * (n + 1) / 2LL;
for (int i = 1; i <= n; i++) {
int lb = 0, ub = i;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
int x = O.query(mid, i - 1, 0, 0, (1 << 18) - 1);
int y = R.query(mid, i - 1, 0, 0, (1 << 18) - 1);
if (y >= a[i]) {
lb = mid;
} else if ((x | a[i]) != a[i]) {
lb = mid;
} else {
ub = mid;
}
}
long long U = i - ub + 1;
lb = i, ub = n + 1;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
int x = O.query(i, mid, 0, 0, (1 << 18) - 1);
int y = R.query(i, mid, 0, 0, (1 << 18) - 1);
if (y > a[i]) {
ub = mid;
} else if ((x | a[i]) != a[i]) {
ub = mid;
} else {
lb = mid;
}
}
long long V = lb - i + 1;
ans -= U * V;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long an = 0;
cin >> n;
int ar[n];
int pref[n][30], suf[n][30];
for (int a = 0; a < 30; a++) {
pref[0][a] = -1, suf[n - 1][a] = n;
}
for (int a = 0; a < n; a++) {
cin >> ar[a];
if (a + 1 < n) {
for (int b = 0; b < 30; b++) {
pref[a + 1][b] = pref[a][b];
if ((ar[a] & (1 << b)) > 0) pref[a + 1][b] = a;
}
}
}
for (int a = n - 2; a >= 0; a--) {
for (int b = 0; b < 30; b++) {
suf[a][b] = suf[a + 1][b];
if ((ar[a + 1] & (1 << b)) > 0) suf[a][b] = a + 1;
}
}
int l[n], r[n];
stack<int> st;
for (int a = 0; a < n; a++) {
while (st.size() > 0) {
if (ar[st.top()] > ar[a])
break;
else
st.pop();
}
if (st.size() == 0)
l[a] = -1;
else
l[a] = st.top();
st.push(a);
}
while (st.size() > 0) st.pop();
for (int a = n - 1; a >= 0; a--) {
while (st.size() > 0) {
if (ar[st.top()] >= ar[a])
break;
else
st.pop();
}
if (st.size() == 0)
r[a] = n;
else
r[a] = st.top();
st.push(a);
}
for (int a = 0; a < n; a++) {
long long cu = 1ll * (a - l[a]) * (r[a] - a);
int lg = l[a], rg = r[a];
for (int b = 0; b < 30; b++) {
if ((ar[a] & (1 << b)) == 0) {
lg = max(lg, pref[a][b]);
rg = min(rg, suf[a][b]);
}
}
cu -= 1ll * (a - lg) * (rg - a);
an += cu;
}
cout << an;
}
|
#include <bits/stdc++.h>
using namespace std;
stack<pair<int, int> > s, EMPTY;
int n, a[200005], pre[200005], nxt[200005], l[200005], r[200005], f[35];
long long ans;
int main() {
ios::sync_with_stdio(false);
int i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
while (!s.empty() && s.top() < make_pair(a[i], i)) s.pop();
if (s.empty())
pre[i] = 1;
else
pre[i] = s.top().second + 1;
s.push(make_pair(a[i], i));
}
s = EMPTY;
for (i = n; i; i--) {
while (!s.empty() && s.top() < make_pair(a[i], i)) s.pop();
if (s.empty())
nxt[i] = n;
else
nxt[i] = s.top().second - 1;
s.push(make_pair(a[i], i));
}
for (i = 1; i <= n; i++) {
for (j = 0; j <= 30; j++)
if ((a[i] >> j) & 1)
f[j] = i;
else
l[i] = max(l[i], f[j]);
}
for (j = 0; j <= 30; j++) f[j] = n + 1;
for (i = 1; i <= n; i++) r[i] = n + 1;
for (i = n; i; i--) {
for (j = 0; j <= 30; j++)
if ((a[i] >> j) & 1)
f[j] = i;
else
r[i] = min(r[i], f[j]);
}
for (i = 1; i <= n; i++)
ans += (long long)(i - pre[i] + 1) * max(0, nxt[i] - r[i] + 1) +
(long long)(nxt[i] - i + 1) * max(0, l[i] - pre[i] + 1) -
(long long)max(0, l[i] - pre[i] + 1) * max(0, nxt[i] - r[i] + 1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acosl(-1);
const int maxn = 200100;
const long long mod = 1e6 + 3;
const int inf = 1e9;
int n;
int a[maxn];
int b[40];
int le[maxn], ri[maxn], lb[maxn], rb[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%d", &a[i]);
for (int i = 2; i < n + 1; i++) {
int x = i - 1;
while (x && a[x] < a[i]) x = le[x];
le[i] = x;
}
for (int i = n + 1 - 1; i >= 1; i--) {
int x = i + 1;
while (x <= n && a[x] <= a[i]) x = ri[x];
ri[i] = x;
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < 32; j++)
if ((a[i] >> j) & 1)
b[j] = i;
else
lb[i] = max(lb[i], b[j]);
}
for (int i = 1; i < n + 1; i++) rb[i] = n + 1;
for (int i = 0; i < 32; i++) b[i] = n + 1;
for (int i = n + 1 - 1; i >= 1; i--) {
for (int j = 0; j < 32; j++)
if ((a[i] >> j) & 1)
b[j] = i;
else
rb[i] = min(rb[i], b[j]);
}
long long ans = (long long)n * (n + 1) / 2;
for (int i = 1; i < n + 1; i++) {
int L = max(le[i], lb[i]) + 1;
int R = min(ri[i], rb[i]) - 1;
ans -= (long long)(R - i + 1) * (i - L + 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int data = 0, m = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') {
m = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = (data << 1) + (data << 3) + (ch ^ 48);
ch = getchar();
}
return (m) ? data : -data;
}
long long Ans;
int LOG[200005], ST[20][200005], A[200005], pre[200005], aft[200005],
pos[200005], n;
inline int QwQ(int l, int r) {
int lg = r - l + 1, e = LOG[lg];
if (A[ST[e][l]] > A[ST[e][r - (1 << e) + 1]])
return ST[e][l];
else
return ST[e][r - (1 << e) + 1];
}
inline void Pre() {
for (int i = 1; i <= n; i++) pre[i] = -1e9, aft[i] = 1e9;
for (int j = 0; j <= 30; j++) pos[j] = 0;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= 30; k++)
if (!(A[i] & (1 << k)) && pos[k]) pre[i] = max(pre[i], pos[k]);
for (int k = 0; k <= 30; k++)
if (A[i] & (1 << k)) pos[k] = i;
}
for (int j = 0; j <= 30; j++) pos[j] = 0;
for (int i = n; i >= 1; i--) {
for (int k = 0; k <= 30; k++)
if (!(A[i] & (1 << k)) && pos[k]) aft[i] = min(aft[i], pos[k]);
for (int k = 0; k <= 30; k++)
if (A[i] & (1 << k)) pos[k] = i;
}
for (int i = 1; i <= n; i++) ST[0][i] = i;
for (int j = 1; j <= 19; j++)
for (int k = 1; k + (1 << j) - 1 <= n; k++) {
if (A[ST[j - 1][k]] > A[ST[j - 1][k + (1 << (j - 1))]])
ST[j][k] = ST[j - 1][k];
else
ST[j][k] = ST[j - 1][k + (1 << (j - 1))];
}
for (int j = 1; j <= n; j++) LOG[j] = log2(j);
}
void dfs(int l, int r) {
if (l >= r) return;
int p = QwQ(l, r);
dfs(l, p - 1);
dfs(p + 1, r);
int l1 = (p - 1) - l + 1, l2 = r - (p + 1) + 1;
Ans = Ans + 1ll * (l1 + 1) * (l2 + 1) - 1;
int lst = max(l - 1, pre[p]), nxt = min(r + 1, aft[p]);
lst = (p - 1) - lst + 1;
lst--;
nxt = nxt - (p + 1) + 1;
nxt--;
Ans = Ans - 1ll * (lst + 1) * (nxt + 1) + 1;
return;
}
int main() {
n = gi();
for (int i = 1; i <= n; i++) A[i] = gi();
Pre();
Ans = 0;
dfs(1, n);
cout << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 100;
const int maxm = 31;
int n, m;
int a[maxn], rem[maxm], b[maxn], c[maxm];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
for (int j = 0; j < maxm; ++j) {
c[j] = j;
if ((a[i] >> j) & 1) {
rem[j] = i;
}
}
while (m && a[b[m - 1]] <= a[i]) {
--m;
}
b[m++] = i;
std::sort(c, c + maxm, [&](int i, int j) { return rem[i] > rem[j]; });
int cur = 0;
for (int ii = 0; ii < maxm; ++ii) {
int jj = ii;
while (jj + 1 < maxm && rem[c[jj + 1]] == rem[c[jj]]) {
++jj;
}
for (int k = ii; k <= jj; ++k) {
cur |= (1 << c[k]);
}
int r = rem[c[ii]], l = (jj + 1 == maxm ? 1 : rem[c[jj + 1]] + 1);
if (l <= r) {
int ll = 0, rr = m - 1;
while (ll <= rr) {
int mid = ll + rr >> 1;
if (a[b[mid]] >= cur) {
ll = mid + 1;
} else {
rr = mid - 1;
}
}
int k = rr >= 0 ? b[rr] + 1 : 1;
if (k < l) {
k = l;
}
if (k <= r) {
ans += (r - k + 1);
}
}
ii = jj;
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
const int M = 30;
int a[N], b[M + 5];
int l[N], r[N];
map<int, int> L;
int main() {
int n, i, j, x, y;
long long ans;
ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i = i + 1) {
scanf("%d", a + i);
x = 0;
for (j = 0; j <= M; j = j + 1) {
y = 1 << j;
if (a[i] & y)
b[j] = i;
else
x = max(x, b[j]);
}
l[i] = x + 1;
if (L.find(a[i]) != L.end()) l[i] = max(l[i], L[a[i]] + 1);
L[a[i]] = i;
}
for (j = 0; j <= M; j = j + 1) b[j] = n + 1;
for (i = n; i >= 1; i = i - 1) {
x = n + 1;
for (j = 0; j <= M; j = j + 1) {
y = 1 << j;
if (a[i] & y)
b[j] = i;
else
x = min(x, b[j]);
}
r[i] = x - 1;
}
ans = (long long)n * (n + 1) / 2;
for (i = 1; i <= n; i = i + 1) {
ans -= (long long)(i - l[i] + 1) * (r[i] - i + 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[200010], prv[200010], cnt[200010], prm[200010];
int main() {
ios::sync_with_stdio(false);
memset(prv, -1, sizeof(prv));
int i, j, n, m, a, b, c;
long long d = 0;
cin >> n;
for (int i = 0; i <= n - 1; i++) cin >> ar[i];
for (int i = 0; i <= n - 1; i++) {
b = a = 0;
c = i;
for (int j = i; j <= n - 1; j++) {
a = a | ar[j];
b = max(b, ar[j]);
c = j;
if (b < a)
cnt[j] = 1;
else
cnt[j] = 0;
if (prv[j] == a && prm[j] == b) break;
prv[j] = a;
prm[j] = b;
}
for (int j = c; j >= i; j--) cnt[j] = cnt[j] + cnt[j + 1];
d += cnt[i];
}
cout << d << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
;
long long read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const double eps = 1e-8;
const int mod = 1e9 + 7;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
long long ans;
int n, f[200005][20], a[200005][31];
int x[200005], pre[200005][31], nxt[200005][31];
void zh(int i, int x) {
int len = 0;
while (x) {
a[i][++len] = x & 1;
x >>= 1;
}
while (len < 30) a[i][++len] = 0;
}
int MAX(int L, int R) {
int k = (double)log(R - L + 1) / (double)log(2);
if (x[f[L][k]] > x[f[R - (1 << k) + 1][k]])
return f[L][k];
else
return f[R - (1 << k) + 1][k];
}
void solve(long long L, long long R) {
if (L > R) return;
int m = MAX(L, R);
long long l = L - 1, r = R + 1;
for (int i = 1; i <= 30; i++)
if (!(x[m] & (1 << (30 - i))))
l = max(l, (long long)pre[m][31 - i]),
r = min(r, (long long)nxt[m][31 - i]);
ans += (l - L + 1) * (R - m + 1) + (R - r + 1) * (m - L + 1) -
(l - L + 1) * (R - r + 1);
solve(L, m - 1);
solve(m + 1, R);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
f[i][0] = i;
zh(i, x[i]);
}
int last[35];
memset(last, 0, sizeof(last));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 30; j++) {
pre[i][j] = last[j];
if (a[i][j] == 1) last[j] = i;
}
}
for (int i = 1; i <= 30; i++) {
last[i] = n + 1;
}
for (int i = n; i; i--) {
for (int j = 1; j <= 30; j++) {
nxt[i][j] = last[j];
if (a[i][j] == 1) last[j] = i;
}
}
for (int j = 1; j <= 30; j++) {
for (int i = 1; i <= n; i++)
if (i + (1 << j) - 1 > n)
break;
else {
if (x[f[i][j - 1]] > x[f[i + (1 << (j - 1))][j - 1]]) {
f[i][j] = f[i][j - 1];
} else {
f[i][j] = f[i + (1 << (j - 1))][j - 1];
}
}
}
ans = 0LL;
solve(1, n);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll p[800001];
ll t[400001];
ll n;
ll dor[2][200002], nagyobbd[2][200002];
void epit() {
{
stack<ll> verem;
verem.push(0);
for (ll i = 1; i <= n; i++) {
while (t[verem.top()] <= t[i]) verem.pop();
nagyobbd[0][i] = verem.top();
verem.push(i);
}
}
{
stack<ll> verem;
verem.push(n + 1);
for (ll i = n; i >= 1; i--) {
while (t[verem.top()] < t[i]) verem.pop();
nagyobbd[1][i] = verem.top();
verem.push(i);
}
}
{
stack<ll> verem;
verem.push(0);
for (ll i = 1; i <= n; i++) {
while ((t[verem.top()] | t[i]) == t[i]) verem.pop();
dor[0][i] = verem.top();
verem.push(i);
}
}
{
stack<ll> verem;
verem.push(n + 1);
for (ll i = n; i >= 1; i--) {
while ((t[verem.top()] | t[i]) == t[i]) verem.pop();
dor[1][i] = verem.top();
verem.push(i);
}
}
}
ll ask_balra(ll honnan) { return dor[0][honnan]; }
ll ask_jobbra(ll honnan) { return dor[1][honnan]; }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (ll i = 1; i <= n; i++) {
cin >> t[i];
}
t[0] = t[n + 1] = (1 << 30) - 1;
epit();
ll valasz = 0;
for (int aktpoz = 1; aktpoz <= n; aktpoz++) {
ll balrakisebb = nagyobbd[0][aktpoz] + 1;
ll jobbrakisebb = nagyobbd[1][aktpoz] - 1;
ll balra_elso = max(ask_balra(aktpoz), balrakisebb - 1),
jobbra_elso = min(ask_jobbra(aktpoz), jobbrakisebb + 1);
valasz += (aktpoz - balrakisebb + 1) * (jobbrakisebb - aktpoz + 1) -
(aktpoz - balra_elso) * (jobbra_elso - aktpoz);
}
cout << valasz;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 2e5 + 5;
map<int, int> pre;
int l[N], r[N], a[N], now[40];
int n;
long long ans;
int main() {
read(n);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1; i <= n; i++) l[i] = 1;
for (register int i = 1; i <= n; i++) {
for (register int j = 0; j < 32; j++) {
if (a[i] & (1 << j)) {
now[j] = i;
} else if (now[j]) {
l[i] = max(l[i], now[j] + 1);
}
}
l[i] = max(l[i], pre[a[i]] + 1);
pre[a[i]] = i;
}
for (register int i = 0; i <= 31; i++) now[i] = n + 1;
for (register int i = 1; i <= n; i++) r[i] = n;
for (register int i = n; i >= 1; i--) {
for (register int j = 0; j < 32; j++) {
if (a[i] & (1 << j)) {
now[j] = i;
} else if (now[j] != n + 1) {
r[i] = min(r[i], now[j] - 1);
}
}
}
for (register int i = 1; i <= n; i++)
ans += (long long)(i - l[i] + 1) * (r[i] - i + 1);
cout << (long long)n * (n + 1) / 2 - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200000 + 10;
vector<int> G[100];
int last[100];
int a[maxn], nex[maxn], pre[maxn];
map<int, int> H;
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
pre[i] = max(pre[i], H[a[i]]);
for (int j = 0; j < 30; j++) {
if (a[i] >> j & 1)
last[j] = i;
else
pre[i] = max(pre[i], last[j]);
}
H[a[i]] = i;
}
for (int i = 0; i < 30; i++) last[i] = n + 1;
for (int i = n; i > 0; i--) {
nex[i] = n + 1;
for (int j = 0; j < 30; j++) {
if (a[i] >> j & 1)
last[j] = i;
else
nex[i] = min(last[j], nex[i]);
}
}
long long ans = 1LL * n * (n + 1) / 2;
for (int i = 1; i <= n; i++) {
ans -= 1LL * (i - pre[i]) * (nex[i] - i);
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000005], Lmax[1000005], Rmax[1000005], Left[1000005][33],
Right[1000005][33], Stack[1000005];
long long ans;
int read() {
char c = getchar();
int ans = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + (c ^ 48), c = getchar();
return ans;
}
void Write(long long x) {
if (x < 10)
putchar(x ^ 48);
else
Write(x / 10), putchar((x % 10) ^ 48);
return;
}
int main() {
n = read();
ans = n * (n + 1ll) / 2;
for (register int i = 1; i <= n; i++) a[i] = read();
a[0] = 2000000000, a[n + 1] = 2000000000;
Stack[Stack[0] = 1] = 0;
for (register int i = 1; i <= n; i++) {
while (a[Stack[Stack[0]]] <= a[i]) --Stack[0];
Lmax[i] = Stack[Stack[0]] + 1;
Stack[++Stack[0]] = i;
}
Stack[Stack[0] = 1] = n + 1;
for (register int i = n; i >= 1; i--) {
while (a[Stack[Stack[0]]] < a[i]) --Stack[0];
Rmax[i] = Stack[Stack[0]] - 1;
Stack[++Stack[0]] = i;
}
for (register int j = 0; j <= 30; j++) Right[n + 1][j] = n + 1;
for (register int i = 1; i <= n; i++)
for (register int j = 0; j <= 30; j++)
Left[i][j] = (a[i] & (1 << j)) ? i : Left[i - 1][j];
for (register int i = n; i >= 1; i--)
for (register int j = 0; j <= 30; j++)
Right[i][j] = (a[i] & (1 << j)) ? i : Right[i + 1][j];
for (register int i = 1; i <= n; i++) {
int LL = Lmax[i], RR = Rmax[i];
for (register int j = 0; j <= 30; j++)
if (!(a[i] & (1 << j)))
LL = max(LL, Left[i][j] + 1), RR = min(RR, Right[i][j] - 1);
ans -= (RR - i + 1) * (i - LL + 1ll);
}
Write(ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 2000000007;
const long long BIG_INF = 2000000000000000005;
const long long mod = 1000000007;
const long long P = 31;
const long double PI = 3.141592653589793238462643;
using namespace std;
vector<pair<long long, long long> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(long long x, long long y, long long n, long long m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
const int N = 200000 + 5, logN = 18;
int a[N], n, lg[N], spOR[N][logN], spMX[N][logN];
long long ans = 0;
unordered_map<int, vector<int> > ch;
int getMax(int l, int r) {
int len = r - l + 1;
return max(spMX[l][lg[len]], spMX[r - (1 << lg[len]) + 1][lg[len]]);
}
int getOr(int l, int r) {
int len = r - l + 1;
return spOR[l][lg[len]] | spOR[r - (1 << lg[len]) + 1][lg[len]];
}
void precalc() {
lg[1] = 0;
for (int i = 2; i <= n; i++) lg[i] = lg[i / 2] + 1;
for (int i = 0; i < n; i++) {
spMX[i][0] = spOR[i][0] = a[i];
}
for (int j = 1; j < logN; j++) {
for (int i = 0; i < n; i++) {
spMX[i][j] =
max(spMX[i][j - 1], spMX[min(n - 1, i + (1 << (j - 1)))][j - 1]);
spOR[i][j] = spOR[i][j - 1] | spOR[min(n - 1, i + (1 << (j - 1)))][j - 1];
}
}
}
int getLMx(int val, int pos) {
int l = 0, r = pos;
while (l != r) {
int mid = (l + r) / 2;
if (r - l == 1) mid = l;
if (getMax(mid, pos) > val)
l = mid + 1;
else
r = mid;
}
return l;
}
int getLOr(int val, int pos) {
int l = 0, r = pos;
while (l != r) {
int mid = (l + r) / 2;
if (r - l == 1) mid = l;
if (getOr(mid, pos) > val)
l = mid + 1;
else
r = mid;
}
return l;
}
int getRMx(int val, int pos) {
int l = pos, r = n - 1;
while (l != r) {
int mid = (l + r) / 2;
if (r - l == 1) mid = r;
if (getMax(pos, mid) > val)
r = mid - 1;
else
l = mid;
}
return l;
}
int getROr(int val, int pos) {
int l = pos, r = n - 1;
while (l != r) {
int mid = (l + r) / 2;
if (r - l == 1) mid = r;
if (getOr(pos, mid) > val)
r = mid - 1;
else
l = mid;
}
return l;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
ch[a[i]].push_back(i);
}
precalc();
for (auto u = ch.begin(); u != ch.end(); u++) {
for (int i = 0; i < u->second.size(); i++) {
int val = u->first, pos = u->second[i];
int l = max(getLMx(val, pos), getLOr(val, pos)),
r = min(getRMx(val, pos), getROr(val, pos));
ans += (long long)(pos - l + 1) * (long long)(r - pos + 1);
int j = i + 1;
while (j < u->second.size() && u->second[j] <= r) {
ans += (long long)(u->second[j] - u->second[j - 1]) *
(long long)(r - u->second[j] + 1);
j++;
}
i = j - 1;
}
}
cout << (long long)n * (long long)(n + 1) / (long long)2 - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
const int N = 2e5 + 7;
int a[N], q[N], L[N], R[N];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
int top = 0;
for (int i = 1; i <= n; i++) {
while (top && ((a[q[top]] | a[i]) == a[i]) && a[q[top]] != a[i]) top--;
if (top)
L[i] = q[top] + 1;
else
L[i] = 1;
q[++top] = i;
}
top = 0;
for (int i = n; i >= 1; i--) {
while (top && ((a[q[top]] | a[i]) == a[i])) top--;
if (top)
R[i] = q[top] - 1;
else
R[i] = n;
q[++top] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += 1ll * (i - L[i]) * (1ll * (R[i] - i)) + R[i] - L[i];
printf("%I64d\n", 1ll * (1ll * n * (n - 1)) / 2 - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_N = 2e5 + 10;
const int l_N = 20;
int st[l_N][max_N];
int lg[max_N];
int inp[max_N];
vector<int> bits[30];
int query_max(int i, int j);
int main() {
{
int j = 0;
for (int i = 0; i < max_N; ++i) {
while ((1 << j) <= i) {
++j;
}
lg[i] = j - 1;
}
}
int N;
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &inp[i]);
st[0][i] = inp[i];
}
for (int j = 1; j < l_N; ++j) {
for (int i = 1; i + (1 << j) - 1 <= N; ++i) {
st[j][i] = max(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < 30; ++j) {
if ((inp[i] >> j) & 1) {
bits[j].push_back(i);
}
}
}
long long ans = 0;
for (int i = 1; i <= N; ++i) {
vector<int> or_changes;
for (int j = 0; j < 30; ++j) {
auto it = lower_bound(bits[j].begin(), bits[j].end(), i);
if (it != bits[j].end()) {
or_changes.push_back(*it);
}
}
sort(or_changes.begin(), or_changes.end());
or_changes.push_back(N + 1);
int cid = *or_changes.begin();
int cor = inp[cid];
for (int j = 1; j < or_changes.size(); ++j) {
int L = cid, R = or_changes[j];
int low = L, high = R - 1, mid, best = R;
while (low <= high) {
mid = (low + high) >> 1;
if (query_max(i, mid) >= cor) {
best = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
ans += best - L;
cid = R;
cor |= inp[R];
}
}
cout << ans << endl;
}
int query_max(int i, int j) {
int d = lg[j - i + 1];
return max(st[d][i], st[d][j - (1 << d) + 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, logN = 20;
int OR[logN][N], floorlog[N], A[N], lft[N], rgt[N], n;
pair<int, int> mx[logN][N];
pair<int, int> max(const pair<int, int>& P, const pair<int, int>& Q) {
return (P > Q) ? P : Q;
}
pair<int, int> P[N];
void getRMQ() {
for (int i = n; i >= 1; i--) {
OR[0][i] = A[i];
mx[0][i] = P[i];
for (int j = 1; i + (1 << j) - 1 <= n; j++) {
OR[j][i] = OR[j - 1][i] | OR[j - 1][i + (1 << (j - 1))];
mx[j][i] = max(mx[j - 1][i], mx[j - 1][i + (1 << (j - 1))]);
}
}
}
inline pair<int, int> getMax(int i, int j) {
int k = floorlog[j - i + 1];
return max(mx[k][i], mx[k][j - (1 << k) + 1]);
}
inline int getOR(int i, int j) {
int k = floorlog[j - i + 1];
return OR[k][i] | OR[k][j - (1 << k) + 1];
}
inline int getLFT(int i) {
int lo = 1, hi = i;
while (lo < hi) {
int mid = (lo + hi) >> 1;
if (getOR(mid, i) == A[i] && getMax(mid, i) == P[i])
hi = mid;
else
lo = mid + 1;
}
return i - lo + 1;
}
int main() {
for (int i = 0; (1 << i) < N; i++) {
for (int j = (1 << i); j < (1 << (i + 1)) && j < N; j++) floorlog[j] = i;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", A + i);
P[i] = {A[i], i};
}
getRMQ();
for (int i = 1; i <= n; i++) lft[i] = getLFT(i);
reverse(A + 1, A + n + 1);
reverse(P + 1, P + n + 1);
getRMQ();
for (int i = 1; i <= n; i++) {
rgt[n - i + 1] = getLFT(i);
}
long long ans = (n * 1ll * (n + 1)) / 2;
for (int i = 1; i <= n; i++) {
ans -= (lft[i] * 1ll * rgt[i]);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[200010];
long long int fos[200010];
long long int sos[200010];
long long int mxm[200010];
long long int ss[35];
long long int rm[200010], lm[200010];
int main() {
long long int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
long long int xm = 0;
for (int i = 0; i < 35; ++i) ss[i] = -1;
for (int i = 1; i <= n; ++i) {
xm = 0;
for (int j = 0; j < 35; ++j) {
if (ss[j] != -1 and !(a[i] & (1ll << j))) {
xm = max(xm, ss[j]);
}
}
fos[i] = xm;
for (int j = 0; j < 35; ++j) {
if (a[i] & (1ll << j)) {
ss[j] = i;
}
}
}
xm = 0;
for (int i = 0; i < 35; ++i) ss[i] = -1;
for (int i = n; i >= 1; --i) {
xm = n + 1;
for (int j = 0; j < 35; ++j) {
if (ss[j] != -1 and !(a[i] & (1ll << j))) {
xm = min(xm, ss[j]);
}
}
sos[i] = xm;
for (int j = 0; j < 35; ++j) {
if (a[i] & (1ll << j)) {
ss[j] = i;
}
}
}
stack<int> stk;
for (int i = 1; i <= n; ++i) {
while (!stk.empty() and a[stk.top()] <= a[i]) {
rm[stk.top()] = i - 1;
stk.pop();
}
stk.push(i);
}
while (!stk.empty()) rm[stk.top()] = n, stk.pop();
for (int i = n; i >= 1; --i) {
while (!stk.empty() and a[stk.top()] < a[i]) {
lm[stk.top()] = i + 1;
stk.pop();
}
stk.push(i);
}
while (!stk.empty()) lm[stk.top()] = 1, stk.pop();
long long int ans = 0;
fos[1] = 0;
sos[n] = n + 1;
for (int i = 1; i <= n; ++i) {
if (fos[i] < lm[i]) fos[i] = lm[i] - 1;
if (sos[i] > rm[i]) sos[i] = rm[i] + 1;
ans += max((rm[i] - i + 1) * (i - lm[i] + 1) - (fos[i] - i) * (i - sos[i]),
0ll);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, logv = 35;
inline long long rd() {
long long x = 0;
char c = getchar();
int neg = 1;
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * neg;
}
int L[maxn], R[maxn], a[maxn], N;
int stk[maxn], sh;
int pre[logv][maxn], nxt[logv][maxn];
int main() {
int i, j, k;
N = rd();
for (i = 1; i <= N; i++) a[i] = rd();
for (i = 1; i <= N; i++) {
for (j = 1, k = a[i]; j <= 30; j++, k >>= 1) {
if (k & 1)
pre[j][i] = i;
else
pre[j][i] = pre[j][i - 1];
}
}
memset(nxt, 127, sizeof(nxt));
for (i = N; i; i--) {
for (j = 1, k = a[i]; j <= 30; j++, k >>= 1) {
if (k & 1)
nxt[j][i] = i;
else
nxt[j][i] = nxt[j][i + 1];
}
}
for (i = 1; i <= N; i++) {
while (sh && a[stk[sh]] <= a[i]) R[stk[sh--]] = i - 1;
stk[++sh] = i;
}
while (sh) R[stk[sh--]] = N;
for (i = N; i; i--) {
while (sh && a[stk[sh]] < a[i]) L[stk[sh--]] = i + 1;
stk[++sh] = i;
}
while (sh) L[stk[sh--]] = 1;
long long ans = 1ll * N * (N + 1) / 2;
for (i = 1; i <= N; i++) {
int mi = N + 1, ma = 0;
for (j = 1, k = a[i]; j <= 30; j++, k >>= 1) {
if (!(k & 1)) mi = min(mi, nxt[j][i]), ma = max(ma, pre[j][i]);
}
ans -= 1ll * min(i - L[i] + 1, i - ma) * min(R[i] - i + 1, mi - i);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
int n, a[N];
static inline int lg(int x) { return 32 - __builtin_clz(x) - 1; }
struct Sparse {
static const int mk = 19;
int* tb[mk];
int* orr[mk];
Sparse(int* a, int n) {
for (int i = 0; i < mk; i++) {
tb[i] = new int[n + 5];
orr[i] = new int[n + 5];
}
for (int i = 0; i < n; i++) {
tb[0][i] = a[i];
orr[0][i] = a[i];
}
for (int k = 1; k <= lg(n); k++) {
for (int i = 0; i < n; i++) {
int nx = i + (1 << (k - 1));
if (nx < n) {
tb[k][i] = max(tb[k - 1][i], tb[k - 1][nx]);
orr[k][i] = orr[k - 1][i] | orr[k - 1][nx];
} else {
tb[k][i] = tb[k - 1][i];
orr[k][i] = orr[k - 1][i];
}
}
}
}
int getmax(int l, int r) {
int g = lg(r - l + 1);
return max(tb[g][l], tb[g][r - (1 << g) + 1]);
}
int getor(int l, int r) {
int g = lg(r - l + 1);
return orr[g][l] | orr[g][r - (1 << g) + 1];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
Sparse st(a, n);
int K = lg(n) + 2;
ll ans = 0;
for (int i = 0; i < n; i++) {
int curOR = a[i];
int curIdx = i;
int prevIdx = i;
int add = 0;
while (true) {
curIdx++;
prevIdx = curIdx;
curOR = st.getor(i, curIdx);
int cor = curOR;
if ((curOR | a[curIdx + 1]) == curOR) {
for (int k = K; k >= 0; k--) {
if (curIdx + (1 << k) >= n) continue;
int ni = curIdx + (1 << k);
if (st.getor(i, ni) == curOR) {
cor |= st.orr[k][curIdx];
curIdx = ni;
}
}
}
if (curIdx >= n) break;
int r = prevIdx - 1;
int cmax = st.getmax(i, curIdx);
for (int k = K; k >= 0; k--) {
if (r + (1 << k) > curIdx) continue;
int ni = r + (1 << k);
if (st.getmax(i, ni) < curOR) {
cmax = max(cmax, st.tb[k][r]);
r = ni;
}
}
add += (r - prevIdx + 1);
}
ans += add;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> temp[30];
map<int, int> m;
void solve() {
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
if (x[i] & (1 << j)) temp[j].push_back(i);
}
}
long long ans = (1LL * n * (n - 1)) / 2;
for (int i = 0; i < n; i++) {
int curmax = n;
int curmin;
if (m.count(x[i]))
curmin = m[x[i]];
else
curmin = -1;
m[x[i]] = i;
for (int j = 0; j < 30; j++) {
if ((x[i] & (1 << j)) == 0) {
auto it = upper_bound((temp[j]).begin(), (temp[j]).end(), i);
if (it != temp[j].end()) curmax = min(curmax, *it);
if (it != temp[j].begin()) {
it--;
curmin = max(curmin, *it);
}
}
}
ans -= (1LL * (curmax - i) * (i - curmin) - 1);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long power(long long a, long long n) {
a %= 1000000007;
if (n == 1) return a;
if (n == 0) return 1;
if (n % 2)
return (a * (power((a * a) % 1000000007, n / 2) % 1000000007)) % 1000000007;
return power((a * a) % 1000000007, n / 2) % 1000000007;
}
const long long inf = (long long)1e18;
long long inverse(long long x) { return power(x, 1000000007 - 2) % 1000000007; }
long long n;
vector<long long> v(1000005);
vector<pair<long long, long long> > u(1000005);
const long long N = 1e6 + 1;
const long long K = 21;
long long table[N + 5][K + 5];
long long numlog[N + 5];
void build() {
numlog[1] = 0;
for (long long i = 2; i < N; i++) numlog[i] = numlog[i / 2] + 1;
for (long long i = 1; i <= n; i++) table[i][0] = v[i];
for (long long j = 1; j < K; j++)
for (long long i = 1; i + (1 << j) - 1 <= n; i++)
table[i][j] = (table[i][j - 1] | table[i + (1 << (j - 1))][j - 1]);
}
long long query(long long l, long long r) {
long long curlog = numlog[r - l + 1];
return (table[l][curlog] | table[r - (1 << curlog) + 1][curlog]);
}
void solve() {
cin >> n;
for (long long i = 1; i < n + 1; ++i) cin >> v[i], u[i] = {v[i], i};
build();
sort(u.begin() + 1, u.begin() + n + 1,
greater<pair<long long, long long> >());
long long ans = (n * (n + 1)) / 2;
set<long long> done;
for (long long i = 1; i < n + 1; ++i) {
long long pos = u[i].second, st, la;
auto it = done.lower_bound(pos);
if (it == done.end())
la = n;
else
la = (*it) - 1;
if (it == done.begin())
st = 1;
else
--it, st = (*it) + 1;
long long lo = pos, hi = la, l, r;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2, val = query(pos, mid);
if ((val & v[pos]) == val)
lo = mid;
else
hi = mid - 1;
}
r = lo;
lo = st, hi = pos;
while (lo < hi) {
long long mid = (lo + hi) / 2, val = query(mid, pos);
if ((val & v[pos]) == val)
hi = mid;
else
lo = mid + 1;
}
l = lo;
ans -= (r - pos + 1) * (pos - l + 1);
done.insert(pos);
}
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
for (long long t = 1; t < T + 1; ++t) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:336777216")
using namespace std;
const int MAXN = 400000 + 10;
int LOG[MAXN];
int N;
long long A[MAXN];
int Order[MAXN];
vector<int> V[31];
int ptr[31], nV[31];
bool Cmp(const int& a, const int& b) { return A[a] > A[b]; }
long long ST[20][MAXN];
void BuildST() {
int C = LOG[N];
for (int j = 0; j < N; j++) ST[0][j] = A[j];
for (int c = 1; c <= C; c++)
for (int j = 0; j < N; j++)
if (j + (1 << (c - 1)) < N)
ST[c][j] = max(ST[c - 1][j], ST[c - 1][j + (1 << (c - 1))]);
else
ST[c][j] = ST[c - 1][j];
}
long long RMQMAX(int a, int b) {
int L = (b - a + 1);
int c = LOG[L];
long long ret = max(ST[c][a], ST[c][b - (1 << c) + 1]);
return ret;
}
int Find(int a, int b, long long bit_or) {
int Left = a, Right = b - 1, Ans = b;
while (Left <= Right) {
int Mid = (Left + Right) / 2;
long long tmp = RMQMAX(a, Mid);
if (tmp >= bit_or) {
Ans = Mid;
Right = Mid - 1;
} else
Left = Mid + 1;
}
return Ans;
}
int tmp[31], ntmp;
void Work() {
for (int i = 1; i < MAXN; i++) LOG[i] = (int)(log((double)i) / log(2.));
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%I64d", &A[i]);
for (int k = 0; k < 31; k++)
if (A[i] & (1LL << k)) {
V[k].push_back(i);
nV[k]++;
}
}
BuildST();
for (int i = 0; i < N; i++) Order[i] = i;
sort(Order, Order + N, Cmp);
long long Ans = 0;
for (int l = 0; l < N; l++) {
long long bit_or = 0;
ntmp = 0;
tmp[ntmp++] = l;
for (int k = 0; k < 31; k++)
if (ptr[k] < nV[k]) tmp[ntmp++] = V[k][ptr[k]];
tmp[ntmp++] = N;
sort(tmp, tmp + ntmp);
ntmp = unique(tmp, tmp + ntmp) - tmp;
bit_or |= A[l];
for (int d = 1; d < ntmp; d++) {
long long fff = Find(l, tmp[d], bit_or);
if (fff > tmp[d - 1]) Ans += fff - tmp[d - 1];
bit_or |= A[tmp[d]];
}
for (int k = 0; k < 31; k++)
if (ptr[k] < nV[k] && V[k][ptr[k]] == l) ptr[k]++;
}
printf("%I64d\n", Ans);
}
int main() {
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10, lg = 30;
long long a[maxn];
struct sparse {
long long arr[lg][maxn];
void init(long long n) {
for (long long i = 0; i < n; ++i) arr[0][i] = a[i];
for (long long i = 1; (1 << i) <= n; ++i) {
for (long long j = 0; j + (1 << i) <= n; ++j)
arr[i][j] = (arr[i - 1][j] | arr[i - 1][j + (1 << (i - 1))]);
}
}
long long query(long long l, long long r) {
long long p = 31 - __builtin_clz(r - l + 1);
return arr[p][l] | arr[p][r - (1 << p) + 1];
}
} sp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; ++i) cin >> a[i];
sp.init(n);
map<long long, long long> pos;
long long ans = n * 1ll * (n - 1) / 2;
for (long long i = 0; i < n; ++i) {
long long d = 1;
while (d <= n) d <<= 1;
long long l = i, r = i;
while (d >>= 1) {
if (l - d >= 0)
if (sp.query(l - d, i) == a[i]) l -= d;
if (r + d < n)
if (sp.query(i, r + d) == a[i]) r += d;
}
if (pos.find(a[i]) != pos.end()) l = max(l, pos[a[i]] + 1);
ans -= (r - i + 1) * (i - l + 1) - 1;
pos[a[i]] = i;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N], nxt[N][31] = {0};
int maxx[N][20];
int Log2[N];
int GetMaxx(int l, int r) {
int len = Log2[r - l + 1];
return max(maxx[l][len], maxx[r - (1 << len) + 1][len]);
}
int Solve(int start, int l, int r, int val) {
while (l <= r) {
int mid = (l + r) / 2;
if (GetMaxx(start, mid) >= val)
r = mid - 1;
else
l = mid + 1;
}
return l;
}
int main() {
Log2[1] = 0;
for (int i = 2; i < N; i++) {
Log2[i] = Log2[i / 2] + 1;
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
maxx[i][0] = a[i];
}
for (int len = 1; (1 << len) <= n; len++)
for (int i = 1; i + (1 << len) - 1 <= n; i++)
maxx[i][len] = max(maxx[i][len - 1], maxx[i + (1 << (len - 1))][len - 1]);
long long res = 1ll * (n + 1) * n / 2;
for (int i = 0; i <= 30; i++) nxt[n][i] = n + 1;
for (int i = n - 1; i >= 1; i--) {
for (int j = 0; j <= 30; j++) {
nxt[i][j] = nxt[i + 1][j];
if ((1 << j) & a[i + 1]) nxt[i][j] = i + 1;
}
}
for (int l = 1; l <= n; l++) {
int r = l, now = a[l];
while (r <= n) {
int nxt_r = n + 1;
for (int j = 0; j <= 30; j++) {
if (now & (1 << j)) continue;
if (nxt[r][j] < nxt_r) nxt_r = nxt[r][j];
}
int t = Solve(l, r, nxt_r - 1, now);
res -= nxt_r - t;
now |= a[nxt_r];
r = nxt_r;
}
}
printf("%lld\n", res);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.